Setting and Recording Module Variables

Source Code

The Python code shown below can be downloaded here.

In some cases, it’s useful to record internal variables from a module, not just the input or output messages. This can be done using Python, though note that recording module variables through Python can slow down the simulation since the logging happens at the scripting layer.

The simulation structure is shown in the figure below. Two modules are created and added to the same task. There are no message connections in this example. Instead, the focus is on recording internal module variables directly.

The code snippet below sets up the modules as in previous examples. The internal variable someVariable from someModule is set in Python using:

someModule.someVariable = ...

from Basilisk.moduleTemplates import cppModuleTemplate
from Basilisk.utilities import SimulationBaseClass
from Basilisk.utilities import macros


def run():
    """
    Illustration of setting and recording module variables
    """

    #  Create a sim module as an empty container
    scSim = SimulationBaseClass.SimBaseClass()

    #  create the simulation process
    dynProcess = scSim.CreateNewProcess("dynamicsProcess")

    # create the dynamics task and specify the integration update time
    dynProcess.addTask(scSim.CreateNewTask("dynamicsTask", macros.sec2nano(1.)))

    # create modules
    mod1 = cppModuleTemplate.CppModuleTemplate()
    mod1.modelTag = "module1"
    scSim.AddModelToTask("dynamicsTask", mod1)

    mod2 = cppModuleTemplate.CppModuleTemplate()
    mod2.modelTag = "module2"
    scSim.AddModelToTask("dynamicsTask", mod2)

    # set module variables
    mod1.dummy = 1
    mod1.dumVector = [1., 2., 3.]
    mod2.dummy = 1
    mod2.dumVector = [1., 2., 3.]

    # request these module variables to be recorded
    mod1Logger = mod1.logger("dummy", macros.sec2nano(1.))
    scSim.AddModelToTask("dynamicsTask", mod1Logger)
    mod2WrapLogger = mod2.logger(["dummy", "dumVector"], macros.sec2nano(1.))
    scSim.AddModelToTask("dynamicsTask", mod2WrapLogger)

    #  initialize Simulation:
    scSim.InitializeSimulation()

    #   configure a simulation stop time and execute the simulation run
    scSim.ConfigureStopTime(macros.sec2nano(1.0))
    scSim.ExecuteSimulation()

    # Print when were the variables logged (the same for every logged variable)
    print("Times: ", mod1Logger.times())

    # Print values logged
    print("mod1.dummy:")
    print(mod1Logger.dummy)
    print("mod2.dummy:")
    print(mod2WrapLogger.dummy)
    print("mod2.dumVector:")
    print(mod2WrapLogger.dumVector)

if __name__ == "__main__":
    run()

Logging a Module Variable

To record a module variable, use the following syntax:

moduleLogger = module.logger(variableName, recordingTime)

Here, variableName can be a string (for one variable) or a list of strings (to log multiple variables). This tells the logger which internal variables to track.

The recordingTime argument is optional. It defines the minimum interval (in nanoseconds) between data recordings. If this argument is not provided, the logging occurs at the module’s update rate.

After the simulation runs, the data can be accessed using:

moduleLogger.variableName

This returns the values of the specified variable over time. To retrieve the times at which the data was recorded, use:

moduleLogger.times()

These time values are in nanoseconds.

Example Output

Running the example script should produce output similar to the following:

source/codeSamples % python bsk-6.py
BSK_INFORMATION: Variable dummy set to 0.000000 in reset.
BSK_INFORMATION: Variable dummy set to 0.000000 in reset.
BSK_INFORMATION: Module ID 1 ran Update at 0.000000s
BSK_INFORMATION: Module ID 2 ran Update at 0.000000s
BSK_INFORMATION: Module ID 1 ran Update at 1.000000s
BSK_INFORMATION: Module ID 2 ran Update at 1.000000s
Times:  [         0 1000000000]
mod1.dummy:
[1. 2.]
mod2.dummy:
[1. 2.]
mod2.dumVector:
[[1. 2. 3.]
 [1. 2. 3.]]

Clearing the Data Log

Like message recorders, loggers accumulate data over the simulation runtime. If you stop the simulation, access the data, and then resume, the data collection continues from where it left off. To reset the log and capture only new data, use the .clear() method:

moduleLogger.clear()

Advanced Data Logging

The module.logger(variableName) method provides a simple way to log variables. However, for more advanced needs—such as logging derived values or data from multiple sources—you can use:

Basilisk.utilities.pythonVariableLogger

This class allows for flexible logging setups with pre-processing logic before storing the data. See scenarioFuelSlosh for an example of advanced logger usage.