The Analysis Server enables users to incorporate analysis software into reusable components that can be published on a network. Once published, users can access these components from any computer on a network, regardless of their platform type, through a simple protocol. The Analysis Server protocol is similar to the HTTP protocol used to publish web documents; as long as the components are properly placed on the server's computer, they can be accessed and used generically. The Analysis Server allows users to control computationally intensive software from cheaper, lightweight platforms. The Analysis Server also hides the details of data management from the user. This means that the user can concentrate on what the data means rather than how to make it fit into an arcane file format for a legacy program. This chapter explains the concept behind the Analysis Server and its benefits to engineers.
The Analysis Server provides generic access and control for components through a technique known as software wrapping. Since the advent of object-oriented technology, programmers have used wrapping as a means of reusing legacy software in object-oriented environments. A software wrapper is a thin software program or module that converts program-specific input and output operations into generic sets of commands that can apply to a wide range of programs. For example, one engineer may have a FORTRAN program that uses input and output decks. In order to publish the program on the Analysis Server, the engineer could write a wrapper that allows him to enter all of his inputs and run the program using simple get and set operations, like these:
>set program.input1 = 3
value set for <program.input1>
>execute program
program completed.
>get program.output1
6.0
Notice that the engineer does not have to write the actual input decks for the program; in fact, he doesn't need to know that the program requires input decks at all. Once the component author invests the one-time effort required to write the wrapper, the wrapper automatically performs the tedious task of writing the input and output file. This leaves the engineer free to focus on results. Most input and output files can be wrapped quickly and easily using the FileWrapper utility. Even files with hundreds of inputs and outputs can be wrapped using the FileWrapper utility in a minimal amount of time. If more flexibility and control is desired, the author can write a wrapper in Java. Java provides excellent flexibility for writing components and is relatively simple to use.
A user is not limited to accessing components through an interactive session. Developers can write Analysis Server clients that can access components automatically. For example, it is possible to write Excel spreadsheet routines that call an Analysis Server component repeatedly to perform a parametric study. Programmers can write Analysis Server clients in a variety of languages, such as Perl, Java, and C++. The Analysis Server can also be reused as an OLE automation component. Because it is possible to connect to the Analysis Server from multiple locations simultaneously, several users can access the same code from different workstations.
As mentioned, one benefit is saving time otherwise spent building and troubleshooting complex files. When software is used extensively as an R&D or production tool, users may spend a large portion of their time on this tedious, error-prone task. Smart users write scripts that partially automate some of the repetitiveness of these tasks, but these scripts often require program-specific knowledge to use. The Analysis Server's simple get and set methods allow users to operate the code without worrying about these details.
The flexibility of software wrapping also allows the Analysis Server to present legacy software as a set of several simple-to-use components rather than as a complex, monolithic program. Expert users understand all of a program's high-level features and can interpret its data accurately and confidently. Basic users operate the program occasionally for a limited number of tasks and may lack the overall conceptual understanding. These basic users may present a dilemma since they cannot reliably use the program in all situations, but may not have an expert available for consultation. The Analysis Server solves this dilemma by allowing developers to create one wrapper that exposes the entire program for the expert user and one wrapper that exposes only one or two well understood features to the novice.
Writing Analysis Server client programs provides another benefit. Developers can integrate several analysis components into a single program where they can share data dynamically. These programs can be written with drivers, such as optimizers and graphing tools, that can treat these components as a unified whole. For example, a user can create a client that links a UNIX-based FORTRAN analysis to a PC based business application. The client allows the user to enter a range of analysis inputs and then graph these inputs against the outputs of the business application. If a better analysis becomes available, the user can swap the new program for the old one without affecting the client, provided that the new program's wrapper has the same interface functions as the old one.
Phoenix Integration has created an Analysis Server client called ModelCenter that enables users to access all the Analysis Servers available on a given network, retrieve their components, and compose them visually into a model containing several components and their data sharing relationships. These relationships, called links, enable users to graphically assign the outputs of one analysis to the inputs of another, creating a chain of linked analysis programs that can operate as a single unit. Users can then employ a collection of tools to perform operations such as graphing, parametric sweeps, and optimization on the integrated model.
A public_aserver directory is a base user directory that holds all of the categories and components that a user has published. When the user establishes a connection to the Analysis Server, the Analysis Server searches for all the public_aserver directories that it can find in a specified path. The Analysis Server's configuration file specifies that path. Each public_aserver is listed as a category when the user performs a listCategories command.
The public_aserver directory is similar to a public_html directory; all items inside this directory are accessible to the public, but no items outside of these directories are accessible. Typically, each user in a multi-user system can own a public_aserver directory in their home directory, just as they can own a public_html directory.
The analyses directory provides the base repository for Analysis Server components. When publishing a widely used component on the Analysis Server, it can be placed inside of the analyses directory. The analyses directory is a master directory for components; components in this directory and its subdirectories belong to the Analysis Server itself rather than to individual users with accounts on that server. When users want to publish their own components, the components can also be placed in their public_aserver directories.
A category is a grouping of components inside an Analysis Server directory. A category hierarchy is analogous to a conventional directory structure inside the computer's directory hierarchy. It is actually implemented by creating subdirectories inside the analyses directory or any public_aserver directory on a server machine. The user can create a hierarchical organization of categories by placing subdirectories inside higher-level category directories. The user can also place any number of components (which are analogous to conventional computer files) inside any category or subcategory directory.
When a public_aserver directory is created in a designated directory on the server machine, the Analysis Server uses the name of that directory as its base category. Users are responsible for creating, maintaining, and documenting any components that they place in their public_aserver directory. The user can traverse a category structure using the listCategories (la) command and a slash (/) syntax.
A component is a wrapped analysis code with a generic interface for setting input values, retrieving output values, and running the analysis. The term component is used here because the wrapper makes it possible to combine the analysis with several other components to form a larger model. A component can be as simple as a parameterized geometric object or as complicated as a wrapped computational fluid dynamics (CFD) code. Typically, a component will perform a calculation based upon a set of inputs and then provide the results of the calculation.
The ExcelWrapper utility is a tool that helps users convert Excel spreadsheets into components through a simple specification method. This manual contains a section that discusses how to use ExcelWrapper, and provides an ExcelWrapper example. Each ExcelWrapper component is defined by a file that has a .excelWrapper extension.
The FileWrapper utility is a tool that helps users create components for file-in/file-out programs through a simple specification method. This manual contains a section that discusses how to use FileWrapper, and provides a FileWrapper example. Each FileWrapper component is defined by a file that has a .fileWrapper extension.
A .jar file is a special Java file that stores a set of Java classes. When the user chooses to create Analysis Server components through Java programming, the component is saved into a .jar file and placed in the analyses directory or a public_aserver directory.
Java is a pure object-oriented language that provides platform independence and dynamic class loading capability. These unique capabilities allow the Analysis Server to dynamically access components and enjoy platform independence. You can write your own components using Java and automatically publish them on the Analysis Server
A method is a function that operates on a component's data. All components require an execute method that controls how to run its analysis and an end method that operates when the component is terminated. Components typically have methods for retrieving and assigning data values as well.
An object or a component instance is an instance of a component. The Analysis Server allows users to run several objects of the same component on one server. For example, say a component that computes the area of a circle exists on an Analysis Server. A user who wants to compute the area of two circles can either start one object and run it twice, or start two objects and run each with a different input radius.
A property is a characteristic of a component. Properties include the component's individual inputs and outputs. They also include hierarchical groupings of properties. For example, an object called cooling_system may be instantiated from a component that computes the total volume of a cooling system. It may include inputs from the system's expansion tank, piping, heat exchanger, and pump. The cooling system components themselves can be listed as properties. Their associated input parameters can be listed as subproperties. Users can traverse an object's property hierarchy using a dot syntax. In this example, the user could list the properties of the pipe subsystem by typing
>listProperties cooling_system.pipeand set its radius equal to 3 by typing
>set cooling_system.pipe.radius = 3
The PerlWrapper utility is a tool that enables users to write components as Perl scripts. The PerlWrapper is a good tool for writing simple components, especially conversion routines and small functions, quickly. This manual contains a section that discusses how to use PerlWrapper and provides a PerlWrapper example.
A tag is a special word in the comment line of a FileWrapper, PerlWrapper, or ExcelWrapper file that specifies a descriptive field for the component. An Analysis Server component contains six such fields: author, description, version, iconFile, helpURL, and keywords. These description fields are optional when creating a component.
A wrapper is a thin piece of software that enables analysis programs to be published as a reusable component. Wrappers hide program-specific quirks and enable users to access programs and their data generically.
See also Analysis Server