Merge branch 'develop' into feature/odf_merge

.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.7.3.dev18
+current_version = 0.7.3.dev20
 commit = True
 tag = True
 parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(\.(?P<release>[a-z]+)(?P<dev>\d+))?

tudatpy/kernel/expose_numerical_simulation/expose_environment.cpp

@@ -628,6 +628,7 @@ void expose_environment(py::module &m) {
                  py::arg( "time" ) );
 
 
+
     /*!
      **************   BODY OBJECTS AND ASSOCIATED FUNCTIONALITY  ******************
      */
@@ -679,14 +680,26 @@ void expose_environment(py::module &m) {
                  py::arg("body_name"),
                  py::arg("process_body") = 1,
                  get_docstring("SystemOfBodies.create_empty_body").c_str())
+            .def("does_body_exist", &tss::SystemOfBodies::doesBodyExist,
+                 py::arg("body_name"),
+                 get_docstring("SystemOfBodies.does_body_exist").c_str())
+            .def("list_of_bodies", &tss::SystemOfBodies::getListOfBodies,
+                 get_docstring("SystemOfBodies.list_of_bodies").c_str())
+//            .def("get_body_dict", &tss::SystemOfBodies::getMap,
+//                 get_docstring("SystemOfBodies.get_body_dict").c_str())
             .def("add_body", &tss::SystemOfBodies::addBody,
                  py::arg("body_to_add"),
                  py::arg("body_name"),
                  py::arg("process_body") = 1,
                  get_docstring("SystemOfBodies.add_body").c_str())
             .def("remove_body", &tss::SystemOfBodies::deleteBody,
                  py::arg("body_name"),
-                 get_docstring("SystemOfBodies.remove_body").c_str());
+                 get_docstring("SystemOfBodies.remove_body").c_str())
+            .def("global_frame_orientation", &tss::SystemOfBodies::getFrameOrientation,
+                 get_docstring("SystemOfBodies.global_frame_orientation").c_str())
+            .def("global_frame_origin", &tss::SystemOfBodies::getFrameOrigin,
+                 get_docstring("SystemOfBodies.global_frame_origin").c_str());
+
 //            .def_property_readonly("number_of_bodies", &tss::SystemOfBodies::getNumberOfBodies,
 //                                   get_docstring("number_of_bodies").c_str() );
 

tudatpy/kernel/expose_numerical_simulation/expose_environment_setup.cpp

@@ -44,6 +44,7 @@ namespace ta = tudat::aerodynamics;
 namespace trf = tudat::reference_frames;
 namespace tg = tudat::gravitation;
 namespace tcc = tudat::coordinate_conversions;
+namespace tp = tudat::propagators;
 
 
 
@@ -153,7 +154,7 @@ namespace environment_setup {
               py::arg("body_settings"),
               get_docstring("create_system_of_bodies").c_str());
 
