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

pyckster/obspy_utils.py

@@ -462,6 +462,45 @@ def mute_trace(stream, muted_trace):
 
     return stream
 
+def zero_pad_trace(stream, trace_number, pad_start=0, pad_end=0):
+    """
+    Zero pad a trace in a stream based on trace number.
+
+    Parameters
+    ----------
+    stream : obspy.Stream
+        Stream containing the traces.
+    trace_number : int
+        Trace number to pad.
+    pad_start : int
+        Number of zero samples to add at the beginning.
+    pad_end : int
+        Number of zero samples to add at the end.
+
+    Returns
+    -------
+    stream : obspy.Stream
+        Stream with the specified trace padded.
+    """
+
+    input_format = check_format(stream)
+
+    # Pad trace based on the trace number in header
+    for trace in stream:
+        if trace.stats[input_format].trace_header.trace_number_within_the_original_field_record == trace_number:
+            # Pad with zeros
+            if pad_start > 0 or pad_end > 0:
+                trace.data = np.pad(trace.data, (pad_start, pad_end), mode='constant', constant_values=0)
+                # Update the number of samples in the header
+                trace.stats.npts = len(trace.data)
+                if input_format == 'segy':
+                    trace.stats.segy.trace_header.number_of_samples_in_this_trace = len(trace.data)
+                elif input_format == 'su':
+                    trace.stats.su.trace_header.number_of_samples_in_this_trace = len(trace.data)
+            break
+
+    return stream
+
 def swap_header_format(stream,output_format):
 
     output_format = output_format.lower()

pyckster/pick_io.py

