Python Code Snippets


# Get reference to running STK instance
from agi.stk13.stkdesktop import STKDesktop

stk = STKDesktop.AttachToApplication()

# Get the IAgStkObjectRoot interface
root = stk.Root

Start STK and get a reference to IAgStkObjectRoot

[Python - STK API]


# Start new instance of STK
from agi.stk13.stkdesktop import STKDesktop

stk = STKDesktop.StartApplication(visible=True) #using optional visible argument

# Get the IAgStkObjectRoot interface
root = stk.Root

# ...

# Clean-up when done
stk.ShutDown()

Start STK Engine and get a reference to IAgStkObjectRoot

[Python - STK API]


# Start new instance of STK Engine
from agi.stk13.stkengine import STKEngine

stk = STKEngine.StartApplication(noGraphics=False) # optionally, noGraphics = True

# Get the IAgStkObjectRoot interface
root = stk.NewObjectRoot()

Add an Exclusion Zone access constraint

[Python - STK API]


# IAgAccessConstraintCollection accessConstraints: Access Constraint collection
excludeZone = accessConstraints.AddNamedConstraint('ExclusionZone')
excludeZone.MaxLat = 45
excludeZone.MinLat = 15
excludeZone.MinLon = -75
excludeZone.MaxLon = -35

Add and configure a central body obstruction access constraint

[Python - STK API]


# IAgAccessConstraintCollection accessConstraints: Access Constraint collection
# Get IAgAccessCnstrCbObstruction interface
cbObstrConstraint = accessConstraints.AddConstraint(AgEAccessConstraints.eCstrCbObstruction)

# AvailableObstructions returns a one dimensional array of obstruction paths
availableArray = cbObstrConstraint.AvailableObstructions

# In this example add all available obstructions
print('Available obstructions')
for i in range(0, len(availableArray)):
    print(availableArray[i])
    if availableArray[i] != "Sun": # Sun is enabled by default
        cbObstrConstraint.AddObstruction(availableArray[i])

# AssignedObstructions returns a one dimensional array of obstruction paths
assignedArray = cbObstrConstraint.AssignedObstructions

print('Assigned obstructions')
for i in range(0, len(assignedArray)):
    print(assignedArray[i])

Add and configure a lighting condition access constraint

[Python - STK API]


# IAgAccessConstraintCollection accessConstraints: Access Constraint collection

# Condition constraint
light = accessConstraints.AddConstraint(AgEAccessConstraints.eCstrLighting)
light.Condition = AgECnstrLighting.eDirectSun

Add and configure a LOS sun exclusion access constraint

[Python - STK API]


# IAgAccessConstraintCollection accessConstraints: Access Constraint collection

# Angle constraint
cnstrAngle = accessConstraints.AddConstraint(AgEAccessConstraints.eCstrLOSSunExclusion)
cnstrAngle.Angle = 176.0

Add and configure a lunar elevation angle access constraint

[Python - STK API]


# IAgAccessConstraintCollection accessConstraints: Access Constraint collection

# To make this more efficient, wrap this method between calls to root.BeginUpdate() and root.EndUpdate()
minmax = accessConstraints.AddConstraint(AgEAccessConstraints.eCstrLunarElevationAngle)
minmax.EnableMin = True
minmax.Min = 11.1
minmax.EnableMax = True
minmax.Max = 88.8

Add and configure a sun elevation angle access constraint

[Python - STK API]


# IAgAccessConstraintCollection accessConstraints: Access Constraint collection

# To make this more efficient, wrap this method between calls to root.BeginUpdate() and root.EndUpdate()
minmax = accessConstraints.AddConstraint(AgEAccessConstraints.eCstrSunElevationAngle)
minmax.EnableMin = True
minmax.Min = 22.2
minmax.EnableMax = True
minmax.Max = 77.7

Add and configure an altitude access constraint

[Python - STK API]


# IAgAccessConstraintCollection accessConstraints: Access Constraint collection

# To make this more efficient, wrap this method between calls to root.BeginUpdate() and root.EndUpdate()
# Attitude constraint
altitude = accessConstraints.AddConstraint(AgEAccessConstraints.eCstrAltitude)
altitude.EnableMin = True
altitude.Min = 20.5  # km

Add multiple access constraints of the same type to an STK Object

[Python - STK API]


# IAgAccessConstraintCollection accessConstraints: Access Constraint collection

objExcl1 = accessConstraints.AddConstraint(AgEAccessConstraints.eCstrObjectExclusionAngle)
objExcl2 = accessConstraints.AddConstraint(AgEAccessConstraints.eCstrObjectExclusionAngle)

Compute Access with Advanced Settings

[Python - STK API]


# IAgStkAccess access: Access object

access.Advanced.EnableLightTimeDelay = True
access.Advanced.TimeLightDelayConvergence = .00005
access.Advanced.AberrationType = AgEAberrationType.eAberrationAnnual
access.Advanced.UseDefaultClockHostAndSignalSense = False
access.Advanced.ClockHost = AgEIvClockHost.eIvBase
access.Advanced.SignalSenseOfClockHost = AgEIvTimeSense.eIvTransmit
access.ComputeAccess()

Compute an access between two STK Objects (using IAgStkObject interface)

[Python - STK API]


# IAgSatellite satellite: Satellite object
# IAgFacility facility: Facility object

# Get access by STK Object
access = satellite.GetAccessToObject(facility)

# Compute access
access.ComputeAccess()

Compute an access between two STK Objects (using object path)

[Python - STK API]


# IAgSatellite satellite: Satellite object

# Get access by object path
access = satellite.GetAccess('Facility/MyFacility')

# Compute access
access.ComputeAccess()

Compute an access for one point

[Python - STK API]


# IAgStkObject facility: Facility object
onePtAccess = facility.CreateOnePointAccess('Satellite/MySatellite')

# Configure properties (if necessary)
onePtAccess.StartTime = root.CurrentScenario.StartTime
onePtAccess.StopTime = root.CurrentScenario.StopTime
onePtAccess.StepSize = 600
onePtAccess.SummaryOption = AgEOnePtAccessSummary.eOnePtAccessSummaryDetailed

# Compute results
results = onePtAccess.Compute()

# Print results
for i in range(0, results.Count):
    result = results.Item(i)
    print('Time: %s HasAccess: %s' % (result.Time, str(result.AccessSatisfied)))

    for j in range(0, result.Constraints.Count):
        constraint = result.Constraints.Item(j)
        print('Constraint: %s Object: %s Status: %s Value:%s' % (constraint.Constraint, constraint.ObjectPath, constraint.Status, str(constraint.Value)))

Compute and extract access interval times

[Python - STK API]


# IAgStkAccess access: Access calculation
# Get and display the Computed Access Intervals
intervalCollection = access.ComputedAccessIntervalTimes

# Set the intervals to use to the Computed Access Intervals
computedIntervals = intervalCollection.ToArray(0, -1)
access.SpecifyAccessIntervals(computedIntervals)

Configure the access analysis time period to specified time instants.

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model root

satellite = root.GetObjectFromPath('Satellite/MySatellite')
facility = root.GetObjectFromPath('Facility/MyFacility')

# For this code snippet, let's use the time interval when the satellite reached min and max altitude values.
# Note, this assumes time at min happens before time at max.
timeOfAltMin = satellite.Vgt.Events.Item('GroundTrajectory.Detic.LLA.Altitude.TimeOfMin')
timeOfAltMax = satellite.Vgt.Events.Item('GroundTrajectory.Detic.LLA.Altitude.TimeOfMax')

# Set the access time period with the times we figured out above.
access = satellite.GetAccessToObject(facility)
access.AccessTimePeriod = AgEAccessTimeType.eUserSpecAccessTime
accessTimePeriod = access.AccessTimePeriodData

accessTimePeriod.AccessInterval.State = AgECrdnSmartIntervalState.eCrdnSmartIntervalStateStartStop

accessStartEpoch = accessTimePeriod.AccessInterval.GetStartEpoch()
accessStartEpoch.SetImplicitTime(timeOfAltMin)
accessTimePeriod.AccessInterval.SetStartEpoch(accessStartEpoch)

accessStopEpoch = accessTimePeriod.AccessInterval.GetStopEpoch()
accessStopEpoch.SetImplicitTime(timeOfAltMax)
accessTimePeriod.AccessInterval.SetStopEpoch(accessStopEpoch)

Configure the access interval to the availability time span of the object where access is being computed to.

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model root

satellite = root.GetObjectFromPath('Satellite/MySatellite')
facility = root.GetObjectFromPath('Facility/MyFacility')
access = satellite.GetAccessToObject(facility)

access.AccessTimePeriod = AgEAccessTimeType.eUserSpecAccessTime
accessTimePeriod = access.AccessTimePeriodData

if (satellite.Vgt.EventIntervals.Contains('AvailabilityTimeSpan')):
    availabilityTimeSpan = satellite.Vgt.EventIntervals.Item('AvailabilityTimeSpan')
    accessTimePeriod.AccessInterval.SetImplicitInterval(availabilityTimeSpan)

Get handle to the object access constraints

[Python - STK API]


# IAgSatellite satellite: Satellite object
accessConstraints = satellite.AccessConstraints

GetAccessBetweenObjectsByPath using the output of GetExistingAccesses

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model root
scenario = root.CurrentScenario
accesses = scenario.GetExistingAccesses()

size = len(accesses)  # number of accesses

object1 = accesses[0][0]   # e.g. "Satellite/MySatellite"
object2 = accesses[0][1]   # e.g.  "Facility/MyFacility"
computed = accesses[0][2]  # e.g. True  (if access has been computed)

access = scenario.GetAccessBetweenObjectsByPath(object1, object2)

Remove all access constraints except for LOS

[Python - STK API]


# IAgAccessConstraintCollection accessConstraints: Access Constraint collection
for i in range(accessConstraints.Count - 1, 0, -1):
    constraint = accessConstraints.Item(i).ConstraintName

    if (constraint == 'LineOfSight') is False:
        if (constraint == 'ExclusionZone'):
            accessConstraints.GetActiveNamedConstraint('ExclusionZone').RemoveAll()

        else:
            accessConstraints.RemoveNamedConstraint(constraint)

Return a list of available constraints

[Python - STK API]


# IAgAccessConstraintCollection accessConstraints: Access Constraint collection
constraintArray = accessConstraints.AvailableConstraints()

print('List of Available Constraints:')
for i in range(0, len(constraintArray)):
    print(constraintArray[i])

Create a New AdvCAT Object

[Python - STK API]


# IAgScenario scenario: Scenario object
advCAT = scenario.Children.New(AgESTKObjectType.eAdvCat, 'MyAdvCAT')

Add Array of Waypoints to Aircraft

[Python - STK API]


# IAgAircraft aircraft: Aircraft object
route = aircraft.Route
ptsArray = [[37.5378, 14.2207, 3.0480, 0.0772, 2], [47.2602, 30.5517, 3.0480, 0.0772, 2]]
route.SetPointsSmoothRateAndPropagate(ptsArray)
# Propagate the route
route.Propagate()

Create a New Aircraft (on the current scenario central body)

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model root
aircraft = root.CurrentScenario.Children.New(AgESTKObjectType.eAircraft, 'MyAircraft')

Set Great Arc Propagator and Add Individual Waypoints to Aircraft

[Python - STK API]


# IAgAircraft aircraft: Aircraft object
# Set route to great arc, method and altitude reference
aircraft.SetRouteType(AgEVePropagatorType.ePropagatorGreatArc)
route = aircraft.Route
route.Method = AgEVeWayPtCompMethod.eDetermineTimeAccFromVel
route.SetAltitudeRefType(AgEVeAltitudeRef.eWayPtAltRefMSL)
# Add first point
waypoint = route.Waypoints.Add()
waypoint.Latitude = 37.5378
waypoint.Longitude = 14.2207
waypoint.Altitude = 5  # km
waypoint.Speed = .1    # km/sec
# Add second point
waypoint2 = route.Waypoints.Add()
waypoint2.Latitude = 47.2602
waypoint2.Longitude = 30.5517
waypoint2.Altitude = 5  # km
waypoint2.Speed = .1    # km/sec
# Propagate the route
route.Propagate()

Set the Attitude of the Aircraft

[Python - STK API]


# IAgAircraft aircraft: Aircraft object
aircraft.Attitude.Basic.SetProfileType(AgEVeProfile.eCoordinatedTurn)

Create an area target (on the current scenario central body)

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model Root

# Create the AreaTarget on the current scenario central body (use
# NewOnCentralBody to specify explicitly the central body)
areaTarget = root.CurrentScenario.Children.New(AgESTKObjectType.eAreaTarget, 'MyAreaTarget')

Define area target boundary and position from list of lat/lon/alt

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model Root
# IAgAreaTarget areaTarget: AreaTarget object

# By using the fine grained interfaces,
# BeginUpdate/EndUpdate prevent intermediate redraws
root.BeginUpdate()
areaTarget.AreaType = AgEAreaType.ePattern
patterns = areaTarget.AreaTypeData
patterns.Add(48.897, 18.637)
patterns.Add(46.534, 13.919)
patterns.Add(44.173, 21.476)
root.EndUpdate()
areaTarget.AutoCentroid = True

