Free data model software for linux

Installation: The simplest way to compile this package is:

1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system.
2. Running `configure might take a while. While running, it prints some messages telling which features it is checking for.
3. Type `make to compile the package.
4. Optionally, type `make check to run any self-tests that come with the package.
5. Type `make install to install the programs and any data files and
6. documentation.
7. You can remove the program binaries and object files from the source code directory by typing `make clean. To also remove the files that `configure created (so you can compile the package for a different kind of computer), type `make disclean. There is also a `make maintainer-clean target, but that is intended mainly for the packages developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution.

Misfit Model 3D is an OpenGL-based 3D model editor that works with triangle-based models. Misfit Model 3D supports multi-level undo, skeletal animations, simple texturing, scripting, command-line batch processing, and a plugin system for adding new model and image filters.
Complete online help is included. It is designed to be easy to use and easy to extend with plugins and scripts.
Misfit Model 3D was written and tested on Linux (2.4 and 2.6 kernels) and has been compiled and tested on most major Linux distributions.
It is not endian-safe so it is unlikely to run on non-x86 hardware platforms--this will probably not change soon unless I get requests for a version thats usable on big-endian archs.
Enhancements:
- The menus have been re-organized. There is a new command to make normals face outward. The texture coordinate window now has a rotate tool. Material support for COB has been improved. Many animation bugs have been fixed. A "File | Export" command has been added to indicate which formats have less reliable write support.

QML (Quantity Modeling Language) is a "thing"-based language for scientific and mathematical data modeling.
Each "thing" is a quantity which may be associated with either a structure or physical phenomena.
Quantities, in turn, may hold other Quantities or values (numbers or strings). Higher-level data models, which associate or define meanings to various quantities (such as velocity or position), can be built from QML quantities.
The higher-level data model (XML) schema that inherits from QML may be understood, and its instance documents may be parsed into QML documents and objects by the QMLReader.
Enhancements:
- This release adds partial Xerces2 DOM support, and works with Java 1.4 and Java 1.5 (no JAXP DocumentBuilder/Factory support currently).
- The test procedure is a little less chatty.
- Support has been added for testing either/both Crimson/Xerces DOM support.
- (Note: Crimson support only works with Java 1.4, as Java 1.5 interfaces have DOM lvl 2 and 3, which crimson doesnt support).
- This release adds compilerargs, and better build support for different configurations to build.xml.

Hydrate is a Java tool that provides for fast efficient and error-free transformation of data between three different representations: relational databases, objects in an object-oriented programming language and extended markup language (XML).
Each of these representations has its strengths and weaknesses as shown in the diagram below; but which should you use as a basis for your application design?
Hydrate relaxes some of the pressure on this decision by providing tools for moving data from one representation to another, guided by a master UML class representation of that data.
- You want to lay a domain object model view over an existing database or set of databases. Hydrate gives you the tools to design that model in UML and map your existing data to that model. Once in the object space, you can perform complex manipulations on the objects, calculate results and save information back to a relational cache for searching or reloading, as well as converting the results to XML for sending to downstream systems or transforming to a readable format for display.
- Your project involves taking various data files fed from external systems that you want to pull into an object model on your server before writing the results down to a fully relational database. You can now respond to requests from external systems by rehydrating the data from its relational form and sending it out as XML documents or transforming those documents to a readable format for display.
- You are building a data warehouse in which you have the broad specifications for the model, but want to provide for flexibility and adaptability for future unpredicted requests. Based on a core data model, Hydrate gives you the tools to create you database schema, and write information to it, but more significantly to subsequently lay a completely different object model perhaps aggregating some of the data over the top of that schema to process it in unforeseen ways.
- You need to integrate data from many different data sources in a highly performant manner. SQL permits you to read a huge data set a row at a time and perform running calculations and filtering on that data. But the performance pressures can lead to code that is highly coupled with the database and what do you do if you need to integrate data from elsewhere in order to complete your calculations? Hydrate permits you to operate in the object space and integrate information from other sources on-the-fly.
Main features:
- To integrate legacy and other data schemas over which you have little control. Map data from many different data sources into a single self-consistent in-memory model. Different parts of the same object, as well as different sub-populations of the same object type can be drawn from different data sources, different schemas and even different database architectures.
- Load, populate and connect up multiple object types from a single query. There is no limit to the number of object types that can be loaded from a single query, or to the complexity of the relationships that can be resolved between them. Objects read from a query are automatically merged into objects already in memory.
- Full control over the SQL that runs against the database (if you need it). Any SQL queries simultaneously from multiple JDBC drivers, even using database specific optimizations, as long as they returns a result set.
- Access and manipulate the same data through the rich and powerful XML toolset. Use the same meta data that describes your objects to easily read from, write to and validate any consistent XML schema. Use XML for display, data transmission or XSLT transformation. Load XML data back into objects.
- Highly optimized performance for reading and writing SQL and XML. Since native types are used and SQL chatter is non-existent, database performance is comparable with doing the mapping by hand. XML reading and writing uses SAX exclusively.

JavaPK for Desktop (JPKD) is a Clinical Pharmacokinetic (CPK) Services (or Therapeutic Drug Monitoring, TDM).
It not only inherits all functionalities of JavaPK for Mobile Devices, but also has a built- in algorithm of users defined Bayesian model for individualized pharmacokinetic parameter estimation (UDBM) for batch input data.
Users can define their own pharmacokinetic prediction models with population PK parameters and then use the defined model to solve batch prediction data or applied the defined model to therapeutic drug monitoring (TDM).
JPKD is created for your own personal uses and testing purposes. JPKD shall be used as a guide or a decision support tool only. Medical decisions should NOT be solely based on the results of this program. Although this program has been tested thoroughly, the accuracy of the information cannot be guaranteed. Once you use JPKD, you have automatically agreed with this disclaimer.
Main features:
- Sawchuk-Zaske (aminoglycosides & vancomycin) and Bayesian method for PK parameter estimation
- 15 built-in drugs for TDM (see the below drug lists)
- functions for users defined Bayesian estimation drug models
- portable function for users defined models
- a built-in spread sheet for batch PK parameter estimation & input data manipulation
- application user-defined Bayesian model to TDM
- multiple desktop platforms (WinXP/NT, Mac OS X, Linux PC) supported
Built-in drug lists
- Amikacin
- Carbamazepine
- Cyclosporin
- Digoxin
- Enfuvirtide
- Everolimus
- Gentamicin
- Indinavir
- Lithium
- Phenytoin
- Ritonavir
- Tacrolimus
- Theophylline
- Tobramycin
- Vancomycin

MODELbuilder is a scientific application that provides a graphical way to derive models from empirical and simulation data. MODELbuilder is fit to do regression and regression analysis.
Enhancements:
- This release has a new project file format, data editor, and data import class.
- An external solver has been added.

WildCAT project is a Java toolkit/framework which can be used to build context-aware applications, of which self-adaptive applications are a special case.

From the client applications point of view, it provides a simple and dynamic data-model to represent the execution context of the application, and offers a simple API for the programmers to access this information both synchronously and synchronously (pull and push).

Internally, it is a framework designed to facilitate the acquisition and aggregation of contextual data and to create reusable ontologies to represent aspects of the execution context relevant to many applications.