tool kit

Satellite Tool Kit

STK is a software tool that allows engineers and scientists to design and develop complex dynamic simulations of real-world problems. Originally created to solve problems involving Earth-orbiting satellites, it is now used in both the aerospace and defense communities.

STK has more than 32,000 installations worldwide, with organizations such as NASA, ESA, CNES, Boeing, JAXA, Lockheed Martin, Northrop Grumman, EADS, DOD, and Civil Air Patrol.

The product is currently used in such areas as:

History

In 1989, the three founders of Analytical Graphics, Inc - Paul Graziani, Scott Reynolds and Jim Poland, left GE Aerospace to create Satellite Tool Kit (STK) as an alternative to bespoke, project-specific aerospace software.

The original version of STK ran only on Silicon Graphics computers, but as PCs became more powerful, the code was converted to run on Windows.

STK was first adopted by the aerospace community for orbit analysis and access calculations (when a satellite can see a ground-station or image target), but as software was expanded, more modules were added that included the ability to perform calculations for communications systems, radar, interplanetary missions and orbit collision avoidance.

The addition of 3D viewing capabilities lead to the adoption of the tool by military users for real-time visualization of air, land and sea forces as well as the space component. STK has also been used by various news organizations to graphically depict complex events to a wider audience.

Interface

The interface to STK is a standard GUI display with customizable toolbars and dockable maps and 3D viewports. All analysis can be done through mouse and keyboard interaction.

In addition, there is a TCP/IP or COM interface that allows STK to act within a client/server environment or as an embedded component within a larger software program. The client/server interface method is called Connect and is language independent.

Each analysis or design space within STK is called a scenario. Within each scenario any number of satellites, aircraft, targets, ships, communications systems or other objects can be created. Each scenario defines the default temporal limits to the child objects, as well as the base unit selection and properties. All of these properties can be overridden for each child object individually, if necessary. Only one scenario may exist at any one time, although data can be exported and reused in subsequent analyzes.

For each object within a scenario, various reports and graphics (both static and dynamic) may be created. Relative parameters, between one object and another can also be reported and the effect of real-world restrictions (constraints) enabled so that more accurate reporting is obtained. Through the use of the constellation and chains objects, multiple child objects may be grouped together and the multipath interactions between them investigated.

Modules

STK is a modular product, in much the same way as Matlab allows you to add modules to the baseline package to enhance specific functions.

Since the release of STK 8.0, the STK product range has been reorganized into Editions with additional add-on modules. A brief summary of the editions and modules is listed below.

STK Basic Edition

STK Basic is free to all users and is also the core module for all other STK modules. It allows access calculations to be performed between satellites and fixed points on the Earth's surface (or between satellites). There is also the ability to import satellites from the NORAD public satellite database (which can be updated online from within STK).

As of STK 8.0, users of the free version can also publish their scenarios to the free .vdf format. This means that scenarios can then be opened using the AGI Viewer product that can be downloaded from here.

http://www.agi.com/products/viewer/

STK Professional Edition

This adds to the Basic Edition with the following abilities:

  • High fidelity trajectories
  • Aircraft performance models
  • Multi-point and group inter-visibility
  • Constrained inter-visibility
  • Complex sensor modeling
  • Integrated 3D analysis tools
  • Custom reports and graphs

STK Expert Edition

This adds a host of additional modules to what is provided in the STK Professional Edition

  • STK/Integration Module (ability to integrate STK with external tools through Connect and/or through Matlab as well as embed STK into a custom application)
  • STK/Terrain, Imagery & Maps Module (high-resolution imagery and terrain of the whole world)
  • STK/Analyzer (perform trade-off studies and what-if analyses)
  • STK/Attitude (integrate custom attitude control laws into STK)
  • STK/Communications (high-fidelity link budget analysis)
  • STK/Coverage (multi-point access calculations and navigation system analysis)
  • STK/Radar (ground, space and airborne radar systems simulation)

Each of the above modules can be purchased individually and added to either the STK/Basic Edition or the STK/Professional Edition.

STK Specialized Analysis Modules

These are modules that can be added to the Basic, Professional or Expert editions:

  • STK/Astrogator (interplanetary orbits, orbit maintenance, LEOP simulation)
  • STK/Conjunction Analysis Tools (In-orbit collision prediction)
  • STK/Missile Modeling Tools (missile simulation)
  • STK/PODS (Precision Orbit Determination System - to reconstruct satellite orbits through observational data)
  • STK/Scheduler (use scarce resources in the most efficient way)
  • STK/Space Environment (radiation dose, debris flux, thermal loading)

Integration

STK can be embedded within another application (as an ActiveX component) or controlled from an external application (through a TCP/IP or COM link). Both integration techniques can make use of the connect keyword system to accomplish this task. There is also an object model for more "programmer oriented" integration methodologies. STK can be driven from a script that is run from the STK internal web browser in the free version of the tool. To control STK from an external source, or embed STK in another application requires the STK/Integration module.

Connect

Since connect is a messaging format, it has the advantage of being completely language independent. This allows applications and client tools to be created in the programming language of the user's or developer's choice. In practice, as long as it is possible to create a TCP/IP socket connection, send information through that socket and then receive information that way then STK can be controlled with connect using that language.

Applications have been developed in C, C++, C#, Perl, Visual Basic, VBScript, Java, JavaScript and Matlab. Examples can also be found in the STK help files or downloaded from the AGI website.

Syntax and Use

The connect syntax is as follows:

  []

Although the is not case sensitive, the and is.

So, to create a new scenario called MyScenario the following command would be issued:

New / Scenario MyScenario

STK will then send an acknowledgment message back.

To create a new satellite, then the parent object should be referenced:

New / Scenario/MyScenario/Satellite MySatellite
In practice, and because only one scenario can be used at any one time, the scenario reference can be replaced thus:
New / */Satellite MySatellite

To change other parameters, specific commands are used. For example, to modify the color of a sensor called MySensor attached to MySatellite, then we can use the Graphics|SetColor command:

Syntax:

Graphics  SetColor {Color} [{Item}]

Command:

Graphics */Satellite/MySatellite/Sensor/MySensor SetColor red

If we want to change multiple objects in the same command, then we can use the wildcard * to do so. For example, if we wanted to change all sensors that are attached to satellites to red, then we could issue the following command:

Graphics */Satellite/*/Sensor/* SetColor red

If we wanted to change all sensors attached to all objects (whether they be satellite, ground stations, aircraft or anything else), then we could issue the following command:

Graphics */*/*/Sensor/* SetColor red

Performance Tips

Sometimes performance is the overriding requirement of an embedded or integrated solution. There are some useful utilities that can be used to increase the performance of commands sent through Connect to help.

The first is to use the BatchGraphics command when making massive changes to a scenario. What this does is halt the refresh of both the 2D and 3D graphics windows until all the changes have been made and then force a single refresh.

Ordinarily, if you sent a command to change the graphics properties of a number of objects, then the display will be redrawn after each refresh. This is not noticeable when changing a small number (5 or so) objects at a time. Since STK can import a large number of objects (8000+ is not unheard of), then refreshing the screen after each object is not particularly efficient.

For example, if we had a script that went through each satellite in the scenario and turned its orbit display off, we would have some pseudo-code like this:

For i = 0 to numberOfObjects
   SendConnectCommand("Graphics */Satellite/MySat" + i + " Basic Orbit Off"
       ##STK refreshes the visualization windows here##
Next i

You can see that if numberOfObjects is large, then we are going to get a delay before the whole for-next loop finishes due to the requirement to refresh the screen at each loop.

To solve this, we use the BatchGraphics command and the pseudo-code would look like this:

SendConnectCommand("BatchGraphics On")

For i = 0 to numberOfObjects

   SendConnectCommand("Graphics */Satellite/MySat" + i + " Basic Orbit Off"
Next i

SendConnectCOmmand("BatchGraphics Off")

  1. STK refreshes the visualization windows here##

Only one refresh takes place and the whole loop takes place in the fraction of the time taken without using the BatchGraphics command.

A word of warning - always ensure that the BatchGraphics Off command is executed, otherwise user interaction with the display windows will be disabled.

STK Object Model

From the STK help files:

The STK Automation Object Model is designed to make it easy for users to build custom solutions using STK and 4DX technology. It provides developers with capabilities to control and automate STK objects, manage the lifetime of STK objects, access Data Provider Tools, perform access and coverage computations, and respond to events generated by STK.

The Automation Object Model is a COM Library containing types, interfaces, events and classes representing various aspects of the STK application structure. It is built upon Microsoft Component Object Model (COM) technology and can be used in environments supporting standard COM Automation. Available environments include . NET (C#, Visual Basic . NET), Java, C++, Visual Basic 6, PowerPoint, Excel, Access, and scripting languages supporting COM late binding.

The STK Automation Object Model is available for use with the STK desktop application as well as custom-built STK X-4DX applications.

The STK Object Model is designed to allow STK to be controlled and integrated using an object oriented programming. An pseudo-code (based on C#) example could be:

root = new AGI.STKObjects.AgStkObjectRootClass(); #initialize the object model
root.NewScenario("MyScenario"); #create a new scenario called MyScenario

IAgFacility baikonur =

   (IAgFacility)root.CurrentScenario.Children.New(AgESTKObjectType. eFacility, "Baikonur"); #create a new facility
IAgGeodetic geodetic = (IAgGeodetic)baikonur.Position.ConvertTo(AgEPositionType.eGeodetic); geodetic.Lat = 48.0; geodetic.Lon = 55.0; geodetic.Alt = 0.0; baikonur.Position.Assign(geodetic); #give the facility the positions defined above

There are many helper functions that will allow the programmer to simplify the development of complex applications. For example, instead of using the object.Position.Assign(geodetic) method, there is a quicker way using the following code:

baikonur.Position.AssignGeodetic(48, 55, 0);

Performance Tips

As with the Connect approach to controlling STK, there is a way with the object model to delay the graphics updates until all the changes have been made. This is done with the BeginUpdate method:

root.BeginUpdate();
#do multiple changes here
root.EndUpdate();

STK/X and 4DX

STK/X and 4DX are the two different mechanisms that can be used to embed STK into a custom application. The code and procedures are identical - only the deployment characteristics differ. Since STK 8.0, STK/X has been incorporated into the STK/Integration Module.

STK/X - STK/Integration

In STK/X the integration occurs using the standard installation of STK plus the installation of the integration-specific code. Licensing is controlled through the standard STK licenses (in this case, an STK/Integration license is needed). Any additional capabilities, such as communications analysis or interplanetary mission design, come from the base STK licenses installed (in the previous example STK/Communications and STK/Astrogator). Each installation of the custom application would require the same set of licenses to be installed to get the functionality required.

This is ideal for one or two installations, or for someone creating a custom application for their own use.

4DX

If someone wishes to create an application that they would like to deploy on a wider scale (five or more installations), then the use of 4DX is often more cost-effective and easier to manage. In this case, the deployment is a single-step procedure, with a single installation that includes both STK and the custom application interface. A single license, controlled by the integrator, is then supplied to activate the entire package.

External links

Search another word or see tool kiton Dictionary | Thesaurus |Spanish
Copyright © 2014 Dictionary.com, LLC. All rights reserved.
  • Please Login or Sign Up to use the Recent Searches feature