Define area target boundary and position from list of lat/lon/alt (using common tasks)

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model Root
# IAgAreaTarget areaTarget: AreaTarget object
# Remove all points in the area target
areaTarget.AreaTypeData.RemoveAll()

# By using the CommonTasks interface,
# make an array of latitude and longitude boundary points
boundary = [[29, -12], [29, 34], [6, 34], [6, -12]]

# SetAreaTypePattern expects a two dimensional array of latitude and longitude values
areaTarget.CommonTasks.SetAreaTypePattern(boundary)

List all points in an area target

[Python - STK API]


# IAgAreaTarget areaTarget: AreaTarget object
if (areaTarget.AreaType == AgEAreaType.ePattern):

    # Get IAgAreaTypePatternCollection interface from AreaTypeData
    patternPoints = areaTarget.AreaTypeData

    # ToArray returns a two dimensional array of latitude and longitude points
    areaTargetPoints = patternPoints.ToArray()

    print('All points in Area Target')
    for i in range(0, len(areaTargetPoints)):
        print('Latitude: %s Longitude: %s' % (str(areaTargetPoints[i][0]), str(areaTargetPoints[i][1])))

Set an elliptical area target

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model Root
# IAgAreaTarget areaTarget: AreaTarget object

# By using the fine grained interfaces,
# BeginUpdate/EndUpdate prevent intermediate redraws
root.BeginUpdate()
areaTarget.AreaType = AgEAreaType.eEllipse
ellipse = areaTarget.AreaTypeData
ellipse.SemiMajorAxis = 85.25  # in km (distance dimension)
ellipse.SemiMinorAxis = 80.75  # in km (distance dimension)
ellipse.Bearing = 44  # in deg (angle dimension)
root.EndUpdate()

Set an elliptical area target (using common tasks)

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model Root
# IAgAreaTarget areaTarget: AreaTarget object

# By using the CommonTasks interface
areaTarget.CommonTasks.SetAreaTypeEllipse(85.25, 80.75, 44)

Create a chain (on the current scenario central body)

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model Root
# Create the Chain on the current scenario central body (use
# NewOnCentralBody to specify explicitly the central body)
chain = root.CurrentScenario.Children.New(AgESTKObjectType.eChain, 'MyChain')

Define and compute a chain (advanced)

[Python - STK API]


# IAgScenario scenario: Scenario object
# IAgChain chain: Chain object

# Remove all previous accesses
chain.ClearAccess()

# Add some objects to chain
chain.StartObject = scenario.Children.GetItemByName("fac1")
chain.EndObject = scenario.Children.GetItemByName("air1")

connections = chain.Connections
connections.Add(scenario.Children.GetItemByName("sat2"), scenario.Children.GetItemByName("air1"), 1, 1)
connections.Add(scenario.Children.GetItemByName("fac1"), scenario.Children.GetItemByName("sat1"), 1, 1)
connections.Add(scenario.Children.GetItemByName("sat1"), scenario.Children.GetItemByName("sat2"), 1, 1)

# Configure chain parameters
chain.AutoRecompute = False
chain.EnableLightTimeDelay = False
chain.TimeConvergence = 0.001
chain.DataSaveMode = AgEDataSaveMode.eSaveAccesses

# Specify our own time period
chain.SetTimePeriodType(AgEChTimePeriodType.eUserSpecifiedTimePeriod)

# Get chain time period interface
chainUserTimePeriod = chain.TimePeriod
chainUserTimePeriod.TimeInterval.SetExplicitInterval(
    scenario.AnalysisInterval.FindStartTime(),
    scenario.AnalysisInterval.FindStopTime())  # Set to scenario period

# Compute the chain
chain.ComputeAccess()

Define and compute a chain (basic)

[Python - STK API]


# IAgScenario scenario: Scenario object
# IAgChain chain: Chain object

chain.StartObject = scenario.Children.GetItemByName("fac1")
chain.EndObject = scenario.Children.GetItemByName("air1")

connections = chain.Connections;
connections.Add(scenario.Children.GetItemByName("sat2"), scenario.Children.GetItemByName("air1"), 1, 1)
connections.Add(scenario.Children.GetItemByName("fac1"), scenario.Children.GetItemByName("sat1"), 1, 1)
connections.Add(scenario.Children.GetItemByName("sat1"), scenario.Children.GetItemByName("sat2"), 1, 1)

# Compute the chain
chain.ComputeAccess()

Prints the strand intervals of chain object

[Python - STK API]


# IAgChain chain: Chain Object
# Compute the chain access if not done already.
chain.ComputeAccess()

# Considered Start and Stop time
print('Chain considered start time: %s' % chain.Vgt.Events.Item('ConsideredStartTime').FindOccurrence().Epoch)
print('Chain considered stop time: %s' % chain.Vgt.Events.Item('ConsideredStopTime').FindOccurrence().Epoch)

objectParticipationIntervals = chain.Vgt.EventIntervalCollections.Item('StrandAccessIntervals')
intervalListResult = objectParticipationIntervals.FindIntervalCollection()

for i in range(0, intervalListResult.IntervalCollections.Count):

    if intervalListResult.IsValid:

        print('Link Name: %s' % objectParticipationIntervals.Labels(i + 1))
        print('--------------')
        for j in range(0, intervalListResult.IntervalCollections.Item(i).Count):

            startTime = intervalListResult.IntervalCollections.Item(i).Item(j).Start
            stopTime = intervalListResult.IntervalCollections.Item(i).Item(j).Stop
            print('Start: %s Stop: %s' % (startTime, stopTime))

Create a New Antenna Object

[Python - STK API]


# IAgStkObject satellite: STK object
antenna = satellite.Children.New(AgESTKObjectType.eAntenna, 'MyAntenna')

Modify Antenna Graphics

[Python - STK API]


# IAgAntenna antenna: Antenna object
contours = antenna.Graphics.ContourGraphics
contours.SetContourType(AgEAntennaContourType.eAntennaContourTypeGain)
contours.Show = True
for i in range(-30, 30, 5):
    contours.Contour.Levels.Add(i)
antenna.VO.ShowContours = True
antenna.VO.VolumeGraphics.Show = True

Modify Antenna Model Type

[Python - STK API]


# IAgAntenna antenna: Antenna object
antenna.ModelComponentLinking.SetComponent('Dipole')
antennaModel = antenna.ModelComponentLinking.Component
antennaModel.DesignFrequency = 15  # GHz
antennaModel.Length = 1.5  # m
antennaModel.LengthToWavelengthRatio = 45
antennaModel.Efficiency = 85  # Percent

Modify Antenna Orientation and Position

[Python - STK API]


# IAgAntenna antenna: Antenna object
antOrientation = antenna.Orientation
antOrientation.AssignAzEl(0, -90, AgEAzElAboutBoresight.eAzElAboutBoresightRotate)
antOrientation.PositionOffset.X = 0.0  # m
antOrientation.PositionOffset.Y = 1  # m
antOrientation.PositionOffset.Z = 0.25  # m

Modify Antenna Refraction

[Python - STK API]


# IAgAntenna antenna: Antenna object
antenna.UseRefractionInAccess = True
antenna.Refraction = AgESnRefractionType.eITU_R_P834_4
refraction = antenna.RefractionModel
refraction.Ceiling = 5000  # m
refraction.AtmosAltitude = 10000  # m
refraction.KneeBendFactor = 0.2

Create a New Receiver Object

[Python - STK API]


# IAgStkObject satellite: STK object
receiver = satellite.Children.New(AgESTKObjectType.eReceiver, 'MyReceiver')

Modify Orientation of the Receiver Antenna

[Python - STK API]


# Complex receivers Only
# IAgReceiver receiver: Receiver object
receiver.ModelComponentLinking.SetComponent("Complex Receiver Model")
recModel = receiver.ModelComponentLinking.Component
antennaControl = recModel.AntennaControl
antOrientation = antennaControl.EmbeddedModelOrientation
antOrientation.AssignAzEl(45, 85, AgEAzElAboutBoresight.eAzElAboutBoresightRotate)
antOrientation.PositionOffset.X = 0.5  # m
antOrientation.PositionOffset.Y = 0.75  # m
antOrientation.PositionOffset.Z = 1  # m

Modify Receiver Demodulator Properties

[Python - STK API]


# IAgReceiver receiver: Receiver object
recModel = receiver.ModelComponentLinking.Component
recModel.AutoSelectDemodulator = False
recModel.SetDemodulator('16PSK')

Modify Receiver Embedded Antenna

[Python - STK API]


# IAgReceiver receiver: Receiver object
receiver.ModelComponentLinking.SetComponent("Complex Receiver Model")
recModel = receiver.ModelComponentLinking.Component
antennaControl = recModel.AntennaControl
antennaControl.EmbeddedModelComponentLinking.SetComponent('Hemispherical')
antennaControl.EmbeddedModelComponentLinking.Component.Efficiency = 85  # Percent

Modify Receiver Filter Properties

[Python - STK API]


# IAgReceiver receiver: Receiver object
recModel = receiver.ModelComponentLinking.Component
recModel.EnableFilter = True
recModel.FilterComponentLinking.SetComponent('Bessel')
recFilter = recModel.FilterComponentLinking.Component
recFilter.LowerBandwidthLimit = -20
recFilter.UpperBandwidthLimit = 20
recFilter.CutoffFrequency = 10

Modify Receiver Model Type

[Python - STK API]


# IAgReceiver receiver: Receiver object
receiver.ModelComponentLinking.SetComponent('Complex Receiver Model')
recModel = receiver.ModelComponentLinking.Component
recModel.AutoTrackFrequency = False
recModel.Frequency = 11.81

Modify Receiver Polarization Properties

[Python - STK API]


# IAgReceiver receiver: Receiver object
recModel = receiver.ModelComponentLinking.Component
recModel.EnablePolarization = True
recModel.SetPolarizationType(AgEPolarizationType.ePolarizationTypeLinear)
polarization = recModel.Polarization
polarization.ReferenceAxis = AgEPolarizationReferenceAxis.ePolarizationReferenceAxisZ
polarization.CrossPolLeakage = -60  # dB

Modify Receiver System Noise Temperature

[Python - STK API]


# IAgReceiver receiver: Receiver object
receiver.ModelComponentLinking.SetComponent("Complex Receiver Model")
recModel = receiver.ModelComponentLinking.Component
recModel.SystemNoiseTemperature.ConstantNoiseTemperature = 280  # K

Receiver additional Gain

[Python - STK API]


# IAgReceiver receiver: Receiver object
recModel = receiver.ModelComponentLinking.Component
gain = recModel.PreReceiveGainsLosses.Add(5)  # dB
gain.Identifier = 'Example Gain'

Create a New Transmitter Object

[Python - STK API]


# IAgStkObject satellite: STK object
transmitter = satellite.Children.New(AgESTKObjectType.eTransmitter, 'MyTransmitter')

Modify Transmitter Embedded Antenna

[Python - STK API]


# IAgTransmitter transmitter: Transmitter object
transmitter.ModelComponentLinking.SetComponent("Complex Transmitter Model")
txModel = transmitter.ModelComponentLinking.Component
antennaControl = txModel.AntennaControl
antennaControl.EmbeddedModelComponentLinking.SetComponent('Isotropic')
antennaControl.EmbeddedModelComponentLinking.Component.Efficiency = 85  # Percent

Modify Transmitter Filter

[Python - STK API]


# IAgTransmitter transmitter: Transmitter object
txModel = transmitter.ModelComponentLinking.Component
txModel.EnableFilter = True
txModel.FilterComponentLinking.SetComponent('Butterworth')
recFilter = txModel.FilterComponentLinking.Component
recFilter.LowerBandwidthLimit = -20
recFilter.UpperBandwidthLimit = 20
recFilter.CutoffFrequency = 10

Modify Transmitter Model Type

[Python - STK API]


# IAgTransmitter transmitter: Transmitter object
transmitter.ModelComponentLinking.SetComponent('Complex Transmitter Model')
txModel = transmitter.ModelComponentLinking.Component
txModel.Frequency = 14  # GHz
txModel.Power = 25  # dBW
txModel.DataRate = 15  # Mb/sec

Modify Transmitter Modulator Properties

[Python - STK API]


# IAgTransmitter transmitter: Transmitter object
txModel = transmitter.ModelComponentLinking.Component
txModel.SetModulator('BPSK')
txModel.Modulator.AutoScaleBandwidth = True

Modify Transmitter Orientation and Position

[Python - STK API]


# IAgTransmitter transmitter: Transmitter object
transmitter.ModelComponentLinking.SetComponent("Complex Transmitter Model")
txModel = transmitter.ModelComponentLinking.Component
antennaControl = txModel.AntennaControl
antOrientation = antennaControl.EmbeddedModelOrientation
antOrientation.AssignAzEl(0, 90, 1)  # 1 represents Rotate About Boresight
antOrientation.PositionOffset.X = 0.0  # m
antOrientation.PositionOffset.Y = 1  # m
antOrientation.PositionOffset.Z = 0.25  # m

