The basic version of the program used to estimate and simulate the model consists of four Java source files. This readme file briefly explain the roles of the classes defined there.

LifeCycle.java
--------------
This is the main program taking care of the optimization of households' life cycle problem. It contains the following main classes and interfaces:

ModelParameters:
A record of the parameters used in a simulation run.

IntegrationWeights:
Generates the weights used in numerical integration (across different match qualities) for a specific Grid. IntegrationDensity is used to calculate these weights for the job offer process under consideration.

JobOffer:
Implements stochastic job offers. This is used in the simulation stage.

Grid:
Implements a grid on which a the optimizer operates. I use a number of different Grids along the various dimensions of the problem. These are derived from this class.

Period:
A record large enough to store all information about a household's value function and optimal choice in one period given a set of grids.

Institutions:
Institutions implement the tax and benefit systems in place in a country. This includes transition rules for states like claims to pensions and UI, as well as an income function y that incorporates taxes and benefits. Institutions also define the grids that are used for the various state variables. Concrete implementations for Germany, the US and the UK 1997 are available.

LifeCycle:
This class incorporates the methods and data used to solve a household's optimization problem, store the results, and provide information on a household's optimal behaviour during simulations. The actual optimization step is encapsulated in the class LCOptimizer.

Optimizer.java
--------------
This class contains the tools to solve minimization problems numerically. It has nothing to do with the household's optimization problem; rather, it is used in the estimation process when minimizing the quadratic function of the moment vectors.

Problem:
This class is an abstract version of an optimization problem. Several classes are derived from it, the only interesting one being EstimateDist, which uses a client-server protocol (see below) to evaluate an objective function in a distributed manner.

Optimizer:
An Optimizer is a class that finds the optimum of a function defined by the class Problem. Two of the optimizers defined here are actually used in the estimation process: Opt_EvolStrat implements the evolutionary strategy used to narrow down the area in which the amoeba algorithm, implemented as Opt_NelderMead, looks for the optimum. 

SSync.java
----------
This file contains a simple implementation of a client/server message-passing architecture. It is used so that a "master" process can send tasks to "slave" processes which complete then and return the result. This is used extensively in the estimation process, where the household's problem is solved and histories are simulated several thousand times.

SyncServer
This class is used by the "master" process. The SyncServer accept a large number of tasks, pass them on to "slave" processes, and can report the results once they are in. Communication is done via TCP/IP.

SyncClient:
This is used by "slave" processes. These processes automatically poll the server for tasks. Once one is available, it is read, completed, and the results are sent back. There is no limit to the number of SyncClients used with a SyncServer (at least one is needed, of course). The SyncClient needs to know the server's address (IP address or domain) and the port to communicate over.

Statistics.java
---------------
This class calculates the statistics used to construct the simulated moments for the estimation process. It basically takes the solution to the household's optimization problem (LifeCycle class) and simulates a large number of individual histories, keeping track of some aggregates by age group.