ephem 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86c850bd01f5699f6605f878ef9a6ce0a35fcce89e3b0ac0fdfeaf1b39872c2c
-  data.tar.gz: 3e9342db922833b977bf78acdde7616c985b5d12e28c84d1189db2747136eeb3
+  metadata.gz: 24301ad81a75b670a87dd1b33e7d8c84e9e2bd9bd007e5d6f3564dbdc5d387ae
+  data.tar.gz: b6c16db80b49173c1aea2853774c2c1fb81bc0513d0273bb1f5564fd2043109c
 SHA512:
-  metadata.gz: 3cebca5c4f487ef0cdda0a68c564db90674c14fccbef232e0b16c6d87b7ce0a603a6d9fede22180d1de2dd8da82f4040ea3f3e5ce22e40c0718012289357413c
-  data.tar.gz: 9801e2dbc8a41bb9f38dc39cfcf827e69fee9ed4490d1aa426c8a951980cc28d31ca20eb3f462dabefa944667cf6906e3df093826645d3fe050229b6544f3f10
+  metadata.gz: 28e9df83433cb9a338197c1911cf136147c05b22909932ed591ce6512be2d58304c182947cc8232437f65342c2ac2d600329fdde648b9378d63ba0770ef724a6
+  data.tar.gz: 4d1a96e724299ecd9c220283807eb47312ea7134698d9cffd31edb1d3be716add8da1af15b831246066ad2cd894c6249d185c3bf8bec87c2b525c931ff3b4a70

data/CHANGELOG.md