Modify Transmitter Polarization Properties

[Python - STK API]


# IAgTransmitter transmitter: Transmitter object
transmitter.ModelComponentLinking.SetComponent("Complex Transmitter Model")
txModel = transmitter.ModelComponentLinking.Component
txModel.EnablePolarization = True
txModel.SetPolarizationType(AgEPolarizationType.ePolarizationTypeLinear)
polarization = txModel.Polarization
polarization.ReferenceAxis = AgEPolarizationReferenceAxis.ePolarizationReferenceAxisY
polarization.TiltAngle = 15  # deg

Transmitter additional Gain

[Python - STK API]


# IAgTransmitter transmitter: Transmitter object
txModel = transmitter.ModelComponentLinking.Component
gain = txModel.PostTransmitGainsLosses.Add(-5)  # dB
gain.Identifier = 'Example Loss'

Define a constellation

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model Root
# IAgSatellite satellite: Satellite object
constellation = root.CurrentScenario.Children.New(AgESTKObjectType.eConstellation, 'MyConstellation')
constellation.Objects.AddObject(satellite)
constellation.Objects.Add('*/Facility/MyFacility')

Compute Coverage

[Python - STK API]


# IAgCoverageDefinition coverage: Coverage object
coverage.ComputeAccesses()

Create a New CoverageDefinition (on the current scenario central body)

[Python - STK API]


# IAgScenario scenario: Scenario object
# Create new Coverage Definition and set the Bounds to an area target
coverage = scenario.Children.New(AgESTKObjectType.eCoverageDefinition, 'MyCoverage')
coverage.Grid.BoundsType = AgECvBounds.eBoundsCustomRegions
covGrid = coverage.Grid
bounds = covGrid.Bounds
bounds.AreaTargets.Add('AreaTarget/MyAreaTarget')
# Define the Grid Resolution
Res = covGrid.Resolution
Res.LatLon = .5   # deg
# Set the satellite as the Asset
coverage.AssetList.Add('Satellite/MySatellite')

# Turn off Show Grid Points
coverage.Graphics.Static.IsPointsVisible = False

Set Advanced Settings for Coverage

[Python - STK API]


# IAgCoverageDefinition coverage: Coverage object
advanced = coverage.Advanced
advanced.AutoRecompute = False
advanced.DataRetention = AgECvDataRetention.eAllData
advanced.SaveMode = AgEDataSaveMode.eSaveAccesses

Set the Coverage Interval to an object's availability Analysis interval

[Python - STK API]


# IAgSatellite satellite: Satellite object
# IAgCoverageDefinition coverage: Coverage object
satVGT = satellite.Vgt
AvailTimeSpan = satVGT.EventIntervals.Item('AvailabilityTimeSpan')
IntResult = AvailTimeSpan.FindInterval()
coverage.Interval.AnalysisInterval.SetStartAndStopTimes(IntResult.Interval.Start, IntResult.Interval.Stop)

Extracting Elements from Data Providers with Groups

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model root
# IAgSatellite satellite: Satellite object
# IAgScenario scenario: Scenario object
# Change DateFormat dimension to epoch seconds to make the data easier to handle in
# Python
root.UnitPreferences.Item('DateFormat').SetCurrentUnit('EpSec')
satPosDP = satellite.DataProviders.Item('Cartesian Position').Group.Item('ICRF').Exec(scenario.StartTime, scenario.StopTime, 60)
satx = satPosDP.DataSets.GetDataSetByName('x').GetValues()
saty = satPosDP.DataSets.GetDataSetByName('y').GetValues()
satz = satPosDP.DataSets.GetDataSetByName('z').GetValues()

satVelDP = satellite.DataProviders.GetDataPrvTimeVarFromPath('Cartesian Velocity/ICRF').Exec(scenario.StartTime, scenario.StopTime, 60)
# There are 4 Methods to get DP From a Path depending on the kind of DP:
#   GetDataPrvTimeVarFromPath
#   GetDataPrvIntervalFromPath
#   GetDataPrvInfoFromPath
#   GetDataPrvFixedFromPath
satvx = satVelDP.DataSets.GetDataSetByName('x').GetValues()
satvy = satVelDP.DataSets.GetDataSetByName('y').GetValues()
satvz = satVelDP.DataSets.GetDataSetByName('z').GetValues()

Extracting Elements from Data Providers with PreData

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model root
# IAgFacility facility: Facility object
# IAgScenario scenario: Scenario object
# Change DateFormat dimension to epoch seconds to make the data easier to handle in
# Python
root.UnitPreferences.Item('DateFormat').SetCurrentUnit('EpSec')
facChooseDP = facility.DataProviders.Item('Points Choose System')
dataProvCenter = facChooseDP.Group.Item('Center')
# Choose the reference system you want to report the Center point in
dataProvCenter.PreData = 'CentralBody/Earth TOD'
rptElems = [['Time'], ['x'], ['y'], ['z']]
results = dataProvCenter.ExecElements(scenario.StartTime, scenario.StopTime, 60, rptElems)
datasets = results.DataSets
Time = datasets.GetDataSetByName('Time').GetValues()
facTODx = datasets.GetDataSetByName('x').GetValues()
facTODy = datasets.GetDataSetByName('y').GetValues()
facTODz = datasets.GetDataSetByName('z').GetValues()

Getting Data for a Single Point in Time

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model root
# IAgSatellite satellite: Satellite object
# Change DateFormat dimension to epoch seconds to make the data easier to handle in
# Python
root.UnitPreferences.Item('DateFormat').SetCurrentUnit('EpSec')
satPassDP = satellite.DataProviders.Item('Precision Passes').ExecSingle(2600)
passes = satPassDP.DataSets.GetDataSetByName('Precision Pass Number').GetValues()

Getting Data for Specific Points and Elements

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model root
# IAgSatellite satellite: Satellite object
# Change DateFormat dimension to epoch seconds to make the data easier to handle in
# Python
root.UnitPreferences.Item('DateFormat').SetCurrentUnit('EpSec')
times = [[0], [15000], [20000], [55000]]
elems = [['Time'], ['Precision Pass Number']]
satPassesDP = satellite.DataProviders.Item('Precision Passes').ExecSingleElementsArray(times, elems)
passes = satPassesDP.GetArray(1)

Using a Time Dependent Data Provider and requesting only specified elements

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model root
# IAgSatellite satellite: Satellite object
# IAgScenario scenario: Scenario object
# Change DateFormat dimension to epoch seconds to make the data easier to handle in
# Python
root.UnitPreferences.Item('DateFormat').SetCurrentUnit('EpSec')
elems = [['Time'], ['q1'], ['q2'], ['q3'], ['q4']]
satDP = satellite.DataProviders.Item('Attitude Quaternions').ExecElements(scenario.StartTime, scenario.StopTime, 60, elems)
# Whenever you pass an index to an array, you need to cast it to a long
# equivalent (int32)
satTime = satDP.DataSets.Item(0).GetValues
satq1 = satDP.DataSets.Item(1).GetValues
satq2 = satDP.DataSets.Item(2).GetValues
satq3 = satDP.DataSets.Item(3).GetValues
satq4 = satDP.DataSets.Item(4).GetValues

Using an interval Data Provider

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model root
# IAgSatellite satellite: Satellite object
# IAgFacility facility: Facility object

# Change DateFormat dimension to epoch seconds to make the data easier to handle in
# Python
root.UnitPreferences.Item('DateFormat').SetCurrentUnit('EpSec')
# Get the current scenario
scenario = root.CurrentScenario
# Set up the access object
access = satellite.GetAccessToObject(facility)
access.ComputeAccess()
# Get the Access AER Data Provider
accessDP = access.DataProviders.Item('Access Data').Exec(scenario.StartTime, scenario.StopTime)

accessStartTimes = accessDP.DataSets.GetDataSetByName('Start Time').GetValues
accessStopTimes = accessDP.DataSets.GetDataSetByName('Stop Time').GetValues

Add an AzEl Mask to a Facility

[Python - STK API]


# IAgFacility facility: Facility Object
facility.SetAzElMask(AgEAzElMaskType.eTerrainData, 0)

Create a facility (on the current scenario central body)

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model Root
facility = root.CurrentScenario.Children.New(AgESTKObjectType.eFacility, 'MyFacility')

Set the geodetic position of the facility

[Python - STK API]


# IAgFacility facility: Facility Object
facility.Position.AssignGeodetic(41.9849, 21.4039, 0)  # Latitude, Longitude, Altitude

# Set altitude to height of terrain
facility.UseTerrain = True

# Set altitude to a distance above the ground
facility.HeightAboveGround = .05   # km

Display the AzElMask in 2D/3D

[Python - STK API]


# IAgFacility facility: Facility Object
azelMask = facility.Graphics.AzElMask
azelMask.RangeVisible = True
azelMask.NumberOfRangeSteps = 10
azelMask.DisplayRangeMinimum = 0    # km
azelMask.DisplayRangeMaximum = 100  # km
azelMask.RangeColorVisible = True
azelMask.RangeColor = Colors.Cyan

Configure the Contours of the FOM and define a color ramp

[Python - STK API]


# IAgCoverageDefinition coverage: Coverage object
# IAgFigureOfMerit fom: Figure Of Merit object
satisfaction = coverage.Graphics.Static
satisfaction.IsRegionVisible = False
Animation = fom.VO.Animation
Animation.IsVisible = False
VOcontours = fom.VO.Static
VOcontours.IsVisible = True
contours = fom.Graphics.Static.Contours
contours.IsVisible = True
contours.ContourType = AgEFmGfxContourType.eSmoothFill
contours.ColorMethod = AgEFmGfxColorMethod.eColorRamp
contours.LevelAttributes.RemoveAll()

contours.LevelAttributes.AddLevelRange(590, 660, 10)   # Start, Start, Step
contours.RampColor.StartColor = Colors.Red
contours.RampColor.EndColor = Colors.Blue

Create a new Figure of Merit of type Access Duration

[Python - STK API]


# IAgCoverageDefinition coverage: Coverage object
fom = coverage.Children.New(AgESTKObjectType.eFigureOfMerit, 'AccessDuration')
fom.SetDefinitionType(AgEFmDefinitionType.eFmAccessDuration)
fom.Definition.SetComputeType(AgEFmCompute.eMaximum)

Add Array of Waypoints to Ground Vehicle and Interpolate over Terrain

[Python - STK API]


# IAgGroundVehicle grndVehicle: Ground Vehicle object
route = grndVehicle.Route
ptsArray = [[41.97766217, 21.44863761, 0, 0.026, .5], [41.97422351, 21.39956154, 0, 0.026, .5], [41.99173299, 21.40796942, 0, 0.026, .5]]
route.SetPointsSmoothRateAndPropagate(ptsArray)
route.SetAltitudeRefType(AgEVeAltitudeRef.eWayPtAltRefTerrain)
route.AltitudeRef.Granularity = .001
route.AltitudeRef.InterpMethod = AgEVeWayPtInterpMethod.eWayPtTerrainHeight
# Propagate the route
route.Propagate()

Create a New Ground Vehicle (on the current scenario central body)

[Python - STK API]


# IAgScenario scenario: Scenario object
grndVehicle = scenario.Children.New(AgESTKObjectType.eGroundVehicle, 'MyVehicle')
grndVehicle.SetRouteType(AgEVePropagatorType.ePropagatorGreatArc)

Set Great Arc Propagator and Add Individual Waypoints to Ground Vehicle

[Python - STK API]


# IAgGroundVehicle grndVehicle: Ground Vehicle object
# Set route to great arc, method and altitude reference
grndVehicle.SetRouteType(AgEVePropagatorType.ePropagatorGreatArc)
route = grndVehicle.Route
route.Method = AgEVeWayPtCompMethod.eDetermineTimeAccFromVel
route.SetAltitudeRefType(AgEVeAltitudeRef.eWayPtAltRefWGS84)
# Add first point
waypoint = route.Waypoints.Add()
waypoint.Latitude = 56.18
waypoint.Longitude = 40.91
waypoint.Altitude = 0  # km
waypoint.Speed = .026  # km/sec
# Add second point
waypoint2 = route.Waypoints.Add()
waypoint2.Latitude = 50.22
waypoint2.Longitude = 11.05
waypoint2.Altitude = 0  # km
waypoint2.Speed = .026  # km/sec
# Propagate the route
route.Propagate()

Create a New LineTarget (on the current scenario central body)

[Python - STK API]


# IAgScenario scenario: Scenario object
lineTarget = scenario.Children.New(AgESTKObjectType.eLineTarget, 'MyLineTarget')
point1 = lineTarget.Points.Add(34.72, -118.34)
point2 = lineTarget.Points.Add(30.83, -82.67)

Create a New Missile (on the current scenario central body)

[Python - STK API]


