Free cell software for linux

E-Cell System is a concept of constructing virtual cells on computers.
E-Cell System is an object-oriented software suite for modeling, simulation, and analysis of large scale complex systems such as biological cells, architected by Kouichi Takahashi and written by a wonderful team of developers. Core part of the system, E-Cell Simulation Environment version 3, allows many components driven by multiple algorithms with different timescales to coexist.
E-Cell Project is an international research project aiming at developing necessary theoretical supports, technologies and software platforms to allow precise whole cell simulation.
E-Cell System consists of the following three major parts:
- E-Cell Simulation Environment (or E-Cell SE)
- E-Cell Modeling Environment (or E-Cell ME)
- E-Cell Analysis Toolkit
Main features:
Basic capabilities
- Object-oriented modeling and simulation of complex systems.
- Plug-in architecture. New user-object classes can be developed, dynamically loaded, and used in simulation.
- Real-time user interaction and visualization during the simulation.
Scripting
- Python scripting of a simulation session (run/stop/parameter manipulation/data processing etc...).
- Python scripting of a simulation experiment that involves many runs of the simulation sessions (such as parameter tuning, metabolic control analysis etc..)
- Python scripting of model file generation (e.g. for automated model construction from databases).
Compatibilities
- SBML level 1/2 importing.
- SBML level 1/2 exporting.
Parallel computation
- Shared-memory, multi-thread parallelization of a single simulation session. (to be merged into the main branch.)
- Cluster and grid distributed computation of multiple simulation sessions. Sun Grid Engine, (Globus toolkit).
Enhancements:
- This release includes improved ODE/DAE solvers, support for numpy, an updated empy preprocessor, and some more minor improvements.

Cell Electrophysiology Simulation Environment (CESE) is a comprehensive framework specifically designed to perform computational electrophysiological simulations, for example, simulations of cardiac myocyte electrical activity.
Cell Electrophysiology Simulation Environment is useful for simulations of action potentials, individual ionic currents, and changes in ionic concentrations.
CESE is a cross-platform program, it runs on any system that has Java runtime environment (JRE) version 1.4 or above. It was tested on Windows, Linux, Solaris, MacOS X, and AIX.
CESE users
CESE is an integrated environment for performing computational simulations using a variety of electrophysiological models.
At this stage CESE allows creation and execution of the single-cell models (containing both Hodgkin-Huxley (HH) and Markovian current formulations). Models of electrical activity of cardiac myocytes with source code are included in the CESE distribution. We hope to extend the number of available models, and add certain neuronal models in the future.
The main strength of CESE is in its uniformity ? a program interface remains the same for different types of models. You can easily switch between models and compare simulation outputs. Model parameters can be modified, selected for output and/or clamped in the same, standard way.
CESE extends the conventional electrophysiological meaning of the "voltage clamp". You can clamp virtually any model variable, including voltage (membrane potential), total or individual ionic currents, ionic concentrations, temperature, gating variables, etc. The clamping commands can be complex piece-wise functions, individually set for the model variable of interest. This opens endless possibilities for the exploration of complex model behavior.
CESE provides simple, but efficient data visualizations. Simulation results can be presented in the graphic and tabulated forms. Plots can be customized, and regions of interest zoomed.
Even though CESE was not designed to be a data analysis tool, you can generate current-voltage relationships (I-Vs) and calculate statistical parameters for a given signal within the program. You can export your data to ASCII, Axon Text File (ATF), and NetCDF formats to continue analysis in your favorite package.
CESE developers
CESE was created from the ground up to incorporate the best programming practices available to Java developers, both in terms of user interface consistency and code clarity and reuse. Wherever possible, CESE rely on available Java APIs (for example Java2D, JavaBeans, JAXP) to simplify the code.
Model creation requires a number of house-keeping functions to be coded ? these include ODE integrators, routines for handling model parameters, saving/restoring model state, visualizing simulation results, etc. CESE provides you with implementation for these routines, hence, you can concentrate on writing the code for concrete ionic current(s), and CESE will handle the rest.
CESE is not trying to create complicated programming frameworks on its own ? rather, it utilizes core Java APIs. For example, models are Java components conforming to the JavaBeans specification. We use XML to specify clamping commands, and Java object serialization to save/restore model parameters.
Enhancements:
- This release improves results printing, adds export to the scalable vector graphics (SVG) format, improves support for continuous simulations, and fixes many bugs in plot rendering and model switching.