@@ -1,4 +1,47 @@
-## [Unreleased]
+# Changelog
+
+## [0.2.0] - 2025-03-28
+
+### Features
+
+* Simplify download ([#12])
+* SPK excerpt generator ([#13])
+* Improve documentation on excerpts ([#16])
+* IMCCE INPOP support ([#20])
+
+### Improvements
+
+* Add Dependabot ([#6])
+* Replace testing kernel ([#17])
+* Add `irb` to dev dependencies ([#14])
+* Add support for Rubies `3.2.7` and `3.4.2` ([#15])
+* Bump csv from 3.3.0 to 3.3.2 by @dependabot ([#7])
+* Bump standard from 1.43.0 to 1.44.0 by @dependabot ([#8])
+* Bump standard from 1.44.0 to 1.45.0 by @dependabot ([#9])
+* Bump csv from 3.3.2 to 3.3.3 by @dependabot ([#11])
+* Bump standard from 1.45.0 to 1.47.0 by @dependabot ([#10])
+* Bump json from 2.10.1 to 2.10.2 by @dependabot ([#18])
+
+### New Contributors
+
+* @dependabot made their first contribution in [#7]
+
+**Full Changelog**: https://github.com/rhannequin/ruby-ephem/compare/v0.1.0...v0.2.0
+
+[#6]: https://github.com/rhannequin/ruby-ephem/pull/6
+[#7]: https://github.com/rhannequin/ruby-ephem/pull/7
+[#8]: https://github.com/rhannequin/ruby-ephem/pull/8
+[#9]: https://github.com/rhannequin/ruby-ephem/pull/9
+[#10]: https://github.com/rhannequin/ruby-ephem/pull/10
+[#11]: https://github.com/rhannequin/ruby-ephem/pull/11
+[#12]: https://github.com/rhannequin/ruby-ephem/pull/12
+[#13]: https://github.com/rhannequin/ruby-ephem/pull/13
+[#14]: https://github.com/rhannequin/ruby-ephem/pull/14
+[#15]: https://github.com/rhannequin/ruby-ephem/pull/15
+[#16]: https://github.com/rhannequin/ruby-ephem/pull/16
+[#17]: https://github.com/rhannequin/ruby-ephem/pull/17
+[#18]: https://github.com/rhannequin/ruby-ephem/pull/18
+[#20]: https://github.com/rhannequin/ruby-ephem/pull/20
 
 ## [0.1.0] - 2025-01-01
 

data/README.md

@@ -1,15 +1,21 @@
 # Ephem
 
-Ephem is a Ruby gem that provides a simple interface to the JPL Development
-Ephemeris (DE) series as SPICE binary kernel files. The DE series is a
-collection of numerical integrations of the equations of motion of the solar
-system, used to calculate the positions of the planets, the Moon, and other
-celestial bodies with high precision.
+Ephem is a Ruby gem that provides a simple interface to the SPICE binary kernel
+files such as:
+* _JPL [Development Ephemeris]_ (DE)
+* _IMCCE [Intégrateur numérique planétaire de l'Observatoire de Paris]_ (INPOP)
 
-Ephem currently only support planetary ephemerides like DE405, DE421, de430,
-etc.
+[Development Ephemeris]: https://ssd.jpl.nasa.gov/planets/eph_export.html
+[Intégrateur numérique planétaire de l'Observatoire de Paris]: https://www.imcce.fr/inpop
 
-The library in high development mode and does not have a stable version yet.
+These files are a collection of numerical integrations of the equations of
+motion of the Solar System, used to calculate the positions of the planets,
+the Moon, and other celestial bodies with high precision.
+
+Ephem currently only support planetary ephemerides like DE421, DE430,
+INPOP19A, etc.
+
+The library is in high development mode and does not have a stable version yet.
 The API is subject to major changes at the moment, please keep that in mind if
 you consider adding this gem as a dependency.
 
@@ -28,14 +34,21 @@ executing:
 gem install ephem
 ```
 
+## How to select the right kernel file
+
+JPL and IMCCE produces many different kernels over the years, with different
+accuracy and ranges of supported years. Here are some that we would recommend to
+begin with:
+
+* `de421.bsp`: from 1900 to 2050, 17 MB
+* `de440s.bsp`: from 1849 to 2150, 32 MB
+* `inpop19a.bsp`: from 1900 to 2100, 22 MB
+
 ## Usage
 
 ```rb
 # Download and store the SPICE binary kernel file
-Ephem::IO::Download.call(
-  name: "de421.bsp",
-  target: "tmp/de421.bsp"
-)
+Ephem::Download.call(name: "de421.bsp", target: "tmp/de421.bsp")
 
 # Load the kernel
 spk = Ephem::SPK.open("tmp/de421.bsp")
@@ -86,6 +99,28 @@ puts "Velocity: #{state.velocity}"
 # The velocity is expressed in km/day
 ```
 
+## CLI
+
+The gem also provides a CLI to generate an excerpt from an original kernel file.
+
+```bash
+ruby-ephem excerpt [options] START_DATE END_DATE INPUT_FILE OUTPUT_FILE
+```
+
+For example, generate an excerpt from DE440s for the year 2025 only supporting
+the Sun, the Earth, the Moon and the Earth-Moon Barycenter:
+
+```bash
+ruby-ephem excerpt --targets 3,10,301,399 2025-01-01 2026-01-01 /path/to/de440s.bsp 2025_excerpt.bsp
+```
+
+While DE440s originally supports 14 segments from 1849 to 2150 with a size of
+32 MB, the excerpt will only support 4 segments from 2025 to 2026 with a size of
+140 KB.
+
+Not only the excerpt is smaller, but most importantly it is way more
+efficient to parse and to use in your application.
+
 ## Accuracy
 
 Data from this library has been tested against the Python library [jplephem]

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "ephem"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require "irb"
+IRB.start(__FILE__)

data/bin/ruby-ephem

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Add the lib directory to the load path
+lib = File.expand_path("../lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "ephem"
+require "ephem/cli"
+
+# Run the CLI
+Ephem::CLI.start(ARGV)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/ephem/cli.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "date"
+
+module Ephem
+  class CLI
+    def self.gregorian_to_julian(date_str)
+      date = Date.parse(date_str)
+
+      a = (14 - date.month) / 12
+      y = date.year + 4800 - a
+      m = date.month + 12 * a - 3
+
+      date.day +
+        ((153 * m + 2) / 5) +
+        365 * y +
+        (y / 4) -
+        (y / 100) +
+        (y / 400) -
+        32045
+    end
+
+    def self.start(args)
+      if args.empty?
+        puts "Usage: ruby-ephem excerpt [options] START_DATE END_DATE INPUT_FILE OUTPUT_FILE"
+        puts "For help: ruby-ephem help"
+        return
+      end
+
+      if args[0] == "help"
+        show_help
+        return
+      end
+
+      if args[0] == "excerpt"
+        handle_excerpt(args[1..])
+        return
+      end
+
+      puts "Unknown command: #{args[0]}"
+      puts "Available commands: excerpt, help"
+    end
+
+    def self.show_help
+      puts <<~HELP
+        Ruby Ephem - A tool for working with JPL Ephemerides
+
+        Commands:
+          excerpt - Create an excerpt of an SPK file
+          help    - Show this help message
+
+        Excerpt command:
+          ruby-ephem excerpt [options] START_DATE END_DATE INPUT_FILE OUTPUT_FILE
+
+        Options:
+          --targets TARGET_IDS  - Comma-separated list of target IDs to include
+                                  (default: all targets)
+
+        Example:
+          ruby-ephem excerpt --targets 3,10,399 2000-01-01 2030-01-01 de440s.bsp excerpt.bsp
+
+        This will create an excerpt of de440s.bsp containing only the specified
+        targets (Earth-Moon barycenter, Sun, Earth) for the period from
+        2000-01-01 to 2030-01-01.
+      HELP
+    end
+
+    # Handle the excerpt command
+    def self.handle_excerpt(args)
+      # Parse options
+      options = {target_ids: nil, debug: false}
+
+      option_parser = OptionParser.new do |opts|
+        opts.banner = "Usage: ruby-ephem excerpt [options] START_DATE END_DATE INPUT_FILE OUTPUT_FILE"
+
+        opts.on("--targets TARGET_IDS", "Comma-separated list of target IDs to include") do |targets|
+          options[:target_ids] = targets.split(",").map(&:strip).map(&:to_i)
+        end
+
+        opts.on("--debug", "Enable debug output") do
+          options[:debug] = true
+        end
+      end
+
+      begin
+        option_parser.parse!(args)
+      rescue OptionParser::InvalidOption => e
+        puts e.message
+        puts option_parser
+        return
+      end
+
+      if args.size < 4
+        puts "Not enough arguments."
+        puts option_parser
+        return
+      end
+
+      start_date_str = args[0]
+      end_date_str = args[1]
+      input_file = args[2]
+      output_file = args[3]
+
+      unless File.exist?(input_file)
+        puts "Error: Input file '#{input_file}' does not exist."
+        return
+      end
+
+      begin
+        start_jd = gregorian_to_julian(start_date_str)
+        end_jd = gregorian_to_julian(end_date_str)
+      rescue Date::Error => e
+        puts "Error parsing dates: #{e.message}"
+        puts "Dates should be in YYYY-MM-DD format."
+        return
+      end
+
+      begin
+        puts "Creating excerpt from #{input_file} to #{output_file}..."
+        puts "Date range: #{start_date_str} to #{end_date_str} (JD #{start_jd} to #{end_jd})"
+        if options[:target_ids]
+          puts "Including targets: #{options[:target_ids].join(", ")}"
+        else
+          puts "Including all targets"
+        end
+
+        spk = Ephem::SPK.open(input_file)
+
+        excerpt_spk = spk.excerpt(
+          output_path: output_file,
+          start_jd: start_jd,
+          end_jd: end_jd,
+          target_ids: options[:target_ids],
+          debug: options[:debug]
+        )
+
+        puts "Excerpt created successfully!"
+        puts "Original segments: #{spk.segments.size}"
+        puts "Excerpt segments: #{excerpt_spk.segments.size}"
+
+        original_size = File.size(input_file)
+        excerpt_size = File.size(output_file)
+        reduction_percentage =
+          ((original_size - excerpt_size) / original_size.to_f * 100).round(2)
+
+        puts "File size reduced by #{reduction_percentage}%"
+        puts "Original: #{original_size} bytes"
+        puts "Excerpt: #{excerpt_size} bytes"
+
+        spk.close
+        excerpt_spk.close
+      rescue => e
+        puts "Error creating excerpt: #{e.message}"
+        puts e.backtrace if options[:debug]
+      end
+    end
+  end
+end

data/lib/ephem/download.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "minitar"
+require "net/http"
+require "tempfile"
+require "zlib"
+
+module Ephem
+  class Download
+    JPL_BASE_URL = "https://ssd.jpl.nasa.gov/ftp/eph/planets/bsp/"
+    IMCCE_BASE_URL = "https://ftp.imcce.fr/pub/ephem/planets/"
+
+    JPL_KERNELS = %w[
+      de102.bsp
+      de200.bsp
+      de202.bsp
+      de403.bsp
+      de405.bsp
+      de405_1960_2020.bsp
+      de406.bsp
+      de410.bsp
+      de413.bsp
+      de414.bsp
+      de418.bsp
+      de421.bsp
+      de422.bsp
+      de422_1850_2050.bsp
+      de423.bsp
+      de424.bsp
+      de424s.bsp
+      de425.bsp
+      de430_1850-2150.bsp
+      de430_plus_MarsPC.bsp
+      de430t.bsp
+      de431.bsp
+      de432t.bsp
+      de433.bsp
+      de433_plus_MarsPC.bsp
+      de433t.bsp
+      de434.bsp
+      de434s.bsp
+      de434t.bsp
+      de435.bsp
+      de435s.bsp
+      de435t.bsp
+      de436.bsp
+      de436s.bsp
+      de436t.bsp
+      de438.bsp
+      de438_plus_MarsPC.bsp
+      de438s.bsp
+      de438t.bsp
+      de440.bsp
+      de440s.bsp
+      de440s_plus_MarsPC.bsp
+      de440t.bsp
+      de441.bsp
+    ].freeze
+
+    IMCCE_KERNELS = {
+      "inpop10b.bsp" => "inpop10b_TDB_m100_p100_spice.bsp",
+      "inpop10b_large.bsp" => "inpop10b_TDB_m1000_p1000_spice.bsp",
+      "inpop10e.bsp" => "inpop10e_TDB_m100_p100_spice.bsp",
+      "inpop10e_large.bsp" => "inpop10e_TDB_m1000_p1000_spice.bsp",
+      "inpop13c.bsp" => "inpop13c_TDB_m100_p100_spice.bsp",
+      "inpop13c_large.bsp" => "inpop13c_TDB_m1000_p1000_spice.bsp",
+      "inpop17a.bsp" => "inpop17a_TDB_m100_p100_spice.bsp",
+      "inpop17a_large.bsp" => "inpop17a_TDB_m1000_p1000_spice.bsp",
+      "inpop19a.bsp" => "inpop19a_TDB_m100_p100_spice.bsp",
+      "inpop19a_large.bsp" => "inpop19a_TDB_m1000_p1000_spice.bsp",
+      "inpop21a.bsp" => "inpop21a_TDB_m100_p100_spice.bsp",
+      "inpop21a_large.bsp" => "inpop21a_TDB_m1000_p1000_spice.bsp"
+    }.freeze
+
+    IMCCE_KERNELS_MATCHING = {
+      "inpop10b.bsp" => "inpop10b/inpop10b_TDB_m100_p100_spice.tar.gz",
+      "inpop10b_large.bsp" => "inpop10b/inpop10b_TDB_m1000_p1000_spice.tar.gz",
+      "inpop10e.bsp" => "inpop10e/inpop10e_TDB_m100_p100_spice_release2.tar.gz",
+      "inpop10e_large.bsp" =>
+        "inpop10e/inpop10e_TDB_m1000_p1000_spice_release2.tar.gz",
+      "inpop13c.bsp" => "inpop13c/inpop13c_TDB_m100_p100_spice.tar.gz",
+      "inpop13c_large.bsp" => "inpop13c/inpop13c_TDB_m1000_p1000_spice.tar.gz",
+      "inpop17a.bsp" => "inpop17a/inpop17a_TDB_m100_p100_spice.tar.gz",
+      "inpop17a_large.bsp" => "inpop17a/inpop17a_TDB_m1000_p1000_spice.tar.gz",
+      "inpop19a.bsp" => "inpop19a/inpop19a_TDB_m100_p100_spice.tar.gz",
+      "inpop19a_large.bsp" => "inpop19a/inpop19a_TDB_m1000_p1000_spice.tar.gz",
+      "inpop21a.bsp" => "inpop21a/inpop21a_TDB_m100_p100_spice.tar.gz",
+      "inpop21a_large.bsp" => "inpop21a/inpop21a_TDB_m1000_p1000_spice.tar.gz"
+    }.freeze
+
+    SUPPORTED_KERNELS = (JPL_KERNELS + IMCCE_KERNELS.keys).freeze
+
+    def self.call(name:, target:)
+      new(name, target).call
+    end
+
+    def initialize(name, local_path)
+      @name = name
+      @local_path = local_path
+      validate_requested_kernel!
+    end
+
+    def call
+      content = jpl_kernel? ? download_from_jpl : download_from_imcce
+      File.write(@local_path, content)
+
+      true
+    end
+
+    private
+
+    def validate_requested_kernel!
+      unless SUPPORTED_KERNELS.include?(@name)
+        raise UnsupportedError,
+          "Kernel #{@name} is not supported by the library at the moment."
+      end
+    end
+
+    def jpl_kernel?
+      JPL_KERNELS.include?(@name)
+    end
+
+    def download_from_jpl
+      uri = URI("#{JPL_BASE_URL}#{@name}")
+      Net::HTTP.get(uri)
+    end
+
+    def download_from_imcce
+      temp_file = Tempfile.new(%w[archive .tar.gz])
+      uri = URI("#{IMCCE_BASE_URL}#{IMCCE_KERNELS_MATCHING[@name]}")
+      content = Net::HTTP.get(uri)
+      temp_file.write(content)
+      temp_file.rewind
+
+      Zlib::GzipReader.open(temp_file.path) do |gz|
+        Minitar::Reader.open(gz) do |tar|
+          tar.each_entry do |entry|
+            return entry.read if entry.full_name == IMCCE_KERNELS[@name]
+          end
+        end
+      end
+    ensure
+      temp_file.close
+      temp_file.unlink
+    end
+  end
+end

data/lib/ephem/excerpt.rb

@@ -0,0 +1,382 @@
+# frozen_string_literal: true
+
+module Ephem
+  # The Excerpt class creates SPK file excerpts with reduced time spans and
+  # target bodies. This is useful for creating smaller files that focus only on
+  # the data needed for specific applications.
+  #
+  # @example Create an excerpt with specific time range and bodies
+  #   spk = Ephem::SPK.open("de421.bsp")
+  #   excerpt = Ephem::Excerpt.new(spk).extract(
+  #     output_path: "excerpt.bsp",
+  #     start_jd: 2458849.5,           # January 1, 2020
+  #     end_jd: 2459580.5,             # December 31, 2021
+  #     target_ids: [3, 10, 301, 399]  # Earth-Moon, Sun, Moon, Earth
+  #   )
+  class Excerpt
+    # Constants for time calculations
+    S_PER_DAY = Core::Constants::Time::SECONDS_PER_DAY
+    J2000_EPOCH = Core::Constants::Time::J2000_EPOCH
+    RECORD_SIZE = 1024
+
+    # @param spk [Ephem::SPK] The SPK object to create an excerpt from
+    def initialize(spk)
+      @spk = spk
+      @daf = spk.instance_variable_get(:@daf)
+      @binary_reader = @daf.instance_variable_get(:@binary_reader)
+    end
+
+    # Creates an excerpt of the SPK file
+    #
+    # @param output_path [String] Path where the excerpt will be written
+    # @param start_jd [Float] Start time as Julian Date
+    # @param end_jd [Float] End time as Julian Date
+    # @param target_ids [Array<Integer>, nil] Optional list of target IDs to
+    #   include
+    # @param debug [Boolean] Whether to print debug information
+    #
+    # @return [Ephem::SPK] A new SPK instance for the excerpt file
+    def extract(output_path:, start_jd:, end_jd:, target_ids: nil, debug: false)
+      start_seconds = seconds_since_j2000(start_jd)
+      end_seconds = seconds_since_j2000(end_jd)
+      output_file = File.open(output_path, "wb+")
+      copy_file_header(output_file)
+      initialize_summary_section(output_file)
+      writer = create_daf_writer(output_file, debug)
+      process_segments(writer, start_seconds, end_seconds, target_ids, debug)
+      output_file.close
+
+      SPK.open(output_path)
+    end
+
+    private
+
+    def seconds_since_j2000(jd)
+      (jd - J2000_EPOCH) * S_PER_DAY
+    end
+
+    def copy_file_header(output_file)
+      # Get the first record number of summaries from original DAF
+      fward = @daf.record_data.forward_record
+
+      # Copy file record and comments
+      (1...fward).each do |n|
+        data = @binary_reader.read_record(n)
+        output_file.write(data)
+      end
+    end
+
+    def initialize_summary_section(output_file)
+      summary_data = "\0".ljust(RECORD_SIZE, "\0")
+      name_data = " ".ljust(RECORD_SIZE, "\0")
+      output_file.write(summary_data)
+      output_file.write(name_data)
+    end
+
+    def create_daf_writer(output_file, debug)
+      writer = DAFWriter.new(output_file, debug)
+      fward = @daf.record_data.forward_record
+      writer.fward = writer.bward = fward
+      writer.free = (fward + 1) * (RECORD_SIZE / 8) + 1
+      writer.endianness = @daf.endianness
+      writer.setup_formats(
+        @daf.record_data.double_count,
+        @daf.record_data.integer_count
+      )
+      writer.write_file_record
+
+      writer
+    end
+
+    def process_segments(writer, start_seconds, end_seconds, target_ids, debug)
+      segments_processed = 0
+      segments_included = 0
+
+      # Get all summaries from the original DAF
+      @daf.summaries.each do |name, values|
+        segments_processed += 1
+
+        # Filter by target ID if specified
+        if target_ids && !target_ids.empty?
+          # The target ID is at index 2 in the summary values
+          target_id = values[2].to_i
+
+          unless target_ids.include?(target_id)
+            if debug
+              puts "Segment #{segments_processed} (#{name}):"
+              puts "Target ID #{target_id} not in requested list, skipping"
+            end
+
+            next
+          end
+        end
+
+        # Extract segment data
+        if extract_segment(
+          writer,
+          name,
+          values,
+          start_seconds,
+          end_seconds,
+          segments_processed,
+          debug
+        )
+          segments_included += 1
+        end
+      end
+
+      if debug
+        puts "Summary:"
+        puts "Processed #{segments_processed} segments,"
+        puts "included #{segments_included} in the excerpt"
+      end
+    end
+
+    def extract_segment(
+      writer,
+      name,
+      values,
+      start_seconds,
+      end_seconds,
+      segment_index,
+      debug
+    )
+      # Get start and end positions of the segment in the file
+      start_pos, end_pos = values[-2], values[-1]
+
+      if debug
+        puts "Processing segment #{segment_index} (#{name}):"
+        puts "start=#{start_pos}, end=#{end_pos}"
+      end
+
+      # Read the metadata from the end of the array
+      init, intlen, rsize, n = @daf.read_array(end_pos - 3, end_pos)
+      rsize = rsize.to_i
+
+      if debug
+        puts "  Metadata: init=#{init}, intlen=#{intlen}, rsize=#{rsize}, n=#{n}"
+      end
+
+      # Calculate which portion of the data to extract based on the date range
+      i = clip(0, n, ((start_seconds - init) / intlen)).to_i
+      j = clip(0, n, ((end_seconds - init) / intlen + 1)).to_i
+
+      puts "  Date range: i=#{i}, j=#{j} out of n=#{n}" if debug
+
+      # Skip if no overlap with requested date range
+      if i == j
+        if debug
+          puts "Segment #{segment_index} (#{name}):"
+          puts "No overlap with requested date range"
+        end
+
+        return false
+      end
+
+      # Update initial time and number of records
+      init += i * intlen
+      n = j - i
+
+      puts "  New metadata: init=#{init}, n=#{n}" if debug
+
+      # Extract the relevant portion of the data
+      extra = 4  # Enough space for the metadata: [init intlen rsize n]
+      excerpt_start = start_pos + rsize * i
+      excerpt_end = start_pos + rsize * j + extra - 1
+
+      puts "  Reading array from #{excerpt_start} to #{excerpt_end}" if debug
+
+      excerpt = @daf.read_array(excerpt_start, excerpt_end)
+
+      puts "  Read #{excerpt.length} values" if debug
+
+      # Update the metadata in the excerpt
+      excerpt[-4..-1] = [init, intlen, rsize, n]
+
+      new_values = if values.length >= 2
+        [init, init + n * intlen] + values[2...-2]
+      else
+        [init, init + n * intlen]
+      end
+
+      puts "  New values: #{new_values.inspect}" if debug
+
+      # Add the extracted array to the output file
+      # Modify the name to indicate it's an excerpt (X prefix)
+      writer.add_array(
+        "X#{name[1..]}".force_encoding("ASCII-8BIT"),
+        new_values,
+        excerpt
+      )
+
+      if debug
+        puts "Segment #{segment_index} (#{name}):"
+        puts "Included in excerpt (#{i} to #{j} of #{n})"
+      end
+
+      true
+    rescue => e
+      puts "Error processing segment #{segment_index} (#{name}): #{e.message}"
+      puts e.backtrace.join("\n") if debug
+      false
+    end
+
+    # Clips a value between lower and upper bounds
+    def clip(lower, upper, n)
+      n.clamp(lower, upper)
+    end
+
+    # Helper class for writing DAF files
+    # This class handles the low-level details of DAF file format
+    class DAFWriter
+      attr_reader :file
+      attr_accessor :fward,
+        :bward,
+        :free,
+        :endianness,
+        :double_format,
+        :int_format,
+        :nd,
+        :ni,
+        :summary_format,
+        :summary_control_format,
+        :summary_length,
+        :summary_step,
+        :summaries_per_record
+
+      def initialize(file, debug = false)
+        @file = file
+        @debug = debug
+        @mutex = Mutex.new
+      end
+
+      def setup_formats(nd, ni)
+        @nd = nd
+        @ni = ni
+
+        # Double is always 8 bytes, int is always 4 bytes
+        double_size = 8
+        int_size = 4
+
+        # Set formats based on endianness
+        if @endianness == :little
+          @double_format = "E"  # Little-endian double
+          @int_format = "l"     # Little-endian signed long (32-bit)
+        else
+          @double_format = "G"  # Big-endian double
+          @int_format = "l>"    # Big-endian signed long (32-bit)
+        end
+
+        # Create formats for summary structures
+        @summary_control_format =
+          "#{@double_format}#{@double_format}#{@double_format}"
+        @summary_format = @double_format.to_s * @nd + @int_format.to_s * @ni
+
+        # Calculate segment summary sizes
+        @summary_length = double_size * @nd + int_size * @ni
+
+        # Pad to 8 bytes
+        @summary_step = @summary_length + (-@summary_length % 8)
+
+        @summaries_per_record = (RECORD_SIZE - 8 * 3) / @summary_step
+      end
+
+      def write_file_record
+        @file.seek(0)
+        data = @file.read(RECORD_SIZE)
+
+        # Update pointers directly in the data buffer
+        fward_pos = 76
+        bward_pos = 80
+        free_pos = 84
+
+        if @endianness == :little
+          data[fward_pos, 4] = [@fward].pack("l")
+          data[bward_pos, 4] = [@bward].pack("l")
+          data[free_pos, 4] = [@free].pack("l")
+        else
+          data[fward_pos, 4] = [@fward].pack("N")
+          data[bward_pos, 4] = [@bward].pack("N")
+          data[free_pos, 4] = [@free].pack("N")
+        end
+
+        # Write the updated record back to the file
+        @file.seek(0)
+        @file.write(data)
+      end
+
+      def read_record(n)
+        @mutex.synchronize do
+          @file.seek(n * RECORD_SIZE - RECORD_SIZE)
+          @file.read(RECORD_SIZE)
+        end
+      end
+
+      def write_record(n, data)
+        @mutex.synchronize do
+          @file.seek(n * RECORD_SIZE - RECORD_SIZE)
+          @file.write(data)
+        end
+      end
+
+      def add_array(name, values, array)
+        record_number = @bward
+        data = read_record(record_number).dup
+
+        control_data = data[0, 24].unpack(@summary_control_format)
+        next_record = control_data[0].to_i
+        previous_record = control_data[1].to_i
+        n_summaries = control_data[2].to_i
+
+        if n_summaries < @summaries_per_record
+          # Add to the existing record
+          summary_record = record_number
+          data[0, 24] = [next_record, previous_record, n_summaries + 1]
+            .pack(@summary_control_format)
+          write_record(summary_record, data)
+        else
+          # Create a new record
+          summary_record = ((@free - 1) * 8 + 1023) / 1024 + 1
+          name_record = summary_record + 1
+          free_record = summary_record + 2
+
+          data[0, 24] = [summary_record, previous_record, n_summaries]
+            .pack(@summary_control_format)
+          write_record(record_number, data)
+
+          n_summaries = 0
+          summaries = [0, record_number, 1]
+            .pack(@summary_control_format)
+            .ljust(RECORD_SIZE, "\0")
+          names = " ".ljust(RECORD_SIZE, "\0")
+          write_record(summary_record, summaries)
+          write_record(name_record, names)
+
+          @bward = summary_record
+          @free = (free_record - 1) * RECORD_SIZE / 8 + 1
+        end
+
+        # Convert array to binary data
+        array_data = array.pack("#{@double_format}*")
+
+        start_word = @free
+        @file.seek((start_word - 1) * 8)
+        @file.write(array_data)
+        end_word = @file.tell / 8
+
+        @free = end_word + 1
+        write_file_record
+
+        # Using values up to nd+ni-2, then adding start_word and end_word
+        new_values = values[0, @nd + @ni - 2] + [start_word, end_word]
+
+        base = RECORD_SIZE * (summary_record - 1)
+        offset = n_summaries * @summary_step
+        @file.seek(base + 24 + offset)  # 24 is summary_control_struct size
+        @file.write(new_values.pack(@summary_format))
+        @file.seek(base + RECORD_SIZE + offset)
+        @file.write(name[0, @summary_length].ljust(@summary_step, " "))
+      end
+    end
+  end
+end

data/lib/ephem/segments/base_segment.rb

@@ -36,6 +36,8 @@ module Ephem
       attr_reader :target
       # @return [Integer] the center body ID
       attr_reader :center
+      # @return [String] the source of the segment
+      attr_reader :source
 
       # Initialize a new segment
       #

data/lib/ephem/spk.rb

@@ -15,7 +15,17 @@ module Ephem
   #   spk.close
   #
   class SPK
+    TYPES = [
+      INPOP = "IMCCE INPOP",
+      JPL_DE = "JPL DE"
+    ].freeze
+
+    INPOP_REGEXP = /^\s+\d{4}\.\d{5}0+$/
+    DE_REGEXP = /^[A-Z]E-(\d{4})LE-\1$/
+    DE_FILENAME = "NIO2SPK"
+
     DATA_TYPE_IDENTIFIER = 5
+    SEGMENT_CLASSES = {}
 
     attr_reader :segments, :pairs
 
@@ -77,6 +87,18 @@ module Ephem
       end
     end
 
+    # Type of SPK file to make the difference between JPL DE and IMCCE INPOP
+    #
+    # @return [String, nil] The type of the SPK file
+    def type
+      @type ||= if @daf.record_data.internal_filename.match?(INPOP_REGEXP)
+        INPOP
+      elsif @daf.record_data.internal_filename == DE_FILENAME ||
+          segments.first&.source&.match?(DE_REGEXP)
+        JPL_DE
+      end
+    end
+
     # Returns the comments stored in the SPK file.
     #
     # @return [String] The comments from the DAF file
@@ -96,6 +118,18 @@ module Ephem
       @segments.each(&block)
     end
 
+    def excerpt(output_path:, start_jd:, end_jd:, target_ids: nil, debug: false)
+      Excerpt
+        .new(self)
+        .extract(
+          output_path: output_path,
+          start_jd: start_jd,
+          end_jd: end_jd,
+          target_ids: target_ids,
+          debug: debug
+        )
+    end
+
     private
 
     def load_segments
@@ -115,7 +149,5 @@ module Ephem
       segment_class = SEGMENT_CLASSES.fetch(data_type, Segments::BaseSegment)
       segment_class.new(daf: @daf, source: source, descriptor: descriptor)
     end
-
-    SEGMENT_CLASSES = {}
   end
 end

data/lib/ephem/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ephem
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/ephem.rb

@@ -9,7 +9,7 @@ require_relative "ephem/core/vector"
 require_relative "ephem/error"
 require_relative "ephem/io/binary_reader"
 require_relative "ephem/io/daf"
-require_relative "ephem/io/download"
+require_relative "ephem/download"
 require_relative "ephem/io/endianness_manager"
 require_relative "ephem/io/record_data"
 require_relative "ephem/io/record_parser"
@@ -18,6 +18,8 @@ require_relative "ephem/spk"
 require_relative "ephem/segments/base_segment"
 require_relative "ephem/segments/registry"
 require_relative "ephem/segments/segment"
+require_relative "ephem/excerpt"
+require_relative "ephem/cli"
 require_relative "ephem/version"
 
 module Ephem

metadata

@@ -1,14 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: ephem
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Rémy Hannequin
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2025-01-13 00:00:00.000000000 Z
+date: 2025-04-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
 - !ruby/object:Gem::Dependency
   name: numo-narray
   requirement: !ruby/object:Gem::Requirement
@@ -23,6 +37,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.9.2.1
+- !ruby/object:Gem::Dependency
+  name: zlib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: csv
   requirement: !ruby/object:Gem::Requirement
@@ -37,6 +65,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: irb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
 - !ruby/object:Gem::Dependency
   name: parallel
   requirement: !ruby/object:Gem::Requirement
@@ -97,7 +139,8 @@ description: Ruby implementation of the parsing and computation of ephemerides f
   NASA JPL Development Ephemerides DE4xx
 email:
 - remy.hannequin@gmail.com
-executables: []
+executables:
+- ruby-ephem
 extensions: []
 extra_rdoc_files: []
 files:
@@ -109,17 +152,22 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/console
+- bin/ruby-ephem
+- bin/setup
 - lib/ephem.rb
+- lib/ephem/cli.rb
 - lib/ephem/computation/chebyshev_polynomial.rb
 - lib/ephem/core/calendar_calculations.rb
 - lib/ephem/core/constants/bodies.rb
 - lib/ephem/core/constants/time.rb
 - lib/ephem/core/state.rb
 - lib/ephem/core/vector.rb
+- lib/ephem/download.rb
 - lib/ephem/error.rb
+- lib/ephem/excerpt.rb
 - lib/ephem/io/binary_reader.rb
 - lib/ephem/io/daf.rb
-- lib/ephem/io/download.rb
 - lib/ephem/io/endianness_manager.rb
 - lib/ephem/io/record_data.rb
 - lib/ephem/io/record_parser.rb

data/lib/ephem/io/download.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-require "net/http"
-
-module Ephem
-  module IO
-    class Download
-      BASE_URL = "https://ssd.jpl.nasa.gov/ftp/eph/planets/bsp/"
-
-      SUPPORTED_KERNELS = %w[
-        de102.bsp
-        de200.bsp
-        de202.bsp
-        de403.bsp
-        de405.bsp
-        de405_1960_2020.bsp
-        de406.bsp
-        de410.bsp
-        de413.bsp
-        de414.bsp
-        de418.bsp
-        de421.bsp
-        de422.bsp
-        de422_1850_2050.bsp
-        de423.bsp
-        de424.bsp
-        de424s.bsp
-        de425.bsp
-        de430_1850-2150.bsp
-        de430_plus_MarsPC.bsp
-        de430t.bsp
-        de431.bsp
-        de432t.bsp
-        de433.bsp
-        de433_plus_MarsPC.bsp
-        de433t.bsp
-        de434.bsp
-        de434s.bsp
-        de434t.bsp
-        de435.bsp
-        de435s.bsp
-        de435t.bsp
-        de436.bsp
-        de436s.bsp
-        de436t.bsp
-        de438.bsp
-        de438_plus_MarsPC.bsp
-        de438s.bsp
-        de438t.bsp
-        de440.bsp
-        de440s.bsp
-        de440s_plus_MarsPC.bsp
-        de440t.bsp
-        de441.bsp
-      ].freeze
-
-      def self.call(name:, target:)
-        new(name, target).call
-      end
-
-      def initialize(name, local_path)
-        @name = name
-        @local_path = local_path
-        validate_requested_kernel!
-      end
-
-      def call
-        uri = URI("#{BASE_URL}#{@name}")
-        Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
-          request = Net::HTTP::Get.new(uri)
-          http.request(request) do |response|
-            File.open(@local_path, "wb") do |file|
-              response.read_body do |chunk|
-                file.write(chunk)
-              end
-            end
-          end
-        end
-      end
-
-      private
-
-      def validate_requested_kernel!
-        unless SUPPORTED_KERNELS.include?(@name)
-          raise UnsupportedError,
-            "Kernel #{@name} is not supported by the library at the moment."
-        end
-      end
-    end
-  end
-end