ComRelay(s): Your agent will communicate with one or more external entities, be they hardware controllers or higher-level controlling software modules. In cases where those entities are not IDEA agents, or the external IDEA agents communicate over a non-standard communications protocol (i.e. not IPC), you'll define a ComRelay that translates from the communications protocol used between the agents to the IDEA AgentRelay protocol.
GoalLoader (optional): If your application must accept pre-generated plans from an external source, in a non-IDEA native representation (for example a file format), you will need to define a custom GoalLoader.
Constraints (optional): The EUROPA planning framework defines a library of constraints between parameters (e.g. equal, greater than, etc.) that can be invoked in the domain model to express relationships between predicate parameters. In some cases, these pre-defined constraints may not cover the relationship required to model your application. In those cases, one can define a custom constraint class to extend the set provided by EUROPA.
Reactors (optional): In some cases, your application must activate software modules as part of the execution process (e.g. a deliberative planner). The IDEA Reactor class can be extended to define a module that can be associated with states in the model, and activated when the state is activated.

Domain Model: A fundamental component of an IDEA agent is the declarative model defining the legal behavior of all systems that the agent interacts with.
Initial State: Users must specify the initial state an agent takes at the start of runtime. This takes the form of a partial plan that encompasses the initial time for all initially-specified objects in its model.
Heuristics: A number of heuristics, preferences and other parameters help steer the planner or planners in an IDEA agent to find the desired solution under different conditions, thereby substantially improving the performance in time-critical scenarios.
Module Configuration: IDEA is built dynamically, at runtime, from dynamic objects built at compile time. The user must define the set of dynamic objects to compose the agent, which in general depends on the IDEA mode (see Normal and Fast Mode), and whether your agent attaches to IDEA-external applications (e.g. interface code to hardware controllers) or operates purely in simulation.

Makefiles: Each application-specific module (e.g. ComRelay, GoalLoader, Constraint, Reactor) will require a makefile. In addition, you will probably define an umbrella makefile that calls the general IDEA makefile plus builds all your application-specific modules. This way, each application has a makefile that builds the entire application from the bottom up.
Run Script: Running IDEA coordinates several applications that must run simultaneously (IPC central router, TimingService, IDEA agent and possibly a simulator). Furthermore, the IDEA agent itself may have different configuration options depending on whether you intend to run simulations or the actual control hardware and software. A standard way to coordinate these is through a "run script" that has a small set of command line options and that enacts the operations needed to get everything working.
Simulator Scripts: For the purpose of model debugging, module debugging and agent regression testing, IDEA provides a generic simulator. The simulator reads scripts that define specific scenarios for your agent, in order to test its behavior under those conditions. Each scenario requires two scripts, a master script and a slave script, and applications typically define many scenarios.

In the next section we introduce the domain that will serve as an example for all discussions on domain development.

Generated on Fri Feb 3 17:09:44 2006 for IDEA.

How to Define a New Domain

Introduction