# IAgScenario scenario: Scenario object
missile = scenario.Children.New(AgESTKObjectType.eMissile, 'MyMissile')
missile.SetTrajectoryType(AgEVePropagatorType.ePropagatorBallistic)
trajectory = missile.Trajectory
root.UnitPreferences.SetCurrentUnit('DateFormat', 'EpSec')
trajectory.EphemerisInterval.SetExplicitInterval(0, 0)  # stop time later computed based on propagation
trajectory.Launch.Lat = 29
trajectory.Launch.Lon = -81
trajectory.ImpactLocation.Impact.Lat = 27
trajectory.ImpactLocation.Impact.Lon = -43
trajectory.ImpactLocation.SetLaunchControlType(AgEVeLaunchControl.eLaunchControlFixedApogeeAlt)
trajectory.ImpactLocation.LaunchControl.ApogeeAlt = 1200   # km
trajectory.Propagate()

Create a New MTO (on the current scenario central body)

[Python - STK API]


# IAgScenario scenario: Scenario object
mto = scenario.Children.New(AgESTKObjectType.eMTO, 'MyMTO')

root.UnitPreferences.SetCurrentUnit('DateFormat', 'EpSec')

mtoTimes = [[0], [7200]]
mtoLats = [[36.77], [34.80]]
mtoLons = [[-77.25], [-78.37]]
mtoAlts = [[5], [5]]

track1 = mto.Tracks.AddTrack(1, mtoTimes, mtoLats, mtoLons, mtoAlts)
track1.Interpolate = True
# Change the color of the track
mto.Graphics.Tracks.GetTrackFromId(1).Color = Colors.Red

Load MTO track points from file

[Python - STK API]


# LoadPoints expects the path an Ephemeris file path
# IAgMto mto: MTO Object
track2 = mto.Tracks.Add(2)
track2.Points.LoadPoints(r'C:\Program Files\AGI\STK_ODTK 13\Data\Resources\stktraining\text\EphemerisLLATimePosVel_Example.e')
track2.Interpolate = True

Compute Object Coverage

[Python - STK API]


# IAgAircraft aircraft: Aircraft object
objCoverage = aircraft.ObjectCoverage
objCoverage.Assets.RemoveAll
objCoverage.Assets.Add('Satellite/MySatellite')
objCoverage.UseObjectTimes = True
objCoverage.Compute()

objCoverageFOM = objCoverage.FOM
objCoverageFOM.SetDefinitionType(AgEFmDefinitionType.eFmCoverageTime)
objCoverageFOM.Definition.SetComputeType(AgEFmCompute.eTotal)

Create a New Planet

[Python - STK API]


# IAgScenario scenario: Scenario object
planet = scenario.Children.New(AgESTKObjectType.ePlanet, 'Mars')
planet.CommonTasks.SetPositionSourceCentralBody('Mars', AgEEphemSourceType.eEphemJPLDE)

Modify Planet 2D Properties

[Python - STK API]


# IAgPlanet planet: Planet object
planet2D = planet.Graphics
planet2D.Color = Colors.Red
planet2D.Inherit = False
planet2D.OrbitVisible = True
planet2D.SubPlanetPointVisible = False
planet2D.SubPlanetLabelVisible = False

Create a satellite (on the current scenario central body)

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model Root
satellite = root.CurrentScenario.Children.New(AgESTKObjectType.eSatellite, 'MySatellite')

Export an ephemeris file to scenario folder

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model Root
# IAgSatellite satellite: Satellite object
scenPath = root.ExecuteCommand('GetDirectory / Scenario').Item(0)
satelliteFilePath = '%s\\%s.e' % (scenPath, satellite.InstanceName)
satelliteFilePath = satelliteFilePath.replace("\\", "\\\\")
satellite.ExportTools.GetEphemerisStkExportTool().Export(satelliteFilePath)

Set initial state of satellite and propagate

[Python - STK API]


# IAgSatellite satellite: Satellite object
keplerian = satellite.Propagator.InitialState.Representation.ConvertTo(AgEOrbitStateType.eOrbitStateClassical)
keplerian.SizeShapeType = AgEClassicalSizeShape.eSizeShapeAltitude
keplerian.LocationType = AgEClassicalLocation.eLocationTrueAnomaly
keplerian.Orientation.AscNodeType = AgEOrientationAscNode.eAscNodeLAN

# Assign the perigee and apogee altitude values:
keplerian.SizeShape.PerigeeAltitude = 500      # km
keplerian.SizeShape.ApogeeAltitude = 600       # km

# Assign the other desired orbital parameters:
keplerian.Orientation.Inclination = 90         # deg
keplerian.Orientation.ArgOfPerigee = 12        # deg
keplerian.Orientation.AscNode.Value = 24       # deg
keplerian.Location.Value = 180                 # deg

# Apply the changes made to the satellite's state and propagate:
satellite.Propagator.InitialState.Representation.Assign(keplerian)
satellite.Propagator.Propagate()

Set satellite attitude basic spinning

[Python - STK API]


# IAgSatellite satellite: Satellite object
basic = satellite.Attitude.Basic
basic.SetProfileType(AgEVeProfile.eProfileSpinning)
basic.Profile.Body.AssignXYZ(0, 0, 1)
basic.Profile.Inertial.AssignXYZ(0, 1, 0)
basic.Profile.Rate = 6   # rev/sec

Set satellite attitude external

[Python - STK API]


# IAgSatellite satellite: Satellite object
satellite.Attitude.External.Load(r'C:\Program Files\AGI\STK_ODTK 13\Data\Resources\stktraining\text\AttitudeTimeEulerAngles_Example.a')

Set satellite attitude targeting

[Python - STK API]


# IAgSatellite satellite: Satellite object
attitudePointing = satellite.Attitude.Pointing
attitudePointing.UseTargetPointing = True
attitudePointing.Targets.RemoveAll()
attitudePointing.Targets.Add('AreaTarget/MyAreaTarget')
attitudePointing.TargetTimes.UseAccessTimes = True

Set satellite propagator to Astrogator and clear segments

[Python - STK API]


# IAgSatellite satellite: Satellite object
satellite.SetPropagatorType(AgEVePropagatorType.ePropagatorAstrogator)
driver = satellite.Propagator
# Clear all segments from the MCS
driver.MainSequence.RemoveAll()

Set satellite propagator to HPOP and set force model properties

[Python - STK API]


# IAgSatellite satellite: Satellite object
satellite.SetPropagatorType(AgEVePropagatorType.ePropagatorHPOP)
satellite.Propagator.Step = 60
satellite.Propagator.InitialState.Representation.AssignCartesian(AgECoordinateSystem.eCoordinateSystemFixed, 6406.92, -1787.59, -506.422, 2.10185, 6.48871, 3.64041)

forceModel = satellite.Propagator.ForceModel
forceModel.CentralBodyGravity.File = r'C:\Program Files\AGI\STK_ODTK 13\STKData\CentralBodies\Earth\WGS84_EGM96.grv'
forceModel.CentralBodyGravity.MaxDegree = 21
forceModel.CentralBodyGravity.MaxOrder = 21
forceModel.Drag.Use = True
forceModel.Drag.DragModel.Cd = 0.01
forceModel.Drag.DragModel.AreaMassRatio = 0.01
forceModel.SolarRadiationPressure.Use = False

integrator = satellite.Propagator.Integrator
integrator.DoNotPropagateBelowAlt = -1e6
integrator.IntegrationModel = AgEVeIntegrationModel.eRKF78
integrator.StepSizeControl.Method = AgEVeMethod.eRelativeError
integrator.StepSizeControl.ErrorTolerance = 1e-13
integrator.StepSizeControl.MinStepSize = 0.1
integrator.StepSizeControl.MaxStepSize = 30
integrator.Interpolation.Method = AgEVeInterpolationMethod.eLagrange
integrator.Interpolation.Order = 7

satellite.Propagator.Propagate()

Set satellite propagator to J4 and assign cartesian position

[Python - STK API]


# IAgSatellite satellite: Satellite object
satellite.SetPropagatorType(AgEVePropagatorType.ePropagatorJ4Perturbation)
propagator = satellite.Propagator
propagator.InitialState.Representation.AssignCartesian(AgECoordinateSystem.eCoordinateSystemICRF, 6678.14, 0, 0, 0, 6.78953, 3.68641)
propagator.Propagate()

Set satellite propagator to SGP4 and propagate

[Python - STK API]


# IAgSatellite satellite: Satellite object
satellite.SetPropagatorType(AgEVePropagatorType.ePropagatorSGP4)
propagator = satellite.Propagator
propagator.EphemerisInterval.SetImplicitInterval(
    root.CurrentScenario.Vgt.EventIntervals.Item("AnalysisInterval"))  # Link to scenario period
propagator.CommonTasks.AddSegsFromOnlineSource('25544')  # International Space Station
propagator.AutoUpdateEnabled = True
propagator.Propagate()

Set satellite propagator to SPICE and propagate

[Python - STK API]


# IAgSatellite satellite: Satellite object
# IAgStkObjectRoot root: STK Object Model Root
satellite.SetPropagatorType(AgEVePropagatorType.ePropagatorSPICE)
propagator = satellite.Propagator
propagator.Spice = r'C:\Program Files\AGI\STK_ODTK 13\STKData\Spice\planets.bsp'   # Make sure this is a valid path
propagator.BodyName = 'MARS'

propagator.EphemerisInterval.SetImplicitInterval(
    root.CurrentScenario.Vgt.EventIntervals.Item("AnalysisInterval"))  # Link to scenario period
propagator.Step = 60.0
propagator.Propagate()

Run the Astrogator MCS

[Python - STK API]


# IAgVADriverMCS driver: MCS driver interface
driver.RunMCS()

Add a Data Display to the 3D Window

[Python - STK API]


# IAgSatellite satellite: Satellite object
# Remove all data displays so you can easily pick one that may already be in
# the list
satellite.VO.DataDisplay.RemoveAll()
# Add LLA data display and change size/title
datadisplay = satellite.VO.DataDisplay.Add('LLA Position')
datadisplay.IsVisible = True
datadisplay.FontSize = AgEVOFontSize.eMedium
datadisplay.TitleText = 'My Data Display'
datadisplay.IsShowNameEnabled = False

Add a Vector to display in 3D

[Python - STK API]


# IAgSatellite satellite: Satellite object
vector = satellite.VO.Vector
angVel = vector.RefCrdns.Add(0, 'Satellite/MySatellite AngVelocity')
angVel.LabelVisible = True

Add Fixed System Orbit System in 3D Display

[Python - STK API]


# IAgSatellite satellite: Satellite object
orbitsystems = satellite.VO.OrbitSystems
orbitsystems.FixedByWindow.IsVisible = True
orbitsystems.FixedByWindow.Inherit = False
orbitsystems.FixedByWindow.Color = Colors.Yellow

Change the 3D Model and marker properties

[Python - STK API]


# IAgSatellite satellite: Satellite object
model = satellite.VO.Model
model.ModelData.Filename = r'STKData\VO\Models\Space\dsp.glb'
orbitmarker = model.OrbitMarker
orbitmarker.SetMarkerImageFile(r'C:\Program Files\AGI\STK_ODTK 13\STKData\VO\Markers\Satellite.ppm')
orbitmarker.MarkerData.IsTransparent = True
orbitmarker.PixelSize = 18
orbitmarker.OrientationMode = AgEVOMarkerOrientation.eVOMarkerOrientationFollowDirection

Change the Display Label of the vehicle

[Python - STK API]


# IAgSatellite satellite: Satellite object
satellite.Graphics.UseInstNameLabel = False
satellite.Graphics.LabelName = 'Python Satellite'

Change the graphics resolution of the orbit for a smooth path

[Python - STK API]


# IAgSatellite satellite: Satellite object
resolution = satellite.Graphics.Resolution
resolution.Orbit = 60

Display droplines in 3D Window

[Python - STK API]


# IAgSatellite satellite: Satellite object
orbitDroplines = satellite.VO.DropLines.Orbit
wgs84 = orbitDroplines.Item(0)  # Droplines to WGS84 surface
wgs84.IsVisible = True
wgs84.LineWidth = AgELineWidth.e2
wgs84.Use2DColor = False
wgs84.Color = Colors.Red

Modify the Detail Thresholds Levels

[Python - STK API]


# IAgSatellite satellite: Satellite object
details = satellite.VO.Model.DetailThreshold
details.EnableDetailThreshold = True
details.All = 1                # km
details.ModelLabel = 2         # km
details.MarkerLabel = 40000    # km
details.Marker = 500000        # km
details.Point = 500000         # km

Set 2D Display times to Custom and add intervals

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model root
# IAgSatellite satellite: Satellite object
root.UnitPreferences.Item('DateFormat').SetCurrentUnit('EpSec')
graphics = satellite.Graphics
graphics.SetAttributesType(AgEVeGfxAttributes.eAttributesCustom)
graphics.Attributes.Default.IsVisible = False

interval1 = graphics.Attributes.Intervals.Add(0, 3600)
interval1.GfxAttributes.IsVisible = True
interval1.GfxAttributes.Inherit = False
interval1.GfxAttributes.Line.Width = AgELineWidth.e2
interval1.GfxAttributes.Line.Style = AgELineStyle.eLongDash
interval1.GfxAttributes.Color = Colors.Fuchsia
interval1.GfxAttributes.MarkerStyle = 'X'

