Issues with get_zero_proper_mode_rotational_state in Tudat

[luigigisolfi]

Question

User: Hello everyone 😃
I am using the get_zero_proper_mode_rotational_state function, which does not have documentation, and I am having a couple of issues with it.

1. One of the inputs, namely propagator_settings, is supposed to be a SingleArcPropagatorSettings object according to the C++ code. But the propagator that my application involves is a RotationalStatePropagatorSettings object. I am not sure whether that presents a problem and how big this problem can be. However, Python does throw a bunch of warnings and errors. Nevertheless, it keeps running. The warnings and errors are these:

Warning when processing deprecated propagator settitngs, integrator settings defined independently, and in propagator settings
Warning when processing deprecated propagator settitngs, initial propagation time is NaN
Error when computing system state derivative. Input time is NaN
Error, propagation terminated at t=nan(snan), returning propagation data up to current time.
Error when computing system state derivative. Input time is NaN
Error, propagation terminated at t=nan(snan), returning propagation data up to current time.
Error when computing system state derivative. Input time is NaN

For some reason it cannot process the initial state from the propagator and then everything goes downhill from there. I am guessing that is where the difference between the two PropagatorSettings make everything fail(?) But not sure.
On the other hand, the function seems to complain that the integrator settings are defined both independently and in the propagator settings. It is true that the function asks for both objects, which seems redundant because the PropagatorSettings object requires the integrator settings to be created. That's Tudat's workflow, so it seems strange that the function complains about it.
And finally, a very strange thing about these errors is that they do not appear everytime at the same place. When I open PyCharm and run the script for the first time, they appear after the function reports entering the first iteration. If I let it finish and run it again immediately after, they appear before anything else is executed. It looks like a patter that might mean something to someone knowledgable, but sadly not to me.
2. The Python wrapper is having troubles converting its output to a Python object. The error message is however not what I was expecting, as all outputs in the signature reported by Python seem fine to me. This is the error I get:

TypeError: Unable to convert function return value to a Python type! The signature was
	(bodies: tudatpy.kernel.numerical_simulation.environment.SystemOfBodies, integrator_settings: tudat::numerical_integrators::IntegratorSettings<double>, propagator_settings: tudat::propagators::SingleArcPropagatorSettings<double,double>, body_mean_rotational_rate: float, dissipation_times: List[float], propagate_undamped: bool = True) -> Tuple[numpy.ndarray[numpy.float64[m, 1]], List[Tuple[Dict[float, numpy.ndarray[numpy.float64[m, 1]]], Dict[float, numpy.ndarray[numpy.float64[m, 1]]]]], List[Tuple[Dict[float, numpy.ndarray[numpy.float64[m, 1]]], Dict[float, numpy.ndarray[numpy.float64[m, 1]]]]]]

I also got a similar error with another function, and there is an issue on the tudat-team/tudat-space Github repo with both problems. But without fixing this I can't really move forward, so it's a tiny bit urgent. I am going to try fixing the problem myself on my machine with local builds of Tudat, but if in the meantime someone knowledgable could take a look at it or give me a hand, that'd be amazing.
Lastly, I leave here the link to my Github repo where you can find the code to replicate the errors I mention. The file in question is model_A2.py and just running it should do the trick.
Link to repo: https://github.com/YorchMcM/MSc_Thesis_Phobos
So yeah. Sorry for the whole Shakespeare that I just wrote. I hope someone knows what's going on.
Thaanks / Cheeers 😉

[luigigisolfi]

Answer

Tudat Team: Hi Jorge, to answer your questions:
The input type is fine, the RotationalStatePropagatorSettings is a derived class of SingleArcPropagatorSettings
The errors you're getting are due to an incompatibility with the new integrator/propagator setup we have. I'll see if I can correct it asap
The return type issue is a mystery that is thus far beyond me. What I'll do is create a wrapper class for all the output of this function, with that you should have no problems.
I'm at the airport, and will see what I can whip up before I have to go. In the coming days, support from my side will be very limited, as I'll be in meetings. My advice would be to build the kernel from source once I've made the updates

[luigigisolfi]

User: Ooh I see. Kk, That sounds great. Yeah, no worries. I'll try to fix as much as I can myself. Thanks for the help, and sorry for the awful timing:see_no_evil:

[luigigisolfi]

Kk

Tudat Team: This better be a different abbreviation than what is used in Dutch 😉

[luigigisolfi]

Tudat Team:
(https://tudat.slack.com/archives/CU777RGUB/p1676896255028189?thread_ts=1676887409.961889&cid=CU777RGUB)
I've pushed a modification to the develop branch of both tudat and tudatpy
(https://tudat.slack.com/archives/CU777RGUB/p1676896308912179?thread_ts=1676887409.961889&cid=CU777RGUB)
Replace your final lines of the .py with:

damping_results = numerical_simulation.propagation.get_zero_proper_mode_rotational_state(bodies,                                                                                                            propagator_settings,                                                                                                             phobos_mean_rotational_rate,                                                                                                             dissipation_times)

damped_initial_state = damping_results.initial_state
damped_states = damping_results.forward_backward_states

(https://tudat.slack.com/archives/CU777RGUB/p1676896428491749?thread_ts=1676887409.961889&cid=CU777RGUB)
A few notes:

• Start with a (much) smaller damping time, and increase it by a factor of 2 every time (e.g. 4, 8, 16, 32, ... hours)
• Make sure that the phobos_mean_rotational_rate is more precise. This may require some iteration. The way the algorithm works is that it tries to damp the rotation rate to this exact value. If it is not very close to the averaged mean motion, you'll get funny results (e.g. moving out of resonance)

[luigigisolfi]

User: Ookey. Will do. Thank you so muuch.