OMS is a development and runtime environment to efficiently create and run models from reusable components. OMS supports the model development/application lifecycle.
The Object Modeling System OMS is a modular modelling framework that uses an open source software approach to enable all members of the scientific community to address collaboratively the many complex issues associated with the design, development, and application of distributed hydrological and environmental models. Implementation of a common modular concept is not a trivial task. However, it brings the resources of a larger community to bear on the problems of distributed modelling, provides a framework in which to compare alternative modeling approaches objectively, and provides a means of sharing the latest modelling advances.
The Object Modeling System OMS is also an extensible and open software system. It is a
collection of software tools, which can be plugged together into an open
modeling platform. This targets customized and flexible modeling support
and reflects the requirement for an open and extensible model development
and application framework.
The OMS architecture can be described as a layered architecture, it
utilizes the NetBeans Desktop Application Framework. This architecture
allows a very flexible customization of desktop application based on
specific user requirements. For example a model software code developer
needs for example access to compiler, a database access tool and a
visualization package. Therefore the usage of a compiler/debugger
components, a database component and a visualization component is
In other cases, an OMS user just wants to run a pre-built model
without the need to change any of its code structure, but parameterize the
model by editing input data. A model execution runtime component is
therefore the one and only component is this case. Such components are
named modules. Modules are extending the functionality of the framework by
providing custom support for different aspects of model development and
Component based Modeling
Components are the main building blocks of simulation models in OMS.
This chapter introduces the process of developing components with respect to
their structure and behavior using development tools in OMS. In Section 1, an
introduction to General component concepts, discusses the details of OMS components with
respect to the API, and introduces tools within OMS to support and
accelerate the development of components.
Traditionally, scientific applications are designed as large blocks
of hand-crafted code, which usually builds a monolithic application. Such
model applications are not designed to have parts of them easily re
purposed if a related application will be required in the future. A major
disadvantage of building monolithic simulation models is that conceptual
boundaries within the model are captured or not there at all.
The term Component refers to a concept in
software development which extends the re usability of code from the
source level to the executable. Components are software units that are
context-independent both in the conceptual and technical domain. A
component is a self contained software unit that is well separated from
The component approach takes object-oriented designs to the next
level. While object-oriented design methods focus on abstraction,
encapsulation, and localization of data and methods, they can also lead to
simulation systems where objects are highly co-dependent. To remove this
limitation, a more rigid idea was introduced in model development using
the Object Modeling System (OMS): component oriented modeling. It
emphasizes the component as an object-oriented software unit which can
be developed and tested independently, and finally delivered as a unit. It
provides its services through well defined interfaces.
Component implementations in general are proven to support reuse in
a more efficient way than just using object-oriented methods. There are
some general benefits of using components for building complex
Components are designed with a standard, well defined interface
in mind. Such a published interface hides the implementation of the
component logic and forces an abstraction level which separates the
offered contract for communication from its implementation.
Components are self contained units from the conceptual and
technical perspective. They can be developed and tested individually.
Finally they are packaged and are delivered to be used in several
The use of components simplifies the construction of complex
systems since they change the way these are built. In contrast to programming all parts of a new simulation model from scratch, it can be composed
using components. Not all parts of a new model can be just composed,
component adaptation may be required. But a significant amount of work
can be accomplished by component adaptation.
The use of components helps facing the challenge building complex
simulation models by reducing model software complexity and by overcoming the
limitations of monolithic, highly coupled model implementations. The
Object Modeling System (OMS) promotes the application of components as
fundamental building blocks. This chapter discusses the details of
components to be used in an OMS model and introduces the supporting tools
for their creation and management in OMS.