{"id":80,"date":"2020-03-11T11:21:01","date_gmt":"2020-03-11T10:21:01","guid":{"rendered":"https:\/\/project.inria.fr\/fiatlux\/?page_id=80"},"modified":"2020-04-13T13:54:42","modified_gmt":"2020-04-13T11:54:42","slug":"developer-guide","status":"publish","type":"page","link":"https:\/\/project.inria.fr\/fiatlux\/developer-guide\/","title":{"rendered":"Indications for developers"},"content":{"rendered":"

Download the indications in pdf: Click here<\/a>.<\/p>\n

Use case<\/h1>\n

Creating a model<\/h2>\n

Implementation of the model<\/h3>\n

<\/span>

\n
\n\"\"
Structure : Implementation of a model (simplified)<\/span><\/figcaption><\/figure>\n
<\/h6>\n

At the start, you need to develop a class which will contain the model\u2019s methods. The package models<\/code> are exclusively created for this and contain packages for each complex system type. Chose the most convenient package for your model. We recommend you create your own package in the ones you took for your model to clarify the hierarchy of the code\u2019s application but this\u2019s not obligatory.<\/p>\n

<\/h6>\n

The name of the class\u2019s model must be like NameOfTheCellularAutomatonModel.java<\/code> with no space, uppercase for each word and finish with \u201c-Model\u201d. The class will need to extend the type of model\u2019s class. You will find this class in the CAmodels<\/code> package. The most used one is ClassicalModel<\/code> but there are the other\u2019s as well.<\/p>\n

<\/h6>\n

For every model you must define a name. It\u2019s important because this variable will serve as a unique reference to the model. Use the same rules than before without the \u201c-Model\u201d termination:<\/p>\n

public static final String NAME = "NameOfTheCellularAutomaton";<\/code><\/pre>\n
Classical cellular automata\u2019s model implementation<\/h4>\n
ApplyLocalFunction<\/h6>\n
ClassicalModel<\/code> extends CellularModel<\/code> and is the model this uses OneRegisterIntCell<\/code>. OneRegisterIntCell<\/code> is a cell\u2019s type whose state is defined by an integer. ClassicalModel implements the method ApplyLocalFunction(OneRegisterIntCell in_Cell)<\/code> which returns an integer : the following state of the cell.<\/p>\n
<\/h6>\n
This is the first function you must define in your model. The object OneRegisterIntCell<\/code> contains methods to read the neighbourhood state and the state of the cell itself. With this data you can implement in this function the update of the cells.<\/p>\n
@Override\r\npublic int ApplyLocalFunction(OneRegisterIntCell in_Cell) {\r\n    \/\/ Your function ... \r\n    return intNextState;\r\n}<\/code><\/pre>\n
GetDefaultInitializer<\/h6>\n
The second method you must define is GetDefaultInitializer()<\/code> where you will choose the initializer of your model. Just instantiate the one this you wish and return this instance.\n<\/p>\n
<\/h6>\n
In the case where you are modelling a binary cellular automaton this\u2019s all you will need. But if you want to implement more specific behavior, you must use different palettes and viewers.<\/p>\n
Palette<\/h5>\n
<\/h6>\n
The color of the simulation is managed by PaintToolKit<\/code>. Many colors stack are already in the application you can choose the one you want for your model by overwriting the GetPalette()<\/code> method in your model. In this function you need to instantiate a color\u2019s stack with PaintToolKit.GetThePaletteYouWant(parameters)<\/code> and define some color if you want (Particularly the 0 state if you want a rule special for it. For example turn it white like most of the cellular automata).<\/p>\n
<\/h6>\n
Here an example with the Rainbow palette but you can found others in the section PaintToolKit<\/code>.<\/p>\n
@Override\r\npublic PaintToolKit GetPalette() {\r\n    PaintToolKit palette= PaintToolKit.GetRainbow(256);\r\n    palette.SetColor(0, FLColor.c_black);\r\n    return palette;\r\n}<\/code><\/pre>\n
Use the model<\/h4>\n
<\/h6>\n
The model is now usable by command-line but if you want it to appear in the menu you need to register it in the tables of the app. For that, in the package main<\/code>>tables<\/code> there is a class named MODEL_TABLE<\/code> which list the different model you can use in the app. In the method FillTable()<\/code> you have to add your model in the list with the command line with the others in the section you\u2019ll find the more appropriate:\n<\/p>\n
AddList(NameOfTheCellularAutomatonModel.class);<\/code><\/pre>\n
<\/h6>\n
Your will find that the list is stratified by the method AddSeparator()<\/code> which add a strait line in the menu as a separator. And by the line m_modelType = MT.*TypeOfModel*<\/code> this one separate the list into other tabs in the menu. Choose the most convenient tabs and add separators if you wish in order to keep the menu tidy.<\/p>\n<\/div>\n
Structure<\/h1>\n
<\/h6>\n
To implement a model, in addition to the rule to be developed as above, it is necessary to use viewer and initializer classes in order to be able to employ it in the software. The hierarchy of these classes is explained here.<\/p>\n
Viewer<\/h3>\n
<\/span>
\n
\n\"\"
Class diagram : Viewers hierarchy (simplified)<\/span><\/figcaption><\/figure>\n
<\/h6>\n
The Viewers<\/code> objects manage the table of cells. This table contains all the cells of the simulation with their values and methods. It also manage the grid view of the simulations. Like the size of the cells, the distribution of the colors, the border of the cells or theirs specials effect visualization. There are four hierarchical levels presented here from the higher to the specifier.<\/p>\n
AutomatonViewer<\/h4>\n
<\/h6>\n
The abstract class AutomatonViewer<\/code> contains the most general methods about the display of the grid. It extends JComponent<\/code>1<\/sup><\/a> it is the most elevated hierarchical level. It associates a palette to each viewer.<\/p>\n
<\/h6>\n
The abstract method GetXYWindowsSize()<\/code> needs to be defined by inheritance. This method must return a couple of int which contains the size of the window\u2019s panel in pixels in the form of a IntC<\/code>.<\/p>\n
GridViewer<\/h4>\n
<\/h6>\n
This abstract class defines the methods which display the components of the grid in the paintComponent()<\/code>, which cannot be overwritten. The class also contains the variables about the grid:<\/p>\n
\n
m_XYsize:<\/dt>\n
\n
the grid size (in number of cells).<\/p>\n<\/dd>\n
m_CellDist:<\/dt>\n
\n
an integer for the distance between two cells.<\/p>\n<\/dd>\n
m_SquareSize:<\/dt>\n
\n
an integer which represents the size of the cells.<\/p>\n<\/dd>\n
m_square:<\/dt>\n
\n
a two-dimensional table of java\u2019s Rectangle class2<\/sup><\/a> which will be used to draw the grid.<\/p>\n<\/dd>\n<\/dl>\n
\n<\/h6>\n
The constructor of the class requires two parameters:<\/p>\n