Generally, you should follow the three step process described below when you run
into a problem using Monte. It may seem tedious as you're just starting out, but
working your problem as described is the quickest and surest way to mastering
Monte.
All new users are encouraged to work through the introductory material (
Introduction, Writing Scripts,
and Core Concepts) on the home page. This will give
you a solid footing in some of the most critical Monte concepts, and will allow
you to more easily understand more advanced applications of Monte.
The first time you use a new Monte system, you are encouraged to read about
that system in the Monte In-Depth section.
This should provide you with the names of the Monte classes relevant to that
system, and an overview of how they work together to solve problems. For
instance, the first time you attempt to set up a non-trivial trajectory
integration, reading through the Integrated Trajectories and Equations section will
show you how to properly configure your force models, set up the integrator,
run the propagation interactively, etc.
Once you know the class names that you will be using, you can go into the
reference documentation for detailed information on
how to use the classes. The classes can be easily found by either searching on
their name in the Monte searchbar, or looking them up alphabetically in the
index.
If you're unable to solve your problem via the documentation, it's
very possible you've encountered a bug. You can file a bug by sending an
email to mdn_software@jpl.nasa.gov . Some guidelines when reporting a bug:
Prefix the email subject with 'BUG: ' (no quotes).
Try and include as much detail about the problem as possible,
including any error messages and the machine and operating system.
Be sure to specify the version of Monte you are running. The output of
mpython--version is ideal.
If possible, include some short scripts that highlight the problem.
Python error messages (and Monte error messages) are structured in three
sections. The very top of the error message tells you where in the failed
application the error occurred (green below). The next section traces down the
stack of called functions to the actual origin of the error (red). Finally,
there is a description of the actual error at the very bottom, along with the
error type (yellow, error type in this case is "ValueError").
So how can you use this information to track down your error? Well, usually
the first step is to read the description of the error from the bottom of
the message. In this case "can not convert string to float: h", doesn't seem
very useful (of course you can't convert the letter "h" to a float!), but
often times this description will have very helpful information. One piece of
information that is useful is that the error seems to be color related - it
occurred in a module called "colors.py", in function named "to_rgba", so it
sounds like it could be an error in some kind of color conversion. Next we
go to the line in our script that actually triggered the error. Here we see
that ax.scatter is trying to plot data, and it is specifying a color that
seems dicey (is chrome even a color)? Indeed, this is the source of the error
and changing the color specification to something more reasonable (red)
resolves the issue.
What is a good website for general programming questions and tips?
Stackoverflow is an excellent Q/A site for general programming questions.
However, since Monte is a JPL proprietary software package, you won't
find any tips concerning Monte there.
Why is Monte written in Python (instead of some other language)?
The core libraries of Monte are written in C++ for speed. They are wrapped
and presented to the user in Python for usability, and also because of the
wide variety of excellent, interoperable Python packages available for
use along side Monte (like matplotlib, pandas, NumPy / SciPy, etc).
What is the difference between Monte and the standard Python language?
Monte is a standard Python package, and can be used in conjunction with the
entire standard library and any other standard 3rd party Python package.