interval2 = satellite.Graphics.Attributes.Intervals.Add(7200, 86400)
interval2.GfxAttributes.IsVisible = True
interval2.GfxAttributes.Inherit = False
interval2.GfxAttributes.Line.Width = AgELineWidth.e2
interval2.GfxAttributes.Line.Style = AgELineStyle.eDashed
interval2.GfxAttributes.Color = Colors.Lime
interval2.GfxAttributes.MarkerStyle = 'Point'

Set 2D Graphics display properties

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model root
# IAgSatellite satellite: Satellite object
# Change the line width, style, color and marker

graphics = satellite.Graphics
graphics.SetAttributesType(AgEVeGfxAttributes.eAttributesBasic)
attributes = graphics.Attributes
attributes.Inherit = False
attributes.Line.Width = AgELineWidth.e4
attributes.Line.Style = AgELineStyle.eLongDash
attributes.Color = Colors.Lime
attributes.MarkerStyle = r'C:\Program Files\AGI\STK_ODTK 13\STKData\Pixmaps\MarkersWin\m010Satellite.bmp'

Set 2D Swath

[Python - STK API]


# IAgSatellite satellite: Satellite object
# Set swath in the 2D properties
swath = satellite.Graphics.Swath
swath.SetElevationType(AgEVeGfxElevation.eElevationGroundElevation)
swath.Elevation.Angle = 30  # deg
satellite.Graphics.Swath.Options = AgEVeGfxOptions.eOptionsEdgeLimits

Set 2D/3D Elevation Contours

[Python - STK API]


# IAgSatellite satellite: Satellite object
# Set the contours in the 2D properties
contours = satellite.Graphics.ElevContours
contours.IsVisible = True
contours.NumOfDecimalDigits = 0
contours.Elevations.AddLevelRange(0, 90, 10)  # Min, Max, Step
# Turn the contours on in the 3D properties
satellite.VO.ElevContours.IsVisible = True

Set 2D/3D Pass Display Properties

[Python - STK API]


# IAgSatellite satellite: Satellite object
# Display one pass for ground track and orbit on 2D
passdata = satellite.Graphics.PassData
groundTrack = passdata.GroundTrack
groundTrack.SetLeadDataType(AgELeadTrailData.eDataOnePass)
groundTrack.SetTrailSameAsLead
orbit = passdata.Orbit
orbit.SetLeadDataType(AgELeadTrailData.eDataOnePass)
orbit.SetTrailSameAsLead
# Display one orbit pass and no ground track on 3D
passdata3D = satellite.VO.Pass.TrackData.PassData
groundTrack3D = passdata3D.GroundTrack
groundTrack3D.SetLeadDataType(AgELeadTrailData.eDataNone)
groundTrack3D.SetTrailSameAsLead
orbit3D = passdata3D.Orbit
orbit3D.SetLeadDataType(AgELeadTrailData.eDataOnePass)
orbit3D.SetTrailSameAsLead

Set 2D/3D Range Contours

[Python - STK API]


# IAgSatellite satellite: Satellite object
# Set a contour level in the 2D properties
rangeContours = satellite.Graphics.RangeContours
rangeContours.IsVisible = True
rangeLevel = rangeContours.LevelAttributes.AddLevel(2000)  # km
rangeLevel.Color = Colors.Fuchsia
rangeLevel.LineWidth = AgELineWidth.e5
rangeLevel.LabelAngle = 90
rangeLevel.UserTextVisible = True
rangeLevel.UserText = 'Range'
# Turn the contours on in the 3D properties
satellite.VO.RangeContours.IsVisible = True

Set Vehicle Lighting Properties

[Python - STK API]


# IAgSatellite satellite: Satellite object
lighting = satellite.Graphics.Lighting
# Settings for vehicle in sunlight
sunlight = lighting.Sunlight
sunlight.Visible = True
sunlight.Color = Colors.Yellow
sunlight.LineWidth = AgELineWidth.e4
# Settings for vehicle in penumbra
penumbra = lighting.Penumbra
penumbra.Visible = True
penumbra.Color = Colors.Orange
penumbra.LineWidth = AgELineWidth.e3
# Settings for vehicle in umbra
umbra = lighting.Umbra
umbra.Visible = True
umbra.Color = Colors.Red
umbra.LineWidth = AgELineWidth.e2

Attach a Sensor Object to a Vehicle

[Python - STK API]


# IAgSatellite satellite: Satellite object
sensor = satellite.Children.New(AgESTKObjectType.eSensor, 'MySensor')

Define sensor pointing fixed axes AzEl

[Python - STK API]


# IAgSensor sensor: Sensor object
# Change pointing and set
sensor.CommonTasks.SetPointingFixedAxesAzEl('CentralBody/Sun J2000 Axes', 11, 22, AgEAzElAboutBoresight.eAzElAboutBoresightHold)

Define sensor pointing fixed axes Euler

[Python - STK API]


# IAgSensor sensor: Sensor object
# Change pointing and set
sensor.CommonTasks.SetPointingFixedAxesEuler('CentralBody/Sun J2000 Axes', AgEEulerOrientationSequence.e132, 30, 40, 50)

Define sensor pointing fixed axes Quaternion

[Python - STK API]


# IAgSensor sensor: Sensor object
# Change pointing and set
sensor.CommonTasks.SetPointingFixedAxesQuat('CentralBody/Sun J2000 Axes', 0.1, 0.2, 0.3, 0.4)

Define sensor pointing fixed axes YPR

[Python - STK API]


# IAgSensor sensor: Sensor object
# Change pointing and set
sensor.CommonTasks.SetPointingFixedAxesYPR('CentralBody/Sun J2000 Axes', AgEYPRAnglesSequence.eRYP, 11, 22, 33)

Define sensor pointing fixed AzEl

[Python - STK API]


# IAgSensor sensor: Sensor object
# Change pointing and set
sensor.CommonTasks.SetPointingFixedAzEl(4.5, -45.0, AgEAzElAboutBoresight.eAzElAboutBoresightRotate)

Define sensor pointing fixed Euler

[Python - STK API]


# IAgSensor sensor: Sensor object
# Change pointing and set
sensor.CommonTasks.SetPointingFixedEuler(AgEEulerOrientationSequence.e132, 30, 40, 50)

Define sensor pointing fixed Quaternion

[Python - STK API]


# IAgSensor sensor: Sensor object
# Change pointing and set
sensor.CommonTasks.SetPointingFixedQuat(0.1, 0.2, 0.3, 0.4)

Define sensor pointing fixed YPR

[Python - STK API]


# IAgSensor sensor: Sensor object
# Change pointing and set
sensor.CommonTasks.SetPointingFixedYPR(AgEYPRAnglesSequence.eRPY, 12, 24, 36)

Sensor Body Mask

[Python - STK API]


# IAgSensor sensor: Sensor object
sensor.SetAzElMaskFile(r'C:\Program Files\AGI\STK_ODTK 13\Data\Resources\stktraining\text\BodyMask_hga.bmsk')

Set Sensor Properties

[Python - STK API]


# IAgSensor sensor: Sensor object
# Change pattern and set
sensor.CommonTasks.SetPatternRectangular(20, 25)
# Change pointing and set
sensor.CommonTasks.SetPointingFixedAzEl(90, 60, AgEAzElAboutBoresight.eAzElAboutBoresightRotate)
# Change location and set
sensor.SetLocationType(AgESnLocation.eSnFixed)
sensor.LocationData.AssignCartesian(-.0004, -.0004, .004)

Sensor Persistence

[Python - STK API]


# IAgSensor sensor: Sensor object
projection = sensor.Graphics.Projection
projection.Persistence = 7200  # sec
projection.ForwardPersistence = True
projection.FillPersistence = True
sensor.Graphics.FillVisible = True
sensor.Graphics.PercentTranslucency = 50

Add a new phase and use the same performance models as the first phase

[Python - STK API]


# IAgAvtrPhases phases: Phase Collection object
# Add a new phase at the end of the mission
newPhase = phases.Add()
# Rename the phase
newPhase.Name = 'New Phase'
# Copy the performance models from the first phase and paste it to the new phase
phases[0].CopyPerformanceModels()
newPhase.PastePerformanceModels()

Add a takeoff procedure from a runway

[Python - STK API]


# IAgAvtrProcedureCollection procedures: Procedure Collection object
# Add a takeoff procedure with a runway as a site
takeoff = procedures.Add(AgEAvtrSiteType.eSiteRunway, AgEAvtrProcedureType.eProcTakeoff)

# Get the runway heading options
headingOptions = takeoff.RunwayHeadingOptions
# Opt to use the headwind runway
headingOptions.RunwayMode = AgEAvtrRunwayHighLowEnd.eHeadwind

# Set the takeoff mode and get that interface
takeoff.TakeoffMode = AgEAvtrTakeoffMode.eTakeoffNormal
takeoffNormal = takeoff.ModeAsNormal

# Set the takeoff climb angle
takeoffNormal.TakeoffClimbAngle = 5
# Set the departure altitude above the runway
takeoffNormal.DepartureAltitude = 600
# Set the altitude offset for the runway
takeoffNormal.RunwayAltitudeOffset = 10
# Use terrain for the runway's altitude
takeoffNormal.UseRunwayTerrain = True

Add and configure a basic maneuver procedure

[Python - STK API]


# IAgAvtrProcedureCollection procedures: Procedure Collection object
# Add a basic maneuver procedure
basicManeuver = procedures.Add(AgEAvtrSiteType.eSiteEndOfPrevProcedure, AgEAvtrProcedureType.eProcBasicManeuver)

# Set the navigation to use a Straight Ahead strategy
basicManeuver.NavigationStrategyType = 'Straight Ahead'
# Get the options for the straight ahead strategy
straightAhead = basicManeuver.Navigation
# Opt to maintain course (as opposed to maintain heading)
straightAhead.ReferenceFrame = AgEAvtrStraightAheadRefFrame.eMaintainCourse

# Set the profile to use a Autopilot - Vertical Plane strategy
basicManeuver.ProfileStrategyType = 'Autopilot - Vertical Plane'
# Get the options for the profile strategy
autopilot = basicManeuver.Profile
# Opt to maintain the initial altitude
autopilot.AltitudeMode = AgEAvtrAutopilotAltitudeMode.eAutopilotHoldInitAltitude
airspeedOptions = autopilot.AirspeedOptions
# Opt to maintain a specified airspeed
airspeedOptions.AirspeedMode = AgEAvtrBasicManeuverAirspeedMode.eMaintainSpecifiedAirspeed
# Specify the airspeed
airspeedOptions.SpecifiedAirspeed = 250

# Configure the options on the Attitude / Performance / Fuel page
basicManeuver.FlightMode = AgEAvtrPhaseOfFlight.eFlightPhaseCruise
# Override the fuel flow
basicManeuver.FuelFlowType = AgEAvtrBasicManeuverFuelFlowType.eBasicManeuverFuelFlowOverride
basicManeuver.OverrideFuelFlowValue = 1000

# Set the basic stopping conditions
basicManeuver.UseMaxDownrange = True
basicManeuver.MaxDownrange = 10
basicManeuver.UseStopFuelState = False
basicManeuver.UseMaxTimeOfFlight = False

Add and configure a landing procedure

[Python - STK API]


# IAgAvtrProcedureCollection procedures: Procedure Collection object
# Add a landing procedure
landing = procedures.Add(AgEAvtrSiteType.eSiteRunway, AgEAvtrProcedureType.eProcLanding)

# Get the runway heading options
headingOptions = landing.RunwayHeadingOptions
# Land from the low end
headingOptions.RunwayMode = AgEAvtrRunwayHighLowEnd.eLowEnd

# Use a standard instrument approach
landing.ApproachMode = AgEAvtrApproachMode.eStandardInstrumentApproach
# Get the options for a standard instrument approach
sia = landing.ModeAsStandardInstrumentApproach
# Change the approach altitude
sia.ApproachAltitude = 1000
# Change the glideslope
sia.Glideslope = 4
# Offset the runway altitude
sia.RunwayAltitudeOffset = 10
# Use the terrain as an altitude reference for the runway
sia.UseRunwayTerrain = True

Add and configure an enroute procedure

[Python - STK API]


# IAgAvtrProcedureCollection procedures: Procedure Collection object
# Add an enroute procedure with a site type of End of Previous Procedure
enroute = procedures.AddAtIndex(1, AgEAvtrSiteType.eSiteEndOfPrevProcedure, AgEAvtrProcedureType.eProcEnroute)
# Get the altitude options
altitudeOptions = enroute.AltitudeMSLOptions
# To specify an altitude, turn off the option to use the default cruise altitude
altitudeOptions.UseDefaultCruiseAltitude = False
# Set the altitude
altitudeOptions.MSLAltitude = 10000

# Get the navigation options
navigationOptions = enroute.NavigationOptions
# Set the route to arrive on a specified course
navigationOptions.NavMode = AgEAvtrPointToPointMode.eArriveOnCourse
# Set the course
navigationOptions.ArriveOnCourse = 30
# Use a magnetic heading
navigationOptions.UseMagneticHeading = True

