The advent of windows-based computing environments changes the way users interact with computers. With multi-threading, multi-tasking and inter-program communication capabilities, users of windows environments expect programs to work in a cooperative manner. Common graphical user interface (GUI) with point-and-click, cut-and-paste, drag-and-drop, multi-level undo and redo editing functions have become basic requirements in all programs running under windows environments.
Developing an object-oriented simulator to run on windows environments requires lots of resources and technical knowledge about windows programming. Migrating legacy simulators to windows environments complicates the matter even more because proper hooks need to be implemented to interact with the environments and their users. With the innovative features in SansGUI, the task is now much easier, no matter if you are creating new simulators or migrating old ones. You no longer need to spend time on learning the intricacy of windows systems and writing graphical user interface (GUI) code but, rather, you can concentrate on the development of simulator engines, their underlying logic and mathematics. This is how the software gets its name, SansGUI, pronounced Sans-'Gooey, for simulation program development without tedious GUI programming.
SansGUI is a general-purpose modeling and simulation environment for developing and deploying scientific and engineering simulators. It is a software framework for modeling systems, be it physical or abstract. SansGUI is applicable to models configured with different levels of complexity, from a few simple data forms, to a single level network of parts and links, or to as complex as multiple levels of assemblies with cross interconnections. The following are some of the sample application domains that can take advantage of SansGUI's modeling capabilities:
Hydraulic Pipeline Systems
Artificial Neural Networks
These areas are, by no means, the only fields SansGUI can be used for. The limit is one's imagination. Also, complexity in models is not a requirement. SansGUI can also be used by programs that need only a few input/output forms or systems with only one part.
One of the many innovative concepts introduced by SansGUI is the SansGUI Data Object, a simple and easy-to-implement protocol for simulation engines to communicate with SansGUI. One data object format and one Application Programming Interface (API) are the only requirements for creating simulators tightly coupled with SansGUI. Such simplicity implies that it require only minimal effort from developers to master the whole system and be ported to other platforms or translated to other protocols easily.
A simulation developer uses SansGUI to specify the classes of objects in a target system, attributes and properties of the classes, referential and connective relations among the classes, and hooks to the class behavior in a Schema Definition. Upon completion, the Schema Definition can be compiled into an Object Library and a set of source routines, in supported programming languages, for implementing the behavior (functions) of the classes. A simulation user installs the Object Library and the associated simulator executables obtained from the simulation developer to create a Project Model with a model configuration, a certain input data set and parameters. The Project Model data can be sent directly to the class functions in the in-process simulator created by the developer or to the overriding functions created by the user. It can also be used to generate a textual Model File with input data blocks and a flattened model configuration to be sent to an external process simulator. The Model File can also be written in the eXtensible Markup Language (XML) to simplify the reading process in the external process simulators. SansGUI provides a mechanism to call the external process simulator written in any programming language.
SansGUI takes care of user interaction, hierarchical model configuration, data entry assistance and validation, unit conversion, dynamic memory allocation, multi-thread/process simulator execution, simulation control, result logging, displaying, plotting, and, most importantly, evolving users' model data in case the simulators have definition changes between versions.
Not only using object-orientation in its own development, SansGUI also gives the power of object-oriented modeling paradigm to the end users. It is essential in constructing and managing large scale models with common properties in their parts. Object-orientation is encouraged; however, it is not required in simulator development using SansGUI. This is because SansGUI transforms hierarchical models into flat, single level models before sending them to the simulators. In other words, the models can contain complex, multi-level assemblies from the users' stand point, but the simulators see the models with only base components connected in one level. Run-time efficiency is always the primary guiding principle in SansGUI's design and development.
SansGUI version 1.0 implements continuous, cycle-driven simulation control for tightly coupled, in-process simulators. Other control mechanisms, such as discrete, event-driven simulation, will be added in future releases. Because SansGUI is built with object-orientation, other simulation paradigms can be incorporated without losing compatibility. External process simulators are not limited to the SansGUI built-in simulation flow control mechanisms.
A summary of primary file types supported by SansGUI follows:
user models with data to be used by the simulator
compiled class schema and commonly used objects distributed by the simulation developer to simulation users
class schema developed by simulation developers
SansGUI uses class-object-part and object-attribute-value (O-A-V) paradigms to model systems and their behavior. It is designed to model systems that can be abstracted into scattered or interconnected parts grouped into a single level assembly or multiple levels of assemblies and subassemblies. Reference data, contained in reference objects can be symbolically linked to from the parts or from other reference objects. Although parts and assemblies are normally used in SansGUI models, some simulators may not require models with network topographies but only a set of reference objects. These simulators can still take advantages of SansGUI's class schema definition/evolution capabilities and the SansGUI Data Object protocol for their input/output data requirements. Please consult the User's Guide for a full explanation on how the SansGUI Object System can simplify your modeling jobs.
The SansGUI Modeling and Simulation Environment consists of two subsystems: the SansGUI Development Environment and the SansGUI Run-Time Environment. Depending on your license level, a software license key is granted to you to enable the corresponding environments. Once SansGUI is up and running, you can check the About SansGUI dialog in the Help menu to find out what license level you have. Consult Permanent License Key for the license options.
The specifications of system classes in a simulator can be created using the SansGUI Development Environment. Using this environment as a tool, developers can define hierarchical class schema, attributes in the classes, interrelationships among the classes, and the entry points of simulator routines, resulting in the first SansGUI file type -- Schema Definition with the file extension .sgs. Schema Definitions of simulators can then be compiled into Object Libraries, with the file name extension .sgo, for distribution along with simulators' DLLs and/or executables to be run in the SansGUI Run-Time Environment. Before distributing the Object Libraries, simulation developers can add commonly used objects with default values in them.
The following is a partial list of the SansGUI Development Environment features:
Choices of object or procedure oriented simulator development.
Hierarchical class schema with attribute inheritance.
Selectable levels of class sharing among simulators, work groups, or companies.
A rich set of GUI control types funneled into a simple set of simulator data types.
Programmable data validation rules for input error checking across multiple fields.
Automatic unit conversion to whatever units the simulator specifies.
Graphics class framework supporting industry-standard OpenGL API and interactive zooming, panning, rotation, and user selection controls for 3D graphics applications.
Aggregate data types with collections, tables, matrices and more.
Choices of row or column major order data storage on a class by class basis.
Dynamic memory allocation requested by the simulators programmatically.
Easy to learn, single SansGUI Data Object format and single Application Program Interface (API) for DLL implementation.
Complexity of multiple levels of assemblies is handled by the SansGUI Run-Time Environment and is hidden from the simulator.
Multiple programming language support for tightly coupled simulators (C/C++ and Fortran).
Class behavior implemented with tightly coupled in-process DLLs which can be, upon the developer's choice, overridden by the user at run-time for extensibility.
Model configuration and data can be written in Tabular Data Blocks or XML Model Data format to simplify external process simulator development.
Schema version evolution with automatic version control for changing simulator specifications.
Customizable shell/batch invocation script for legacy simulation codes with no programming language limitation.
Debugging and tracing your own code using the supported development environments.
On-line documentation support with developer specified manual formats.
Please consult the Developer's Guide for more details.
The SansGUI Run-Time Environment allows users to configure models of real world systems using component objects, reference objects, parts, links, and assemblies, according to the definitions stored in Object Libraries. Once a model is created, the user can execute the simulation, view the results, and plot the resulting data. The models are stored in Project Model files with the extension .sgp.
Here is a partial list of some SansGUI Run-Time features:
Object-oriented modeling environment.
A consistent modeling and simulation environment for all simulators installed.
Component objects storing common properties of parts to reduce data redundancy.
Part override capability for minor variations in parts without creating multiple similar objects.
Dynamic typing during model building for flexibility.
Static typing during simulation for efficiency.
Input data type and range checks for error avoidance.
Input assistant for entering quantitative values from ranges mapped by qualitative ranks selected.
User extensible unit objects for units not supplied by the simulation developer.
Copy and paste data operations within the environment and with outside windows applications.
Multiple levels of undo and redo for canvas operations.
Drag and drop operations for sharable objects across Object Libraries and Project Models.
Configurations of single level, flat models or multiple level hierarchical models with subassemblies.
Replication of parts containing multiple levels of subassemblies.
Automatic process for building completely connected graphs from selected parts.
Dynamic memory allocation requested interactively by the users.
User programmable DLL plug-ins to populate data objects.
Single step or fast forward a simulation.
Data value modifications when a simulation is paused.
Data value plotting when a simulation is paused or finished.
Dynamic charting when a simulation is running.
3D graphics visualization with zooming, panning, rotation, and selection controls.
Simultaneous execution of multiple models with one or more simulators.
Context-sensitive on-line help for the SansGUI Modeling and Simulation Environment and the simulators supplied by the simulator developers.
Please consult the User's Guide for more details.
SansGUI Modeling and Simulation Environment Version 1.2
Copyright © 2000-2003 ProtoDesign, Inc. All rights reserved.