The techniques required for integrating custom models with STK will vary quite a bit depending on a few things, such as:
• The inputs that the model needs
- Are they time dependent?
- Do you need information from other objects in STK?
- Is there a feedback loop (i.e., does the behavior mode change based on parameters of other objects)?
• The intended use of the model in STK
- Are you just trying to visualize something, or are you making a movie?
- Do you need to compute access?
If you’re thinking about integrating a custom model, try to answer the above questions. You should then be able to put your model into one of the four categories identified and described below. Doing this will put you on the right track to start using your model in STK.
Category 1: Static model
• Description
- It does not vary over time.
- It's not dependent on anything else in the scenario.
• Examples
• Things to consider with this type
- This is the simplest type of external model. STK will be able to use this with its full suite of capabilities.
• Method of use
- This is a static file. You can find documentation for the formats of these files in the STK help. Follow the links in the examples above to see some examples of this documentation. You can bring these files into STK by changing the properties of the object from being defined by one of the built-in analytical types to using the object’s External type and then browsing to the desired file.
• Description
- This model type is a simple function of time.
- You can give it a specific time and it will return the same value consistently regardless of the time of the previous call to the model.
- It is not dependent on anything else in the scenario.
• Examples
- A vehicle that follows a known, predetermined path
- A sensor that scans in a predetermined circular pattern about some central point
• Things to consider with this type
- The time-dependent files are as simple as the static files in Category 1.
- The items that can take a script plugin as an input are listed
here.
- Regardless of the method, STK will be able to use its full suite of capabilities with this category of models.
• Method of Use
- You can put most formulaic and deterministic models into STK through a time-dependent file.
* You can use this method for
ephemeris (.e) and
attitude (.a) files. Put in time-ordered values, and STK reads them and then automatically interpolates between the specified time values.
- For some objects, you can also use a script plugin that takes time as an input from STK and returns a value based on either a lookup table inside your script or some formula that you specify to calculate the value as a function of time.
• Description
- These depend on time or other objects (or both) in the scenario.
- They follow a single control law (no feedback loop).
- They integrate numerically over time from a known starting point to the time of interest to determine the output value.
• Example
- A sensor that tracks another object in the scenario but has limited slew rates
• Things to consider with this type
- They work well with forward animation and reporting values over a time interval.
- Animating backward in time or calculating access intervals may cause unexpected results.
•Method of Use
- Use a script plugin as in Category 2, but include any necessary information from other objects in the scenario as inputs to the script. An example is the current position of the object the sensor is trying to track.
- The script will have to use global variables to remember the time of the previous call and calculate change in time between script calls to do numeric integration over time.
- If you want to do analysis with this model after implementing the script, you will use STK as a forward time simulator to report the values of the model over time. You can write this data to a time-dependent file, which reduces it to a Category 2 model that you can use in place of the Integration model. This will open up the full suite of analysis in STK.
- An example scenario that shows this type of model is linked
here. You will need to have the
Matlab Connectors installed for this scenario to work.
• Description
- These meet the description of either Category 2 or Category 3 except that the formulaic or control law behavior changes based on feedback in the model.
• Example
- A radar performs a raster scan until the probability of detection to a target is greater than a threshold, at which point it changes its mode to track that target.
• Things to consider with this type
- This will likely introduce circular dependencies. In the above example, the probability of detection calculation is dependent on the current orientation of the radar antenna as determined by the scripted behavior; however, the orientation of the antenna depends on the mode of the radar which in turn is a function of the probability of detection.
• Method of Use
- First, break the circular dependencies by having the dependent input values lag by a single time step. In the case of the above example, the radar would point itself based on its raster scan logic and then evaluate the probability of detection (pDet) given that orientation. In the next time step, the pointing on the radar would be dependent on the pDet from the previous time step.
- After breaking this circular dependency, it would still be necessary to reduce this to a Category 2 model (using the method described for the Category 3 model) if you want to have STK’s full suite of analysis capabilities available in your scenario.