# Get the navigation options
airspeedOptions = enroute.EnrouteCruiseAirspeedOptions
# Fly at max speed
airspeedOptions.CruiseSpeedType = AgEAvtrCruiseSpeed.eMaxAirspeed
# To specify an airspeed to fly at, set the speed type to other airspeed
airspeedOptions.CruiseSpeedType = AgEAvtrCruiseSpeed.eOtherAirspeed
# Then set the airspeed and airspeed type
airspeedOptions.SetOtherAirspeed(AgEAvtrAirspeedType.eTAS, 200)

Add and remove procedures

[Python - STK API]


# IAgAvtrProcedureCollection procedures: Procedure Collection object
# IAgAvtrPropagator propagator: Aviator Propagator object
# Add a takeoff procedure with a runway as a site. This will add the procedure
takeoff = procedures.Add(AgEAvtrSiteType.eSiteRunway, AgEAvtrProcedureType.eProcTakeoff)
# Add a procedure at a given index (starting from 0)
enroute = procedures.AddAtIndex(1, AgEAvtrSiteType.eSiteEndOfPrevProcedure, AgEAvtrProcedureType.eProcEnroute)

# Make sure to propagate the mission to calculate the route
propagator.Propagate()
# Get the mission
mission = propagator.AvtrMission
# Check to see if the mission is valid (must first be propagated)
isValid = mission.IsValid

# Get the number of procedures
procedureCount = procedures.Count
# Remove the procedure at the given index
procedures.RemoveAtIndex(1)
# Remove the given procedure
procedures.Remove(takeoff)

# Propagate the mission
propagator.Propagate()

Configure a procedure time options

[Python - STK API]


# IAgAvtrProcedure procedure: Procedure object
# Get the time in epoch seconds
root.UnitPreferences.SetCurrentUnit('DateFormat', 'EpSec')
# Get the time options
timeOptions = procedure.TimeOptions
# Get the start time
startTime = timeOptions.StartTime
# Set the procedure to interrupt after 15 seconds
timeOptions.SetInterruptTime(15)

Configure a runway site

[Python - STK API]


# IAgAvtrSiteRunway runway: Runway object
# Set the latitude, longitude, and altitude
runway.Latitude = 41
runway.Longitude = 77
runway.Altitude = 5

# Set the altitude reference
runway.AltitudeRef = AgEAvtrAGLMSL.eAltMSL

# Set the heading
runway.HighEndHeading = 195
# Opt to use true heading
runway.IsMagnetic = False

# Set the length of the runway
runway.Length = 5

# Rename the runway
runway.Name = 'New User Runway'
# Add the runway to the catalog to use it for next time
runway.AddToCatalog(1)

Configure a runway site from a runway in the Aviator catalog

[Python - STK API]


# IAgAvtrSiteRunway runway: Runway object
# IAgAvtrCatalog catalog: Aviator catalog object
# Get the source of user runways
userRunways = catalog.RunwayCategory.UserRunways
# Check that the runway exists in the catalog
if userRunways.Contains('New User Runway') is True:
    # If so, get the user runway with the given name
    runwayFromCatalog = userRunways.GetUserRunway('New User Runway')
    # Copy the parameters of that runway
    runway.CopyFromCatalog(runwayFromCatalog)

Configure the Advanced Fixed Wing Tool and set the aircraft to use the resulting performance models

[Python - STK API]


# IAgAvtrAircraft aviatorAircraft: Aviator Aircraft object
# Get the advanced fixed wing tool
advFixedWingTool = aviatorAircraft.AdvFixedWingTool
# Set the basic geometry
advFixedWingTool.WingArea = 300
advFixedWingTool.FlapsArea = 50
advFixedWingTool.SpeedbrakesArea = 10
# Set the structural and human factor limits
advFixedWingTool.MaxAltitude = 65000
advFixedWingTool.MaxMach = 0.98
advFixedWingTool.MaxEAS = 460
advFixedWingTool.MinLoadFactor = -2.5
advFixedWingTool.MaxLoadFactor = 4.5

# Opt to enforce the max temperature limit
advFixedWingTool.UseMaxTemperatureLimit = True
advFixedWingTool.MaxTemperature = 900

# Use a subsonic aerodynamic strategy
advFixedWingTool.AeroStrategy = AgEAvtrAdvFixedWingAeroStrategy.eSubsonicAero
# Cache the aerodynamic data to improve calculation speed
advFixedWingTool.CacheAeroData = True
# Use a high bypass turbofan
advFixedWingTool.PowerplantStrategy = AgEAvtrAdvFixedWingPowerplantStrategy.eTurbofanHighBypass
# Cache the fuel flow data to improve calculation speed
advFixedWingTool.CacheFuelFlow = True

# Create the corresponding performance models that reference the advanced fixed wing tool
# Specify the name, whether to override any existing models with the same name, and whether to set the new models as the default performance models
advFixedWingTool.CreateAllPerfModels('AdvancedModels', True, True)

# Save the changes in the catalog
aviatorAircraft.Save()

Configure the Aviator propagator

[Python - STK API]


# IAgAircraft aircraft: Aircraft object
# Set to Propagator to Aviator
aircraft.SetRouteType(AgEVePropagatorType.ePropagatorAviator)
# Get the aircraft's route
aircraftRoute = aircraft.Route
# Get the Aviator propagator
propagator = aircraftRoute.AvtrPropagator
# Get the Aviator mission
mission = propagator.AvtrMission
# Get the list of phases from the mission
phases = mission.Phases
# Get the list of procedures from the first phase
procedures = phases[0].Procedures
# Propagate the route
propagator.Propagate()

Configure the basic acceleration performance model of an aircraft

[Python - STK API]


# IAgAvtrAircraft aviatorAircraft: Aviator Aircraft object
# Get the acceleration type
acceleration = aviatorAircraft.Acceleration
# Get the build in performance model
basicAccModel = acceleration.GetBuiltInModel()

# Get the level turns options
levelTurns = basicAccModel.LevelTurns
# Set a max bank angle of 25
levelTurns.SetLevelTurn(AgEAvtrTurnMode.eTurnModeBankAngle, 25)
# Get the climb and descent transition options
climbAndDescent = basicAccModel.ClimbAndDescentTransitions
# Set the max pull up G to 1
climbAndDescent.MaxPullUpG = 1.2
# Get the attitude transition options
attitudeTransitions = basicAccModel.AttitudeTransitions
# Set the max roll rate to 25
attitudeTransitions.RollRate = 25

# Get the aerodynamics
aero = basicAccModel.Aerodynamics
# Use simple aerodynamics
aero.AeroStrategy = AgEAvtrAircraftAeroStrategy.eAircraftAeroSimple
# Get the options for the simple aerodynamics and set some parameters
simpleAero = aero.ModeAsSimple
simpleAero.SRef = 5
simpleAero.ClMax = 3.1
simpleAero.Cd = 0.05

# Get the propulsion
prop = basicAccModel.Propulsion
# Use simple propulsion
prop.PropStrategy = AgEAvtrAircraftPropStrategy.eAircraftPropSimple
# Get the simple propulsion options and set some parameters
simpleProp = prop.ModeAsSimple
simpleProp.MaxThrustAccel = 0.6
simpleProp.MinThrustDecel = 0.4
simpleProp.SetDensityScaling(True, 0.02)

# Save the changes to the catalog
aviatorAircraft.Save()

Configure the basic cruise performance model of an aircraft

[Python - STK API]


# IAgAvtrAircraft aviatorAircraft: Aviator Aircraft object
# Get the cruise type
cruise = aviatorAircraft.Cruise
# Get the build in performance model
basicCruiseModel = cruise.GetBuiltInModel()

# Set the ceiling altitude
basicCruiseModel.CeilingAltitude = 50000
# Set the default cruise altitude
basicCruiseModel.DefaultCruiseAltitude = 10000
# Set the airspeed type
basicCruiseModel.AirspeedType = AgEAvtrAirspeedType.eTAS
# Opt to not use the fuel flow calculated by the aero/prop model and instead specify the values
basicCruiseModel.UseAeroPropFuel = False

# Set the various airspeeds and fuel flows
basicCruiseModel.MinAirspeed = 110
basicCruiseModel.MinAirspeedFuelFlow = 10000

basicCruiseModel.MaxEnduranceAirspeed = 135
basicCruiseModel.MaxEnduranceFuelFlow = 8000

basicCruiseModel.MaxAirspeed = 570
basicCruiseModel.MaxAirspeedFuelFlow = 30000

basicCruiseModel.MaxRangeAirspeed = 140
basicCruiseModel.MaxRangeFuelFlow = 9000

basicCruiseModel.MaxPerfAirspeed = 150
basicCruiseModel.MaxPerfAirspeedFuelFlow = 12000

# Save the changes to the catalog
aviatorAircraft.Save()

Configure the performance models to be used in the phase

[Python - STK API]


# IAgAvtrPhase phase: Phase object
# Get the acceleration performance model used for the current phase
acceleration = phase.GetPerformanceModelByType('Acceleration')
# Check if it is linked to the catalog
isLinkedToCatalog = acceleration.IsLinkedToCatalog
# Use the performance model in the catalog named "Built-In Model"
acceleration.LinkToCatalog('Built-In Model')

# Get the VTOL performance model
vtol = phase.GetPerformanceModelByType('VTOL')
# Create a new vtol model of type AGI VTOL Model. Note that this new model does not exist in the catalog and only exists in the phase.
vtol.CreateNew('AGI VTOL Model')
# Rename the performance model
vtol.Rename('Temporary VTOL Model')

Configure the weather and atmosphere of the Mission

[Python - STK API]


# IAgAvtrMission mission: Aviator Mission object
# Get the wind model used for the mission
windModel = mission.WindModel
# Let's use the mission model
windModel.WindModelSource = AgEAvtrWindAtmosModelSource.eMissionModel
# Let's use constant wind
windModel.WindModelType = AgEAvtrWindModelType.eConstantWind
# Get the constant wind model options
constantWind = windModel.ModeAsConstant
# Set the wind bearing
constantWind.WindBearing = 30
# Set the wind speed
constantWind.WindSpeed = 5

# Get the atmosphere model used for the mission
atmosphere = mission.AtmosphereModel
# Let's use the mission model
atmosphere.AtmosphereModelSource = AgEAvtrWindAtmosModelSource.eMissionModel
# Get the basic atmosphere options
basicAtmosphere = atmosphere.ModeAsBasic
# Use standard 1976 atmosphere
basicAtmosphere.BasicModelType = AgEAvtrAtmosphereModel.eStandard1976
# Opt to override the values
basicAtmosphere.UseNonStandardAtmosphere = True
# Override the temperature
basicAtmosphere.Temperature = 290

Configure the wind and atmosphere for a procedure

[Python - STK API]


# IAgAvtrProcedure procedure: Procedure object
# Get the wind model for the procedure
windModel = procedure.WindModel
# Use the procedure model
windModel.WindModelSource = AgEAvtrWindAtmosModelSource.eProcedureModel
# Let's use constant wind
windModel.WindModelType = AgEAvtrWindModelType.eConstantWind
# Get the constant wind model options
constantWind = windModel.ModeAsConstant
# Set the wind bearing
constantWind.WindBearing = 30
# Set the wind speed
constantWind.WindSpeed = 5

# Get the atmosphere model used for the procedure
atmosphere = procedure.AtmosphereModel
# Let's use the procedure model
atmosphere.AtmosphereModelSource = AgEAvtrWindAtmosModelSource.eProcedureModel
# Get the basic atmosphere options
basicAtmosphere = atmosphere.ModeAsBasic
# Use standard 1976 atmosphere
basicAtmosphere.BasicModelType = AgEAvtrAtmosphereModel.eStandard1976

Create a new performance model for an aircraft

[Python - STK API]


# IAgAvtrAircraft aviatorAircraft: Aviator Aircraft object
# Get the acceleration type
acceleration = aviatorAircraft.Acceleration
# Get the names of the current acceleration models
modelNames = acceleration.ChildNames
# Check how many models there are
modelCount = len(modelNames)
# Get the child types (for example AGI Basic Acceleration Model, Advanced Acceleration Model)
modelTypes = acceleration.ChildTypes
# Create a new performance model of type "Advanced Acceleration Model"
newPerformanceModel = acceleration.AddChildOfType('Advanced Acceleration Model', 'Model Name')
# Save the changes to the catalog
aviatorAircraft.Save()

Rename a procedure and its site

[Python - STK API]


# IAgAvtrProcedure procedure: Procedure object
# Rename the procedure
procedure.Name = 'New Procedure'
# Get the site corresponding to the procedure
site = procedure.Site
# Rename the site
site.Name = 'New Site'

Set the aircraft used for the mission to an aircraft found in the Aviator catalog

[Python - STK API]


# IAgAvtrPropagator propagator: Aviator Propagator object
# Get the Aviator catalog
catalog = propagator.AvtrCatalog
# Get the aircraft category
category = catalog.AircraftCategory
# Get the user aircraft models
aircraftModels = category.AircraftModels
# Get the basic fighter
fighter = aircraftModels.GetAircraft('Basic Fighter')
# Get the mission
mission = propagator.AvtrMission
# Set the vehicle used for the mission
mission.Vehicle = fighter