PyCAGE fairly generic and complete cellular automata simulation engine.
Its written in Python and it supports both 1D and 2D automata, a variety of prepackaged rules, and the concept of "agents" which can move about independently on the map for implementing agent behavior.
It comes with numerous examples of fully-functional CA systems, including Conways Game of Life, Langtons self-reproducing automaton, Langtons "vants," and 1D automata rule explorers.
It also comes with simple displayers (including a curses interface for 2D automata) and a unique implementation of a finite state machine.
Main features:
- time is measured in discrete steps, called time units;
- a network of cells, each of which with a well-defined state at each time unit;
- at each time unit, each cell has a series of other cells which constitutes its neighorhood;
- the state each of cell changes according to a state transition function which depends on the state of that cell and the states of the cells of its neighbors;
- in synchronous automata (the typical usage), all cell transitions take place simultaneously.
Enhancements:
- Minor organizational changes; add stepping stone automaton.

CTBClient is a mobile client for the CTB. The main objective of CTBClient is to allow registering expenses and other financial events in the road, and later uploading them to the mother system.
It puts in use a set of exciting technologies: Bluetooth, Python SQL DBI, serialization (marshaling) of objects, GTK+, Python for Series 60 Nokia cell phones (known as S60), perhaps PyObjc in future Mac OS X versions etc. CTBClient is also meant to be a guinea pig for portable Python development.
CTBClient is a project sponsored by INdT - Instituto Nokia de Tecnologia (Nokia Institute of Technology), where I work and have the environment and time to make such experiments.
Functional clients are:
- GTK+ Linux/local (no Bluetooth, for quick tests);
- GTK+ Linux Bluetooth
- Symbian/S60 cell phone
- GTK+/Hildon Linux (Maemo platform, like Nokia 770 tablets)
Functional servers:
- Linux/local (for testing)
- Linux/Bluetooth

Overflow project is a board game about chain reactions.
Overflow is a board game for two players or one player against the computer. Put pieces on the board until critical mass is reached, and watch a chain reaction go off.
Although the rules are simple, several different tactical considerations are required in order to play the game well.
The name refers to the key principle in the game that each cell on the board can hold a maximum of three units (pieces), and if you add another unit to a filled up cell, the units will be distributed to the four neighbor cells.
Main features:
- Play against the computer or another person
- Advanced hint feature
- Unlimited take backs and redos
- Ugly but scalable graphics
- Selectable colors

PyHtmlTable is a class for Python CGIs to generate HTML tables on the fly. The reason that i made this script is I couldnt find something like Table.pm or Table.php
Main features:
- Allows setting of individual row and cell attributes via arbitrary dictionaries
- Allows spanning of rows and columns
- Autogrows table if cells set outside initial Range.
- Allows dynamic insertion of new rows and columns anywhere in the table
- Allows bulk population of table data via arrays to arbitrary locations in the table.
- Provides default cell attributes for tablewide uniformity and the ability to override these on a cell by cell basis.
- NOTE: Row indexes start at 0 like God and Kernighan demand!
- Influenced heavily by Table.pm and Table.php

Games::PerlWar is a Perl variant of the classic Corewar game.

This is a sparring program, similar to the programmed reality of the Matrix.
It has the same basic rules, rules like gravity. What you must learn is that
these rules are no different than the rules of a computer system. Some of
them can be bent, others can be broken. - Morpheus

PerlWar is inspired by the classic http://www.corewar.info/|Corewar game. In this game, players pit snippets of Perl code (called agents) against each other in order to gain control of the vicious virtual battlefield known as... the Array.

GAME PARAMETERS

Size of the Array

The number of cells that the Array possesses. Each cell can hold one agent.

Agent Maximal Size

The maximal length, in characters, of an agent. If an agent is or becomes larger than this limit, it automatically segfaults upon execution.

Game Maximal Number of Iterations

The maximal number of rounds that can be played before a game is declared over.