@@ -1,12 +1,53 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 """
-Pick I/O utilities for reading and writing seismic picks in PyGimLi .sgt format.
+Pick I/O utilities for reading and writing seismic picks.
 
 This module provides functions to save and load first-arrival traveltime picks
-in the PyGimLi .sgt format, which is widely used in seismic refraction processing.
+in multiple formats:
 
-Copyright (C) 2024, 2025 Sylvain Pasquet
+**Supported Formats:**
+
+1. **PyGimLi .sgt format** (read/write)
+   - Widely used in seismic refraction processing
+   - Contains station coordinates and source-geophone-time picks
+   - Functions: read_sgt_file(), save_picks_to_sgt(), match_picks_to_geometry()
+
+2. **Rayfract .LST format** (read only)
+   - First break picks from Rayfract software
+   - Format: shot_no trace_no position time synthetic
+   - Invalid picks marked as -1.000
+   - Functions: read_lst_file(), match_lst_picks_to_geometry()
+
+**Typical Usage:**
+
+For SGT files::
+
+    from pick_io import read_sgt_file, match_picks_to_geometry
+    
+    # Read SGT file
+    sgt_data = read_sgt_file('picks.sgt', verbose=True)
+    
+    # Match to geometry
+    matched = match_picks_to_geometry(
+        sgt_data['stations'], sgt_data['picks'],
+        trace_positions, trace_elevations,
+        source_positions, source_elevations
+    )
+
+For LST files::
+
+    from pick_io import read_lst_file, match_lst_picks_to_geometry
+    
+    # Read LST file
+    lst_data = read_lst_file('picks.LST', verbose=True)
+    
+    # Match to geometry
+    matched = match_lst_picks_to_geometry(
+        lst_data, trace_positions, source_positions
+    )
+
+Copyright (C) 2024, 2025, 2026 Sylvain Pasquet
 Email: sylvain.pasquet@sorbonne-universite.fr
 
 This program is free software: you can redistribute it and/or modify
@@ -453,3 +494,487 @@ def match_picks_to_geometry(sgt_stations, sgt_picks,
         'n_matched': n_matched,
         'n_total': n_total
     }
+
+
+def read_vs_file(vs_file, verbose=False):
+    """
+    Read SeisImager/PickWin .vs file and parse first break picks.
+    
+    VS file format:
+    - Line 1: Header (discarded)
+    - Line 2: min_offset n_shots spacing
+    - Line 3: Header (discarded)
+    - For each shot:
+      - Shot header: shot_position n_picks 0
+      - n_picks data lines: geophone_offset time quality_flag
+    
+    Parameters
+    ----------
+    vs_file : str
+        Path to .vs file
+    verbose : bool, optional
+        Print debug information, default False
+    
+    Returns
+    -------
+    dict
+        Dictionary containing:
+        - 'picks': list of (shot_position, geophone_offset, time) tuples
+        - 'n_picks': int (number of valid picks)
+        - 'shots': list of shot positions
+        - 'n_shots': int (number of shots from header)
+        - 'spacing': float (spacing from header)
+    """
+    picks = []
+    shots = []
+    n_shots = 0
+    spacing = 0.0
+    
+    with open(vs_file, 'r') as f:
+        lines = f.readlines()
+    
+    if len(lines) < 3:
+        if verbose:
+            print(f"File too short: {len(lines)} lines")
+        return {'picks': [], 'n_picks': 0, 'shots': [], 'n_shots': 0, 'spacing': 0.0}
+    
+    # Line 1: discard
+    # Line 2: 0 n_shots spacing
+    try:
+        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}")
+        return {'picks': [], 'n_picks': 0, 'shots': [], 'n_shots': 0, 'spacing': 0.0}
+    
+    # Start reading shot data from line 3 (index 2)
+    # No third discard line - shot data starts immediately after header
+    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()
+        
+        if verbose and shot_count < 3:
+            print(f"\nProcessing line {line_idx}: '{line}'")
+        
+        # Skip empty lines
+        if not line:
+            if verbose and shot_count < 3:
+                print(f"  -> Empty line, skipping")
+            line_idx += 1
+            continue
+        
+        # Check if this is a shot header line (third value equals 0)
+        parts = line.split()
+        if verbose and shot_count < 3:
+            print(f"  -> Parts: {parts}, length: {len(parts)}")
+        
+        if len(parts) >= 3:
+            try:
+                # Check if the third value (index 2) is 0
+                third_value = float(parts[2])
+                if verbose and shot_count < 3:
+                    print(f"  -> Third value: {third_value}, is shot header: {abs(third_value) < 0.0001}")
+                
+                if abs(third_value) < 0.0001:  # Close to zero (shot header)
+                    shot_position = float(parts[0])
+                    n_picks_for_shot = int(parts[1])
+                    shot_position = float(parts[0])
+                    n_picks_for_shot = int(parts[1])
+                    shots.append(shot_position)
+                    shot_count += 1
+                    
+                    if verbose:
+                        print(f"Shot {shot_count}: position {shot_position}m, {n_picks_for_shot} picks")
+                    
+                    # Read the pick lines for this shot
+                    for i in range(n_picks_for_shot):
+                        line_idx += 1
+                        if line_idx >= len(lines):
+                            break
+                        
+                        pick_line = lines[line_idx].strip()
+                        pick_parts = pick_line.split()
+                        
+                        if len(pick_parts) >= 3:
+                            try:
+                                geophone_position = float(pick_parts[0])  # Absolute geophone position
+                                time = float(pick_parts[1])
+                                # quality_flag = int(pick_parts[2])
+                                
+                                picks.append((shot_position, geophone_position, time))
+                            except (ValueError, IndexError):
+                                if verbose:
+                                    print(f"Error parsing pick line: {pick_line}")
+            except (ValueError, IndexError) as e:
+                if verbose:
+                    print(f"Error parsing shot header: {line}, error: {e}")
+        
+        line_idx += 1
+    
+    if verbose:
+        print(f"Read {len(picks)} picks from {len(shots)} shots")
+        print(f"Shot positions: {shots[:5]}..." if len(shots) > 5 else f"Shot positions: {shots}")
+    
+    return {
+        'picks': picks,
+        'n_picks': len(picks),
+        'shots': shots,
+        'n_shots': n_shots,
+        'spacing': spacing
+    }
+
+
+def match_vs_picks_to_geometry(vs_picks_data, trace_positions, source_positions,
+                                offset_tolerance=0.5, position_scale=1.0, verbose=False):
+    """
+    Match picks from .vs file to actual trace/source geometry.
+    
+    VS files store shot positions and absolute geophone positions.
+    
+    Parameters
+    ----------
+    vs_picks_data : dict
+        Dictionary returned by read_vs_file()
+    trace_positions : list of arrays
+        Actual trace positions in dataset
+    source_positions : list
+        Actual source positions in dataset
+    offset_tolerance : float, optional
+        Tolerance for matching offsets in meters, default 0.5
+    position_scale : float, optional
+        Scaling factor to apply to VS positions (VS_pos * scale = actual_pos), default 1.0
+    verbose : bool, optional
+        Print debug information, default False
+    
+    Returns
+    -------
+    dict
+        Dictionary containing:
+        - 'picks': 2D list [source][trace] of matched pick times (NaN where no pick)
+        - 'errors': 2D list [source][trace] of matched errors (0.001 default)
+        - 'n_matched': Number of successfully matched picks
+        - 'n_total': Total picks in VS file
+        - 'unmatched_shots': List of shot positions that couldn't be matched
+    """
+    n_sources = len(source_positions)
+    n_traces_per_source = [len(tp) if tp is not None else 0 for tp in trace_positions]
+    
+    # Initialize pick and error arrays with NaN
+    matched_picks = [[np.nan] * n_traces for n_traces in n_traces_per_source]
+    matched_errors = [[0.001] * n_traces for n_traces in n_traces_per_source]
+    
+    n_matched = 0
+    n_total = vs_picks_data['n_picks']
+    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
+        scaled_geophone_position = geophone_position * position_scale
+        
+        # Find matching source by position
+        matched_source = None
+        min_source_dist = float('inf')
+        
+        for i_src, src_pos in enumerate(source_positions):
+            dist = abs(src_pos - scaled_shot_position)
+            if dist < min_source_dist:
+                min_source_dist = dist
+                if dist <= offset_tolerance:
+                    matched_source = i_src
+        
+        if matched_source is None:
+            if shot_position not in unmatched_shots:
+                unmatched_shots.add(shot_position)  # Store original position
+                if shot_position not in unmatched_details:
+                    unmatched_details[shot_position] = {
+                        'scaled_position': scaled_shot_position,
+                        'min_dist': min_source_dist,
+                        'closest_source': source_positions[np.argmin(np.abs(source_positions - scaled_shot_position))],
+                        'n_picks': 0
+                    }
+                unmatched_details[shot_position]['n_picks'] += 1
+            continue
+        
+        # Find matching trace by geophone position
+        if trace_positions[matched_source] is None:
+            continue
+        
+        matched_trace = None
+        min_trace_dist = float('inf')
+        
+        for i_tr, tr_pos in enumerate(trace_positions[matched_source]):
+            dist = abs(tr_pos - scaled_geophone_position)
+            if dist < min_trace_dist and dist <= offset_tolerance:
+                min_trace_dist = dist
+                matched_trace = i_tr
+        
+        if matched_trace is not None:
+            # Convert time to seconds if in milliseconds
+            time_seconds = time / 1000.0 if time > 1.0 else time
+            matched_picks[matched_source][matched_trace] = time_seconds
+            n_matched += 1
+    
+    if verbose:
+        print(f"\nMatched {n_matched}/{n_total} picks ({n_matched*100.0/n_total:.1f}%)")
+        if unmatched_shots:
+            print(f"Unmatched shots: {len(unmatched_shots)}")
+            # Show first 10 unmatched shots with details
+            for i, shot_pos in enumerate(sorted(unmatched_shots)[:10]):
+                if shot_pos in unmatched_details:
+                    details = unmatched_details[shot_pos]
+                    print(f"  Shot {shot_pos} (scaled: {details['scaled_position']:.2f}m) - "
+                          f"closest source: {details['closest_source']:.2f}m, "
+                          f"distance: {details['min_dist']:.2f}m, "
+                          f"picks: {details['n_picks']}")
+            if len(unmatched_shots) > 10:
+                print(f"  ... and {len(unmatched_shots) - 10} more")
+    
+    return {
+        'picks': matched_picks,
+        'errors': matched_errors,
+        'n_matched': n_matched,
+        'n_total': n_total,
+        'unmatched_shots': sorted(list(unmatched_shots))
+    }
+
+
+def read_lst_file(lst_file, verbose=False):
+    """
+    Read Rayfract .LST file and parse first break picks.
+    
+    LST file format:
+    - Header lines (ignored until data starts)
+    - Data lines: shot_no trace pos. time synthetic
+    - Time of -1.000 indicates no pick
+    
+    Parameters
+    ----------
+    lst_file : str
+        Path to .LST file
+    verbose : bool, optional
+        Print debug information, default False
+    
+    Returns
+    -------
+    dict
+        Dictionary containing:
+        - 'picks': list of (shot_no, trace_no, position, time) tuples
+        - 'n_picks': int (number of valid picks, excluding -1.000)
+        - 'shots': list of unique shot numbers
+        - 'traces_per_shot': dict mapping shot_no to list of (trace_no, position, time) tuples
+    """
+    picks = []
+    traces_per_shot = {}
+    shots = []
+    
+    with open(lst_file, 'r') as f:
+        # Skip header lines until we find data
+        # Data starts when we see lines matching the pattern: integer integer float float
+        for line in f:
+            line = line.strip()
+            
+            # Skip empty lines and comments
+            if not line or line.startswith('#'):
+                continue
+            
+            # Try to parse as data line
+            parts = line.split()
+            if len(parts) >= 4:
+                try:
+                    shot_no = int(parts[0])
+                    trace_no = int(parts[1])
+                    position = float(parts[2])
+                    time = float(parts[3])
+                    # synthetic = float(parts[4]) if len(parts) > 4 else None  # Optional synthetic time
+                    
+                    # Skip picks marked as invalid (-1.000)
+                    if time > 0:  # Valid pick
+                        picks.append((shot_no, trace_no, position, time))
+                        
+                        # Organize by shot
+                        if shot_no not in traces_per_shot:
+                            traces_per_shot[shot_no] = []
+                            shots.append(shot_no)
+                        traces_per_shot[shot_no].append((trace_no, position, time))
+                    
+                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),
+        'shots': sorted(shots),
+        'traces_per_shot': traces_per_shot
+    }
+
+
+def match_lst_picks_to_geometry(lst_picks_data, trace_positions, source_positions,
+                                 shot_number_offset=0, position_tolerance=0.1,
+                                 position_scale=1.0, verbose=False):
+    """
+    Match picks from LST file to actual trace/source geometry.
+    
+    LST files contain shot number, trace number, and position information.
+    This function matches based on:
+    1. Shot number -> source index (with optional offset)
+    2. Trace position -> actual trace position (within tolerance)
+    
+    Parameters
+    ----------
+    lst_picks_data : dict
+        Dictionary returned by read_lst_file()
+    trace_positions : list of arrays
+        Actual trace positions in dataset
+    source_positions : list
+        Actual source positions in dataset
+    shot_number_offset : int, optional
+        Offset to apply to shot numbers (LST shot 1 = dataset shot 1+offset), default 0
+    position_tolerance : float, optional
+        Tolerance for matching trace positions in meters, default 0.1
+    position_scale : float, optional
+        Scaling factor to apply to LST positions (LST_pos * scale = actual_pos), default 1.0
+    verbose : bool, optional
+        Print debug information, default False
+    
+    Returns
+    -------
+    dict
+        Dictionary containing:
+        - 'picks': 2D list [source][trace] of matched pick times (NaN where no pick)
+        - 'errors': 2D list [source][trace] of matched errors (0.001 default)
+        - 'n_matched': Number of successfully matched picks
+        - 'n_total': Total picks in LST file
+        - 'unmatched_shots': List of shot numbers that couldn't be matched
+        - 'unmatched_positions': List of (shot, position) that couldn't be matched
+    """
+    n_sources = len(source_positions)
+    n_traces_per_source = [len(tp) if tp is not None else 0 for tp in trace_positions]
+    
+    # Initialize pick and error arrays with NaN
+    matched_picks = [[np.nan] * n_traces for n_traces in n_traces_per_source]
+    matched_errors = [[0.001] * n_traces for n_traces in n_traces_per_source]  # Default error 1ms
+    
+    n_matched = 0
+    n_total = lst_picks_data['n_picks']
+    unmatched_shots = set()
+    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
+        
+        # Check if source index is valid
+        if source_idx < 0 or source_idx >= n_sources:
+            if shot_no not in unmatched_shots:
+                unmatched_shots.add(shot_no)
+                if shot_no not in unmatched_shot_details:
+                    unmatched_shot_details[shot_no] = f"out of range [0, {n_sources-1}]"
+            continue
+        
+        # Find matching trace by position
+        if trace_positions[source_idx] is None:
+            if shot_no not in unmatched_shot_details:
+                unmatched_shot_details[shot_no] = "no trace positions for this shot"
+            continue
+        
+        # Apply position scaling
+        scaled_position = position * position_scale
+        
+        matched_trace = None
+        min_distance = float('inf')
+        
+        for i_tr, tr_pos in enumerate(trace_positions[source_idx]):
+            dist = abs(tr_pos - scaled_position)
+            if dist < min_distance and dist <= position_tolerance:
+                min_distance = dist
+                matched_trace = i_tr
+        
+        if matched_trace is not None:
+            # Convert milliseconds to seconds if needed
+            time_seconds = time / 1000.0 if time > 1.0 else time
+            matched_picks[source_idx][matched_trace] = time_seconds
+            n_matched += 1
+        else:
+            unmatched_positions.append((shot_no, position))
+            # Track which traces are available for this shot
+            if shot_no not in unmatched_shot_details:
+                available_positions = trace_positions[source_idx] if trace_positions[source_idx] is not None else []
+                if len(available_positions) > 0:
+                    min_avail = min(available_positions)
+                    max_avail = max(available_positions)
+                    unmatched_shot_details[shot_no] = f"scaled pos {scaled_position:.1f}m (LST: {position:.1f}m) not in [{min_avail:.1f}, {max_avail:.1f}]m"
+                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,
+        'n_matched': n_matched,
+        'n_total': n_total,
+        'unmatched_shots': sorted(unmatched_shots),
+        'unmatched_positions': unmatched_positions
+    }

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

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

@@ -1,25 +1,25 @@
-pyckster/__init__.py,sha256=uMDTvad1_QktTO-D059x7iGtIUeWegaW6BIdSfRIqsM,905
+pyckster/__init__.py,sha256=pRpWyxN9aZ3Nc5qVhA9bc8VURQUWwwBmecGxfD_wVws,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=6q1mUorJmTJHs_eUM1Kcdz7Iw-z3X89I9ks4OnuxWUo,1146176
+pyckster/core.py,sha256=Sxyw0_ZtaDKgkGw6SarNM5_wgUgda4ishril3x0UlRA,1208902
 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=01fNI9ryIYuiGOl4NR0J9C_xXupcnsBb1mLSz1Qo63A,20569
-pyckster/pick_io.py,sha256=1svAzh1g73zEsjHnIy1ruEOrCC-vVMQnicXim3oWFa0,18027
+pyckster/obspy_utils.py,sha256=Me8j6FHIEQgx2GH0phEcg1t7TOpGKpyLl_AwmCRnDak,21943
+pyckster/pick_io.py,sha256=-oDMR054tBep8STi9pYTIxc7qJEIPbnbTkhiWFK5Ems,38666
 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.1.5.dist-info/licenses/LICENCE,sha256=-uaAIm20JrJKoMdCdn2GlFQfNU4fbsHWK3eh4kIQ_Ec,35143
-pyckster-26.1.5.dist-info/METADATA,sha256=gbenYr4NMbBnA1PSKibKwDnW0SP7WCfz8d_40RkFr6I,4567
-pyckster-26.1.5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-pyckster-26.1.5.dist-info/entry_points.txt,sha256=yrOQx1wHi84rbxX_ZYtYaVcK3EeuRhHRQDZRc8mB0NI,100
-pyckster-26.1.5.dist-info/top_level.txt,sha256=eaihhwhEmlysgdZE4HmELFdSUwlXcMv90YorkjOXujQ,9
-pyckster-26.1.5.dist-info/RECORD,,
+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,,