Set the Configuration used for the Mission

[Python - STK API]


# IAgAvtrMission mission: Aviator Mission object
# Get the configuration used for the mission
configuration = mission.Configuration
# Set the max landing weight
configuration.MaxLandingWeight = 300000
# Set the empty weight
configuration.EmptyWeight = 210000
# Update the center of gravity of the aircraft when empty
configuration.SetEmptyCG(2, 0, 1)

# Get the stations
stations = configuration.GetStations()
# Check if there is an internal fuel station
if stations.ContainsStation('Internal Fuel') is True:
    # Get the fuel tank
    fuelTank = stations.GetInternalFuelTankByName('Internal Fuel')
    # Set the capacity of the fuel tank
    fuelTank.Capacity = 175000
    # Set the initial state of the fuel tank
    fuelTank.InitialFuelState = 125000

# Add a new payload station
newPayload = stations.AddPayloadStation()
# Set the position of the payload station
newPayload.SetPosition(0, 2, 0)
# Add an external fuel tank
externalTank = newPayload.AddExternalFuelTank()
# Set the empty weight of the tank
externalTank.EmptyWeight = 2000

Execute Connect command

[Python - STK API]


root.ExecuteCommand('New / */Target MyTarget')

Execute multiple Connect commands

[Python - STK API]


commandList = [['New / */Place MyPlace'], ['SetPosition */Place/MyPlace Geodetic 37.9 -75.5 0.0']]
root.ExecuteMultipleCommands(commandList, AgEExecMultiCmdResultAction.eExceptionOnError)

Extract data from Connect result

[Python - STK API]


result = root.ExecuteCommand('Report_RM */Place/MyPlace Style "Cartesian Position"')

for i in range(0, result.Count):
    cmdRes = result.Item(i)
    print(cmdRes)

Change camera reference frame

[Python - STK API]


# IAgScenario scenario: Scenario object
# IAgStkObjectRoot root: STK Object Model Root
manager = scenario.SceneManager
manager.Scenes.Item(0).Camera.ViewCentralBody('Earth', root.CentralBodies.Earth.Vgt.Axes.Item('Fixed'))
manager.Render()

Change camera view to Imagery Extents

[Python - STK API]


# IAgScenario scenario: Scenario object
# IAgStkGraphicsAGIProcessedImageGlobeOverlay imageryTile: Image Overlay object
manager = scenario.SceneManager
extent = imageryTile.Extent
# Change extent in the default 3D window
manager.Scenes.Item(0).Camera.ViewExtent('Earth', extent)
manager.Render()

Add Imagery and Terrain to the Scene

[Python - STK API]


# IAgScenario scenario: Scenario object
# Retrieve the boundaries of the imported files
manager = scenario.SceneManager
# Add Terrain
terrainTile = manager.Scenes.Item(0).CentralBodies.Earth.Terrain.AddUriString(r'C:\Program Files\AGI\STK_ODTK 13\Data\Resources\stktraining\samples\SRTM_Skopje.pdtt')
extentTerrain = terrainTile.Extent
print('Terrain boundaries: LatMin: %s LatMax: %s LonMin: %s LonMax: %s' % (str(extentTerrain[0]), str(extentTerrain[2]), str(extentTerrain[1]), str(extentTerrain[3])))
# Add Imagery
imageryTile = manager.Scenes.Item(0).CentralBodies.Earth.Imagery.AddUriString(r'C:\Program Files\AGI\STK_ODTK 13\Data\Resources\stktraining\imagery\NPS_OrganPipeCactus_Map.pdttx')
extentImagery = imageryTile.Extent
print('Imagery boundaries: LatMin: %s LatMax: %s LonMin: %s LonMax: %s' % (str(extentImagery[0]), str(extentImagery[2]), str(extentImagery[1]), str(extentImagery[3])))

Control Display of Stars and Water Texture

[Python - STK API]


# IAgScenario scenario: Scenario object
# Turn off the stars and water texture
manager = scenario.SceneManager
manager.Scenes.Item(0).ShowStars = False
manager.Scenes.Item(0).ShowWaterSurface = False

Control the Lighting of the 3D scene

[Python - STK API]


# IAgScenario scenario: Scenario object
# Modify the lighting levels
manager = scenario.SceneManager
lighting = manager.Scenes.Item(0).Lighting
lighting.AmbientIntensity = .20  # Percent
lighting.DiffuseIntensity = 4  # Percent
lighting.NightLightsIntensity = 5  # Percent

Create a Bounding Sphere

[Python - STK API]


# IAgScenario scenario: Scenario object
manager = scenario.SceneManager
sphere = manager.Initializers.BoundingSphere.Initialize([[-1061.22], [-5773.98], [4456.04]], 100)

Display a Primitive During an Interval

[Python - STK API]


# IAgScenario scenario: Scenario object
# IAgStkGraphicsModelPrimitive model: Graphics Primitive
manager = scenario.SceneManager
composite = manager.Initializers.CompositeDisplayCondition.Initialize()
root.UnitPreferences.Item('DateFormat').SetCurrentUnit('EpSec')
start = root.ConversionUtility.NewDate('EpSec', str(scenario.StartTime))
stop = root.ConversionUtility.NewDate('EpSec', str(scenario.StartTime + 600))
timeInterval = manager.Initializers.TimeIntervalDisplayCondition.InitializeWithTimes(start, stop)
composite.Add(timeInterval)
model.DisplayCondition = composite

Draw a new Surface Extent Triangulator

[Python - STK API]


# IAgScenario scenario: Scenario object
manager = scenario.SceneManager
texture = manager.Textures.LoadFromStringUri(r'C:\Program Files\AGI\STK_ODTK 13\STKData\VO\Textures\AGI_logo_small.png')
mesh = manager.Initializers.SurfaceMeshPrimitive.Initialize()
mesh.Texture = texture
mesh.Translucency = 0
cartographicExtent = [[-55], [10], [-24], [30]]

triangles = manager.Initializers.SurfaceExtentTriangulator.ComputeSimple('Earth', cartographicExtent)
mesh.Set(triangles)
mesh.Translucency = .25
c0 = [[10], [-55]]
c1 = [[30], [-55]]
c2 = [[30], [-24]]
c3 = [[10], [-24]]

mesh.TextureMatrix = manager.Initializers.TextureMatrix.InitializeWithRectangles(c0, c1, c2, c3)
mesh.TransparentTextureBorder = True
manager.Primitives.Add(mesh)
manager.Render()

Draw a new Surface Mesh

[Python - STK API]


# IAgScenario scenario: Scenario object
manager = scenario.SceneManager
cartesianPts = [[6030.721052], [1956.627139], [-692.397578], [5568.375825], [2993.600713], [-841.076362], [5680.743568], [2490.379622], [-1480.882721]]  # X, Y, Z (km)

triangles = manager.Initializers.SurfacePolygonTriangulator.Compute('Earth', cartesianPts)
surfaceMesh = manager.Initializers.SurfaceMeshPrimitive.Initialize()
surfaceMesh.Color = Colors.Red
surfaceMesh.Set(triangles)
manager.Primitives.Add(surfaceMesh)
manager.Render()

Draw a new Text Primitive

[Python - STK API]


# IAgScenario scenario: Scenario object
manager = scenario.SceneManager
font = manager.Initializers.GraphicsFont.InitializeWithNameSizeFontStyleOutline('MS Sans Serif', 24, AgEStkGraphicsFontStyle.eStkGraphicsFontStyleBold, True)
textBatch = manager.Initializers.TextBatchPrimitive.InitializeWithGraphicsFont(font)
textBatch.SetCartographic('Earth', [[0], [0], [0]], ['Example Text'])  # Lat, Lon, Alt
manager.Primitives.Add(textBatch)

Draw a new Texture Screen Overlay

[Python - STK API]


# IAgScenario scenario: Scenario object
manager = scenario.SceneManager
overlays = manager.ScreenOverlays.Overlays
textureOverlay = manager.Initializers.TextureScreenOverlay.InitializeWithXYWidthHeight(0, 0, 128, 128)
textureOverlay.Texture = manager.Textures.LoadFromStringUri(r'C:\Program Files\AGI\STK_ODTK 13\STKData\VO\Textures\agilogo3.ppm')
textureOverlay.MaintainAspectRatio = True
textureOverlay.Origin = AgEStkGraphicsScreenOverlayOrigin.eStkGraphicsScreenOverlayOriginTopLeft
textureOverlay.Position = [[0], [20], [int(AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitPixels)], [int(AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitPixels)]]
overlays.Add(textureOverlay)
# Render the Scene
manager.Render()

Draw a Point Primitive and set properties

[Python - STK API]


# IAgScenario scenario: Scenario object
manager = scenario.SceneManager
point = manager.Initializers.PointBatchPrimitive.Initialize()
ptPosition = [[0], [-1], [0]]  # Lat, Lon, Alt

point.SetCartographic('Earth', ptPosition)
point.PixelSize = 15
point.Color = Colors.Lime
point.DisplayOutline = True
point.OutlineWidth = 5
point.OutlineColor = Colors.Red

manager.Primitives.Add(point)
# Render the Scene
manager.Render()

Draw a Solid Box Primitive and set properties

[Python - STK API]


# IAgScenario scenario: Scenario object
manager = scenario.SceneManager
originBox = root.ConversionUtility.NewPositionOnEarth()
originBox.AssignGeodetic(0, 3, 100)

orientBox = root.ConversionUtility.NewOrientation()
orientBox.AssignAzEl(0, 0, AgEAzElAboutBoresight.eAzElAboutBoresightRotate)

size = [[100], [100], [200]]
result = manager.Initializers.BoxTriangulator.Compute(size)
solidBox = manager.Initializers.SolidPrimitive.Initialize()
solidBox.ReferenceFrame = root.CentralBodies.Earth.Vgt.Systems.Item('Fixed')
solidBox.Position = originBox.QueryCartesianArray()
solidBox.SetWithResult(result)
solidBox.Color = Colors.Red
solidBox.OutlineColor = Colors.Cyan
solidBox.Translucency = .75
solidBox.Rotation = orientBox
manager.Primitives.Add(solidBox)
manager.Render()

Draw a Solid Cylinder Primitive and set properties

[Python - STK API]


# IAgScenario scenario: Scenario object
manager = scenario.SceneManager
originCylinder = root.ConversionUtility.NewPositionOnEarth()
originCylinder.AssignGeodetic(0, 7, 100)

orientCylinder = root.ConversionUtility.NewOrientation()
orientCylinder.AssignAzEl(0, 0, AgEAzElAboutBoresight.eAzElAboutBoresightRotate)

cylinder = manager.Initializers.CylinderTriangulator.CreateSimple(200, 100)
solidCylinder = manager.Initializers.SolidPrimitive.Initialize()
solidCylinder.ReferenceFrame = root.CentralBodies.Earth.Vgt.Systems.Item('Fixed')
solidCylinder.Position = originCylinder.QueryCartesianArray()
solidCylinder.SetWithResult(cylinder)
solidCylinder.Color = Colors.Lime
solidCylinder.OutlineColor = Colors.Blue
solidCylinder.OutlineWidth = 3
solidCylinder.Translucency = .75
solidCylinder.Rotation = orientCylinder
manager.Primitives.Add(solidCylinder)
manager.Render()

Draw a Solid Ellipsoid Primitive and set properties

[Python - STK API]


# IAgScenario scenario: Scenario object
manager = scenario.SceneManager
originEllipsoid = root.ConversionUtility.NewPositionOnEarth()
originEllipsoid.AssignGeodetic(0, 5, 100)

orientEllipsoid = root.ConversionUtility.NewOrientation()
orientEllipsoid.AssignAzEl(0, 0, AgEAzElAboutBoresight.eAzElAboutBoresightRotate)

radii = [[200], [100], [100]]
ellipsoid = manager.Initializers.EllipsoidTriangulator.ComputeSimple(radii)
solidEllipsoid = manager.Initializers.SolidPrimitive.Initialize()
solidEllipsoid.ReferenceFrame = root.CentralBodies.Earth.Vgt.Systems.Item('Fixed')  # vgtSat.Systems.Item('Body')
solidEllipsoid.Position = originEllipsoid.QueryCartesianArray()
solidEllipsoid.SetWithResult(ellipsoid)
solidEllipsoid.Color = Colors.White
solidEllipsoid.OutlineColor = Colors.DeepPink
solidEllipsoid.Translucency = .75
solidEllipsoid.Rotation = orientEllipsoid
manager.Primitives.Add(solidEllipsoid)
manager.Render()

GreatArcInterpolator Primitives

[Python - STK API]


# IAgScenario scenario: Scenario object
# Create a array of LLA values and interoplate them over the specified
# central body
positionArray = [[35.017], [-118.540], [0], [44.570], [-96.474], [0], [31.101], [-82.619], [0]]
manager = scenario.SceneManager
# Interpolate points over great arc
interpolator = manager.Initializers.GreatArcInterpolator.InitializeWithCentralBody('Earth')
interpolator.Granularity = .1
result = interpolator.Interpolate(positionArray)

