diff --git a/tudatpy/kernel/expose_numerical_simulation/expose_estimation.cpp b/tudatpy/kernel/expose_numerical_simulation/expose_estimation.cpp index 5318a537..b8e83bd5 100644 --- a/tudatpy/kernel/expose_numerical_simulation/expose_estimation.cpp +++ b/tudatpy/kernel/expose_numerical_simulation/expose_estimation.cpp @@ -259,6 +259,177 @@ void expose_estimation(py::module &m) { *************** OBSERVATIONS *************** */ + py::enum_< tom::ObservationFilterType >(m, "ObservationFilterType", + get_docstring("ObservationFilterType").c_str() ) + .value("residual_filtering", tom::ObservationFilterType::residual_filtering ) + .value("absolute_value_filtering", tom::ObservationFilterType::absolute_value_filtering ) + .value("epochs_filtering", tom::ObservationFilterType::epochs_filtering ) + .value("time_bounds_filtering", tom::ObservationFilterType::time_bounds_filtering ) + .value("dependent_variable_filtering", tom::ObservationFilterType::dependent_variable_filtering ) + .export_values(); + + py::enum_< tom::ObservationSetSplitterType >(m, "ObservationSetSplitterType", + get_docstring("ObservationSetSplitterType").c_str() ) + .value("time_tags_splitter", tom::ObservationSetSplitterType::time_tags_splitter ) + .value("time_interval_splitter", tom::ObservationSetSplitterType::time_interval_splitter ) + .value("time_span_splitter", tom::ObservationSetSplitterType::time_span_splitter ) + .value("nb_observations_splitter", tom::ObservationSetSplitterType::nb_observations_splitter ) + .value("dependent_variables_splitter", tom::ObservationSetSplitterType::dependent_variables_splitter ) + .export_values(); + + py::enum_< tom::ObservationParserType >(m, "ObservationParserType", + get_docstring("ObservationParserType").c_str() ) + .value("empty_parser", tom::ObservationParserType::empty_parser ) + .value("observable_type_parser", tom::ObservationParserType::observable_type_parser ) + .value("link_ends_parser", tom::ObservationParserType::link_ends_parser ) + .value("link_end_str_parser", tom::ObservationParserType::link_end_string_parser ) + .value("time_bounds_parser", tom::ObservationParserType::time_bounds_parser ) + .value("ancillary_settings_parser", tom::ObservationParserType::ancillary_settings_parser ) + .value("multi_type_parser", tom::ObservationParserType::multi_type_parser ) + .export_values(); + + py::class_>(m, "ObservationFilterBase", + get_docstring("ObservationFilterBase").c_str() ); + + m.def("observation_filter", + py::overload_cast< tom::ObservationFilterType, + const double, const bool, const bool >( &tom::observationFilter ), + py::arg("filter_type"), + py::arg("filter_value"), + py::arg("filter_out") = true, + py::arg("use_opposite_condition") = false, + get_docstring("observation_filter").c_str() ); + + m.def("observation_filter", + py::overload_cast< tom::ObservationFilterType, + const std::vector< double >, const bool, const bool >( &tom::observationFilter ), + py::arg("filter_type"), + py::arg("filter_value"), + py::arg("filter_out") = true, + py::arg("use_opposite_condition") = false, + get_docstring("observation_filter").c_str() ); + + m.def("observation_filter", + py::overload_cast< tom::ObservationFilterType, + const std::pair< double, double >, const bool, const bool >( &tom::observationFilter ), + py::arg("filter_type"), + py::arg("filter_value"), + py::arg("filter_out") = true, + py::arg("use_opposite_condition") = false, + get_docstring("observation_filter").c_str() ); + + py::class_>(m, "ObservationSetSplitterBase", + get_docstring("ObservationSetSplitterBase").c_str() ); + + m.def("observation_set_splitter", + py::overload_cast< tom::ObservationSetSplitterType, + const std::vector< double >, const int >( &tom::observationSetSplitter ), + py::arg("splitter_type"), + py::arg("splitter_value"), + py::arg("min_number_observations") = 0, + get_docstring("observation_set_splitter").c_str() ); + + m.def("observation_set_splitter", + py::overload_cast< tom::ObservationSetSplitterType, + const double, const int >( &tom::observationSetSplitter), + py::arg("splitter_type"), + py::arg("splitter_value"), + py::arg("min_number_observations") = 0, + get_docstring("observation_set_splitter").c_str() ); + + m.def("observation_set_splitter", + py::overload_cast< tom::ObservationSetSplitterType, + const int, const int >( &tom::observationSetSplitter ), + py::arg("splitter_type"), + py::arg("splitter_value"), + py::arg("min_number_observations") = 0, + get_docstring("observation_set_splitter").c_str() ); + + py::class_>(m, "ObservationCollectionParser", + get_docstring("ObservationCollectionParser").c_str() ); + + m.def("observation_parser", + py::overload_cast< >( &tom::observationParser ), + get_docstring("observation_parser").c_str() ); + + m.def("observation_parser", + py::overload_cast< const tom::ObservableType, const bool >( &tom::observationParser ), + py::arg("observable_type"), + py::arg("use_opposite_condition") = false, + get_docstring("observation_parser").c_str() ); + + m.def("observation_parser", + py::overload_cast< const std::vector< tom::ObservableType >&, const bool >( &tom::observationParser ), + py::arg("observable_type_vector"), + py::arg("use_opposite_condition") = false, + get_docstring("observation_parser").c_str() ); + + m.def("observation_parser", + py::overload_cast< const tom::LinkEnds, const bool >( &tom::observationParser ), + py::arg("link_ends"), + py::arg("use_opposite_condition") = false, + get_docstring("observation_parser").c_str() ); + + m.def("observation_parser", + py::overload_cast< const std::vector< tom::LinkEnds >&, const bool >( &tom::observationParser ), + py::arg("link_ends_vector"), + py::arg("use_opposite_condition") = false, + get_docstring("observation_parser").c_str() ); + + m.def("observation_parser", + py::overload_cast< const std::string, const bool, const bool >( &tom::observationParser ), + py::arg("link_ends_id"), + py::arg( "is_reference_point") = false, + py::arg("use_opposite_condition") = false, + get_docstring("observation_parser").c_str() ); + + m.def("observation_parser", + py::overload_cast< const std::vector< std::string >&, const bool, const bool >( &tom::observationParser ), + py::arg("link_ends_id_vector"), + py::arg( "is_reference_point") = false, + py::arg("use_opposite_condition") = false, + get_docstring("observation_parser").c_str() ); + + m.def("observation_parser", + py::overload_cast< const std::pair< double, double >&, const bool >( &tom::observationParser ), + py::arg("time_bounds"), + py::arg("use_opposite_condition") = false, + get_docstring("observation_parser").c_str() ); + + m.def("observation_parser", + py::overload_cast< const std::vector< std::pair< double, double > >&, const bool >( &tom::observationParser ), + py::arg("time_bounds_vector"), + py::arg("use_opposite_condition") = false, + get_docstring("observation_parser").c_str() ); + + m.def("observation_parser", + py::overload_cast< + const std::shared_ptr< tom::ObservationAncilliarySimulationSettings >, + const bool >( &tom::observationParser ), + py::arg("ancillary_settings"), + py::arg("use_opposite_condition") = false, + get_docstring("observation_parser").c_str() ); + + m.def("observation_parser", + py::overload_cast< + const std::vector< std::shared_ptr< tom::ObservationAncilliarySimulationSettings > >&, + const bool >( &tom::observationParser ), + py::arg("ancillary_settings_vector"), + py::arg("use_opposite_condition") = false, + get_docstring("observation_parser").c_str() ); + + m.def("observation_parser", + py::overload_cast< + const std::vector< std::shared_ptr< tom::ObservationCollectionParser > >&, + const bool >( &tom::observationParser ), + py::arg("observation_parsers"), + py::arg("combine_conditions") = false, + get_docstring("observation_parser").c_str() ); + + py::class_>(m, "ObservationViabilityCalculator", get_docstring("ObservationViabilityCalculator").c_str() ) @@ -298,6 +469,13 @@ void expose_estimation(py::module &m) { py::arg("bodies"), get_docstring("simulate_observations").c_str() ); + m.def("compute_and_set_residuals", + &tss::computeAndSetResiduals, + py::arg("observation_collection"), + py::arg("observation_simulators" ), + py::arg("bodies"), + get_docstring("compute_and_set_residuals").c_str() ); + m.def("create_pseudo_observations_and_models", &tss::simulatePseudoObservations, @@ -349,18 +527,39 @@ void expose_estimation(py::module &m) { py::arg("is_station_transmitting"), get_docstring("compute_target_angles_and_range").c_str() ); - m.def("create_residual_collection", - &tom::createResidualCollection< double, TIME_TYPE >, - py::arg("observed_data"), - py::arg("computed_data" ), - get_docstring("create_residual_collection").c_str() ); + m.def("create_filtered_observation_collection", + py::overload_cast< + const std::shared_ptr< tom::ObservationCollection< double, TIME_TYPE > >, + const std::map< std::shared_ptr< tom::ObservationCollectionParser >, std::shared_ptr< tom::ObservationFilterBase > >& >( + &tom::filterObservations< double, TIME_TYPE > ), + py::arg("original_observation_collection"), + py::arg("observation_filters_map"), + get_docstring("create_filtered_observation_collection").c_str() ); m.def("create_filtered_observation_collection", - &tom::filterResidualOutliers< double, TIME_TYPE >, - py::arg("observed_data"), - py::arg("residual_data" ), - py::arg("cutoff_value_per_observable" ), - get_docstring("create_filtered_residual_collection").c_str() ); + py::overload_cast< + const std::shared_ptr< tom::ObservationCollection< double, TIME_TYPE > >, + const std::shared_ptr< tom::ObservationFilterBase >, + const std::shared_ptr< tom::ObservationCollectionParser > >( + &tom::filterObservations< double, TIME_TYPE > ), + py::arg("original_observation_collection"), + py::arg("observation_filter"), + py::arg("observation_parser") = std::make_shared< tom::ObservationCollectionParser >( ), + get_docstring("create_filtered_observation_collection").c_str() ); + + m.def("split_observation_collection", + &tom::splitObservationSets< double, TIME_TYPE >, + py::arg("original_observation_collection"), + py::arg("observation_set_splitter"), + py::arg("observation_parser") = std::make_shared< tom::ObservationCollectionParser >( ), + get_docstring("split_observation_collection").c_str() ); + + m.def("create_new_observation_collection", + &tom::createNewObservationCollection< double, TIME_TYPE >, + py::arg("original_observation_collection"), + py::arg("observation_parser") = std::make_shared< tom::ObservationCollectionParser >( ), + get_docstring("create_new_observation_collection ").c_str() ); + py::class_< tom::ObservationCollection, std::shared_ptr>>(m, "ObservationCollection", @@ -371,7 +570,7 @@ void expose_estimation(py::module &m) { get_docstring("ObservationCollection.concatenated_times").c_str() ) .def_property_readonly("concatenated_float_times", &tom::ObservationCollection::getConcatenatedDoubleTimeVector, get_docstring("ObservationCollection.concatenated_times").c_str() ) - .def_property_readonly("concatenated_weights", &tom::ObservationCollection::getConcatenatedWeightVector, + .def_property_readonly("concatenated_weights", &tom::ObservationCollection::getConcatenatedWeights, get_docstring("ObservationCollection.concatenated_weights").c_str() ) .def_property_readonly("concatenated_observations", &tom::ObservationCollection::getObservationVector, get_docstring("ObservationCollection.concatenated_observations").c_str() ) @@ -395,6 +594,30 @@ void expose_estimation(py::module &m) { get_docstring("ObservationCollection.time_bounds").c_str() ) .def_property_readonly("sorted_per_set_time_bounds", &tom::ObservationCollection::getSortedObservationSetsTimeBounds, get_docstring("ObservationCollection.time_bounds").c_str() ) + .def("set_observations", py::overload_cast< const Eigen::Matrix< double, Eigen::Dynamic, 1 >& >( + &tom::ObservationCollection::setObservations ), + py::arg("observations"), get_docstring("set_observations").c_str( ) ) + .def("set_observations", py::overload_cast< + const Eigen::Matrix< double, Eigen::Dynamic, 1 >&, + const std::shared_ptr< tom::ObservationCollectionParser > >( + &tom::ObservationCollection::setObservations ), + py::arg("observations"), py::arg("observation_parser"), get_docstring("set_observations").c_str( ) ) + .def("set_observations", py::overload_cast< + const std::map< std::shared_ptr< tom::ObservationCollectionParser >, Eigen::Matrix< double, Eigen::Dynamic, 1 > >& >( + &tom::ObservationCollection::setObservations ), + py::arg("observations_per_parser"), get_docstring("set_observations").c_str( ) ) + .def("set_residuals", py::overload_cast< const Eigen::Matrix< double, Eigen::Dynamic, 1 >& >( + &tom::ObservationCollection::setResiduals ), + py::arg("residuals"), get_docstring("set_residuals").c_str( ) ) + .def("set_residuals", py::overload_cast< + const Eigen::Matrix< double, Eigen::Dynamic, 1 >&, + const std::shared_ptr< tom::ObservationCollectionParser > >( + &tom::ObservationCollection::setResiduals ), + py::arg("residuals"), py::arg("observation_parser"), get_docstring("set_residuals").c_str( ) ) + .def("set_residuals", py::overload_cast< + const std::map< std::shared_ptr< tom::ObservationCollectionParser >, Eigen::Matrix< double, Eigen::Dynamic, 1 > >& >( + &tom::ObservationCollection::setResiduals ), + py::arg("residuals_per_parser"), get_docstring("set_residuals").c_str( ) ) .def("get_link_definitions_for_observables", &tom::ObservationCollection::getLinkDefinitionsForSingleObservable, py::arg( "observable_type" ), get_docstring("ObservationCollection.get_link_definitions_for_observables").c_str() ) @@ -404,30 +627,243 @@ void expose_estimation(py::module &m) { .def("get_single_link_and_type_observations", &tom::ObservationCollection::getSingleLinkAndTypeObservationSets, py::arg( "observable_type" ), py::arg( "link_definition" ), - get_docstring("ObservationCollection.get_single_link_and_type_observations").c_str() ); + get_docstring("ObservationCollection.get_single_link_and_type_observations").c_str() ) + .def( "get_observable_types", &tom::ObservationCollection< double, TIME_TYPE >::getObservableTypes, + py::arg( "observation_parser" ) = std::make_shared< tom::ObservationCollectionParser >( ), + get_docstring( "get_observable_types" ).c_str() ) + .def( "get_bodies_in_link_ends", &tom::ObservationCollection< double, TIME_TYPE >::getBodiesInLinkEnds, + py::arg( "observation_parser" ) = std::make_shared< tom::ObservationCollectionParser >( ), + get_docstring( "get_bodies_in_link_ends" ).c_str() ) + .def( "get_reference_points_in_link_ends", &tom::ObservationCollection< double, TIME_TYPE >::getReferencePointsInLinkEnds, + py::arg( "observation_parser" ) = std::make_shared< tom::ObservationCollectionParser >( ), + get_docstring( "get_reference_points_in_link_ends" ).c_str() ) + .def( "get_time_bounds_list", &tom::ObservationCollection< double, TIME_TYPE >::getTimeBoundsList, + py::arg( "observation_parser" ) = std::make_shared< tom::ObservationCollectionParser >( ), + get_docstring( "get_time_bounds_list" ).c_str() ) + .def( "get_observations", &tom::ObservationCollection< double, TIME_TYPE >::getObservations, + py::arg( "observation_parser" ) = std::make_shared< tom::ObservationCollectionParser >( ), + get_docstring( "get_observations" ).c_str() ) + .def( "get_concatenated_observations", &tom::ObservationCollection< double, TIME_TYPE >::getConcatenatedObservations, + py::arg( "observation_parser" ) = std::make_shared< tom::ObservationCollectionParser >( ), + get_docstring( "get_concatenated_observations" ).c_str() ) + .def( "get_observation_times", &tom::ObservationCollection< double, TIME_TYPE >::getObservationTimes, + py::arg( "observation_parser" ) = std::make_shared< tom::ObservationCollectionParser >( ), + get_docstring( "get_observation_times" ).c_str() ) + .def( "get_concatenated_observation_times", &tom::ObservationCollection< double, TIME_TYPE >::getConcatenatedObservationTimes, + py::arg( "observation_parser" ) = std::make_shared< tom::ObservationCollectionParser >( ), + get_docstring( "get_concatenated_observation_times" ).c_str() ) + .def( "get_observations_and_times", &tom::ObservationCollection< double, TIME_TYPE >::getObservationsAndTimes, + py::arg( "observation_parser" ) = std::make_shared< tom::ObservationCollectionParser >( ), + get_docstring( "get_observations_and_times" ).c_str() ) + .def( "get_concatenated_observations_and_times", &tom::ObservationCollection< double, TIME_TYPE >::getConcatenatedObservationsAndTimes, + py::arg( "observation_parser" ) = std::make_shared< tom::ObservationCollectionParser >( ), + get_docstring( "get_concatenated_observations_and_times" ).c_str() ) + .def( "get_weights", &tom::ObservationCollection< double, TIME_TYPE >::getWeights, + py::arg( "observation_parser" ) = std::make_shared< tom::ObservationCollectionParser >( ), + get_docstring( "get_weights" ).c_str() ) + .def( "get_concatenated_weights", &tom::ObservationCollection< double, TIME_TYPE >::getConcatenatedWeights, + py::arg( "observation_parser" ) = std::make_shared< tom::ObservationCollectionParser >( ), + get_docstring( "get_concatenated_weights" ).c_str() ) + .def( "get_residuals", &tom::ObservationCollection< double, TIME_TYPE >::getResiduals, + py::arg( "observation_parser" ) = std::make_shared< tom::ObservationCollectionParser >( ), + get_docstring( "get_residuals" ).c_str() ) + .def( "get_concatenated_residuals", &tom::ObservationCollection< double, TIME_TYPE >::getConcatenatedResiduals, + py::arg( "observation_parser" ) = std::make_shared< tom::ObservationCollectionParser >( ), + get_docstring( "get_concatenated_residuals" ).c_str() ) + .def( "get_computed_observations", &tom::ObservationCollection< double, TIME_TYPE >::getComputedObservations, + py::arg( "observation_parser" ) = std::make_shared< tom::ObservationCollectionParser >( ), + get_docstring( "get_computed_observations" ).c_str() ) + .def( "get_concatenated_computed_observations", + &tom::ObservationCollection< double, TIME_TYPE >::getConcatenatedComputedObservations, + py::arg( "observation_parser" ) = std::make_shared< tom::ObservationCollectionParser >( ), + get_docstring( "get_concatenated_computed_observations" ).c_str() ) + .def( "set_constant_weight", py::overload_cast< + const double, + const std::shared_ptr< tom::ObservationCollectionParser > >( + &tom::ObservationCollection< double, TIME_TYPE >::setConstantWeight ), + py::arg( "weight" ), + py::arg( "observation_parser" ) = std::make_shared< tom::ObservationCollectionParser >( ), + get_docstring( "set_constant_weight" ).c_str() ) + .def( "set_constant_weight", py::overload_cast< + const Eigen::VectorXd, + const std::shared_ptr< tom::ObservationCollectionParser > >( + &tom::ObservationCollection< double, TIME_TYPE >::setConstantWeight ), + py::arg( "weight" ), + py::arg( "observation_parser" ) = std::make_shared< tom::ObservationCollectionParser >( ), + get_docstring( "set_constant_weight" ).c_str() ) + .def( "set_constant_weight_per_observation_parser", + py::overload_cast< std::map< std::shared_ptr< tom::ObservationCollectionParser >, double > >( + &tom::ObservationCollection< double, TIME_TYPE >::setConstantWeightPerObservable ), + py::arg( "weights_per_observation_parser" ), + get_docstring( "set_constant_weight_per_observation_parser" ).c_str() ) + .def( "set_constant_weight_per_observation_parser", + py::overload_cast< std::map< std::shared_ptr< tom::ObservationCollectionParser >, Eigen::VectorXd > >( + &tom::ObservationCollection< double, TIME_TYPE >::setConstantWeightPerObservable ), + py::arg( "weights_per_observation_parser" ), + get_docstring( "set_constant_weight_per_observation_parser" ).c_str() ) + .def( "set_tabulated_weights", + py::overload_cast< + const Eigen::VectorXd, + const std::shared_ptr< tom::ObservationCollectionParser > >( + &tom::ObservationCollection< double, TIME_TYPE >::setTabulatedWeights ), + py::arg( "tabulated_weights" ), + py::arg( "observation_parser" ) = std::make_shared< tom::ObservationCollectionParser >( ), + get_docstring( "set_tabulated_weights" ).c_str() ) + .def( "set_tabulated_weights", + py::overload_cast< std::map< std::shared_ptr< tom::ObservationCollectionParser >, Eigen::VectorXd > >( + &tom::ObservationCollection< double, TIME_TYPE >::setTabulatedWeights ), + py::arg( "tabulated_weights" ), + get_docstring( "set_tabulated_weights" ).c_str() ) + .def( "filter_observations", + py::overload_cast< + const std::map< std::shared_ptr< tom::ObservationCollectionParser >, + std::shared_ptr< tom::ObservationFilterBase > >&, + const bool >( &tom::ObservationCollection< double, TIME_TYPE >::filterObservations ), + py::arg( "observation_filters" ), + py::arg("save_filtered_observations") = true, + get_docstring( "filter_observations" ).c_str( ) ) + .def( "filter_observations", + py::overload_cast< + std::shared_ptr< tom::ObservationFilterBase >, + std::shared_ptr< tom::ObservationCollectionParser >, + const bool >( &tom::ObservationCollection< double, TIME_TYPE >::filterObservations ), + py::arg( "observation_filters" ), + py::arg( "observation_parser" ) = std::make_shared< tom::ObservationCollectionParser >( ), + py::arg("save_filtered_observations") = true, + get_docstring( "filter_observations" ).c_str( ) ) + .def( "split_observation_sets", + py::overload_cast< + std::shared_ptr< tom::ObservationSetSplitterBase >, + std::shared_ptr< tom::ObservationCollectionParser > >( + &tom::ObservationCollection< double, TIME_TYPE >::splitObservationSets ), + py::arg( "observation_set_splitter" ), + py::arg( "observation_parser" ) = std::make_shared< tom::ObservationCollectionParser >( ), + get_docstring( "split_observation_sets" ).c_str( ) ) + .def( "get_single_observation_sets", + &tom::ObservationCollection< double, TIME_TYPE >::getSingleObservationSets, + py::arg( "observation_parser" ) = std::make_shared< tom::ObservationCollectionParser >( ), + get_docstring( "get_single_observation_sets" ).c_str( ) ) + .def( "print_observation_sets_start_and_size", + &tom::ObservationCollection< double, TIME_TYPE >::printObservationSetsStartAndSize, + get_docstring( "print_observation_sets_start_index_and_size" ).c_str( ) ) + .def( "remove_single_observation_sets", + py::overload_cast< std::shared_ptr< tom::ObservationCollectionParser > >( + &tom::ObservationCollection< double, TIME_TYPE >::removeSingleObservationSets ), + py::arg("observation_parser"), + get_docstring( "remove_single_observation_sets" ).c_str( ) ) + .def( "remove_empty_observation_sets", + &tom::ObservationCollection< double, TIME_TYPE >::removeEmptySingleObservationSets, + get_docstring( "remove_empty_observation_sets" ).c_str( ) ); + + + m.def( "create_single_observation_set", + py::overload_cast< + const tom::ObservableType, const tom::LinkEnds&, + const std::vector< Eigen::Matrix< double, Eigen::Dynamic, 1 > >&, + const std::vector< TIME_TYPE >, const tom::LinkEndType, + const std::shared_ptr< tom::ObservationAncilliarySimulationSettings > >( + &tom::createSingleObservationSet< double, TIME_TYPE > ), + py::arg( "observable_type" ), + py::arg( "link_ends" ), + py::arg( "observations" ), + py::arg( "observation_times" ), + py::arg( "reference_link_end" ), + py::arg( "ancillary_settings" ), + get_docstring( "create_single_observation_set" ).c_str( ) ); + + m.def("filter_observations", + py::overload_cast< + const std::shared_ptr< tom::SingleObservationSet< double, TIME_TYPE > >, + const std::shared_ptr< tom::ObservationFilterBase >, const bool >( + &tom::filterObservations< double, TIME_TYPE > ), + py::arg( "original_observation_set" ), + py::arg( "observation_filter" ), + py::arg( "save_filtered_observations" ) = false, + get_docstring( "filter_observations" ).c_str( ) ); + + m.def("split_observation_set", + py::overload_cast< + const std::shared_ptr< tom::SingleObservationSet< double, TIME_TYPE > >, + const std::shared_ptr< tom::ObservationSetSplitterBase > >( + &tom::splitObservationSet< double, TIME_TYPE > ), + py::arg( "original_observation_set" ), + py::arg( "observation_splitter" ), + get_docstring( "split_observation_set" ).c_str( ) ); py::class_< tom::SingleObservationSet, std::shared_ptr>>(m, "SingleObservationSet", get_docstring("SingleObservationSet").c_str() ) + .def("set_observations", py::overload_cast< const std::vector< Eigen::Matrix< double, Eigen::Dynamic, 1 > >&>( + &tom::SingleObservationSet::setObservations), + py::arg("observations"), get_docstring("SingleObservationSet.set_observations").c_str() ) + .def("set_observations", py::overload_cast< const Eigen::Matrix< double, Eigen::Dynamic, 1 >& >( + &tom::SingleObservationSet::setObservations), + py::arg("observations"), get_docstring("SingleObservationSet.set_observations").c_str() ) + .def("set_residuals", py::overload_cast< const std::vector< Eigen::Matrix< double, Eigen::Dynamic, 1 > >&>( + &tom::SingleObservationSet::setResiduals), + py::arg("residuals"), get_docstring("SingleObservationSet.set_residuals").c_str() ) + .def("set_residuals", py::overload_cast< const Eigen::Matrix< double, Eigen::Dynamic, 1 >& >( + &tom::SingleObservationSet::setResiduals), + py::arg("residuals"), get_docstring("SingleObservationSet.set_residuals").c_str() ) + .def("set_constant_weight", py::overload_cast< const double >( &tom::SingleObservationSet::setConstantWeight ), + py::arg("weight"), get_docstring("SingleObservationSet.set_constant_weight").c_str() ) + .def("set_constant_weight", py::overload_cast< const Eigen::Matrix< double, Eigen::Dynamic, 1 >& >( &tom::SingleObservationSet::setConstantWeight ), + py::arg("weight"), get_docstring("SingleObservationSet.set_constant_weight").c_str() ) + .def("set_tabulated_weights", py::overload_cast< const Eigen::VectorXd& >( &tom::SingleObservationSet::setTabulatedWeights ), + py::arg("weights"), get_docstring("SingleObservationSet.set_tabulated_weights").c_str() ) + .def("filter_observations", &tom::SingleObservationSet::filterObservations, + py::arg("filter"), py::arg("save_filtered_obs") = true, + get_docstring("SingleObservationSet.filter_observations").c_str() ) .def_property_readonly("observable_type", &tom::SingleObservationSet::getObservableType, get_docstring("SingleObservationSet.observable_type").c_str() ) - .def_property_readonly("link_definition", &tom::SingleObservationSet::getLinkEnds, - get_docstring("SingleObservationSet.link_definition").c_str() ) + .def_property("link_definition", + &tom::SingleObservationSet::getLinkEnds, + &tom::SingleObservationSet::setLinkEnds, + get_docstring("SingleObservationSet.link_definition").c_str() ) .def_property_readonly("reference_link_end", &tom::SingleObservationSet::getReferenceLinkEnd, get_docstring("SingleObservationSet.reference_link_end").c_str() ) + .def_property_readonly("number_of_observables", &tom::SingleObservationSet::getNumberOfObservables, + get_docstring("SingleObservationSet.number_of_observables").c_str()) + .def_property_readonly("single_observable_size", &tom::SingleObservationSet::getSingleObservableSize, + get_docstring("SingleObservationSet.single_observaable_size").c_str()) + .def_property_readonly("total_observation_set_size", &tom::SingleObservationSet::getTotalObservationSetSize, + get_docstring("SingleObservationSet.total_observation_set_size").c_str()) + .def_property_readonly("time_bounds", &tom::SingleObservationSet::getTimeBounds, + get_docstring("SingleObservationSet.time_bounds").c_str()) .def_property_readonly("list_of_observations", &tom::SingleObservationSet::getObservations, get_docstring("SingleObservationSet.list_of_observations").c_str() ) .def_property_readonly("observation_times", &tom::SingleObservationSet::getObservationTimes, get_docstring("SingleObservationSet.observation_times").c_str() ) .def_property_readonly("concatenated_observations", &tom::SingleObservationSet::getObservationsVector, get_docstring("SingleObservationSet.concatenated_observations").c_str() ) + .def_property_readonly("computed_observations", &tom::SingleObservationSet::getComputedObservations, + get_docstring("SingleObservationSet.computed_observations").c_str() ) + .def_property_readonly("concatenated_computed_observations", + &tom::SingleObservationSet::getComputedObservationsVector, + get_docstring("SingleObservationSet.concatenated_computed_observations").c_str() ) + .def_property_readonly("residuals", &tom::SingleObservationSet::getResiduals, + get_docstring("SingleObservationSet.residuals").c_str() ) + .def_property_readonly("concatenated_residuals", &tom::SingleObservationSet::getResidualsVector, + get_docstring("SingleObservationSet.concatenated_residuals").c_str() ) + .def_property_readonly("weights", &tom::SingleObservationSet::getWeights, + get_docstring("SingleObservationSet.weights").c_str()) + .def_property_readonly("concatenad_weights", &tom::SingleObservationSet::getWeightsVector, + get_docstring("SingleObservationSet.concatenad_weights").c_str()) + .def_property_readonly("dependent_variables", &tom::SingleObservationSet::getObservationsDependentVariables, + get_docstring("SingleObservationSet.dependent_variables").c_str()) + .def_property_readonly("dependent_variables_history", &tom::SingleObservationSet::getDependentVariableHistory, + get_docstring("SingleObservationSet.dependent_variables_history").c_str()) .def_property_readonly("observations_history", &tom::SingleObservationSet::getObservationsHistory, get_docstring("SingleObservationSet.observations_history").c_str() ) .def_property_readonly("ancilliary_settings", &tom::SingleObservationSet::getAncilliarySettings, get_docstring("SingleObservationSet.ancilliary_settings").c_str() ) .def_property("weights_vector", &tom::SingleObservationSet::getWeightsVector, - &tom::SingleObservationSet::setWeightsVector, - get_docstring("SingleObservationSet.weights_vector").c_str() ); + &tom::SingleObservationSet::setTabulatedWeights, + get_docstring("SingleObservationSet.weights_vector").c_str() ) + .def_property_readonly("filtered_observation_set", &tom::SingleObservationSet::getFilteredObservationSet, + get_docstring("SingleObservationSet.filtered_observation_set").c_str() ) + .def_property_readonly("number_filtered_observations", &tom::SingleObservationSet::getNumberOfFilteredObservations, + get_docstring("SingleObservationSet.number_filtered_observations").c_str() ); m.def("single_observation_set", @@ -620,9 +1056,9 @@ void expose_estimation(py::module &m) { py::arg( "limit_condition_number_for_warning" ) = 1.0E8, get_docstring("CovarianceAnalysisInput.define_covariance_settings").c_str() ) .def_property("weight_matrix_diagonal", - &tss::CovarianceAnalysisInput::getWeightsMatrixDiagonals, - &tss::CovarianceAnalysisInput::setWeightsMatrixDiagonals, - get_docstring("CovarianceAnalysisInput.weight_matrix_diagonal").c_str() ); + &tss::CovarianceAnalysisInput::getWeightsMatrixDiagonals, + &tss::CovarianceAnalysisInput::setWeightsMatrixDiagonals, + get_docstring("CovarianceAnalysisInput.weight_matrix_diagonal").c_str() ); py::class_< tss::EstimationInput, diff --git a/tudatpy/kernel/expose_numerical_simulation/expose_estimation_setup/expose_estimated_parameter_setup.cpp b/tudatpy/kernel/expose_numerical_simulation/expose_estimation_setup/expose_estimated_parameter_setup.cpp index ca6c3840..1463ca09 100644 --- a/tudatpy/kernel/expose_numerical_simulation/expose_estimation_setup/expose_estimated_parameter_setup.cpp +++ b/tudatpy/kernel/expose_numerical_simulation/expose_estimation_setup/expose_estimated_parameter_setup.cpp @@ -38,7 +38,7 @@ void expose_estimated_parameter_setup(py::module &m) { .value("constant_drag_coefficient_type", tep::EstimatebleParametersEnum::constant_drag_coefficient) .value("radiation_pressure_coefficient_type", tep::EstimatebleParametersEnum::radiation_pressure_coefficient) .value("arc_wise_radiation_pressure_coefficient_type", tep::EstimatebleParametersEnum::arc_wise_radiation_pressure_coefficient) - .value("spherical_harmonics_cosine_coefficient_block_type", tep::EstimatebleParametersEnum::arc_wise_initial_body_state) + .value("spherical_harmonics_cosine_coefficient_block_type", tep::EstimatebleParametersEnum::spherical_harmonics_cosine_coefficient_block) .value("spherical_harmonics_sine_coefficient_block_type", tep::EstimatebleParametersEnum::spherical_harmonics_sine_coefficient_block) .value("constant_rotation_rate_type", tep::EstimatebleParametersEnum::constant_rotation_rate) .value("rotation_pole_position_type", tep::EstimatebleParametersEnum::rotation_pole_position) diff --git a/tudatpy/kernel/expose_numerical_simulation/expose_estimation_setup/expose_observation_setup.cpp b/tudatpy/kernel/expose_numerical_simulation/expose_estimation_setup/expose_observation_setup.cpp index 078b15f9..a7568f63 100644 --- a/tudatpy/kernel/expose_numerical_simulation/expose_estimation_setup/expose_observation_setup.cpp +++ b/tudatpy/kernel/expose_numerical_simulation/expose_estimation_setup/expose_observation_setup.cpp @@ -751,10 +751,10 @@ void expose_observation_setup(py::module &m) { &tss::ObservationSimulationSettings< TIME_TYPE >::setViabilitySettingsList, get_docstring("ObservationSimulationSettings.viability_settings_list").c_str() ) .def_property("noise_function", - &tss::ObservationSimulationSettings< TIME_TYPE >::getObservationNoiseFunction, - py::overload_cast< const std::function< double( const double ) >& >( - &tss::ObservationSimulationSettings< TIME_TYPE >::setObservationNoiseFunction ), - get_docstring("ObservationSimulationSettings.noise_function").c_str() ); + &tss::ObservationSimulationSettings< TIME_TYPE >::getObservationNoiseFunction, + py::overload_cast< const std::function< double( const double ) >& >( + &tss::ObservationSimulationSettings< TIME_TYPE >::setObservationNoiseFunction ), + get_docstring("ObservationSimulationSettings.noise_function").c_str() ); // .def_property("observable_type", // &tss::ObservationSimulationSettings::getObservableType, // &tss::ObservationSimulationSettings::setObservableType, @@ -1130,10 +1130,10 @@ void expose_observation_setup(py::module &m) { m.def("process_odf_data_multiple_files", py::overload_cast< - const std::vector< std::string >&, - const std::string&, - const bool, - const std::map< std::string, Eigen::Vector3d >& >( &tom::processOdfData ), + const std::vector< std::string >&, + const std::string&, + const bool, + const std::map< std::string, Eigen::Vector3d >& >( &tom::processOdfData ), py::arg("file_names"), py::arg("spacecraft_name"), py::arg("verbose") = true, @@ -1142,10 +1142,10 @@ void expose_observation_setup(py::module &m) { m.def("process_odf_data_single_file", py::overload_cast< - const std::string&, - const std::string&, - const bool, - const std::map< std::string, Eigen::Vector3d >& >( &tom::processOdfData ), + const std::string&, + const std::string&, + const bool, + const std::map< std::string, Eigen::Vector3d >& >( &tom::processOdfData ), py::arg("file_name"), py::arg("spacecraft_name"), py::arg("verbose") = true, @@ -1172,17 +1172,11 @@ void expose_observation_setup(py::module &m) { py::arg("start_and_end_times_to_process"), get_docstring("create_odf_observed_observation_collection").c_str() ); - m.def("split_observation_sets_into_arc", - &tom::splitObservationSetsIntoArcs< double, TIME_TYPE >, - py::arg("original_observation_collection"), - py::arg("arc_split_interval"), - py::arg("minimum_number_of_observations"), - get_docstring("split_observation_sets_into_arc").c_str() ); - m.def("create_compressed_doppler_collection", &tom::createCompressedDopplerCollection< double, TIME_TYPE >, py::arg("original_observation_collection"), py::arg("compression_ratio"), + py::arg("minimum_number_of_observations") = 10, get_docstring("create_compressed_doppler_collection").c_str() ); diff --git a/tudatpy/kernel/expose_numerical_simulation/expose_propagation_setup/expose_dependent_variable_setup.cpp b/tudatpy/kernel/expose_numerical_simulation/expose_propagation_setup/expose_dependent_variable_setup.cpp index 187bf7ff..15e2caa3 100644 --- a/tudatpy/kernel/expose_numerical_simulation/expose_propagation_setup/expose_dependent_variable_setup.cpp +++ b/tudatpy/kernel/expose_numerical_simulation/expose_propagation_setup/expose_dependent_variable_setup.cpp @@ -301,6 +301,7 @@ namespace dependent_variable { py::arg( "dependent_variable_settings" ), py::arg( "bodies" ), get_docstring( "get_dependent_variable_shape" ).c_str( )); + ////////////////////////////////////////////////////////////////////////////////////// /// FREE FUNCTIONS /////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////