Analysis Tool Controllers

The TimeProvider is the single source of truth for the progression of time throughout the simulation. It represents the 'clock' of a simulation, defining the current simulation time for all events and other AnalysisToolController implementations.

In this snippet, the timeProvider is being used in a BasicProperty to inform the simulation when the passenger is satisfied with a photo. The BasicProperty uses the timeProvider when keeping track of the exact times during execution when the property's value changes.

mIsSatisfiedWithPhoto = new BasicProperty<Boolean>(timeProvider, false);

The MoxieUnitConverter is a utility class that provides the means of converting an instance of javax.measure.Quantity to a different kind of unit. A Quantity represents the Java equivalent of a SysML value type containing a "quantity kind" and a "unit". Quantity and MoxieUnitConverter serve to help Java delegate authors manipulate these values from the Java code while ensuring consistency between the units in the SysML model and the units required by the analysis code. Quantity comes from the "Units of Measurement" 2.0 API in JSR-385. For more details, see the section on using Units under Properties and Operations.

You can find more information about the "Units of Measurement" 2.0 API in JSR-385 at https://unitsofmeasurement.github.io/pages/about.html.

Provides manual control over sending call events and signal events to state machine sessions from within operations. When using @AutoDelegateImplementation, the autogenerated code will handle triggering call events automatically, even if a concrete implementation is provided. Therefore, you only need this dependency when manually implementing an entire delegate class or for manually sending signal events. Otherwise, there is no need to inject this in your constructor.

Here is an example of sending a signal event using the stateMachineRemoteControl:

stateMachineRemoteControl.sendSignalEvent("Structure::Passenger::BuckleUp", target);

Provides a mechanism for instantiating new Java delegate objects and SysML instance specifications during simulation. The classifier behaviors for each newly created delegate instance will start immediately after it is created. The DelegateInstanceManager also enables delegate authors to assign both values for the instance's slots and custom stereotypes for the instance itself. This is especially useful for cases where simulations require a large number of objects parameterized by other objects in the scenario. For instance, when defining the parameters of a large satellite constellation or a group of drones forming a swarm, it can be useful to create each individual instance programmatically at runtime rather than creating separate SysML instance specifications for hundreds of individual objects.

Here is an example of creating a new instance with initialized slots and a custom stereotype:

@AutoDelegateImplementation
@DelegateFor("Structure::CustomBlock")
class MyCustomBlock{
    private DelegateInstanceManager delegateInstanceManager;
    private final BasicProperty<MyCustomBlock> child;

    public MyCustomBlock(@InjectByName("delegateInstanceManager") DelegateInstanceManager instanceManager) {
        delegateInstanceManager = instanceManager;
        //"name", "setting", and "child" Properties will be initialized during Wire-Up
    }

    public void callThisOperationFromSysMLToCreateNewInstanceOfMyself(){
        MyCustomBlock newObject = delegateInstanceManager.create(MyCustomBlock.class)
            .withSlotValue("name", "doppelganger")
            .withSlotValue("setting", 42)
            .withStereotypeInstance(new MyCustomStereotype("hello world!"))
            .spawnNewInstance();
        child.setValue(newObject);
    }
}

@StereotypeImplementationFor("Configuration::CustomStereotype")
class MyCustomStereotype{
    private String tag;
    public MyCustomStereotype(@InjectByTag("tag") String newTag){ tag = newTag; }
    String getValue(){ return tag; }
}

The SimulationLogger provides you with the ability to log custom messages to the simulation log file and console.

In this snippet, the simulationLogger is being used to log a message when the balloon is launching.

mLogger.info("Launching balloon.");

The StkToolbox contains utility methods for interacting with the instance of STK that is supporting the current simulation. It also provides access to the StkObjectModel through IAgStkObjectRoot. The StkObjectModel is also exposed through the StkApplication dependency shown below. Moxie supports only one instance of STK per simulation. See StkToolbox for more information.

The following snippet creates and returns a new STK Aircraft Object:

stkAircraft = toolbox.getRoot().getCurrentScenario().getChildren().
    _new(AgESTKObjectType.E_AIRCRAFT, instanceName);

Provides access to the default representation of Earth inside of STK. In particular, for space-domain operations, it provides information about the inertial and fixed frames exposed as part of the Moxie model libraries.

The earth object provides well-known reference frames for use in analysis inside STK.

earth.getInternationalCelestialReferenceFrame();
earth.getFixedReferenceFrame();

While most interactions with STK happen through the StkToolbox detailed above, StkApplication provides access to the STK application instance in situations when the simulation requires closing, loading, or creating new STK scenarios. If other objects require access to specific STK object paths, closing the existing STK scenario may cause those objects to become invalid. Since there is not a particular order in which objects are instantiated, ensure STK application-level operations occur at well-known times in a simulation, ideally before using any STK Objects within the scenario. Lastly, while this provides some simple operations for interacting with STK, you can perform additional tasks using stkApplication.getCurrentScenario().getRootObject().

The following snippet will start and attach to a new instance of STK and load a blank scenario called "BalloonRide":

StkApplication stkApplication = StkApplication.createNewInstance("BalloonRide");

Provides access to the STK object in the current scenario with the path specified in the stkObjectPath tag of the Moxie-STK::Configuration::MoxieStkExistingObject stereotype.

In this snippet, the StkSpatialPoint adapts the "Center" from the STK object stkObject (the stkAircraft) into an actual SpatialPoint from the Moxie model libraries:

IAgStkObject stkAircraft = stkObject;
mCenter = new StkSpatialPoint(
    toolbox,
                              timeProvider,
                              stkAircraft,
                              earth.getInternationalCelestialReferenceFrame().getReferenceAxes());