grss 4.3.2__tar.gz → 4.3.6__tar.gz

{grss-4.3.2/grss.egg-info → grss-4.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: grss
-Version: 4.3.2
+Version: 4.3.6
 Summary: GRSS: Gauss-Radau Small-body Simulator
 Author: Rahil Makadia
 Author-email: makadia2@illinois.edu

{grss-4.3.2 → grss-4.3.6}/build_cpp.sh

@@ -1,4 +1,6 @@
 #!/bin/bash
+# make error stop the script
+set -e
 
 clean=0
 docs=0

{grss-4.3.2 → grss-4.3.6}/grss/fit/fit_simulation.py

@@ -3,6 +3,7 @@
 import sys
 import datetime
 import numpy as np
+import pandas as pd
 import matplotlib.pyplot as plt
 from astropy.time import Time
 
@@ -562,7 +563,7 @@ class FitSimulation:
                 self.fixed_propsim_params[key] = nongrav_info[key]
         self.fixed_propsim_params['events'] = events if events is not None else []
         self.prior_est = None
-        self.prior_sigs = None
+        self.prior_sig = None
         self._priors_given = False
         self._xbar0 = None
         self._info0 = None
@@ -574,6 +575,7 @@ class FitSimulation:
         num_auto_rejected = np.sum(sel_ast == 'D')
         num_force_rejected = np.sum(sel_ast == 'd')
         self.num_rejected = num_auto_rejected + num_force_rejected
+        self.info_mats = []
         self.converged = False
         return None
 
@@ -642,10 +644,10 @@ class FitSimulation:
         ValueError
             If the prior estimates and sigmas do not have the same length.
         """
-        # check that the keys in self.x_init are the same as in self.prior_est and self.prior_sigs
-        if self.prior_est is not None and self.prior_sigs is not None:
+        # check that the keys in self.x_init are the same as in self.prior_est and self.prior_sig
+        if self.prior_est is not None and self.prior_sig is not None:
             self._priors_given = True
-            if len(self.prior_est) != len(self.prior_sigs):
+            if len(self.prior_est) != len(self.prior_sig):
                 raise ValueError("Prior estimates and sigmas must have the same length.")
             for key in self.prior_est.keys():
                 if key not in self.x_init:
@@ -654,7 +656,7 @@ class FitSimulation:
             self._xbar0 = np.zeros(self.n_fit)
             for key in self.prior_est.keys():
                 idx = list(self.x_init.keys()).index(key)
-                self._info0[idx, idx] = 1/self.prior_sigs[key]**2
+                self._info0[idx, idx] = 1/self.prior_sig[key]**2
                 self._xbar0[idx] = self.prior_est[key] - self.x_init[key]
             self._prior_constant = list(self.x_nom.values())+self._xbar0
         return None
@@ -693,56 +695,60 @@ class FitSimulation:
             raise ValueError("Simulated observation data must have the same length.")
         perm_id = self.obs['permID'][0]
         prov_id = self.obs['provID'][0]
+        new_sim_obs = []
         for i, time in enumerate(times):
-            idx = len(self.obs)
+            this_obs = {}
             mode = modes[i]
             if mode not in {'SIM_CCD', 'SIM_OCC', 'SIM_RAD_DEL', 'SIM_RAD_DOP'}:
                 raise ValueError(f"Unknown simulated observation mode {mode}.")
             weight = weights[i]
             if isinstance(perm_id, str):
-                self.obs.loc[idx, 'permID'] = f'SIM_{perm_id}'
+                this_obs['permID'] = f'SIM_{perm_id}'
             if isinstance(prov_id, str):
-                self.obs.loc[idx, 'provID'] = f'SIM_{prov_id}'
-            self.obs.loc[idx, 'obsTime'] = f'{time.utc.isot}Z'
-            self.obs.loc[idx, 'obsTimeMJD'] = time.utc.mjd
-            self.obs.loc[idx, 'obsTimeMJDTDB'] = time.tdb.mjd
-            self.obs.loc[idx, 'mode'] = mode
+                this_obs['provID'] = f'SIM_{prov_id}'
+            this_obs['obsTime'] = f'{time.utc.isot}Z'
+            this_obs['obsTimeMJD'] = time.utc.mjd
+            this_obs['obsTimeMJDTDB'] = time.tdb.mjd
+            this_obs['mode'] = mode
             if mode in {'SIM_CCD', 'SIM_OCC'}:
-                self.obs.loc[idx, 'stn'] = 'SIM'
-                self.obs.loc[idx, 'ra'] = np.nan
-                self.obs.loc[idx, 'rmsRA'] = weight[0]
-                self.obs.loc[idx, 'sigRA'] = weight[0]
-                self.obs.loc[idx, 'dec'] = np.nan
-                self.obs.loc[idx, 'rmsDec'] = weight[1]
-                self.obs.loc[idx, 'sigDec'] = weight[1]
-                self.obs.loc[idx, 'rmsCorr'] = weight[2]
-                self.obs.loc[idx, 'sigCorr'] = weight[2]
-                self.obs.loc[idx, 'cosDec'] = 1.0
+                this_obs['stn'] = 'SIM'
+                this_obs['ra'] = np.nan
+                this_obs['rmsRA'] = weight[0]
+                this_obs['sigRA'] = weight[0]
+                this_obs['dec'] = np.nan
+                this_obs['rmsDec'] = weight[1]
+                this_obs['sigDec'] = weight[1]
+                this_obs['rmsCorr'] = weight[2]
+                this_obs['sigCorr'] = weight[2]
+                this_obs['cosDec'] = 1.0
             elif mode in {'SIM_RAD_DEL', 'SIM_RAD_DOP'}:
-                self.obs.loc[idx, 'trx'] = 'SIM'
-                self.obs.loc[idx, 'rcv'] = 'SIM'
-                self.obs.loc[idx, 'com'] = 1
+                this_obs['trx'] = 'SIM'
+                this_obs['rcv'] = 'SIM'
+                this_obs['com'] = 1
                 if mode == 'SIM_RAD_DEL':
-                    self.obs.loc[idx, 'delay'] = np.nan
-                    self.obs.loc[idx, 'rmsDelay'] = weight[0]
-                    self.obs.loc[idx, 'sigDelay'] = weight[0]
-                    self.obs.loc[idx, 'doppler'] = np.nan
-                    self.obs.loc[idx, 'rmsDoppler'] = np.nan
-                    self.obs.loc[idx, 'sigDoppler'] = np.nan
+                    this_obs['delay'] = np.nan
+                    this_obs['rmsDelay'] = weight[0]
+                    this_obs['sigDelay'] = weight[0]
+                    this_obs['doppler'] = np.nan
+                    this_obs['rmsDoppler'] = np.nan
+                    this_obs['sigDoppler'] = np.nan
                 else:
-                    self.obs.loc[idx, 'delay'] = np.nan
-                    self.obs.loc[idx, 'rmsDelay'] = np.nan
-                    self.obs.loc[idx, 'sigDelay'] = np.nan
-                    self.obs.loc[idx, 'doppler'] = np.nan
-                    self.obs.loc[idx, 'rmsDoppler'] = weight[0]
-                    self.obs.loc[idx, 'sigDoppler'] = weight[0]
-                    self.obs.loc[idx, 'frq'] = 8560.0
-            self.obs.loc[idx, 'ctr'] = 399
-            self.obs.loc[idx, 'sys'] = 'ITRF'
-            self.obs.loc[idx, 'pos1'] = 0.0
-            self.obs.loc[idx, 'pos2'] = 0.0
-            self.obs.loc[idx, 'pos3'] = 0.0
-            self.obs.loc[idx, 'selAst'] = 'a'
+                    this_obs['delay'] = np.nan
+                    this_obs['rmsDelay'] = np.nan
+                    this_obs['sigDelay'] = np.nan
+                    this_obs['doppler'] = np.nan
+                    this_obs['rmsDoppler'] = weight[0]
+                    this_obs['sigDoppler'] = weight[0]
+                    this_obs['frq'] = 8560.0
+            this_obs['ctr'] = 399
+            this_obs['sys'] = 'ITRF'
+            this_obs['pos1'] = 0.0
+            this_obs['pos2'] = 0.0
+            this_obs['pos3'] = 0.0
+            this_obs['selAst'] = 'a'
+            new_sim_obs.append(this_obs)
+        sim_obs_df = pd.DataFrame(new_sim_obs)
+        self.obs = pd.concat([self.obs, sim_obs_df], ignore_index=True)
         return None
 
     def _parse_observation_arrays(self, obs_df):
@@ -1635,33 +1641,29 @@ class FitSimulation:
                 raise ValueError("Observer info length not recognized.")
             resid = residuals[i]
             # calculate chi-squared for each residual if after the first iteration
-            if self.n_iter > 1:
+            if start_rejecting and size == 2:
                 obs_cov = self.obs_cov[i]
                 obs_partials = partials[j:j+size, :]
                 if sel_ast[i] in {'D', 'd'}:
                     resid_cov = obs_cov + obs_partials @ full_cov @ obs_partials.T
                 else:
                     resid_cov = obs_cov - obs_partials @ full_cov @ obs_partials.T
-                if size == 1:
-                    resid_cov_inv = 1.0/resid_cov
-                else:
-                    resid_cov_det = resid_cov[0,0]*resid_cov[1,1] - resid_cov[0,1]*resid_cov[1,0]
-                    resid_cov_inv = np.array([[resid_cov[1,1], -resid_cov[0,1]],
-                                                [-resid_cov[1,0], resid_cov[0,0]]])/resid_cov_det
-                residual_chi_squared = resid @ resid_cov_inv @ resid.T
-                res_chisq_vals[i] = residual_chi_squared
-            # outlier rejection, only reject RA/Dec measurements
-            if start_rejecting and size == 2:
-                if abs(residual_chi_squared) > chi_reject**2 and sel_ast[i] not in {'a', 'd'}:
+                resid_cov_det = resid_cov[0,0]*resid_cov[1,1] - resid_cov[0,1]*resid_cov[1,0]
+                resid_cov_inv = np.array([[resid_cov[1,1], -resid_cov[0,1]],
+                                            [-resid_cov[1,0], resid_cov[0,0]]])/resid_cov_det
+                outlier_chisq = resid @ resid_cov_inv @ resid.T
+                # outlier rejection, only reject RA/Dec measurements
+                if abs(outlier_chisq) > chi_reject**2 and sel_ast[i] not in {'a', 'd'}:
                     if sel_ast[i] == 'A':
                         self.num_rejected += 1
                     sel_ast[i] = 'D'
-                elif abs(residual_chi_squared) < chi_recover**2 and sel_ast[i] == 'D':
+                elif abs(outlier_chisq) < chi_recover**2 and sel_ast[i] == 'D':
                     sel_ast[i] = 'A'
                     self.num_rejected -= 1
+            res_chisq_vals[i] = resid @ self.obs_weight[i] @ resid.T
             if sel_ast[i] not in {'D', 'd'}:
                 rms_u += resid @ resid.T
-                chi_sq += resid @ self.obs_weight[i] @ resid.T
+                chi_sq += res_chisq_vals[i]
             j += size
         # # write res_chisq_vals to file if any values are negative
         # if np.any(res_chisq_vals < 0):
@@ -1759,6 +1761,7 @@ class FitSimulation:
             atwb = np.zeros(self.n_fit)
         j = 0
         sel_ast = self.obs['selAst'].values
+        self.info_mats = []
         for i, obs_info_len in enumerate(self.observer_info_lengths):
             if obs_info_len in {4, 7}:
                 size = 2
@@ -1768,10 +1771,12 @@ class FitSimulation:
                 raise ValueError("Observer info length not recognized.")
             if sel_ast[i] in {'D', 'd'}:
                 j += size
+                self.info_mats.append(atwa.copy())
                 continue
             atwa += partials[j:j+size, :].T @ self.obs_weight[i] @ partials[j:j+size, :]
             atwb += partials[j:j+size, :].T @ self.obs_weight[i] @ residuals[i]
             j += size
+            self.info_mats.append(atwa.copy())
         # use pseudo-inverse if the data arc is less than 7 days
         if self.obs.obsTimeMJD.max() - self.obs.obsTimeMJD.min() < 7.0:
             self.covariance = np.linalg.pinv(atwa, rcond=1e-20, hermitian=True)
@@ -2074,7 +2079,7 @@ class FitSimulation:
                     f.write(f" {units_dict[key[:2]]}")
                 if self._priors_given and key in self.prior_est:
                     p_val = self.prior_est[key]
-                    p_sig = self.prior_sigs[key]
+                    p_sig = self.prior_sig[key]
                     if key in ['om', 'w', 'i']:
                         p_val *= 180/np.pi
                         p_sig *= 180/np.pi
@@ -2114,7 +2119,7 @@ class FitSimulation:
                     f.write(f" {units_dict[key[:2]]}")
                 if self._priors_given and key in self.prior_est:
                     p_val = self.prior_est[key]
-                    p_sig = self.prior_sigs[key]
+                    p_sig = self.prior_sig[key]
                     if key in ['om', 'w', 'i']:
                         p_val *= 180/np.pi
                         p_sig *= 180/np.pi
@@ -2211,7 +2216,7 @@ class FitSimulation:
                         f.write(f'{final_val:18.11e}{half_tab}')
                         f.write(f'{final_unc:18.11e}{half_tab}')
                         f.write(f'{final_val-init_val:+18.11e}{half_tab}')
-                        f.write(f'{(final_val-init_val)/init_unc:+10.3f}\n')
+                        f.write(f'{(final_val-init_val)/final_unc:+10.3f}\n')
                 f.write("\n")
                 if itrn.iter_number <= self.n_iter:
                     f.write(subsection_full + '\n')

{grss-4.3.2 → grss-4.3.6}/grss/prop/prop_utils.py

@@ -12,6 +12,7 @@ __all__ = [ 'equat2eclip',
             'plot_ca_summary',
             'plot_bplane',
             'plot_earth_impact',
+            'compare_earth_impact',
 ]
 
 earth_obliq = 84381.448/3600.0*np.pi/180.0
@@ -536,27 +537,48 @@ def plot_bplane(ca_list, plot_offset=False, scale_coords=False, n_std=3, units_k
         lon = None
         lat = None
     impact_any = lon is not None and lat is not None
+    if kizner_nan and opik_nan and scaled_nan and not mtp_nan:
+        print("WARNING: Close approaches have some invalid B-planes but do have MTP. "
+                "Object might be captured.")
     if len(ca_list) >= 100 or sigma_points is not None:
+        # remove nans before converting data to ellipse
         if not kizner_nan:
             kizner_data = data_to_ellipse(kizner_x, kizner_y, n_std, 'kizner',
                                             print_ellipse_params, units, sigma_points)
         else:
-            kizner_data = None
+            print(f"Kizner B-plane nan count: {np.sum(np.isnan(kizner_x))}")
+            non_nan_idx = np.where(~np.isnan(kizner_x) & ~np.isnan(kizner_y))[0]
+            kizner_data = data_to_ellipse(kizner_x[non_nan_idx], kizner_y[non_nan_idx],
+                                            n_std, 'kizner',
+                                            print_ellipse_params, units, sigma_points)
         if not opik_nan:
             opik_data = data_to_ellipse(opik_x, opik_y, n_std, 'opik',
                                         print_ellipse_params, units, sigma_points)
         else:
-            opik_data = None
+            print(f"Opik B-plane nan count: {np.sum(np.isnan(opik_x))}")
+            non_nan_idx = np.where(~np.isnan(opik_x) & ~np.isnan(opik_y))[0]
+            opik_data = data_to_ellipse(opik_x[non_nan_idx], opik_y[non_nan_idx],
+                                        n_std, 'opik',
+                                        print_ellipse_params, units, sigma_points)
         if not scaled_nan:
             scaled_data = data_to_ellipse(scaled_x, scaled_y, n_std, 'scaled',
                                             print_ellipse_params, units, sigma_points)
         else:
-            scaled_data = None
+            print(f"Scaled B-plane nan count: {np.sum(np.isnan(scaled_x))}")
+            non_nan_idx = np.where(~np.isnan(scaled_x) & ~np.isnan(scaled_y))[0]
+            scaled_data = data_to_ellipse(scaled_x[non_nan_idx], scaled_y[non_nan_idx],
+                                            n_std, 'scaled',
+                                            print_ellipse_params, units, sigma_points)
         if not mtp_nan:
             mtp_data = data_to_ellipse(mtp_x, mtp_y, n_std, 'mtp',
                                         print_ellipse_params, units, sigma_points)
         else:
-            mtp_data = None
+            print(f"MTP B-plane nan count: {np.sum(np.isnan(mtp_x))}")
+            non_nan_idx = np.where(~np.isnan(mtp_x) & ~np.isnan(mtp_y))[0]
+            mtp_data = data_to_ellipse(mtp_x[non_nan_idx], mtp_y[non_nan_idx],
+                                        n_std, 'mtp',
+                                        print_ellipse_params, units, sigma_points)
+
     elif len(ca_list[0].xRel) >= 42 and analytic_info is not None:
         all_data = partials_to_ellipse(ca_list[0], au2units, n_std,
                                         print_ellipse_params, units, analytic_info)
@@ -566,9 +588,6 @@ def plot_bplane(ca_list, plot_offset=False, scale_coords=False, n_std=3, units_k
         opik_data = None
         scaled_data = None
         mtp_data = None
-    if kizner_nan and opik_nan and scaled_nan and not mtp_nan:
-        print("WARNING: Close approaches have no valid B-planes but do have MTP. "
-                "Object might be captured.")
     fig, axes = plt.subplots(2, 2, figsize=(9, 9), dpi=250)
     plot_single_bplane(axes[0,0], kizner_x, kizner_y, kizner_data, 'kizner',
                         focus_factor, show_central_body, plot_offset, scale_coords,
@@ -886,3 +905,95 @@ def plot_earth_impact(impact_list, print_ellipse_params=False, sigma_points=None
                     y=0.93)
     plt.show()
     return None
+
+def compare_earth_impact(coord1, coord2, sig1, sig2, labels, zoom_size=5.0e3, save_name=None):
+    """
+    Show two impact circumstances and compare them.
+
+    Parameters
+    ----------
+    coord1 : np.ndarray
+        [time, lon, lat] of the first impact
+    coord2 : np.ndarray
+        [time, lon, lat] of the second impact
+    sig1 : np.ndarray
+        [time, lon, lat] uncertainty of the first impact
+    sig2 : np.ndarray
+        [time, lon, lat] uncertainty of the second impact
+    labels : list
+        List of labels for the two impacts
+    zoom_size : float, optional
+        Size of the zoomed in plot, in km, by default 5.0e3.
+    save_name : str, optional
+        Name to save the plots as, by default None.
+
+    Returns
+    -------
+    None : NoneType
+        None
+    """
+    _, lon1, lat1 = coord1
+    _, lon2, lat2 = coord2
+    fig, ax = plt.subplots(1, 3, figsize=(10, 4), dpi=150, gridspec_kw={'width_ratios': [4, 3, 1]})
+    size = zoom_size*1e3
+    m = Basemap(width=size,height=size,
+                rsphere=(6378137.00,6356752.3142),
+                resolution='i',area_thresh=size/100,projection='lcc',
+                lat_0=lat1,lon_0=lon1,ax=ax[0])
+    m.bluemarble()
+    m.drawcountries()
+    lat_step = lon_step = 3 if zoom_size <= 1e3 else 10
+    if zoom_size <= 500:
+        lat_step = lon_step = 1
+    if zoom_size <= 100:
+        lat_step = lon_step = 0.5
+    if zoom_size > 5e3:
+        lon_step = 20
+        lat_step = 20
+    # draw parallels and meridians.
+    parallels = np.arange(-90, 91, lat_step)
+    # labels = [left,right,top,bottom]
+    m.drawparallels(parallels,labels=[True,False,False,False], color='gray')
+    meridians = np.arange(0, 361, lon_step)
+    m.drawmeridians(meridians,labels=[False,False,False,True], color='gray')
+    x_lon1,y_lat1 = m(lon1,lat1)
+    m.plot(x_lon1,y_lat1,'b.')
+    x_lon2,y_lat2 = m(lon2,lat2)
+    m.plot(x_lon2,y_lat2,'r.')
+    # draw line between two points
+    m.plot([x_lon1,x_lon2], [y_lat1,y_lat2], 'g--')
+
+    # plot error bars for grss solution, and plot GRSS solution
+    n_sig = 1
+    deg2m = np.pi/180*6378137.0
+    sig1[1:] *= deg2m
+    sig2[1:] *= deg2m
+    diff = coord2 - coord1
+    # diff[0] *= 86400*1e3
+    diff[1:] *= deg2m
+    diff[1] *= np.cos(lat1*np.pi/180)
+
+    # add two subplots
+    ax[1].set_xlabel('Longitude Difference [m]')
+    ax[1].set_ylabel('Latitude Difference [m]')
+    ax[1].errorbar(0.0, 0.0, xerr=sig1[1]*n_sig, yerr=sig1[2]*n_sig,
+                    fmt='s', capsize=6, markeredgewidth=1.5, lw=1.5, label=labels[0])
+    ax[1].errorbar(diff[1], diff[2], xerr=sig2[1]*n_sig, yerr=sig2[2]*n_sig,
+                    fmt='o', capsize=6, markeredgewidth=1.5, lw=1.5, label=labels[1])
+    ax[1].legend(ncol=1)
+
+    ax[2].set_ylabel('Time Difference [ms]')
+    ax[2].errorbar(0.0, 0.0, yerr=sig1[0]*n_sig,
+                    fmt='s', capsize=6, markeredgewidth=1.5, lw=1.5, label=labels[0])
+    ax[2].errorbar(0.0, diff[0], yerr=sig2[0]*n_sig,
+                    fmt='o', capsize=6, markeredgewidth=1.5, lw=1.5, label=labels[1])
+    ax[2].set_xticks([])
+    ax[2].yaxis.tick_right()
+    ax[2].yaxis.set_label_position('right')
+
+    fig.tight_layout()
+    if save_name is not None:
+        plt.savefig(save_name, bbox_inches='tight')
+    plt.suptitle(f'Impact Circumstance Comparison ({n_sig}$\\sigma$)', y=1.05)
+    plt.show()
+    return None

{grss-4.3.2 → grss-4.3.6}/grss/utils.py

@@ -12,11 +12,11 @@ __all__ = [ 'default_kernel_path',
 grss_path = os.path.dirname(os.path.abspath(__file__))
 default_kernel_path = f'{grss_path}/kernels/'
 
-def _connected_to_internet(url='http://www.google.com/', timeout=5):
+def _connected_to_internet(url='http://www.google.com/', timeout=30):
     try:
         _ = requests.head(url, timeout=timeout)
         return True
-    except requests.ConnectionError:
+    except (requests.ConnectionError, requests.Timeout):
         print("No internet connection available.")
     return False
 

grss-4.3.6/grss/version.txt

@@ -0,0 +1 @@
+4.3.6

{grss-4.3.2 → grss-4.3.6/grss.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: grss
-Version: 4.3.2
+Version: 4.3.6
 Summary: GRSS: Gauss-Radau Small-body Simulator
 Author: Rahil Makadia
 Author-email: makadia2@illinois.edu

{grss-4.3.2 → grss-4.3.6}/include/approach.h

@@ -28,6 +28,12 @@ void impact_r_calc(PropSimulation *propSim, const size_t &i, const size_t &j,
 std::vector<real> get_rel_state(PropSimulation *propSim, const size_t &i,
                                 const size_t &j, const real &t);
 
+/**
+ * @brief Compute partials of B-plane parameters.
+ */
+void get_bplane_partials(PropSimulation *propSim, CloseApproachParameters *ca,
+                         const real &mu, const real &radius);
+
 /**
  * @brief Compute the time of close approach or impact using Brent's method
  *       for root finding in a bracketed interval.

{grss-4.3.2 → grss-4.3.6}/include/grss.h

@@ -16,7 +16,9 @@ void PropSimulation::integrate() {
     this->map_ephemeris();
     this->preprocess();
     gr15(this);
-    this->unmap_ephemeris();
+    if (!this->unsafePersistentMemoryMap) {
+        this->unmap_ephemeris();
+    }
 
     // flip vectors if integration is backwards in time
     if (this->integParams.t0 > this->integParams.tf) {

{grss-4.3.2 → grss-4.3.6}/include/simulation.h

@@ -109,11 +109,17 @@ class Body {
     real J2 = 0.0L;
     real poleRA = 0.0L;
     real poleDec = 90.0L;
+    size_t nZon = 0;
+    size_t nTes = 0;
+    std::vector<real> J = {};
+    std::vector<std::vector<real>> C = {};
+    std::vector<std::vector<real>> S = {};
     std::string name;
     int spiceId;
     real pos[3], vel[3], acc[3];
     bool isPPN = false;
     bool isJ2 = false;
+    bool isHarmonic = false;
     bool isNongrav = false;
     bool isMajor = false;
     real caTol = 0.1;
@@ -121,6 +127,12 @@ class Body {
      * @brief Set the J2 for the body.
      */
     void set_J2(real J2, real poleRA, real poleDec);
+    /**
+     * @brief Set the harmonic coefficients for the body.
+     */
+    void set_harmonics(real poleRA, real poleDec, int nZon, int nTes,
+                       std::vector<real> J, std::vector<std::vector<real>> C,
+                       std::vector<std::vector<real>> S);
 };
 
 /**
@@ -389,12 +401,19 @@ class ImpactParameters : public CloseApproachParameters {
 /**
  * @brief Structure to hold interpolation parameters for a PropSimulation.
  * 
+ * @param interpIdx Index of the interpolation parameters.
+ * @param t0 Initial time of the interpolation window.
+ * @param dt0 Timespan of the interpolation window.
+ * @param b0 Interpolation coefficients for the interpolation window.
+ * @param xInteg0 States at the initial time of the interpolation window.
+ * @param accInteg0 Accelerations at the initial time of the interpolation window.
  * @param tStack Stack of integrator epochs.
  * @param xIntegStack Stack of states at integrator epochs.
  * @param bStack Stack of interpolation coefficients at integrator epochs.
  * @param accIntegStack Stack of accelerations at integrator epochs.
  */
 struct InterpolationParameters {
+    size_t interpIdx = 0;
     real t0;
     real dt0;
     std::vector<real> b0;
@@ -411,7 +430,9 @@ struct InterpolationParameters {
  * 
  * @param name Name of the simulation.
  * @param DEkernelPath Path to DE kernels.
- * @param ephem Ephemeris object for the simulation.
+ * @param spkEphem SPK ephemeris object for the simulation.
+ * @param pckEphem PCK ephemeris object for the simulation.
+ * @param unsafePersistentMemoryMap Flag to indicate if ephemeris memory maps should not be unmapped (unsafe, default: false).
  * @param consts Constants object for the simulation.
  * @param integParams Integration parameters for the simulation.
  * @param spiceBodies Vector of SpiceBody objects in the simulation.
@@ -423,7 +444,6 @@ struct InterpolationParameters {
  * @param t Current time of the simulation.
  * @param xInteg Current state of the simulation.
  * @param interpParams Interpolation parameters for the simulation.
- * @param interpIdx Index of the interpolation parameters.
  * @param tEvalUTC Flag to indicate if the evaluation times are in UTC.
  * @param evalApparentState Flag to indicate if the apparent state is evaluated.
  * @param evalMeasurements Flag to indicate if measurements are evaluated.
@@ -459,6 +479,7 @@ class PropSimulation {
     std::string DEkernelPath;
     SpkEphemeris spkEphem;
     PckEphemeris pckEphem;
+    bool unsafePersistentMemoryMap = false;
     /**
      * @brief Construct a new PropSimulation object.
      */
@@ -490,7 +511,6 @@ class PropSimulation {
     real t;
     std::vector<real> xInteg;
     InterpolationParameters interpParams;
-    size_t interpIdx = 0;
     bool tEvalUTC = false;
     bool evalApparentState = false;
     bool evalMeasurements = false;

{grss-4.3.2 → grss-4.3.6}/include/utilities.h

@@ -63,6 +63,16 @@ using std::tanh;
  * 
  */
 #define EARTH_OBLIQUITY 84381.448 / 3600.0 * DEG2RAD
+/**
+ * @brief Value of Earth's WGS84 radius in AU.
+ * 
+ */
+#define EARTH_RAD_WGS84 6378.137 / 1.495978707e8
+/**
+ * @brief Value of Earth's WGS84 flattening.
+ * 
+ */
+#define EARTH_FLAT_WGS84 1.0 / 298.257223563
 
 /**
  * @brief Wrap an angle to the range [0, 2*pi).

{grss-4.3.2 → grss-4.3.6}/pyproject.toml

@@ -66,6 +66,9 @@ dependencies = {file = "requirements.txt"}
 
 [tool.cibuildwheel]
 before-build = [
+    "cd ./extern/",
+    "python3 get_cspice.py",
+    "cd ..",
     "pip install pybind11",
     ". ./build_cpp.sh -clean",
 ]

{grss-4.3.2 → grss-4.3.6}/setup.py

@@ -31,14 +31,17 @@ class CMakeBuild(build_ext):
     """
 
     def build_extension(self, ext: CMakeExtension) -> None:
-        subprocess.run(["./build_cpp.sh"], cwd=ext.sourcedir, check=True)
+        result = subprocess.run(["./build_cpp.sh"], cwd=ext.sourcedir, check=True)
+        # check return code of subprocess
+        if result.returncode != 0:
+            raise subprocess.CalledProcessError(returncode=result.returncode, cmd=result.args)
         binary_created = [f for f in os.listdir(f"{ext.sourcedir}/build/")
                             if f.startswith("libgrss")]
         if not binary_created:
             raise FileNotFoundError("libgrss binary for C++ source code not found "
                                     "in cmake build directory")
         os.system(f"cp {ext.sourcedir}/build/libgrss.* {self.build_lib}/grss/")
-        return
+        return None
 
 setup(
     ext_modules=[CMakeExtension("libgrss")],