• Fire in NetLogo


    The Fire model is a common NetLogo example. It studies the percolation of a fire in a forest depending on the density of the forest. This worklow studies the impact of the density factor for a fixed population size. To do this, it perform a design of experiment where the density factor ranges from 20% to 80% by steps of 10.

    Since the Fire model is stochastic, the workflow replicates the execution for each instance of the density factor. Results for each replication are be stored it in a CSV file.

    Packaged archive (can be imported in OpenMOLE)
    Source repository

  • Metamimetic Networks


    This is an implementation of a prisonner’s dilemma metamimetic game for different network topologies under netlogo 5.1.0.

    Agents play the prisoner's dilemma game with each one of their neighbours in a torus lattice or a network (small world or random).

    The parameter p corresponds to the strength of dilemma in the widget:

                                 Payoff Matrix
          BEHAVIORS   Cooperate            Defect
           Cooperate |(1-p, 1-p)            (0, 1)
      YOU            |
           Defect    |(1, 0)                (p, p)
            (x, y) = x: your score, y: your partner's score
            Note: higher the score (amount of the benefit), the better.

    The agents can have one of 4 types:

    Maxi : The agent tries to maximize the score (payoff)
    Mini : The agent tries to minimize the score
    Conformist: The agent tries to behave as the majority
    Anti-conformist: The agent tries to behave as the minority

    Each round agents play they copy the most succesfull agent in their neighborhood according to their own current type:

    A Maxi agent would copy the type and behavior (C or D) of the agent in its neighborhood with highest payoffs. A Mini agent would copy the type and behavior (C or D) of the agent in its neighborhood with lower payoffs. A Conformist would copy the type and behavior (C or D) that the majority of its neighborhood is using. An Anti-Conformist would copy the type and behavior (C or D) that the minority of its neighborhood is using.


    Decide the topology structure or load one. Decide a Number of Agents that will be playing. Decide what percentage of agents should cooperate at the initial stage with inicoop. Decide what is the strenght of the dilemma p. If you are not loading a topology; choose the parameters for the desired topology. Choose to add noise to the model by renovating the population and have some agents die.


    At each period:

    Each agent A plays a prisoner's dilemma game pairwise with all of its neighbours. The scores for all the pairwise games played are summed up to become the new payoffs of the agent.

    Each agent looks at the payoffs, decision-making rules and behaviours of other agents in its neighbourhood Gamma_A.

    For any agent A, if according to A's type (payoffs based or non-materialistic) there is one neighbour B that is more successful than A himself, and if B has a different decision-making rule, then A copies the rule of agent B. In the case of two or more candidates to copy, then A chooses one of the rules at random.

    If according to its new rule of behaviour and its associated utility function, A is still not among the most successful agents in the neighborhood, then A copies the behaviour of the neighbour with the best situation.


    If agent A had the conformist type and if the majority of its neighbours have turned to maxi since last round, then A will adopt the maxi rule. Here, the imitation rule is used to update itself (reflexivity). If same agent A, which is now a maxi agent, played C last round but a D-player did strictly better than all of A’s neighbours (A included), then A will become a D-player. Here, the imitation rule is used to update the behaviour (metacognition).


    How do populations change with the strength of the dilemma? What is the effect of noise with renovation of the population? Where are agents located in the network at the attractor? What is the effect of the initial disposition towards cooperation? Are there differences in the final populations for each topology?

    Packaged archive (can be imported in OpenMOLE)
    Source repository

  • Pi Computation

    Parallel estimation of Pi

    This workflow exposes how to compute an estimation of Pi usign a Monte-Carlo estimation of Pi. The computation task is a Scala task using a self contained code. The workflow computes parallely 100 independant executions of this task using randomly generated seeds for the random number generator. It produces 100 independant realisation of the Monte-Caro estimation. Then the workflow gathers them in a vector and computes an average on the values of the vector. Finally the result is displayed on the standard output.

    Packaged archive (can be imported in OpenMOLE)
    Source repository

  • Random Forest

    Random Forest image classifier

    This workflow explores the parameters of a random forest image classifier written in Python using scikit-learn.

    The classifier is trained against the leaves dataset publicly available from here: The idea is to distinguish the leaves of 3 different species.

    The Python script receives 3 input parameters: - the location of the dataset - the number of trees in a forest - the depth of each tree

    The OpenMOLE workflow explores those 3 parameters as follows: - the input dataset is shuffled so that it's picked up in a different order by the Python script - the number of trees ranges from 5 to 25 by steps of 5 - the tree depth ranges from 3 to 18 by steps of 3

    The output of the Python script is a double precision floating point number representing the precision accuracy.

    All the computed accuracies are stored in a CSV file using a hook for later post-processing.

    Two environmments are defined (Slurm and Condor) to delegate the execution of the Python script.

    Finally, the Python task was packaged using CARE with the resulting archive being available along this workflow. It should run seamlessly on any Linux platform.
    The original Python script is also available for records purpose.

    Packaged archive (can be imported in OpenMOLE)
    Source repository

  • SimpopLocal

    Calibration of the SimpopLocal model

    This project automatically calibrates the SimpopLocal model given 3 objective usign a genetic algorithm, distributed on a computation grid. The workflow runs 200000 hours of computation. The model sources are available in the model directory. The result have been published in 2 papers: * Half a billion simulations: evolutionary algorithms and distributed computing for calibrating the SimpopLocal geographical model * A New Method to Evaluate Simulation Models: The Calibration Profile (CP) Algorithm

    Packaged archive (can be imported in OpenMOLE)
    Source repository