-        m.def("add_empty_tabulated_ephemeris", &tss::addEmptyTabulatedEphemeris,
+        m.def("add_empty_tabulated_ephemeris", &tp::addEmptyTabulatedEphemeris< double, TIME_TYPE >,
               py::arg("bodies"),
               py::arg("body_name"),
               py::arg("ephemeris_origin") = "",

tudatpy/kernel/expose_numerical_simulation/expose_estimation.cpp

@@ -345,6 +345,11 @@ void expose_estimation(py::module &m) {
                                    get_docstring("ObservationCollection.sorted_observation_sets").c_str() )
             .def_property_readonly("link_ends_per_observable_type", &tom::ObservationCollection<double, TIME_TYPE>::getLinkEndsPerObservableType,
                                    get_docstring("ObservationCollection.link_ends_per_observable_type").c_str() )
+            .def_property_readonly("link_definitions_per_observable", &tom::ObservationCollection<double, TIME_TYPE>::getLinkDefinitionsPerObservable,
+                                   get_docstring("ObservationCollection.link_definitions_per_observable").c_str() )
+            .def("get_link_definitions_for_observables", &tom::ObservationCollection<double, TIME_TYPE>::getLinkDefinitionsForSingleObservable,
+                 py::arg( "observable_type" ),
+                 get_docstring("ObservationCollection.get_link_definitions_for_observables").c_str() )
             .def("get_single_link_and_type_observations", &tom::ObservationCollection<double, TIME_TYPE>::getSingleLinkAndTypeObservationSets,
                                    py::arg( "observable_type" ),
                                    py::arg( "link_definition" ),
@@ -394,12 +399,14 @@ void expose_estimation(py::module &m) {
                  &tp::CombinedStateTransitionAndSensitivityMatrixInterface::
                  getCombinedStateTransitionAndSensitivityMatrix,
                  py::arg("time"),
+                 py::arg("add_central_body_dependency") = true,
                  py::arg("arc_defining_bodies" ) = std::vector< std::string >( ),
                  get_docstring("CombinedStateTransitionAndSensitivityMatrixInterface.state_transition_sensitivity_at_epoch").c_str() )
             .def("full_state_transition_sensitivity_at_epoch",
                  &tp::CombinedStateTransitionAndSensitivityMatrixInterface::
                  getFullCombinedStateTransitionAndSensitivityMatrix,
                  py::arg("time"),
+                 py::arg("add_central_body_dependency") = true,
                  py::arg("arc_defining_bodies" ) = std::vector< std::string >( ),
                  get_docstring("CombinedStateTransitionAndSensitivityMatrixInterface.full_state_transition_sensitivity_at_epoch").c_str() )
             .def_property_readonly(
@@ -502,30 +509,53 @@ void expose_estimation(py::module &m) {
             .def(py::init<
                  const std::shared_ptr< tom::ObservationCollection<double, TIME_TYPE> >&,
                  const Eigen::MatrixXd,
-                 const Eigen::MatrixXd >( ),
+                 const Eigen::MatrixXd,
+                 const double >( ),
                  py::arg( "observations_and_times" ),
                  py::arg( "inverse_apriori_covariance" ) = Eigen::MatrixXd::Zero( 0, 0 ),
                  py::arg( "consider_covariance" ) = Eigen::MatrixXd::Zero( 0, 0 ),
+                 py::arg( "limit_condition_number_for_warning" ) = 1.0E8,
                  get_docstring("CovarianceAnalysisInput.ctor").c_str() )
             .def( "set_constant_weight",
                   &tss::CovarianceAnalysisInput<double, TIME_TYPE>::setConstantWeightsMatrix,
                   py::arg( "weight" ),
                   get_docstring("CovarianceAnalysisInput.set_constant_weight").c_str() )
+            .def( "set_constant_single_observable_weight",
+                  &tss::CovarianceAnalysisInput<double, TIME_TYPE>::setConstantSingleObservableWeights,
+                  py::arg( "observable_type" ),
+                  py::arg( "weight" ),
+                  get_docstring("CovarianceAnalysisInput.set_constant_single_observable_weight").c_str() )
+            .def( "set_constant_single_observable_vector_weight",
+                  &tss::CovarianceAnalysisInput<double, TIME_TYPE>::setConstantSingleObservableVectorWeights,
+                  py::arg( "observable_type" ),
+                  py::arg( "weight" ),
+                  get_docstring("CovarianceAnalysisInput.set_constant_single_observable_vector_weight").c_str() )
+            .def( "set_constant_single_observable_and_link_end_weight",
+                  &tss::CovarianceAnalysisInput<double, TIME_TYPE>::setConstantSingleObservableAndLinkEndsWeights,
+                  py::arg( "observable_type" ),
+                  py::arg( "link_ends" ),
+                  py::arg( "weight" ),
+                  get_docstring("CovarianceAnalysisInput.set_constant_single_observable_and_link_end_vector_weight").c_str() )
+            .def( "set_constant_single_observable_and_link_end_vector_weight",
+                  &tss::CovarianceAnalysisInput<double, TIME_TYPE>::setConstantSingleObservableAndLinkEndsVectorWeights,
+                  py::arg( "observable_type" ),
+                  py::arg( "link_ends" ),
+                  py::arg( "weight" ),
+                  get_docstring("CovarianceAnalysisInput.set_constant_single_observable_and_link_end_vector_weight").c_str() )
+            .def( "set_total_single_observable_and_link_end_vector_weight",
+                  &tss::CovarianceAnalysisInput<double, TIME_TYPE>::setTabulatedSingleObservableAndLinkEndsWeights,
+                  py::arg( "observable_type" ),
+                  py::arg( "link_ends" ),
+                  py::arg( "weight_vector" ),
+                  get_docstring("CovarianceAnalysisInput.set_constant_single_observable_and_link_end_vector_weight").c_str() )
             .def( "set_constant_weight_per_observable",
                   &tss::CovarianceAnalysisInput<double, TIME_TYPE>::setConstantPerObservableWeightsMatrix,
                   py::arg( "weight_per_observable" ),
                   get_docstring("CovarianceAnalysisInput.set_constant_weight_per_observable").c_str() )
-            .def( "set_constant_weight_per_observable",
-                  &tss::CovarianceAnalysisInput<double, TIME_TYPE>::setTabulatedPerObservableAndLinkEndsWeights,
+            .def( "set_constant_vector_weight_per_observable",
+                  &tss::CovarianceAnalysisInput<double, TIME_TYPE>::setConstantPerObservableVectorWeightsMatrix,
                   py::arg( "weight_per_observable" ),
                   get_docstring("CovarianceAnalysisInput.set_constant_weight_per_observable").c_str() )
-			.def( "set_constant_weight_per_observable_and_link_end",
-                  py::overload_cast< const tom::ObservableType, const tom::LinkEnds&, const double >(
-                          &tss::CovarianceAnalysisInput<double, TIME_TYPE>::setConstantPerObservableAndLinkEndsWeights ),
-                  py::arg( "observable_type" ),
-                  py::arg( "link_ends" ),
-                  py::arg( "weight_per_observable" ),
-                  get_docstring("CovarianceAnalysisInput.set_constant_weight_per_observable_and_link_end").c_str() )
             .def( "define_covariance_settings",
                   &tss::CovarianceAnalysisInput<double, TIME_TYPE>::defineCovarianceSettings,
                   py::arg( "reintegrate_equations_on_first_iteration" ) = true,
@@ -547,12 +577,18 @@ void expose_estimation(py::module &m) {
                  const Eigen::MatrixXd,
                  std::shared_ptr< tss::EstimationConvergenceChecker >,
                  const Eigen::MatrixXd,
-                 const Eigen::VectorXd >( ),
+                 const Eigen::VectorXd,
+                 const double,
+                 const bool,
+                 const bool >( ),
                  py::arg( "observations_and_times" ),
                  py::arg( "inverse_apriori_covariance" ) = Eigen::MatrixXd::Zero( 0, 0 ),
                  py::arg( "convergence_checker" ) = std::make_shared< tss::EstimationConvergenceChecker >( ),
                  py::arg( "consider_covariance" ) = Eigen::MatrixXd::Zero( 0, 0 ),
                  py::arg( "consider_parameters_deviations" ) = Eigen::VectorXd::Zero( 0 ),
+                 py::arg( "limit_condition_number_for_warning" ) = 1.0E8,
+                 py::arg( "condition_number_warning_each_iteration" ) = true,
+                 py::arg( "apply_final_parameter_correction" ) = true,
                  get_docstring("EstimationInput.ctor").c_str() )
             .def( "define_estimation_settings",
                   &tss::EstimationInput<double, TIME_TYPE>::defineEstimationSettings,

tudatpy/kernel/expose_numerical_simulation/expose_estimation_setup/expose_estimated_parameter_setup.cpp

@@ -388,6 +388,11 @@ void expose_estimated_parameter_setup(py::module &m) {
           py::arg("body_name"),
           get_docstring("scaled_longitude_libration_amplitude").c_str() );
 
+    m.def("yarkovsky_parameter",
+          &tep::yarkovskyParameter,
+          py::arg("body_name"),
+          py::arg("central_body_name") = "Sun",
+          get_docstring("yarkovsky_parameter").c_str() );
     // ###############  Global (GR) Model Parameters ################################
 
     m.def("ppn_parameter_gamma",

tudatpy/kernel/expose_numerical_simulation/expose_estimation_setup/expose_observation_setup.cpp

@@ -351,6 +351,13 @@ void expose_observation_setup(py::module &m) {
           py::arg("bias_settings") = nullptr,
           get_docstring("cartesian_position").c_str() );
 
+    m.def("relative_cartesian_position",
+          &tom::relativePositionObservableSettings,
+          py::arg("link_ends"),
+          py::arg("bias_settings") = nullptr,
+          get_docstring("cartesian_position").c_str() );
+
+
     m.def("cartesian_velocity",
           &tom::velocityObservableSettings,
           py::arg("link_ends"),

tudatpy/kernel/expose_numerical_simulation/expose_propagation.cpp

@@ -267,6 +267,12 @@ void expose_propagation(py::module &m)
             .def_property_readonly("dependent_variable_ids",
                                    &tp::SingleArcSimulationResults<double, TIME_TYPE>::getDependentVariableId,
                                    get_docstring("SingleArcSimulationResults.dependent_variable_ids").c_str() )
+            .def_property_readonly("ordered_dependent_variable_settings",
+                                   &tp::SingleArcSimulationResults<double, TIME_TYPE>::getOrderedDependentVariableSettings,
+                                   get_docstring("SingleArcSimulationResults.ordered_dependent_variable_settings").c_str() )
+            .def_property_readonly("unordered_dependent_variable_settings",
+                                   &tp::SingleArcSimulationResults<double, TIME_TYPE>::getOriginalDependentVariableSettings,
+                                   get_docstring("SingleArcSimulationResults.unordered_dependent_variable_settings").c_str() )
             .def_property_readonly("processed_state_ids",
                                    &tp::SingleArcSimulationResults<double, TIME_TYPE>::getProcessedStateIds,
                                    get_docstring("SingleArcSimulationResults.state_ids").c_str() )

tudatpy/kernel/expose_numerical_simulation/expose_propagation_setup/expose_acceleration_setup.cpp

@@ -248,6 +248,10 @@ void expose_acceleration_setup(py::module &m) {
           py::arg( "cosine_acceleration" ) = Eigen::Vector3d::Zero( ),
           get_docstring("empirical").c_str());
 
+    m.def("yarkovsky", &tss::yarkovskyAcceleration,
+          py::arg( "yarkovsky_parameter" ),
+          get_docstring("yarkovsky").c_str());
+
     m.def("custom",
           &tss::customAccelerationSettingsDeprecated,
           py::arg( "acceleration_function" ) );

tudatpy/kernel/expose_numerical_simulation/expose_propagation_setup/expose_dependent_variable_setup.cpp

@@ -273,14 +273,24 @@ namespace dependent_variable {
 //                 py::arg("component_index") = -1);
 
 
+        m.def("get_dependent_variable_id",
+              &tp::getDependentVariableId,
+              py::arg("dependent_variable_settings"),
+              get_docstring("get_dependent_variable_id").c_str());
+
+        m.def("get_dependent_variable_size",
+              &tp::getDependentVariableSaveSize,
+              py::arg("dependent_variable_settings"),
+              get_docstring("get_dependent_variable_size").c_str());
+
+        m.def("get_dependent_variable_shape",
+              &tp::getDependentVariableShape,
+              py::arg("dependent_variable_settings"),
+              get_docstring("get_dependent_variable_shape").c_str());
         //////////////////////////////////////////////////////////////////////////////////////
         /// FREE FUNCTIONS ///////////////////////////////////////////////////////////////////
         //////////////////////////////////////////////////////////////////////////////////////
 
-//        m.def("create",
-//              &tp::createDependentVariableSaveSettings,
-//              py::arg("dependent_variable_list"),
-//              py::arg("print_variable_indices") = true);
 
         m.def("mach_number",
               &tp::machNumberDependentVariable,
@@ -698,6 +708,16 @@ namespace dependent_variable {
               py::arg("minimum_elevation_angle"),
               get_docstring("minimum_visible_station_body_distances").c_str());
 
+        m.def("center_of_mass",
+              &tp::centerOfMassVariableSaveSettings,
+              py::arg("body"),
+              get_docstring("center_of_mass").c_str());
+
+        m.def("inertia_tensor",
+              &tp::inertiaTensorVariableSaveSettings,
+              py::arg("body"),
+              get_docstring("inertia_tensor").c_str());
+
 
     }
 

tudatpy/kernel/expose_numerical_simulation/expose_propagation_setup/expose_propagator_setup.cpp

@@ -110,8 +110,8 @@ void expose_propagator_setup(py::module &m) {
                           &tp::PropagatorProcessingSettings::setClearNumericalSolutions,
                           get_docstring("PropagatorProcessingSettings.clear_numerical_solution").c_str() )
             .def_property("create_dependent_variable_interface",
-                          &tp::PropagatorProcessingSettings::getCreateDependentVariablesInterface,
-                          &tp::PropagatorProcessingSettings::setCreateDependentVariablesInterface,
+                          &tp::PropagatorProcessingSettings::getUpdateDependentVariableInterpolator,
+                          &tp::PropagatorProcessingSettings::setUpdateDependentVariableInterpolator,
                           get_docstring("PropagatorProcessingSettings.create_dependent_variable_interface").c_str() );
 
     py::class_<tp::SingleArcPropagatorProcessingSettings,

version

@@ -1 +1 @@
-0.7.3.dev18
+0.7.3.dev21