Create a Data Element Scalar

[Python - STK API]


# IAgCrdnProvider vgtSat: Vector Geometry Tool Interface
calcFactory = vgtSat.CalcScalars.Factory
trueAnom = calcFactory.Create('TrueAnomaly', '', AgECrdnCalcScalarType.eCrdnCalcScalarTypeDataElement)
trueAnom.SetWithGroup('Classical Elements', 'ICRF', 'True Anomaly')

Create a new Aligned and Constrained Axes

[Python - STK API]


# IAgCrdnProvider vgtSat: Vector Geometry Tool Interface
# IAgCrdnVectorDisplacement Sat2EarthCenter: vector component
# IAgCrdnVectorFixedInAxes bodyYSat: vector component
AxesFactory = vgtSat.Axes.Factory
AlignConstain = AxesFactory.Create('AlignConstrain', 'Aligned to displacement vector and constrained to Body Y', AgECrdnAxesType.eCrdnAxesTypeAlignedAndConstrained)
AlignConstain.AlignmentReferenceVector.SetVector(Sat2EarthCenter)
AlignConstain.AlignmentDirection.AssignXYZ(1, 0, 0)
AlignConstain.ConstraintReferenceVector.SetVector(bodyYSat)
AlignConstain.ConstraintDirection.AssignXYZ(0, 0, 1)

Create a new Assembled System

[Python - STK API]


# IAgCrdnProvider vgtSat: Vector Geometry Tool Interface
# IAgCrdnPointFixedInSystem fixedPt: point component
# IAgCrdnAxes bodyAxes: axes component
SysFactory = vgtSat.Systems.Factory
assemSys = SysFactory.Create('FixedPtSystem', 'System with origin at the new point', AgECrdnSystemType.eCrdnSystemTypeAssembled)
assemSys.OriginPoint.SetPoint(fixedPt)
assemSys.ReferenceAxes.SetAxes(bodyAxes)

Create a new Attitude Parameter Set

[Python - STK API]


# IAgCrdnProvider vgtSat: Vector Geometry Tool Interface
# IAgCrdnAxes bodyAxes: axes component
# IAgCrdnAxes icrfAxes: axes component
paraFactory = vgtSat.ParameterSets.Factory
paraSet = paraFactory.Create('attitudeICRF', 'Attitude Set', AgECrdnParameterSetType.eCrdnParameterSetTypeAttitude)
paraSet.Axes = bodyAxes
paraSet.ReferenceAxes = icrfAxes

Create a new Between Vectors Angle

[Python - STK API]


# IAgCrdnProvider vgtSat: Vector Geometry Tool Interface
# IAgCrdnVectorDisplacement Sat2EarthCenter: vector component
# IAgCrdnVectorFixedInAxes bodyYSat: vector component
AngFactory = vgtSat.Angles.Factory
betwVect = AngFactory.Create('SatEarth2Y', 'Displacement Vector to Sat Body Y', AgECrdnAngleType.eCrdnAngleTypeBetweenVectors)
betwVect.FromVector.SetVector(Sat2EarthCenter)
betwVect.ToVector.SetVector(bodyYSat)

Create a new Collection of Interval List

[Python - STK API]


# IAgCrdnProvider vgtSat: Vector Geometry Tool Interface
# IAgCrdnPoint centerPtSat: point component
timeCollListFactory = vgtSat.EventIntervalCollections.Factory
timeColl = timeCollListFactory.CreateEventIntervalCollectionLighting('LightingList', 'Collection of lighting intervals')
timeColl.UseObjectEclipsingBodies = True
timeColl.Location = centerPtSat

Create a new Cross Product Vector

[Python - STK API]


# IAgCrdnProvider vgtSat: Vector Geometry Tool Interface
# IAgCrdnVectorDisplacement Sat2EarthCenter: vector component
# IAgCrdnVectorDisplacement fixedAxesVector: vector component
VectFactory = vgtSat.Vectors.Factory
lineOfNodesVector = VectFactory.CreateCrossProductVector('CrossProduct', Sat2EarthCenter, fixedAxesVector)

Create a new Custom Script Vector

[Python - STK API]


# IAgCrdnProvider vgtSat: Vector Geometry Tool Interface
VectFactory = vgtSat.Vectors.Factory
customScript = VectFactory.Create('Script', 'Description', AgECrdnVectorType.eCrdnVectorTypeCustomScript)
# Initialization script if needed
# customScript.InitializationScriptFile = ''
customScript.ScriptFile = r'C:\Program Files\AGI\STK_ODTK 13\Data\Resources\stktraining\samples\Heliograph\Scripting\VectorTool\Vector\vector.vbs'
if customScript.IsValid is False:
    print('Script component not valid!')
    from os import getenv
    print(r'Copy vbs file from C:\Program Files\AGI\STK_ODTK 13\Data\Resources\stktraining\samples\Heliograph\Scripting\VectorTool\Vector\vector.vbs to C:\Users\%s\Documents\STK_ODTK 13\Config\Scripting\VectorTool' % getenv('USERNAME'))

Create a new Displacement Vector

[Python - STK API]


# IAgCrdnProvider vgtSat: Vector Geometry Tool Interface
# IAgCrdnPoint centerPtSat: point component
# IAgCrdnPoint centerPtEarth: point component
VectFactory = vgtSat.Vectors.Factory
Sat2EarthCenter = VectFactory.CreateDisplacementVector('Sat2EarthCenter', centerPtSat, centerPtEarth)

Create a new Fixed at Time Instant Point

[Python - STK API]


# IAgCrdnProvider vgtSat: Vector Geometry Tool Interface
# IAgCrdnSystemAssembled icrf: system component
PtFactory = vgtSat.Points.Factory
timeInstantPt = PtFactory.Create('AtTimePt', 'Point at time instant', AgECrdnPointType.eCrdnPointTypeAtTimeInstant)
timeInstantPt.SourcePoint = vgtSat.Points.Item('Center')
timeInstantPt.ReferenceSystem = icrf
timeInstantPt.ReferenceTimeInstant = vgtSat.Events.Item('AvailabilityStartTime')

Create a new Fixed in Axes Vector

[Python - STK API]


# IAgCrdnProvider vgtSat: Vector Geometry Tool Interface
# IAgCrdnAxes bodyAxes: axes component
VectFactory = vgtSat.Vectors.Factory
fixedAxesVector = VectFactory.Create('FixedInAxes', '', AgECrdnVectorType.eCrdnVectorTypeFixedInAxes)
fixedAxesVector.ReferenceAxes.SetAxes(bodyAxes)
fixedAxesVector.Direction.AssignXYZ(0, 0, 1)

Create a new Fixed in System Point

[Python - STK API]


# IAgCrdnProvider vgtSat: Vector Geometry Tool Interface
PtFactory = vgtSat.Points.Factory
fixedPt = PtFactory.Create('FixedPt', 'Point offset from Center', AgECrdnPointType.eCrdnPointTypeFixedInSystem)
fixedPt.FixedPoint.AssignCartesian(.005, 0, .005)

Create a new Model Attachment Point

[Python - STK API]


# IAgCrdnProvider vgtSat: Vector Geometry Tool Interface
PtFactory = vgtSat.Points.Factory
modelPt = PtFactory.Create('ModelPt', 'Attach point defined in model', AgECrdnPointType.eCrdnPointTypeModelAttachment)
modelPt.PointableElementName = 'MainSensor-000000'

Create a new Orbit Parameter Set

[Python - STK API]


# IAgCrdnProvider vgtSat: Vector Geometry Tool Interface
paraFactory = vgtSat.ParameterSets.Factory
paraSetOribit = paraFactory.Create('orbitSun', 'Orbit', AgECrdnParameterSetType.eCrdnParameterSetTypeOrbit)
paraSetOribit.OrbitingPoint = vgtSat.Points.Item('Center')
paraSetOribit.CentralBody = 'Sun'
paraSetOribit.UseCentralBodyGravitationalParameter = False
paraSetOribit.GravitationalParameter = 398600  # km^3/sec^2

Create a new Projection Vector

[Python - STK API]


# IAgCrdnProvider vgtSat: Vector Geometry Tool Interface
# IAgCrdnVectorDisplacement Sat2EarthCenter: vector component
VectFactory = vgtSat.Vectors.Factory
projectionVector = VectFactory.Create('Projection', '', AgECrdnVectorType.eCrdnVectorTypeProjection)
projectionVector.Source.SetVector(Sat2EarthCenter)
horizontalPlane = vgtSat.Planes.Item('LocalHorizontal')
projectionVector.ReferencePlane.SetPlane(horizontalPlane)

Create a new Time Instant

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model Root
# IAgCrdnProvider vgtSat: Vector Geometry Tool Interface
# Change DateFormat dimension to epoch seconds to make the time easier to handle in
# Python
root.UnitPreferences.Item('DateFormat').SetCurrentUnit('EpSec')
timeInstFactory = vgtSat.Events.Factory
timeEpoch = timeInstFactory.CreateEventEpoch('FixedTime', 'Fixed Epoch Time')
timeEpoch.Epoch = 3600

Create a new Time Interval

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model Root
# IAgCrdnProvider vgtSat: Vector Geometry Tool Interface
# Change DateFormat dimension to epoch seconds to make the time easier to handle in
# Python
root.UnitPreferences.Item('DateFormat').SetCurrentUnit('EpSec')
timeIntFactory = vgtSat.EventIntervals.Factory
timeInterval = timeIntFactory.CreateEventIntervalFixed('TimeInterval', 'Fixed time interval')
timeInterval.SetInterval(60, 120)

Create a new Vector Magnitude Scalar

[Python - STK API]


# IAgCrdnProvider vgtSat: Vector Geometry Tool Interface
# IAgCrdnVectorDisplacement Sat2EarthCenter: vector component
calcFactory = vgtSat.CalcScalars.Factory
displScalar = calcFactory.CreateCalcScalarVectorMagnitude('VectorDisplacement', 'Vector Magnitude of Displacement Vector')
displScalar.InputVector = Sat2EarthCenter

Get a Scalar component and evaluate at a time

[Python - STK API]


# IAgCrdnProvider vgtSat: Vector Geometry Tool Interface
# IAgScenario scenario: Scenario object
deticLatitude = vgtSat.CalcScalars.Item('GroundTrajectory.Detic.LLA.Latitude')
result = deticLatitude.Evaluate(scenario.StartTime)
print('The value of detic latitude is %s' % result.Value)

Get Center point and Inertial System of Earth CB

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model root
centerPtEarth = root.CentralBodies.Earth.Vgt.Points.Item('Center')
icrf = root.CentralBodies.Earth.Vgt.Systems.Item('ICRF')

Get default VGT component on vehicle

[Python - STK API]


# IAgSatellite satellite: Satellite object
vgtSat = satellite.Vgt
# Get handle to the Center point on the satellite
centerPtSat = vgtSat.Points.Item('Center')
# Get handle to the Body Y Vector
bodyYSat = vgtSat.Vectors.Item('Body.Y')
# Get handle to the Body Axes
bodyAxes = vgtSat.Axes.Item('Body')
icrfAxes = vgtSat.Axes.Item('ICRF')

Get Times From Defined Time Instant and create an cell array

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model Root
# IAgCrdnProvider vgtSat: Vector Geometry Tool Interface
# Change DateFormat dimension to epoch seconds to make the time easier to handle in
# Python
root.UnitPreferences.Item('DateFormat').SetCurrentUnit('EpSec')
satStart = vgtSat.Events.Item('AvailabilityStartTime')
start = satStart.FindOccurrence().Epoch

satStop = vgtSat.Events.Item('AvailabilityStopTime')
stop = satStop.FindOccurrence().Epoch
interval = [[start], [540], [600], [stop]]  # EpSec

Change animation mode

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model Root
scenario = root.CurrentScenario
root.AnimationOptions = AgEAnimationOptions.eAniOptionStop
root.Mode = AgEAnimationModes.eAniXRealtime
scenario.Animation.AnimStepValue = 1    # second
scenario.Animation.RefreshDelta = .03   # second

Change scenario font

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model Root
scenario = root.CurrentScenario
scenario.VO.MediumFont.Name = 'Arial'
scenario.VO.MediumFont.PtSize = 18
scenario.VO.MediumFont.Bold = True
scenario.VO.MediumFont.Italic = False

Close an open Scenario

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model Root
root.CloseScenario()

Close STK

[Python - STK API]


# AgUiApplication uiApplication: STK Application
uiApplication.ShutDown()

Create a new Scenario

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model Root
root.NewScenario('Example_Scenario')

Open a VDF

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model Root
root.LoadVDF(r'C:\Program Files\AGI\STK_ODTK 13\Data\ExampleScenarios\Intro_STK_Space_Systems.vdf', '')

Reset the scenario time

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model Root
root.Rewind()

Set unit preferences for Object Model

[Python - STK API]


# IAgStkObjectRoot root: STK Object Model Root
root.UnitPreferences.Item('DateFormat').SetCurrentUnit('UTCG')
root.UnitPreferences.Item('Distance').SetCurrentUnit('km')