public code v1

plugins/afryca.consensusmodel/.classpath

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

plugins/afryca.consensusmodel/.gitignore

@@ -0,0 +1 @@
+/bin/

plugins/afryca.consensusmodel/.project

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>afryca.consensusmodel</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ds.core.builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

plugins/afryca.consensusmodel/.settings/org.eclipse.core.resources.prefs

@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+encoding/<project>=UTF-8

plugins/afryca.consensusmodel/.settings/org.eclipse.core.runtime.prefs

@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+line.separator=\n

plugins/afryca.consensusmodel/.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,10 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning
+org.eclipse.jdt.core.compiler.release=disabled
+org.eclipse.jdt.core.compiler.source=1.8

plugins/afryca.consensusmodel/.settings/org.eclipse.m2e.core.prefs

@@ -0,0 +1,4 @@
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1

plugins/afryca.consensusmodel/META-INF/MANIFEST.MF

@@ -0,0 +1,48 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: %Bundle-Name
+Bundle-SymbolicName: afryca.consensusmodel;singleton:=true
+Bundle-Version: 1.0.0.qualifier
+Bundle-Vendor: %Bundle-Vendor
+Export-Package: afryca.consensumodel.addon,
+ afryca.consensusmodel,
+ afryca.consensusmodel.cluster,
+ afryca.consensusmodel.clustering,
+ afryca.consensusmodel.command,
+ afryca.consensusmodel.definition,
+ afryca.consensusmodel.preferences,
+ afryca.consensusmodel.provider,
+ afryca.consensusmodel.service,
+ afryca.consensusmodel.service.events,
+ afryca.consensusmodel.variable,
+ afryca.consensusmodel.variable.array_relation,
+ afryca.consensusmodel.variable.array_relation.definition,
+ afryca.consensusmodel.variable.array_restriction,
+ afryca.consensusmodel.variable.array_restriction.definition,
+ afryca.consensusmodel.variable.definition,
+ afryca.consensusmodel.variable.relation,
+ afryca.consensusmodel.variable.relation.definition,
+ afryca.consensusmodel.variable.restriction,
+ afryca.consensusmodel.variable.restriction.definition
+Require-Bundle: afryca.ase,
+ afryca.gdmp;visibility:=reexport,
+ afryca.cm;visibility:=reexport,
+ afryca.behavior,
+ afryca.parametervalueconverterhelper,
+ afryca.workspace.service.events,
+ afryca.elicit,
+ javax.inject,
+ org.apache.commons.io,
+ org.eclipse.core.runtime,
+ org.eclipse.core.commands,
+ org.eclipse.e4.core.di,
+ org.eclipse.e4.core.services,
+ org.eclipse.e4.core.contexts,
+ org.eclipse.e4.ui.workbench,
+ org.eclipse.e4.ui.model.workbench,
+ org.eclipse.ui,
+ org.eclipse.e4.core.di.extensions;visibility:=reexport
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Service-Component: OSGI-INF/consensus_model_service_context_function.xml,OSGI-INF/variables_provider_context_function.xml,OSGI-INF/configuration_provider_context_function.xml,OSGI-INF/consensus_model_provider_context_function.xml
+Bundle-ActivationPolicy: lazy
+Automatic-Module-Name: afryca.consensusmodel

plugins/afryca.consensusmodel/OSGI-INF/configuration_provider_context_function.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<scr:component xmlns:scr="http://www.osgi.org/xmlns/scr/v1.1.0" name="IConfigurationProvider context function">
+   <implementation class="afryca.consensusmodel.provider.internal.ConfigurationProviderContextFunction"/>
+	<property 
+		name="service.context.key"
+		type="String"
+		value="afryca.consensusmodel.provider.IConfigurationProvider"/>
+	<service>
+		<provide
+			interface="org.eclipse.e4.core.contexts.IContextFunction"/>
+	</service>
+</scr:component>

plugins/afryca.consensusmodel/OSGI-INF/consensus_model_provider_context_function.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<scr:component xmlns:scr="http://www.osgi.org/xmlns/scr/v1.1.0" name="IConsensusModelProvider context function">
+   <implementation class="afryca.consensusmodel.provider.internal.ConsensusModelProviderContextFunction"/>
+	<property 
+		name="service.context.key"
+		type="String"
+		value="afryca.consensusmodel.provider.IConsensusModelProvider"/>
+	<service>
+		<provide
+			interface="org.eclipse.e4.core.contexts.IContextFunction"/>
+	</service>
+</scr:component>

plugins/afryca.consensusmodel/OSGI-INF/consensus_model_service_context_function.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<scr:component xmlns:scr="http://www.osgi.org/xmlns/scr/v1.1.0" name="IConsensusModelService context function">
+   <implementation class="afryca.consensusmodel.service.provider.ConsensusModelServiceContextFunction"/>
+	<property 
+		name="service.context.key"
+		type="String"
+		value="afryca.consensusmodel.service.IConsensusModelService"/>
+	<service>
+		<provide
+			interface="org.eclipse.e4.core.contexts.IContextFunction"/>
+	</service>
+</scr:component>

plugins/afryca.consensusmodel/OSGI-INF/l10n/bundle.properties

@@ -0,0 +1,8 @@
+#Properties file for afryca.consensusmodel
+afryca.consensusmodel.command.open_configuration.description = Open model's configuration
+afryca.consensusmodel.command.open_configuration.name = &Open configuration
+afryca.consensusmodel.command.save_configuration.description = Save model's configuration
+afryca.consensusmodel.command.save_configuration.name = &Save configuration
+Bundle-Name = Consensus model
+Bundle-Vendor = Sinbad\u00B2
+consensus-model.extension-point.name = Consensus model

plugins/afryca.consensusmodel/OSGI-INF/l10n/bundle_es.properties

@@ -0,0 +1,8 @@
+#Archivo de propiedades para afryca.consensusmodel
+afryca.consensusmodel.command.open_configuration.description = Abrir configuración de modelo de consenso
+afryca.consensusmodel.command.open_configuration.name = &Abrir configuración
+afryca.consensusmodel.command.save_configuration.description = Guardar configuración de modelo de consenso
+afryca.consensusmodel.command.save_configuration.name = &Guardar configuración
+Bundle-Name = Modelo de consenso
+Bundle-Vendor = Sinbad\u00B2
+consensus-model.extension-point.name = Modelo de consenso

plugins/afryca.consensusmodel/OSGI-INF/variables_provider_context_function.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<scr:component xmlns:scr="http://www.osgi.org/xmlns/scr/v1.1.0" name="IVariablesProvider context function">
+   <implementation class="afryca.consensusmodel.provider.internal.VariablesProviderContextFunction"/>
+	<property 
+		name="service.context.key"
+		type="String"
+		value="afryca.consensusmodel.provider.IVariablesProvider"/>
+	<service>
+		<provide
+			interface="org.eclipse.e4.core.contexts.IContextFunction"/>
+	</service>
+</scr:component>

plugins/afryca.consensusmodel/build.properties

@@ -0,0 +1,8 @@
+output.. = bin/
+bin.includes = META-INF/,\
+               .,\
+               plugin.xml,\
+               OSGI-INF/,\
+               fragment.e4xmi,\
+               preferences.ini
+source.. = src/

plugins/afryca.consensusmodel/fragment.e4xmi

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="ASCII"?>
+<fragment:ModelFragments xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:application="http://www.eclipse.org/ui/2010/UIModel/application" xmlns:commands="http://www.eclipse.org/ui/2010/UIModel/application/commands" xmlns:fragment="http://www.eclipse.org/ui/2010/UIModel/fragment" xmi:id="_izelcLJLEeaZ4qpc7p8VpQ">
+  <fragments xsi:type="fragment:StringModelFragment" xmi:id="_uoCYoLJLEeaZ4qpc7p8VpQ" featurename="commands" parentElementId="afryca.rcp.application">
+    <elements xsi:type="commands:Command" xmi:id="_0SZTYLJLEeaZ4qpc7p8VpQ" elementId="afryca.consensusmodel.command.open_configuration" commandName="%afryca.consensusmodel.command.open_configuration.name" description="%afryca.consensusmodel.command.open_configuration.description">
+      <parameters xmi:id="_5zeWULJLEeaZ4qpc7p8VpQ" elementId="file" name="file" optional="false"/>
+    </elements>
+    <elements xsi:type="commands:Command" xmi:id="_m2sJ8LJQEea1BcvRyBOoEA" elementId="afryca.consensusmodel.command.save_configuration" commandName="%afryca.consensusmodel.command.save_configuration.name" description="%afryca.consensusmodel.command.save_configuration.description">
+      <parameters xmi:id="_-5dmcLJQEea1BcvRyBOoEA" elementId="configuration" name="configuration" typeId="afryca.consensusmodel.command.parameter.configuration" optional="false"/>
+    </elements>
+  </fragments>
+  <fragments xsi:type="fragment:StringModelFragment" xmi:id="_wzBpgLJLEeaZ4qpc7p8VpQ" featurename="handlers" parentElementId="afryca.rcp.application">
+    <elements xsi:type="commands:Handler" xmi:id="_8nxp8LJLEeaZ4qpc7p8VpQ" elementId="afryca.consensusmodel.handler.open_configuration" contributionURI="bundleclass://afryca.consensusmodel/afryca.consensusmodel.command.OpenConfiguration" command="_0SZTYLJLEeaZ4qpc7p8VpQ"/>
+    <elements xsi:type="commands:Handler" xmi:id="_pcNasLJQEea1BcvRyBOoEA" elementId="afryca.consensusmodel.handler.save_configuration" contributionURI="bundleclass://afryca.consensusmodel/afryca.consensusmodel.command.SaveConfiguration" command="_m2sJ8LJQEea1BcvRyBOoEA"/>
+  </fragments>
+  <fragments xsi:type="fragment:StringModelFragment" xmi:id="_poHQEKjiEeePZ4e6uOoj8w" featurename="addons" parentElementId="afryca.rcp.application">
+    <elements xsi:type="application:Addon" xmi:id="_r0Uo8KjiEeePZ4e6uOoj8w" elementId="afryca.consensusmodel.addon.E4DIAddon" contributionURI="bundleclass://afryca.consensusmodel/afryca.consensumodel.addon.E4DIAddon"/>
+    <elements xsi:type="application:Addon" xmi:id="_w1QMMKjiEeePZ4e6uOoj8w" elementId="afryca.consensusmodel.addon.PreferencesAddon" contributionURI="bundleclass://afryca.consensusmodel/afryca.consensumodel.addon.PreferencesAddon"/>
+  </fragments>
+</fragment:ModelFragments>

plugins/afryca.consensusmodel/plugin.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.4"?>
+<plugin>
+   <extension-point id="afryca.consensusmodel" name="%consensus-model.extension-point.name" schema="schema/afryca.consensusmodel.exsd"/>
+   <extension
+         id="afryca.consensusmodel.fragment"
+         point="org.eclipse.e4.workbench.model">
+      <fragment
+            uri="fragment.e4xmi">
+      </fragment>
+   </extension>
+   <extension
+         point="org.eclipse.ui.commands">
+      <commandParameterType
+            converter="afryca.consensusmodel.command.parameter.ConfigurationParameterValueConverter"
+            id="afryca.consensusmodel.command.parameter.configuration">
+      </commandParameterType>
+   </extension>
+</plugin>

plugins/afryca.consensusmodel/preferences.ini

@@ -0,0 +1,7 @@
+epsilon.consensusmodel.value=0.001
+fuzziness.consensusmodel.value=2.00
+epsilonhongbin.consensusmodel.value=0.7
+khongbin.consensusmodel.value=1000
+costhongbin.consensusmodel.value=1;1;1;1;1;1;1;1
+weighthongbin.consensusmodel.value=0.125;0.125;0.125;0.125;0.125;0.125;0.125;0.125
+measurementhongbin.consensusmodel.value=false

plugins/afryca.consensusmodel/schema/afryca.consensusmodel.exsd

@@ -0,0 +1,405 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<!-- Schema file written by PDE -->
+<schema targetNamespace="afryca.consensusmodel" xmlns="http://www.w3.org/2001/XMLSchema">
+<annotation>
+      <appinfo>
+         <meta.schema plugin="afryca.consensusmodel" id="ConsensusModel" name="ConsensusModel"/>
+      </appinfo>
+      <documentation>
+         [Enter description of this extension point.]
+      </documentation>
+   </annotation>
+
+   <element name="extension">
+      <annotation>
+         <appinfo>
+            <meta.element />
+         </appinfo>
+      </annotation>
+      <complexType>
+         <choice minOccurs="1" maxOccurs="unbounded">
+            <element ref="ConsensusModel"/>
+         </choice>
+         <attribute name="point" type="string" use="required">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+         </attribute>
+         <attribute name="id" type="string">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+         </attribute>
+         <attribute name="name" type="string">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+               <appinfo>
+                  <meta.attribute translatable="true"/>
+               </appinfo>
+            </annotation>
+         </attribute>
+      </complexType>
+   </element>
+
+   <element name="ConsensusModel">
+      <complexType>
+         <sequence minOccurs="0" maxOccurs="unbounded">
+            <choice minOccurs="0" maxOccurs="unbounded">
+               <element ref="Variable" minOccurs="0" maxOccurs="unbounded"/>
+            </choice>
+         </sequence>
+         <attribute name="id" type="string" use="required">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+               <appinfo>
+                  <meta.attribute kind="identifier"/>
+               </appinfo>
+            </annotation>
+         </attribute>
+         <attribute name="ConsensusModel" type="string" use="required">
+            <annotation>
+               <documentation>
+                  The class that implement the consensus model
+               </documentation>
+               <appinfo>
+                  <meta.attribute kind="java" basedOn="afryca.consensusmodel.ConsensusModel:"/>
+               </appinfo>
+            </annotation>
+         </attribute>
+         <attribute name="Name" type="string" use="default" value="Model name">
+            <annotation>
+               <documentation>
+                  Model name
+               </documentation>
+               <appinfo>
+                  <meta.attribute translatable="true"/>
+               </appinfo>
+            </annotation>
+         </attribute>
+         <attribute name="Information" type="string" use="default" value="Model information">
+            <annotation>
+               <documentation>
+                  Model information
+               </documentation>
+               <appinfo>
+                  <meta.attribute translatable="true"/>
+               </appinfo>
+            </annotation>
+         </attribute>
+         <attribute name="MainFeatures" type="string" use="default" value="Model main features">
+            <annotation>
+               <documentation>
+                  Model main features
+               </documentation>
+               <appinfo>
+                  <meta.attribute translatable="true"/>
+               </appinfo>
+            </annotation>
+         </attribute>
+         <attribute name="Observations" type="string" use="default" value="Model observations">
+            <annotation>
+               <documentation>
+                  Model observations
+               </documentation>
+               <appinfo>
+                  <meta.attribute translatable="true"/>
+               </appinfo>
+            </annotation>
+         </attribute>
+         <attribute name="WithFeedback" type="boolean" use="default" value="false">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+         </attribute>
+         <attribute name="Structure" type="string" use="required">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+               <appinfo>
+                  <meta.attribute kind="identifier" basedOn="afryca.structure.structure/structure_type/@id"/>
+               </appinfo>
+            </annotation>
+         </attribute>
+         <attribute name="Multicriteria" type="boolean" use="default" value="false">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+         </attribute>
+      </complexType>
+   </element>
+
+   <element name="Variable">
+      <complexType>
+         <sequence minOccurs="0" maxOccurs="unbounded">
+            <choice minOccurs="0" maxOccurs="unbounded">
+               <element ref="Restriction" minOccurs="0" maxOccurs="unbounded"/>
+               <element ref="Array_restriction" minOccurs="0" maxOccurs="unbounded"/>
+               <element ref="Array_relation" minOccurs="0" maxOccurs="unbounded"/>
+               <element ref="Relation" minOccurs="0" maxOccurs="unbounded"/>
+               <element ref="Dialog" minOccurs="0" maxOccurs="unbounded"/>
+            </choice>
+         </sequence>
+         <attribute name="id" type="string" use="required">
+            <annotation>
+               <documentation>
+                  Variable id
+               </documentation>
+            </annotation>
+         </attribute>
+         <attribute name="description" type="string">
+            <annotation>
+               <documentation>
+                  Variable description
+               </documentation>
+               <appinfo>
+                  <meta.attribute translatable="true"/>
+               </appinfo>
+            </annotation>
+         </attribute>
+         <attribute name="type" use="required">
+            <annotation>
+               <documentation>
+                  Variable type
+               </documentation>
+            </annotation>
+            <simpleType>
+               <restriction base="string">
+                  <enumeration value="Boolean">
+                  </enumeration>
+                  <enumeration value="Integer">
+                  </enumeration>
+                  <enumeration value="Float">
+                  </enumeration>
+                  <enumeration value="FPR">
+                  </enumeration>
+                  <enumeration value="String">
+                  </enumeration>
+                  <enumeration value="Operation">
+                  </enumeration>
+                  <enumeration value="Dialog">
+                  </enumeration>
+               </restriction>
+            </simpleType>
+         </attribute>
+         <attribute name="default_value" type="string">
+            <annotation>
+               <documentation>
+                  Default value for variable. It is possible to define a equation.
+               </documentation>
+            </annotation>
+         </attribute>
+         <attribute name="array_default_element_value" type="string">
+            <annotation>
+               <documentation>
+                  Default value for array elements
+               </documentation>
+            </annotation>
+         </attribute>
+         <attribute name="is_array" type="boolean" use="default" value="false">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+         </attribute>
+         <attribute name="is_internal" type="boolean" use="default" value="false">
+            <annotation>
+               <documentation>
+                  Default value for variable
+               </documentation>
+            </annotation>
+         </attribute>
+      </complexType>
+   </element>
+
+   <element name="Restriction">
+      <complexType>
+         <attribute name="type" use="required">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+            <simpleType>
+               <restriction base="string">
+                  <enumeration value="lower_limit">
+                  </enumeration>
+                  <enumeration value="upper_limit">
+                  </enumeration>
+               </restriction>
+            </simpleType>
+         </attribute>
+         <attribute name="value" type="string" use="required">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+         </attribute>
+      </complexType>
+   </element>
+
+   <element name="Array_restriction">
+      <complexType>
+         <attribute name="type" use="required">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+            <simpleType>
+               <restriction base="string">
+                  <enumeration value="element_lower_limit">
+                  </enumeration>
+                  <enumeration value="element_upper_limit">
+                  </enumeration>
+                  <enumeration value="elements_sum_value">
+                  </enumeration>
+                  <enumeration value="elements_sum_lower_limit">
+                  </enumeration>
+                  <enumeration value="elements_sum_upper_limit">
+                  </enumeration>
+                  <enumeration value="number_of_elements">
+                  </enumeration>
+                  <enumeration value="number_of_elements_greater_than">
+                  </enumeration>
+               </restriction>
+            </simpleType>
+         </attribute>
+         <attribute name="value" type="string" use="required">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+         </attribute>
+      </complexType>
+   </element>
+
+   <element name="Relation">
+      <complexType>
+         <attribute name="type" use="required">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+            <simpleType>
+               <restriction base="string">
+                  <enumeration value="equals_to">
+                  </enumeration>
+                  <enumeration value="lower_than">
+                  </enumeration>
+                  <enumeration value="greater_than">
+                  </enumeration>
+                  <enumeration value="at_least">
+                  </enumeration>
+                  <enumeration value="at_most">
+                  </enumeration>
+               </restriction>
+            </simpleType>
+         </attribute>
+         <attribute name="variable" type="string" use="required">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+               <appinfo>
+                  <meta.attribute kind="identifier" basedOn="afryca.consensusmodel/ConsensusModel/Variable/@id"/>
+               </appinfo>
+            </annotation>
+         </attribute>
+      </complexType>
+   </element>
+
+   <element name="Array_relation">
+      <complexType>
+         <attribute name="type" use="required">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+            <simpleType>
+               <restriction base="string">
+                  <enumeration value="number_of_elements_equals_to">
+                  </enumeration>
+               </restriction>
+            </simpleType>
+         </attribute>
+         <attribute name="variable" type="string" use="required">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+         </attribute>
+      </complexType>
+   </element>
+
+   <element name="Dialog">
+      <complexType>
+         <attribute name="dialog" type="string">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+               <appinfo>
+                  <meta.attribute kind="java" basedOn="org.eclipse.jface.dialogs.TitleAreaDialog:"/>
+               </appinfo>
+            </annotation>
+         </attribute>
+      </complexType>
+   </element>
+
+   <annotation>
+      <appinfo>
+         <meta.section type="since"/>
+      </appinfo>
+      <documentation>
+         [Enter the first release in which this extension point appears.]
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appinfo>
+         <meta.section type="examples"/>
+      </appinfo>
+      <documentation>
+         [Enter extension point usage example here.]
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appinfo>
+         <meta.section type="apiinfo"/>
+      </appinfo>
+      <documentation>
+         [Enter API information here.]
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appinfo>
+         <meta.section type="implementation"/>
+      </appinfo>
+      <documentation>
+         [Enter information about supplied implementation of this extension point.]
+      </documentation>
+   </annotation>
+
+
+</schema>

plugins/afryca.consensusmodel/src/afryca/consensumodel/addon/E4DIAddon.java

@@ -0,0 +1,21 @@
+package afryca.consensumodel.addon;
+
+import javax.annotation.PostConstruct;
+
+import afryca.ase.service.IASEService;
+
+/**
+ * Add-on to obtain Eclipse 4 DI container objects
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class E4DIAddon {
+	
+	public static IASEService aseService;
+
+	@PostConstruct
+	private void initialize(IASEService aseService) {
+		E4DIAddon.aseService = aseService;
+	}
+}

plugins/afryca.consensusmodel/src/afryca/consensumodel/addon/PreferencesAddon.java

@@ -0,0 +1,144 @@
+package afryca.consensumodel.addon;
+
+import java.text.MessageFormat;
+import java.util.Map;
+
+import javax.annotation.PostConstruct;
+import javax.inject.Inject;
+
+import org.eclipse.core.runtime.preferences.BundleDefaultsScope;
+import org.eclipse.core.runtime.preferences.IEclipsePreferences;
+import org.eclipse.e4.core.di.annotations.Optional;
+import org.eclipse.e4.core.di.extensions.EventTopic;
+import org.eclipse.e4.core.di.extensions.Preference;
+import org.eclipse.e4.core.services.log.ILoggerProvider;
+import org.eclipse.e4.core.services.log.Logger;
+import org.eclipse.e4.core.services.nls.Translation;
+import org.osgi.service.prefs.BackingStoreException;
+
+import afryca.ase.service.IASEService;
+import afryca.consensusmodel.l10n.Messages;
+import afryca.consensusmodel.preferences.PreferenceConstants;
+import afryca.gdmp.service.IGDMPService;
+import afryca.gdmp.service.events.IGDMPServiceEvents;
+import afryca.workspace.service.events.IWorkspaceServiceEvents;
+
+/**
+ * Add-on to manage preferences changes
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+@SuppressWarnings("restriction")
+public class PreferencesAddon {
+	
+	private IEclipsePreferences preferences;
+	private Logger logger;
+	private Messages messages;
+	
+	@Inject
+	@Optional
+	IGDMPService gdmpService;
+
+	@PostConstruct
+	private void initialize(
+			@Translation Messages messages,
+			ILoggerProvider loggerProvider,
+			IASEService aseService,
+			@Preference(nodePath = PreferenceConstants.NODEPATH) IEclipsePreferences preferences) {
+		logger = loggerProvider.getClassLogger(this.getClass());
+		this.preferences = preferences;
+		setValues();
+	}
+	
+	private void setValues() {
+		setPreferenceValidValue(PreferenceConstants.EPSILON, "");
+		setPreferenceValidValue(PreferenceConstants.FUZZINESS, "");
+		setPreferenceValidValue(PreferenceConstants.EPSILON_HONGBIN, "");
+		setPreferenceValidValue(PreferenceConstants.COST_HONGBIN, "");
+		setPreferenceValidValue(PreferenceConstants.WEIGHT_HONGBIN, "");
+		setPreferenceValidValue(PreferenceConstants.CONSTANT_K, "");
+		addPreferenceChangeListener();
+	}
+
+	private void setPreferenceValidValue(String key, String value) {
+		
+		if(value != null) {
+			if(value.isEmpty()) {
+				restorePreferenceFunction(key);
+			} else {
+				putPreference(key, value);
+			}
+		} else {
+			restorePreferenceFunction(key);
+		}
+	}
+	
+	private void restorePreferenceFunction(String key) {
+		String value = getPreferencesDefaultValue(key);
+		putPreference(key, value);
+	}
+	
+	private String getPreferencesDefaultValue(String key) {
+		return BundleDefaultsScope
+				.INSTANCE
+				.getNode(PreferenceConstants.NODEPATH)
+				.get(key, null);
+	}
+	
+	private void putPreference(String key, String value) {
+		preferences.put(key, value);
+		try {
+			preferences.flush();
+		} catch (BackingStoreException e) {
+			logger.error(MessageFormat.format(messages.preferences_x_flush_fail, PreferenceConstants.NODEPATH));
+		}
+	}
+	
+	private void addPreferenceChangeListener() {
+		preferences.addPreferenceChangeListener(event -> {
+			setPreferenceValidValue(event.getKey(), (String) event.getNewValue());
+		});
+	}
+
+	@Inject
+	@Optional
+	private void subscribeTopicWorkspaceChanged(
+			@EventTopic(IWorkspaceServiceEvents.WORKSPACE_CHANGED) Map<String, String> event) {
+		setValues();
+	}
+	
+	private void createDefaultConfiguration() {
+		if(gdmpService.getSelection()!=null){
+			String costPTDG="";
+			String weightPTDG="";
+			for (int i = 0; i < gdmpService.getSelection().getExperts().size(); i++) {
+				costPTDG+="1";
+				weightPTDG+=Float.toString((1.0f/gdmpService.getSelection().getExperts().size()));
+				if(i!=gdmpService.getSelection().getExperts().size()-1){
+					costPTDG+=";";
+					weightPTDG+=";";
+				}
+			}
+			preferences.put(PreferenceConstants.COST_HONGBIN, costPTDG);
+			preferences.put(PreferenceConstants.WEIGHT_HONGBIN, weightPTDG);
+		}
+		
+	}
+	
+	@Inject
+	@Optional
+	public void subscribeTopicGDMP(
+			@EventTopic(IGDMPServiceEvents.GDMP_SELECTION_UPDATED) Map<String, String> event) {
+		createDefaultConfiguration();
+	}
+	
+	@Inject
+	@Optional
+	public void subscribeTopicUPDATE(
+			@EventTopic(IGDMPServiceEvents.GDMP_EXPERTS_UPDATED) Map<String, String> event) {
+		createDefaultConfiguration();
+	}
+	
+			
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/Advice.java

@@ -0,0 +1,99 @@
+package afryca.consensusmodel;
+
+/**
+ * Advice
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class Advice {
+
+	private int alternative1;
+	private int alternative2;
+
+	private float expertValue;
+	private float groupValue;
+
+	/**
+	 * Builder
+	 */
+	public Advice() {
+		this.expertValue = this.groupValue = -1;
+	}
+
+	/**
+	 * Builder
+	 * 
+	 * @param alternative1
+	 *            Alternative 1
+	 * @param alternative2
+	 *            Alternative 2
+	 */
+	public Advice(int alternative1, int alternative2) {
+		this();
+		this.alternative1 = alternative1;
+		this.alternative2 = alternative2;
+	}
+
+	/**
+	 * Set Expert value
+	 * 
+	 * @param value
+	 *            Expert value
+	 */
+	public void setExpertValue(float value) {
+		expertValue = value;
+	}
+
+	/**
+	 * Set group value
+	 * 
+	 * @param value
+	 *            Group value
+	 */
+	public void setGroupValue(float value) {
+		groupValue = value;
+	}
+
+	/**
+	 * Return change to make
+	 * 
+	 * @return Change to make
+	 */
+	public EChangeType getChange() {
+		return canComputeAdvice() ? computeAdvice() : null;
+	}
+
+	private boolean canComputeAdvice() {
+		return (expertValue != -1) && (groupValue != -1);
+	}
+
+	private EChangeType computeAdvice() {
+		if (expertValue < groupValue) {
+			return EChangeType.Increase;
+		} else if (expertValue > groupValue) {
+			return EChangeType.Decrease;
+		} else {
+			return EChangeType.NotChange;
+		}
+	}
+
+	/**
+	 * Return alternative 1
+	 * 
+	 * @return Alternative 1
+	 */
+	public int getAlternative1() {
+		return alternative1;
+	}
+
+	/**
+	 * Return alternative 2
+	 * 
+	 * @return Alternative 2
+	 */
+	public int getAlternative2() {
+		return alternative2;
+	}
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/Configuration.java

@@ -0,0 +1,460 @@
+package afryca.consensusmodel;
+
+import java.beans.PropertyChangeListener;
+import java.beans.PropertyChangeSupport;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.eclipse.core.commands.ParameterValueConversionException;
+
+import afryca.consensusmodel.command.parameter.ConfigurationParameterValueConverter;
+import afryca.consensusmodel.variable.definition.EVariableTypes;
+import afryca.structure.Structure;
+
+/**
+ * Consensus model's configuration
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class Configuration {
+
+	public final static String ID = "configuration"; //$NON-NLS-1$
+
+	public final static String FIELD_FILE = "file"; //$NON-NLS-1$
+	public final static String FIELD_CONSENSUS_MODEL = "consensusModel"; //$NON-NLS-1$
+	public final static String FIELD_VALUES = "values"; //$NON-NLS-1$
+
+	public final static String CONFIGURATION_EXTENSION = ".configuration"; //$NON-NLS-1$
+
+	private static final ConfigurationParameterValueConverter converter = new ConfigurationParameterValueConverter();
+
+	private PropertyChangeSupport changes = new PropertyChangeSupport(this);
+
+	private String file;
+	private String consensusModel;
+	private Map<String, Object> values;
+
+	/**
+	 * Default builder
+	 */
+	public Configuration() {
+		super();
+		file = null;
+		consensusModel = null;
+		values = new HashMap<>();
+	}
+
+	/**
+	 * Return file name
+	 * 
+	 * @return File name
+	 */
+	public String getFile() {
+		return file;
+	}
+
+	/**
+	 * Set file name
+	 * 
+	 * @param file
+	 *            File name
+	 */
+	public void setFile(String file) {
+		changes.firePropertyChange(FIELD_FILE, this.file, this.file = file);
+	}
+
+	/**
+	 * Return consensus model id
+	 * 
+	 * @return Consensus model id
+	 */
+	public String getConsensusModel() {
+		return consensusModel;
+	}
+
+	/**
+	 * Set consensus model id
+	 * 
+	 * @param consensusModel
+	 *            Consensus model id
+	 */
+	public void setConsensusModel(String consensusModel) {
+		changes.firePropertyChange(FIELD_CONSENSUS_MODEL, this.consensusModel, this.consensusModel = consensusModel);
+	}
+
+	/**
+	 * Return values
+	 * 
+	 * @return Values
+	 */
+	public Map<String, Object> getValues() {
+		return values;
+	}
+
+	/**
+	 * Set values
+	 * 
+	 * @param values
+	 *            Values
+	 */
+	public void setValues(Map<String, Object> values) {
+		changes.firePropertyChange(FIELD_VALUES, this.values, this.values = values);
+	}
+
+	/**
+	 * Set the value of configuration's variable
+	 * 
+	 * @param key
+	 *            Identifier
+	 * @param type
+	 *            Type
+	 * @param value
+	 *            Value
+	 * @param isArray
+	 *            Variable is an array
+	 */
+	public void setValue(String key, EVariableTypes type, String value, boolean isArray) {
+		if (value != null) {
+			values.put(key, isArray ? EVariableTypes.parseArray(type, value) : EVariableTypes.parseValue(type, value, key));
+			changes.firePropertyChange(FIELD_VALUES, null, values);
+		}
+	}
+
+	/**
+	 * Set value of variable
+	 * 
+	 * @param key
+	 *            Identifier
+	 * @param value
+	 *            Value
+	 */
+	public void setValue(String key, Object value) {
+		values.put(key, value);
+		changes.firePropertyChange(FIELD_VALUES, null, values);
+	}
+
+	/**
+	 * Get value of variable
+	 * 
+	 * @param key
+	 *            Identifier
+	 * @return Value of variable
+	 */
+	public Object getValue(String key) {
+		return values.get(key);
+	}
+
+	/**
+	 * Get type of configuration's variable
+	 * 
+	 * @param key
+	 *            Identifier
+	 * @return Type of variable
+	 */
+	public Class<?> getType(String key) {
+		Object value = values.get(key);
+		return (value != null) ? value.getClass() : null;
+	}
+
+	/**
+	 * Copy Configuration
+	 * 
+	 * @return Configuration copy
+	 */
+	public Configuration copy() {
+		Configuration copy = new Configuration();
+		copy.file = (file != null) ? new String(file) : null;
+		copy.consensusModel = (consensusModel != null) ? new String(consensusModel) : consensusModel;
+		values.forEach((K, V) -> copy.values.put(new String(K), cloneConfigurationValue(V)));
+		return copy;
+	}
+
+	private Object cloneConfigurationValue(Object value) {
+		if (value == null) {
+			return null;
+		}
+
+		if (value instanceof Integer) {
+			return Integer.valueOf((Integer) value);
+		}
+
+		if (value instanceof Integer[]) {
+			List<Integer> out = new ArrayList<>();
+			Arrays.stream((Integer[]) value).forEach(v -> out.add(Integer.valueOf(v)));
+			return out.toArray(new Integer[0]);
+		}
+
+		if (value instanceof Double) {
+			return Double.valueOf((Double) value);
+		}
+
+		if (value instanceof Double[]) {
+			List<Double> out = new ArrayList<>();
+			Arrays.stream((Double[]) value).forEach(v -> out.add(Double.valueOf(v)));
+			return out.toArray(new Double[0]);
+		}
+
+		if (value instanceof Float) {
+			return Float.valueOf((Float) value);
+		}
+
+		if (value instanceof Float[]) {
+			List<Float> out = new ArrayList<>();
+			Arrays.stream((Float[]) value).forEach(v -> out.add(Float.valueOf(v)));
+			return out.toArray(new Float[0]);
+		}
+
+		if (value instanceof Long) {
+			return Long.valueOf((Long) value);
+		}
+
+		if (value instanceof Long[]) {
+			List<Long> out = new ArrayList<>();
+			Arrays.stream((Long[]) value).forEach(v -> out.add(Long.valueOf(v)));
+			return out.toArray(new Long[0]);
+		}
+
+		if (value instanceof Boolean) {
+			return Boolean.valueOf((Boolean) value);
+		}
+
+		if (value instanceof Boolean[]) {
+			List<Boolean> out = new ArrayList<>();
+			Arrays.stream((Boolean[]) value).forEach(v -> out.add(Boolean.valueOf(v)));
+			return out.toArray(new Boolean[0]);
+		}
+
+		if (value instanceof Structure) {
+			try {
+				return ((Structure) value).clone();
+			} catch (CloneNotSupportedException e) {
+				e.printStackTrace();
+				return null;
+			}
+		}
+
+		if (value instanceof Structure[]) {
+			List<Structure> out = new ArrayList<>();
+			Arrays.stream((Structure[]) value).forEach(v -> {
+				Structure aux = null;
+				try {
+					aux = (Structure) v.clone();
+				} catch (CloneNotSupportedException e) {
+					e.printStackTrace();
+				}
+				out.add(aux);
+			});
+			return out.toArray(new Structure[0]);
+		}
+
+		if (value instanceof String) {
+			return new String((String) value);
+		}
+
+		if (value instanceof String[]) {
+			List<String> out = new ArrayList<>();
+			Arrays.stream((String[]) value).forEach(v -> out.add(new String(v)));
+			return out.toArray(new String[0]);
+		}
+		
+		//Ishizaka method
+		if(value instanceof Map<?,?>) {
+			return new String[0];
+		}
+
+		throw new IllegalArgumentException();
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + ((values == null) ? 0 : values.hashCode());
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		Configuration other = (Configuration) obj;
+		if (!deepEquals(file, other.file))
+			return false;
+		if (!deepEquals(consensusModel, other.consensusModel))
+			return false;
+		if (!deepEquals(values, other.values))
+			return false;
+
+		return true;
+	}
+
+	private static <T> boolean deepEquals(T t1, T t2) {
+
+		if (t1 == t2) {
+			return true;
+		}
+
+		if (t1 == null || t2 == null) {
+			return false;
+		}
+
+		if (t1 instanceof Map && t2 instanceof Map) {
+			return mapDeepEquals((Map<?, ?>) t1, (Map<?, ?>) t2);
+		} else if (t1 instanceof List && t2 instanceof List) {
+			return linearDeepEquals((List<?>) t1, (List<?>) t2);
+
+		} else if (t1 instanceof Set && t2 instanceof Set) {
+			return linearDeepEquals((Set<?>) t1, (Set<?>) t2);
+
+		} else if (t1 instanceof Object[] && t2 instanceof Object[]) {
+			return linearDeepEquals((Object[]) t1, (Object[]) t2);
+
+		} else {
+			return t1.equals(t2);
+		}
+	}
+
+	private static boolean mapDeepEquals(Map<?, ?> m1, Map<?, ?> m2) {
+		if (m1.size() != m1.size()) {
+			return false;
+		}
+
+		Set<?> allKeys = m1.keySet();
+		if (!linearDeepEquals(allKeys, m2.keySet())) {
+			return false;
+		}
+
+		for (Object key : allKeys) {
+			if (!deepEquals(m1.get(key), m2.get(key))) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	private static boolean linearDeepEquals(Collection<?> s1, Collection<?> s2) {
+		if (s1.size() != s2.size()) {
+			return false;
+		}
+
+		for (Object s1Item : s1) {
+			boolean found = false;
+			for (Object s2Item : s2) {
+				if (deepEquals(s2Item, s1Item)) {
+					found = true;
+					break;
+				}
+			}
+			if (!found) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	private static boolean linearDeepEquals(Object[] s1, Object[] s2) {
+
+		if (s1.length != s2.length) {
+			return false;
+		}
+
+		for (Object s1Item : s1) {
+			boolean found = false;
+			for (Object s2Item : s2) {
+				if (deepEquals(s2Item, s1Item)) {
+					found = true;
+					break;
+				}
+			}
+			if (!found) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * Add property change listener
+	 * 
+	 * @param listener
+	 *            Property change listener
+	 */
+	public void addPropertyChangeListener(PropertyChangeListener listener) {
+		changes.addPropertyChangeListener(listener);
+	}
+
+	/**
+	 * Remove property change listener
+	 * 
+	 * @param listener
+	 *            Property change listener
+	 */
+	public void removePropertyChangeListener(PropertyChangeListener listener) {
+		changes.removePropertyChangeListener(listener);
+	}
+
+	@Override
+	public String toString() {
+		try {
+			return converter.convertToString(this);
+		} catch (ParameterValueConversionException e) {
+			e.printStackTrace();
+			return null;
+		}
+	}
+
+	/**
+	 * Parse configuration from string value
+	 * 
+	 * @param value
+	 *            Configuration string value
+	 * @return Configuration
+	 */
+	public static Configuration parseConfiguration(String value) {
+		try {
+			return (Configuration) converter.convertToObject(value);
+		} catch (ParameterValueConversionException e) {
+			e.printStackTrace();
+			return null;
+		}
+	}
+
+	/**
+	 * Return configuration simple name
+	 * 
+	 * @return configuration simple name
+	 */
+	public String getSimpleName() {
+		return getSimpleName(file);
+	}
+
+	/**
+	 * Return file simple name
+	 * 
+	 * @param file
+	 *            File name
+	 * @return File simple name
+	 */
+	public static String getSimpleName(String file) {
+		if (file != null) {
+			String simpleName = new File(file).getName();
+			return simpleName.contains(CONFIGURATION_EXTENSION)
+					? simpleName.substring(0, simpleName.length() - CONFIGURATION_EXTENSION.length())
+					: simpleName;
+		}
+
+		return file;
+	}
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/ConsensusModel.java

@@ -0,0 +1,444 @@
+package afryca.consensusmodel;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.inject.Inject;
+
+import org.eclipse.e4.core.contexts.ContextInjectionFactory;
+import org.eclipse.e4.core.contexts.IEclipseContext;
+import org.eclipse.e4.core.services.nls.Translation;
+
+import afryca.behavior.service.IBehaviorService;
+import afryca.consensusmodel.definition.EResultElements;
+import afryca.consensusmodel.definition.ERoundResult;
+import afryca.consensusmodel.l10n.Messages;
+import afryca.consensusmodel.variable.Variable;
+import afryca.consensusmodel.variable.definition.EVariableElements;
+import afryca.consensusmodel.variable.definition.EVariableTypes;
+import afryca.consensusmodel.variable.definition.MockVariableConfigurationElement;
+import afryca.consensusmodel.variable.definition.VariableRegistry;
+import afryca.structure.Structure;
+import afryca.structure.ranking.AbstractDominanceRanking;
+import afryca.structure.ranking.AlternativeRanking;
+
+/**
+ * Interface for consensus models
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public abstract class ConsensusModel {
+
+	// Extension point id
+	public static final String EXTENSION_POINT = "afryca.consensusmodel"; //$NON-NLS-1$
+
+	public static final String EXPERTS = "experts"; //$NON-NLS-1$
+	public static final String ALTERNATIVES = "alternatives"; //$NON-NLS-1$
+	public static final String CRITERIA = "criteria"; //$NON-NLS-1$
+	public static final String PREFERENCES = "preferences"; //$NON-NLS-1$
+	public static final String WITH_FEEDBACK = "WithFeedback"; //$NON-NLS-1$
+	public static final String UNDEFINED = "undefined"; //$NON-NLS-1$
+
+	protected String[] experts;
+	protected String[] alternatives;
+	protected String[] criteria;
+	protected Integer numberOfExperts;
+	protected Integer numberOfAlternatives;
+	protected Integer numberOfCriteria;
+	protected Structure[] preferences;
+
+	protected Map<EResultElements, Object> result;
+	protected List<Map<ERoundResult, Object>> roundsResults;
+	
+	protected boolean validConfiguration;
+	protected Variables variables = null;
+	
+	protected Configuration configuration;
+
+	@Inject
+	protected IBehaviorService behaviorService;
+	
+	@Inject
+	protected IEclipseContext context;
+
+	@Inject
+	@Translation
+	private Messages messages;
+
+	/**
+	 * Set the consensus model variables
+	 * 
+	 * @param variables
+	 *            Consensus model variables
+	 */
+	public void setVariables(Variables variables) {
+		this.variables = variables;
+		setDefaultVariables();
+	}
+
+	private void setDefaultVariables() {
+		addArrayVariable(variables, EXPERTS, messages.experts_description, EVariableTypes.String);
+		addArrayVariable(variables, ALTERNATIVES, messages.alternatives_description, EVariableTypes.String);
+		addArrayVariable(variables, CRITERIA, messages.criteria_description, EVariableTypes.String);
+		addArrayVariable(variables, PREFERENCES, messages.preferences_description, EVariableTypes.FPR);
+	}
+
+	private void addArrayVariable(Variables variables, String id, String description, EVariableTypes type) {
+		MockVariableConfigurationElement configurationElement = new MockVariableConfigurationElement();
+		configurationElement.addAttribute(EVariableElements.id.name(), id);
+		configurationElement.addAttribute(EVariableElements.description.name(), description);
+		configurationElement.addAttribute(EVariableElements.type.name(), type.name());
+		configurationElement.addAttribute(EVariableElements.default_value.name(), null);
+		configurationElement.addAttribute(EVariableElements.array_default_element_value.name(), null);
+		configurationElement.addAttribute(EVariableElements.is_array.name(), Boolean.toString(true));
+		configurationElement.addAttribute(EVariableElements.is_internal.name(), Boolean.toString(true));
+		addVariable(variables, new VariableRegistry(configurationElement));
+	}
+	
+	private void addVariable(Variables variables, VariableRegistry variableRegistry) {
+		Variable variable = ContextInjectionFactory.make(Variable.class, injectInChildContext(variableRegistry));
+		variables.addVariable(variable);
+	}
+	
+	private IEclipseContext injectInChildContext(Object element) {
+		IEclipseContext childContext = context.createChild();
+		ContextInjectionFactory.inject(element, childContext);
+		childContext.set(element.getClass().getName(), element);
+		return childContext;
+	}
+
+	
+	/**
+	 * Return consensus model variables
+	 * 
+	 * @return Consensus model variables
+	 */
+	public Variables getVariables() {
+		return variables;
+	}
+
+	/**
+	 * Configure model
+	 * 
+	 * @param configuration
+	 *            Model configuration
+	 * 
+	 * @return True valid configuration
+	 *         <p>
+	 *         False invalid configuration
+	 */
+	public boolean setConfiguration(Configuration configuration) {
+		this.configuration = configuration;
+		validConfiguration = true;
+		setElementsConfiguration();
+		if (validConfiguration) {
+			setModelConfiguration();
+		}
+		return validConfiguration;
+	}
+
+	private void setElementsConfiguration() {
+		try {
+			roundsResults = new ArrayList<>();
+			setExpertsConfiguration();
+			setAlternativesConfiguration();
+			setCriteriaConfiguration();
+			setPreferencesConfiguration();
+			setConsensusModelInformationConfiguration();
+		} catch (Exception e) {
+			validConfiguration = false;
+		}
+	}
+
+	private void setExpertsConfiguration() {
+		experts = (String[]) configuration.getValue(EXPERTS);
+		numberOfExperts = experts.length;
+	}
+
+	private void setAlternativesConfiguration() {
+		alternatives = (String[]) configuration.getValue(ALTERNATIVES);
+		numberOfAlternatives = alternatives.length;
+	}
+
+	private void setCriteriaConfiguration() {
+		criteria = (String[]) configuration.getValue(CRITERIA);
+		numberOfCriteria = criteria.length;
+	}
+
+	private void setPreferencesConfiguration() throws CloneNotSupportedException {
+		Structure[] configurationPreferences = (Structure[]) configuration.getValue(PREFERENCES);
+		preferences = new Structure[numberOfExperts * numberOfCriteria + 1];
+		for (int i = 0; i < numberOfExperts * numberOfCriteria; i++) {
+			preferences[i] =  (Structure) configurationPreferences[i].clone();
+		}
+		preferences[numberOfExperts * numberOfCriteria] = (Structure) configurationPreferences[0].clone();
+		preferences[numberOfExperts * numberOfCriteria].initialize();
+		configuration.setValue(PREFERENCES, preferences);
+	}
+
+	private void setConsensusModelInformationConfiguration() {
+		result = new HashMap<>();
+		for (EResultElements element : EResultElements.values()) {
+			result.put(element, UNDEFINED);
+		}
+		result.put(EResultElements.experts, experts);
+		result.put(EResultElements.number_of_experts, numberOfExperts);
+		result.put(EResultElements.alternatives, alternatives);
+		result.put(EResultElements.number_of_alternatives, numberOfAlternatives);
+		result.put(EResultElements.criteria, criteria);
+		result.put(EResultElements.number_of_criteria, numberOfCriteria);
+	}
+
+	/**
+	 * Set model specific configuration
+	 */
+	protected abstract void setModelConfiguration();
+	
+	/**
+	 * Pre save round result
+	 * 
+	 * @param round
+	 *            Current round
+	 * @param preferences2
+	 *            Current preferences
+	 * @param consensusDegreeAchieved
+	 *            Consensus degree achieved
+	 */
+	public void preSaveRoundResult(int round, Structure[] preferences2,Float[][][] preferencesGroupVisualization, Float consensusDegreeAchieved) {
+		Map<ERoundResult, Object> r = new HashMap<>();
+		roundsResults.add(r);
+		r.put(ERoundResult.round, round);
+		r.put(ERoundResult.pre_preferences, clonePreferences(preferences2));
+		r.put(ERoundResult.pre_preferencesGroupVisualization, preferencesGroupVisualization.clone());
+		r.put(ERoundResult.pre_consensus_degree_achieved, consensusDegreeAchieved);
+
+		computePreRoundResults(r);
+	}
+
+	protected Structure[] clonePreferences(Structure[] preferences2) {
+		Structure[] result = new Structure[preferences2.length];
+		for (int pos = 0; pos < preferences2.length; pos++) {
+			try {
+				result[pos] = (Structure) ((Structure) preferences2[pos]).clone();
+			} catch (CloneNotSupportedException e) {
+				// Nothing to do
+			}
+		}
+
+		return result;
+	}
+
+	private void computePreRoundResults(Map<ERoundResult, Object> roundResults) {
+		Structure[] preferences = (Structure[]) roundResults.get(ERoundResult.pre_preferences);
+
+		int[][] order = new int[numberOfExperts + 1][numberOfAlternatives];
+		AlternativeRanking[] ranking;
+		AlternativeRanking[] orderedRanking = null;
+		for (int i = 0; i <= numberOfExperts; i++) {
+			ranking = selection(preferences[i]);
+			orderedRanking = AlternativeRanking.orderRanking(ranking);
+			for (int j = 0; j < numberOfAlternatives; j++) {
+				order[i][j] = orderedRanking[j].getPosition() + 1;
+			}
+		}
+
+		roundResults.put(ERoundResult.pre_ranking_of_alternatives, order);
+	}
+
+	private static AlternativeRanking[] selection(Structure preference) {
+		AbstractDominanceRanking ranking = preference.createRanking();
+		return ranking.getAlternativesRanking();
+	}
+
+	/**
+	 * Pos save round result
+	 * 
+	 * @param currentPreferences
+	 *            Current preferences
+	 * @param consensusDegreeAchieved
+	 *            Consensus degree achieved
+	 * @param advises
+	 *            Number of advises
+	 * @param preferences2 
+	 */
+	public void posSaveRoundResult(Structure[] currentPreferences,Float[][][] preferencesGroupVisualization, Float consensusDegreeAchieved, int[] advises) {
+		Map<ERoundResult, Object> r = roundsResults.get(roundsResults.size() - 1);
+
+		r.put(ERoundResult.pos_preferences, clonePreferences(currentPreferences));
+		r.put(ERoundResult.pos_preferencesGroupVisualization,preferencesGroupVisualization.clone());
+		r.put(ERoundResult.pos_consensus_degree_achieved, consensusDegreeAchieved);
+		r.put(ERoundResult.advices, advises);
+
+		computePosRoundResults(r);
+	}
+
+	private void computePosRoundResults(Map<ERoundResult, Object> roundResults) {
+
+		Structure[] preferences = (Structure[]) roundResults.get(ERoundResult.pos_preferences);
+		int[][] order = new int[numberOfExperts + 1][numberOfAlternatives];
+		
+		AlternativeRanking[] ranking;
+		AlternativeRanking[] orderedRanking = null;
+		
+		for (int i = 0; i <= numberOfExperts; i++) {
+			ranking = selection(preferences[i]);
+			orderedRanking = AlternativeRanking.orderRanking(ranking);
+			
+			for (int j = 0; j < numberOfAlternatives; j++) {
+				order[i][j] = orderedRanking[j].getPosition() + 1;
+			}
+		}
+		roundResults.put(ERoundResult.pos_ranking_of_alternatives, order);
+	}
+
+	/**
+	 * Pos save round result
+	 * 
+	 * @param preferences2
+	 *            Current preferences
+	 * @param consensusDegreeAchieved
+	 *            Consensus degree achieved
+	 * @param advises
+	 *            Number of advises
+	 * @param preferences3
+	 *            Group's preferences
+	 */
+	public void posSaveRoundResult(Structure[] preferences2, Float[][][] preferencesGroupVisualization, Float consensusDegreeAchieved, int[] advises, Structure preferences3) {
+
+		Map<ERoundResult, Object> r = roundsResults.get(roundsResults.size() - 1);
+		
+		r.put(ERoundResult.pos_preferences, clonePreferencesUnion(preferences2, preferences3));
+		r.put(ERoundResult.pos_preferencesGroupVisualization,preferencesGroupVisualization );
+		r.put(ERoundResult.pos_consensus_degree_achieved, consensusDegreeAchieved);
+		r.put(ERoundResult.advices, advises);
+
+		computePosRoundResults(r);
+	}
+
+	protected Structure[] clonePreferencesUnion(Structure[] preferences2, Structure collective) {
+		Structure[] result = new Structure[preferences2.length];
+		for (int pos = 0; pos < preferences2.length; pos++) {
+			try {
+				result[pos] = (pos < (preferences2.length - 1)) ? (Structure) ((Structure) preferences2[pos]).clone() : (Structure) ((Structure) collective).clone();
+			} catch (CloneNotSupportedException e) {
+				// Nothing to do
+			}
+		}
+
+		return result;
+	}
+
+	/**
+	 * Execute model
+	 * 
+	 * @return Execution result
+	 */
+	public Map<EResultElements, Object> execute() {
+		if (validConfiguration) {
+			obtainConfigurationValues();
+			boolean firstRound = true;
+			do {
+				if (firstRound) {
+					preFirstSaveRoundResults();
+					firstRound = false;
+				} else {
+					preSaveRoundResults();
+				}
+				consensusRound();
+				posSaveRoundResults();
+			} while (mustBeCarriedOutAnotherRound());
+			computeExecutionResults();
+		} else {
+			return null;
+		}
+
+		return getResult();
+	}
+	
+	/**
+	 * Obtain configuration values
+	 */
+	protected abstract void obtainConfigurationValues();
+	
+	/**
+	 * Save in 'preferencesGroupVisualization' only one preference by expert and the collective of this preferences
+	*/
+	protected abstract Float[][][] obtainVisualizeValues();
+
+	/**
+	 * Save pre first round results
+	 */
+	protected abstract void preFirstSaveRoundResults();
+
+	/**
+	 * Save pre round results
+	 */
+	protected abstract void preSaveRoundResults();
+
+	/**
+	 * Carried out consensus round
+	 */
+	protected abstract void consensusRound();
+
+	/**
+	 * Save pos round results
+	 */
+	protected abstract void posSaveRoundResults();
+
+	/**
+	 * Must be carried out another round
+	 * 
+	 * @return True if another round should take place, False in other case
+	 */
+	protected abstract boolean mustBeCarriedOutAnotherRound();
+
+	/**
+	 * Save execution results
+	 */
+	protected abstract void saveExecutionResults();
+
+	protected void computeExecutionResults() {
+		saveExecutionResults();
+
+		Structure[] preferences = (Structure[]) configuration.getValue(PREFERENCES);
+		
+		if(result.get(EResultElements.classification_of_alternatives) == "undefined") {
+			AlternativeRanking[] ranking = selection(preferences);
+			AlternativeRanking[] orderedRanking = AlternativeRanking.orderRanking(ranking);
+			String orderedRankingInStringFormat = AlternativeRanking.orderedAlternativesRankingToString(orderedRanking);
+			
+			this.result.put(EResultElements.ranking_of_alternatives, orderedRankingInStringFormat);
+			this.result.put(EResultElements.solution_set_of_alternatives, AlternativeRanking.getAlternativesWithRankingPos(ranking, 1));
+		}
+		
+		this.result.put(EResultElements.preferences, preferences);
+		this.result.put(EResultElements.rounds_results, roundsResults);
+	}
+
+	private static AlternativeRanking[] selection(Structure[] preferences) {
+		return selection(preferences[preferences.length - 1]);
+	}
+
+	/**
+	 * Return execution result
+	 * 
+	 * @return Execution result
+	 */
+	public Map<EResultElements, Object> getResult() {
+		return result;
+	}
+
+	/**
+	 * Return n changes
+	 * 
+	 * @param n
+	 *            Number of changes
+	 * @return n changes
+	 */
+	protected double[] getNChanges(int n) {
+		return behaviorService.getNChanges(n);
+	}
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/ConsensusModelMulticriteria.java

@@ -0,0 +1,48 @@
+package afryca.consensusmodel;
+
+import java.util.Map;
+
+import afryca.consensusmodel.definition.EResultElements;
+
+public abstract class ConsensusModelMulticriteria extends ConsensusModel {
+	
+
+	/**
+	 * Execute model
+	 * 
+	 * @return Execution result
+	 */
+	@Override
+	public Map<EResultElements, Object> execute() {
+		if (validConfiguration) {
+			obtainConfigurationValues();
+			boolean firstRound = true;
+			do {
+				groupPreferencesByCriteria();
+				obtainVisualizeValues();
+				if (firstRound) {
+					preFirstSaveRoundResults();
+					firstRound = false;
+				} else {
+					preSaveRoundResults();
+				}
+				consensusRound();
+				groupPreferencesByCriteria();
+				obtainVisualizeValues();
+				posSaveRoundResults();
+			} while (mustBeCarriedOutAnotherRound());
+			computeExecutionResults();
+		} else {
+			return null;
+		}
+
+		return getResult();
+	}
+
+	/**
+	 * Group preferences by criteria, obtain only one preference for expert
+	 */
+	protected abstract void groupPreferencesByCriteria();
+	
+	
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/EChangeType.java

@@ -0,0 +1,11 @@
+package afryca.consensusmodel;
+
+/**
+ * Types of changes
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public enum EChangeType {
+	Increase, Decrease, NotChange;
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/Variables.java

@@ -0,0 +1,77 @@
+package afryca.consensusmodel;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import afryca.consensusmodel.variable.Variable;
+
+/**
+ * Consensus model's variables
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class Variables {
+
+	private Map<String, Variable> variables = new LinkedHashMap<>();
+
+	/**
+	 * Add variable
+	 * 
+	 * @param variable
+	 *            Variable to add
+	 */
+	public void addVariable(Variable variable) {
+		variables.put(variable.getId(), variable);
+	}
+
+	/**
+	 * Get variable
+	 * 
+	 * @param id
+	 *            Variable identifier
+	 * @return Variable with id identifier
+	 */
+	public Variable getVariable(String id) {
+		return variables.get(id);
+	}
+
+	/**
+	 * Set all variables
+	 * 
+	 * @param variables
+	 *            Map of variables
+	 */
+	public void setVariables(Map<String, Variable> variables) {
+		this.variables = variables;
+	}
+
+	/**
+	 * Get all variables
+	 * 
+	 * @return Map of variables
+	 */
+	public Map<String, Variable> getVariables() {
+		return variables;
+	}
+
+	/**
+	 * Get all variables identifiers
+	 * 
+	 * @return Array with variables' identifiers
+	 */
+	public String[] getVariablesIDs() {
+		return variables.keySet().toArray(new String[0]);
+	}
+
+	/**
+	 * Copy variables
+	 * 
+	 * @return Variables copy
+	 */
+	public Variables copy() {
+		Variables result = new Variables();
+		variables.forEach((K, V) -> result.addVariable(V.copy()));
+		return result;
+	}
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/cluster/Cluster.java

@@ -0,0 +1,117 @@
+package afryca.consensusmodel.cluster;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import afryca.pr.PR;
+
+
+public abstract class Cluster implements Cloneable {
+	
+	protected int id;
+	
+	protected List<Integer> experts;
+	protected Map<Integer, PR> preferences;
+
+	public Cluster() {
+		super();
+		
+		id = -1;
+			
+		experts = new LinkedList<Integer>();
+		preferences = new HashMap<Integer, PR>();
+	}
+
+	public int getId() {
+		return id;
+	}
+
+	public void setId(int id) {
+		this.id = id;
+	}
+
+	public List<Integer> getExperts() {
+		Collections.sort(experts);
+		return experts;
+	}
+
+	public void setExperts(List<Integer> experts) {
+		this.experts = experts;
+	}
+	
+	public Map<Integer, PR> getPreferences() {
+		return preferences;
+	}
+
+	public void setPreferences(Map<Integer, PR> preferences) {
+		this.preferences = preferences;
+	}
+	
+	public int getSize() {
+		return this.experts.size();
+	}
+	
+	public abstract Object getCentroid();
+
+	public abstract void setCentroid(Object centroid);
+
+	public boolean containExpert(int id) {
+		return (getExpert(id) != null);
+	}
+
+	public Integer getExpert(int id) {
+		for (Integer expert : experts) {
+			if (id == expert) {
+				return expert;
+			}
+		}
+		return null;
+	}
+	
+	public Object getPreferencesExpert(int idExpert) {
+		return preferences.get(idExpert);
+	}
+
+	public void addExpertCluster(Integer expert, PR preferences2) {
+		experts.add(expert);
+		preferences.put(expert, (PR) preferences2);
+	}
+
+	@SuppressWarnings("rawtypes")
+	public void removeExpertCluster(Integer expert) {
+		Iterator iter = experts.iterator();
+		while (iter.hasNext()) {
+			Integer e = (Integer) iter.next();
+			if (e == expert) {
+				iter.remove();
+				preferences.remove(expert);
+			}
+		}
+	}
+
+	public abstract void generateCluster(int alternative, int alternative2, int numberOfAlternatives);
+
+	public List<Integer> cloneExperts() throws CloneNotSupportedException {
+		List<Integer> experts = new LinkedList<Integer>();
+		for (Integer expert : this.experts) {
+			experts.add(expert);
+		}
+		return experts;
+	}
+
+	public Map<Integer, PR> clonePreferencesCluster() throws CloneNotSupportedException {
+		Map<Integer, PR> values = new HashMap<Integer, PR>();
+
+		for (Integer expert : this.experts) {
+			PR matrix = this.preferences.get(expert);
+			values.put(expert, (PR) matrix.clone());
+		}
+
+		return values;
+	}
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/cluster/ClusterELICITPR.java

@@ -0,0 +1,162 @@
+package afryca.consensusmodel.cluster;
+
+import afryca.domain.fuzzyset.FuzzySet;
+import afryca.domain.fuzzyset.function.types.TrapezoidalFunction;
+import afryca.domain.fuzzyset.labelset.LabelSet;
+import afryca.elicit.ELICIT;
+import afryca.elicit.ELICITPR;
+
+public class ClusterELICITPR extends Cluster {
+	
+	private ELICIT[][] centroid;
+	
+	private FuzzySet domain;
+
+	public ClusterELICITPR(FuzzySet domain) {
+		super();
+		
+		centroid = null;
+		
+		this.domain = domain;
+	}
+	
+	public ClusterELICITPR(FuzzySet domain, ClusterELICITPR previousCluster) {
+		this(domain);
+		
+		try {
+			setId(previousCluster.getId());
+			setCentroid(((ELICIT[][]) previousCluster.getCentroid()).clone());
+		} catch (Exception e) {
+			throw new IllegalArgumentException(e.getMessage());
+		}
+	}
+	
+	public FuzzySet getDomain() {
+		return domain;
+	}
+	
+	public Object getCentroid() {
+		return centroid;
+	}
+
+	public void setCentroid(Object centroid) {
+		this.centroid = (ELICIT[][]) centroid;
+	}
+
+	public void generateCluster(int clusterAlternative, int otherAlternative, int numberOfAlternatives) {
+		this.setId(clusterAlternative);
+		generateCentroidInitial(otherAlternative, numberOfAlternatives);
+	}
+
+	private void generateCentroidInitial(int clusterAlternative, int numberOfAlternatives) {
+		centroid = new ELICIT[numberOfAlternatives][numberOfAlternatives];
+		
+		initializeCentroid(numberOfAlternatives);
+		
+		LabelSet labelset = domain.getLabelSet();
+		
+		for (int j = 0; j < numberOfAlternatives; j++) {
+			if(clusterAlternative != j) {
+				ELICIT elicitPref = new ELICIT(domain);
+				ELICIT elicitAdv = new ELICIT(domain);
+				
+				elicitPref.setTwoTupleLabel(labelset.getCardinality() - 1);
+				elicitAdv.setTwoTupleLabel(0);
+				
+				centroid[clusterAlternative][j] = elicitPref;
+				centroid[j][clusterAlternative] = elicitAdv;
+			}
+		}
+	}
+	
+	public void initializeCentroid(int numberOfAlternatives, int id) {
+		setId(id);
+		
+		centroid = new ELICIT[numberOfAlternatives][numberOfAlternatives];
+		LabelSet labelset = domain.getLabelSet();
+		for (int row = 0; row < numberOfAlternatives; row++) {
+			for (int col = 0; col < numberOfAlternatives; col++) {
+				ELICIT elicitMedium = new ELICIT(domain);
+				elicitMedium.setTwoTupleLabel((labelset.getCardinality() - 1) / 2);
+				centroid[row][col] = elicitMedium;
+			}
+		}
+	}
+	
+	private void initializeCentroid(int numberOfAlternatives) {
+		LabelSet labelset = domain.getLabelSet();
+		for (int row = 0; row < numberOfAlternatives; row++) {
+			for (int col = 0; col < numberOfAlternatives; col++) {
+				ELICIT elicitMedium = new ELICIT(domain);
+				elicitMedium.setTwoTupleLabel((labelset.getCardinality() - 1) / 2);
+				centroid[row][col] = elicitMedium;
+			}
+		}
+	}
+	
+	public void updateCentroid(int nAlternatives) {
+		TrapezoidalFunction acum, average;
+		
+		int expert;
+		for (int i = 0; i < nAlternatives; i++) {
+			for (int j = 0; j < nAlternatives; j++) {
+				
+				acum = new TrapezoidalFunction(new double[] {0d, 0d, 0d, 0d});
+				
+				for (int k = 0; k < experts.size(); ++k) {
+					
+					expert = experts.get(k);
+					
+					ELICIT elicit = ((ELICITPR) preferences.get(expert)).getELICITValuation(i, j);
+					
+					TrapezoidalFunction tpf;
+					if(elicit.getBeta() != null)
+						tpf = elicit.getBeta();
+					else
+						tpf = elicit.computeInverse();
+					
+					acum = acum.addition(tpf);	
+				}
+				
+				average = acum.divisionScalar(experts.size());
+				ELICIT aggregated = new ELICIT(domain);
+				aggregated.createRelation(average);
+				
+				centroid[i][j] = aggregated;
+			}
+		}
+	}
+	
+	@Override
+	public Cluster clone() throws CloneNotSupportedException {
+		Cluster result = (Cluster) super.clone();
+		result.setId(id);
+		result.setExperts(cloneExperts());
+		result.setCentroid((ELICIT[][]) centroid.clone());
+		result.setPreferences(clonePreferencesCluster());
+		return result;
+	}
+	
+	@Override
+	public String toString() {
+		StringBuilder result = new StringBuilder();
+
+		result.append("Id cluster: " + id);
+		result.append("\n");
+		result.append("List experts: ");
+		for (Integer expert : experts) {
+			result.append(expert + " ");
+		}
+		result.append("\n");
+		result.append("Centroid:" + "\n");
+		for(int i = 0; i < centroid.length;++i) {
+			for(int j = 0; j < centroid[i].length;++j) {
+				result.append(centroid[i][j].toString());
+			}
+			result.append("\n");
+		}
+		
+
+		return result.toString();
+	}
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/cluster/ClusterFPR.java

@@ -0,0 +1,167 @@
+package afryca.consensusmodel.cluster;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import afryca.fpr.FPR;
+
+public class ClusterFPR extends Cluster {
+	
+	private FPR centroid;
+	
+	public ClusterFPR() {
+		super();
+		centroid = null;
+	}
+	
+	public ClusterFPR(ClusterFPR previousCluster) {
+		this();
+		try {
+			setId(previousCluster.getId());
+			setCentroid(((FPR) previousCluster.getCentroid()).clone());
+		} catch (Exception e) {
+			throw new IllegalArgumentException(e.getMessage());
+		}
+	}
+	
+	public Object getCentroid() {
+		return centroid;
+	}
+
+	public void setCentroid(Object centroid) {
+		this.centroid = (FPR) centroid;
+	}
+
+	public void generateCluster(int alternative, int alternative2, int numberOfAlternatives) {
+		this.setId(alternative);
+		generateCentroidInitial(alternative2, numberOfAlternatives);
+	}
+
+	private void generateCentroidInitial(int idAlt, int numberOfAlternatives) {
+		centroid = new FPR(numberOfAlternatives);
+
+		initializeCentroid(numberOfAlternatives);
+		for (int j = 0; j < numberOfAlternatives; j++) {
+			centroid.setValueSymmetrically(idAlt, j, 1f);
+			centroid.setValueSymmetrically(j, j, 0.5f);
+		}
+	}
+	
+	private void initializeCentroid(int numberOfAlternatives) {
+		for (int row = 0; row < numberOfAlternatives; row++) {
+			for (int col = 0; col < numberOfAlternatives; col++) {
+				centroid.getPreferences()[row][col] = centroid.getIndifferenceValue();
+			}
+		}
+	}
+	
+	public void updateCentroidKMeans(int nAlternatives) {
+		float value, average;
+		for (int i = 0; i < nAlternatives; i++) {
+			for (int j = i + 1; j < nAlternatives; j++) {
+				value = 0f;
+				for (Integer expert : experts) {
+					value += (float) ((FPR) preferences.get(expert)).getValue(i, j);
+				}
+				average = value / experts.size();
+				centroid.setValueSymmetrically(i, j, average);
+			}
+		}
+	}
+	
+	public void updateCentroidMedoide(int nAlternatives) {
+		
+		for (int i = 0; i < nAlternatives; i++) {
+			for (int j = i + 1; j < nAlternatives; j++) {
+				List<Float> valuesExperts = new ArrayList<Float>();
+				for (Integer expert : experts) {
+					valuesExperts.add( (float) ((FPR) preferences.get(expert)).getValue(i, j));
+				}
+				
+				Collections.sort(valuesExperts);
+
+				if(experts.size()%2==0){
+					float value1=valuesExperts.get((experts.size()/2)-1);
+					float value2=valuesExperts.get(experts.size()/2);
+					float total=(value1+value2)/2f;
+					centroid.setValueSymmetrically(i, j,total);
+					
+				}else{
+					centroid.setValueSymmetrically(i, j, valuesExperts.get(experts.size()/2));
+				}		
+			}
+		}
+	}
+	
+	public void updateCentroidFuzzyCMeans(ArrayList<ArrayList<Double>> degreesMatrix, int nAlternatives) {
+		float sum, denominator, result;
+		for (int i = 0; i < nAlternatives; i++) {
+			for (int j = i + 1; j < nAlternatives; j++) {
+				sum = 0f;
+				denominator = 0f;
+				for (Integer expert : experts) {
+					int idExpert = expert;
+					double degree = degreesMatrix.get(idExpert).get(id);
+					sum += degree * (float) ((FPR) preferences.get(expert)).getValue(i, j);
+					denominator += degree;
+				}
+				result = sum / denominator;
+				centroid.setValueSymmetrically(i, j, result);
+			}
+		}
+	}
+	
+	public float maximumValue(FPR values, int nAlternatives, int idCluster) {
+		float max = 0f;
+
+		for (int col = 0; col < nAlternatives; col++) {
+			if (col != idCluster) {
+				if (max < (float) values.getValue(idCluster, col)) {
+					max = (float) values.getValue(idCluster, col);
+				}
+			}
+		}
+		return max;
+	}
+
+	public float minimumValue(FPR values, int nAlternatives, int idCluster) {
+		float min = 1f;
+
+		for (int col = 0; col < nAlternatives; col++) {
+			if (col != idCluster) {
+				if (min > (float) values.getValue(idCluster, col)) {
+					min = (float) values.getValue(idCluster, col);
+				}
+			}
+		}
+		return min;
+	}
+	
+	@Override
+	public Cluster clone() throws CloneNotSupportedException {
+		Cluster result = (Cluster) super.clone();
+		result.setId(id);
+		result.setExperts(cloneExperts());
+		result.setCentroid((FPR) centroid.clone());
+		result.setPreferences(clonePreferencesCluster());
+		return result;
+	}
+	
+	@Override
+	public String toString() {
+		StringBuilder result = new StringBuilder();
+
+		result.append("Id cluster: " + id);
+		result.append("\n");
+		result.append("List experts: ");
+		for (Integer expert : experts) {
+			result.append(expert + " ");
+		}
+		result.append("\n");
+		result.append("Centroid:" + "\n");
+		result.append(centroid.prettyFormat());
+
+		return result.toString();
+	}
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/cluster/ClusterHLPR.java

@@ -0,0 +1,141 @@
+package afryca.consensusmodel.cluster;
+
+import afryca.consensusmodel.ConsensusEngine;
+import afryca.domain.fuzzyset.FuzzySet;
+import afryca.domain.fuzzyset.function.types.TrapezoidalFunction;
+import afryca.domain.fuzzyset.labelset.LabelSet;
+import afryca.hlpr.HLPR;
+import afryca.hlpr.valuation.HesitantLinguisticValuation;
+
+public class ClusterHLPR extends Cluster {
+	
+	private TrapezoidalFunction[][] centroid;
+	
+	private FuzzySet domain;
+
+	public ClusterHLPR(FuzzySet domain) {
+		super();
+		
+		centroid = null;
+		
+		this.domain = domain;
+	}
+	
+	public ClusterHLPR(FuzzySet domain, ClusterHLPR previousCluster) {
+		this(domain);
+		
+		try {
+			setId(previousCluster.getId());
+			setCentroid(((TrapezoidalFunction[][]) previousCluster.getCentroid()).clone());
+		} catch (Exception e) {
+			throw new IllegalArgumentException(e.getMessage());
+		}
+	}
+	
+	public FuzzySet getDomain() {
+		return domain;
+	}
+	
+	public Object getCentroid() {
+		return centroid;
+	}
+
+	public void setCentroid(Object centroid) {
+		this.centroid = (TrapezoidalFunction[][]) centroid;
+	}
+
+	public void generateCluster(int clusterAlternative, int otherAlternative, int numberOfAlternatives) {
+		this.setId(clusterAlternative);
+		generateCentroidInitial(otherAlternative, numberOfAlternatives);
+	}
+
+	private void generateCentroidInitial(int clusterAlternative, int numberOfAlternatives) {
+		centroid = new TrapezoidalFunction[numberOfAlternatives][numberOfAlternatives];
+		
+		initializeCentroid(numberOfAlternatives);
+		
+		LabelSet labelset = domain.getLabelSet();
+		
+		for (int j = 0; j < numberOfAlternatives; j++) {
+			if(clusterAlternative != j) {
+				centroid[clusterAlternative][j] = (TrapezoidalFunction) labelset.getLabel(labelset.getCardinality() - 1).getSemantic();
+				centroid[j][clusterAlternative] = (TrapezoidalFunction) labelset.getLabel(0).getSemantic();
+			}
+		}
+	}
+	
+	public void initializeCentroid(int numberOfAlternatives, int id) {
+		setId(id);
+		
+		centroid = new TrapezoidalFunction[numberOfAlternatives][numberOfAlternatives];
+		LabelSet labelset = domain.getLabelSet();
+		for (int row = 0; row < numberOfAlternatives; row++) {
+			for (int col = 0; col < numberOfAlternatives; col++) {
+				centroid[row][col] = (TrapezoidalFunction) labelset.getLabel(((labelset.getCardinality() + 1) / 2) - 1).getSemantic();
+			}
+		}
+	}
+	
+	private void initializeCentroid(int numberOfAlternatives) {
+		LabelSet labelset = domain.getLabelSet();
+		for (int row = 0; row < numberOfAlternatives; row++) {
+			for (int col = 0; col < numberOfAlternatives; col++) {
+				centroid[row][col] = (TrapezoidalFunction) labelset.getLabel(((labelset.getCardinality() + 1) / 2) - 1).getSemantic();
+			}
+		}
+	}
+	
+	public void updateCentroid(int nAlternatives) {
+		TrapezoidalFunction acum, average;
+		
+		int expert;
+		for (int i = 0; i < nAlternatives; i++) {
+			for (int j = 0; j < nAlternatives; j++) {
+				
+				acum = new TrapezoidalFunction(new double[] {0d, 0d, 0d, 0d});
+				
+				for (int k = 0; k < experts.size(); ++k) {
+					expert = experts.get(k);
+					acum = acum.addition(ConsensusEngine.calculateFuzzyEnvelope(domain, 
+						(HesitantLinguisticValuation) ((HLPR) preferences.get(expert)).getValue(i, j)));	
+				}
+				
+				average = acum.divisionScalar(experts.size());
+				centroid[i][j] = average;
+			}
+		}
+	}
+	
+	@Override
+	public Cluster clone() throws CloneNotSupportedException {
+		Cluster result = (Cluster) super.clone();
+		result.setId(id);
+		result.setExperts(cloneExperts());
+		result.setCentroid((TrapezoidalFunction[][]) centroid.clone());
+		result.setPreferences(clonePreferencesCluster());
+		return result;
+	}
+	
+	@Override
+	public String toString() {
+		StringBuilder result = new StringBuilder();
+
+		result.append("Id cluster: " + id);
+		result.append("\n");
+		result.append("List experts: ");
+		for (Integer expert : experts) {
+			result.append(expert + " ");
+		}
+		result.append("\n");
+		result.append("Centroid:" + "\n");
+		for(int i = 0; i < centroid.length;++i) {
+			for(int j = 0; j < centroid[i].length;++j) {
+				result.append(centroid[i][j].toString());
+			}
+			result.append("\n");
+		}
+		
+
+		return result.toString();
+	}
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/clustering/FuzzyCMeansELICITPR.java

@@ -0,0 +1,225 @@
+package afryca.consensusmodel.clustering;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.eclipse.core.runtime.preferences.InstanceScope;
+
+import afryca.consensusmodel.ConsensusEngine;
+import afryca.consensusmodel.cluster.ClusterELICITPR;
+import afryca.consensusmodel.preferences.PreferenceConstants;
+import afryca.domain.fuzzyset.FuzzySet;
+import afryca.domain.fuzzyset.function.types.TrapezoidalFunction;
+import afryca.elicit.ELICIT;
+import afryca.elicit.ELICITPR;
+
+/**
+ *  Fuzzy C-Means Algorithm for ELICIT information
+ * @author Álvaro
+ *
+ */
+public class FuzzyCMeansELICITPR {
+
+	public static List<ClusterELICITPR> doClusteringFuzzyCMeansClusterForEachAlternative(String[] alternatives, String[] experts, ELICITPR[] preferences, 
+			List<ClusterELICITPR> previousClusters, float parameterDist) {
+		
+		double epsilon = Double.parseDouble(InstanceScope.INSTANCE.getNode(PreferenceConstants.NODEPATH).get(PreferenceConstants.EPSILON, null));
+		double variation = 1.0;
+		
+		FuzzySet domain = (FuzzySet) preferences[0].getDomain(null, null);
+
+		List<ClusterELICITPR> clusters = generateClustersForEachAlternative(alternatives, previousClusters, domain);
+		
+		int iteration = 0, expertID, clusterID;
+		List<ArrayList<ArrayList<Double>>> all_membership = new ArrayList<ArrayList<ArrayList<Double>>>();
+		ArrayList<Double> expertMembershipDegreesByCluster;
+		
+		do {
+			// Step 3: Compute membership degrees between experts and centroids
+			ArrayList<ArrayList<Double>> expertsMembershipDegreeByCluster = new ArrayList<ArrayList<Double>>();
+			for (String expert : experts) {
+				
+				expertID = ConsensusEngine.getExpertId(experts, expert);
+				
+				expertMembershipDegreesByCluster = computeExpertMembershipDegrees(expertID, preferences[expertID], parameterDist, clusters);
+				clusterID = getClusterWithMaximumMembershipDegree(expertMembershipDegreesByCluster); 
+				
+				// Step 4: Assign the expert to the cluster whose
+				// membership degree to its centroid is maximum
+				assigExpertToCluster(clusterID, expertID, preferences, clusters);	
+				
+				expertsMembershipDegreeByCluster.add(expertMembershipDegreesByCluster);
+			}
+			
+			all_membership.add(iteration, expertsMembershipDegreeByCluster);
+			
+			// compute variation
+			if (iteration > 0)
+				variation = compareMembershipDegrees(all_membership.get(iteration), all_membership.get(iteration - 1));
+			
+			// Step 5: Update centroids
+			if (variation > epsilon) {
+				for (ClusterELICITPR cluster : clusters) {
+					if (!cluster.getExperts().isEmpty())
+						cluster.updateCentroid(alternatives.length);
+				}
+			}
+			
+			iteration++;
+		
+		} while (variation > epsilon);
+
+		
+		return clusters;
+	}
+	
+	private static List<ClusterELICITPR> generateClustersForEachAlternative(String[] alternatives, List<ClusterELICITPR> previousClusters, FuzzySet domain) {
+		List<ClusterELICITPR> clusters = new LinkedList<>();
+		int alternativeID;
+
+		// Step 1: Generate a cluster for each alternative
+		// Step 2: Initialization of centroids
+		if (previousClusters == null) {// round = 0, technique of initialization
+			for (String alternative : alternatives) {
+				alternativeID = ConsensusEngine.getAlternativeId(alternatives, alternative);
+				ClusterELICITPR cluster = new ClusterELICITPR(domain);
+				cluster.generateCluster(alternativeID, alternativeID, alternatives.length);
+				clusters.add(cluster);
+			}
+		} else { // round > 0, initialization of centroids from previous round
+			for (ClusterELICITPR c : previousClusters) {
+				ClusterELICITPR cluster = new ClusterELICITPR(domain, c);
+				clusters.add(cluster);
+			}
+		}
+		return clusters;
+	}
+
+	/**
+	 * Maximum membership degree of the expert
+	 * @param expertMembershipDegreesByCluster
+	 * @return
+	 */
+	private static int getClusterWithMaximumMembershipDegree(ArrayList<Double> expertMembershipDegreesByCluster) {
+		double maxValue = 0;
+		int clusterID = -1;
+		
+		double degree;
+		for (int pos = 0; pos < expertMembershipDegreesByCluster.size(); pos++) {
+			degree = expertMembershipDegreesByCluster.get(pos);
+			if (degree > maxValue) {
+				maxValue = degree;
+				clusterID = pos;
+			}
+		}
+		
+		return clusterID;
+	}
+	
+	private static void assigExpertToCluster(int clusterID, int expertID, ELICITPR[] preferences, List<ClusterELICITPR> clusters) {
+		for (ClusterELICITPR cluster : clusters) {
+			if (cluster.getId() == clusterID) {
+				if (!cluster.containExpert(expertID)) {
+					boolean found = false;
+					Iterator<ClusterELICITPR> iterOtherCluster = clusters.iterator();
+					while (iterOtherCluster.hasNext() && !found) {
+						ClusterELICITPR otherCluster = (ClusterELICITPR) iterOtherCluster.next();
+						if (otherCluster.containExpert(expertID)) {
+							otherCluster.removeExpertCluster(expertID);
+							found = true;
+						}
+					}
+					cluster.addExpertCluster(expertID, preferences[expertID]);
+				}
+			}
+		}
+	}
+	
+	/*
+	 * Membership degree of one expert to all the clusters
+	 */
+	public static ArrayList<Double> computeExpertMembershipDegrees(int expert, ELICITPR elicitPR, float parameter, List<ClusterELICITPR> clusters) {
+		
+		double FUZZYNESS = Double.parseDouble(InstanceScope.INSTANCE.getNode(PreferenceConstants.NODEPATH).get(PreferenceConstants.FUZZINESS, null));
+		double denominator = 0;
+
+		List<Double> distancesToClusters = new LinkedList<>();
+		for (ClusterELICITPR c : clusters) {
+			double dist_c =  distance(elicitPR,  (ELICIT[][]) c.getCentroid(), parameter);
+			denominator += Math.pow((1.0 / dist_c), (1.0 / (FUZZYNESS - 1.0)));
+			
+			distancesToClusters.add(dist_c);
+		}
+		
+		double numerator, degree_Pi;
+		
+		ArrayList<Double> expertMembershipDegreesByCluster = new ArrayList<Double>();
+		for (double dist_cluster : distancesToClusters) {
+
+			numerator = Math.pow((1.0 / dist_cluster), (1.0 / (FUZZYNESS - 1)));
+
+			if (dist_cluster == 0)
+				degree_Pi = 1.0;
+			else
+				degree_Pi = numerator / denominator;
+			
+			expertMembershipDegreesByCluster.add(degree_Pi);
+		}
+
+		return expertMembershipDegreesByCluster;
+	}
+	
+	private static double compareMembershipDegrees(ArrayList<ArrayList<Double>> current, ArrayList<ArrayList<Double>> previous) {
+		double result;
+		double sum = 0;
+		int num = 0;
+		for (int i = 0; i < current.size(); i++) {
+			for (int j = 0; j < current.get(0).size(); j++) {
+				sum += Math.abs(current.get(i).get(j) - previous.get(i).get(j));
+				num++;
+			}
+		}
+		result = sum / num;
+		return result;
+	}
+	
+	/**
+	 * Get the distance between a ELICIT preference relation and centroid
+	 * 
+	 * @param elicitPR
+	 *            ELICIT preference relation
+	 * @param centroid
+	 *           Centroid
+	 * @return The distance between a ELICIT preference relation and centroid
+	 */
+	public static double distance(ELICITPR elicitPR, ELICIT[][] centroid, float p) {
+		double result;
+		double sum = 0;
+		for (int i = 0; i < elicitPR.getNumberOfAlternatives() - 1; i++) {
+			for (int j = i + 1; j < elicitPR.getNumberOfAlternatives(); j++) {
+				
+				ELICIT elicit1 = elicitPR.getELICITValuation(i, j);
+				ELICIT elicit2 = centroid[i][j];
+				
+				TrapezoidalFunction env1, env2;
+				
+				if(elicit1.getBeta() != null)
+					env1 = elicit1.getBeta();
+				else
+					env1 = elicit1.computeInverse();
+				
+				if(elicit2.getBeta() != null)
+					env2 = elicit2.getBeta();
+				else
+					env2 = elicit2.computeInverse();
+				
+				sum += env1.distance(env2, p);
+			}
+		}
+		sum = sum / ((elicitPR.getNumberOfAlternatives() * (elicitPR.getNumberOfAlternatives() - 1d)) / 2d);
+		result = Math.pow(sum, 1.0 / p);
+		return result;
+	}
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/clustering/FuzzyCMeansFPR.java

@@ -0,0 +1,168 @@
+package afryca.consensusmodel.clustering;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.eclipse.core.runtime.preferences.InstanceScope;
+
+import afryca.consensusmodel.ConsensusEngine;
+import afryca.consensusmodel.cluster.Cluster;
+import afryca.consensusmodel.cluster.ClusterFPR;
+import afryca.consensusmodel.preferences.PreferenceConstants;
+import afryca.fpr.FPR;
+
+/**
+ *  Fuzzy C-Means Algorithm based on the proposal presented in Rodríguez et al (2018): A large scale consensus reaching process managing group hesitation
+ * @author Álvaro
+ *
+ */
+public class FuzzyCMeansFPR {
+
+	@SuppressWarnings({ "rawtypes" })
+	/**
+	 * Adapted Fuzzy C-Means Algorithm based on the proposal presented in Rodríguez et al (2018): A large scale consensus reaching process managing group hesitation
+	 * @param alternatives: alternatives of the problem
+	 * @param experts: experts of the problem
+	 * @param preferences: experts' preferences
+	 * @param previousClusters: cluster from previous rounds
+	 * @param parameterDist: distance parameter
+	 * @return
+	 */
+	public static List<ClusterFPR> doClusteringFuzzyCMeansClusterForEachAlternative(String[] alternatives, String[] experts, FPR[] preferences, List<ClusterFPR> previousClusters, int parameterDist) {
+		double epsilon = Double.parseDouble(InstanceScope.INSTANCE.getNode(PreferenceConstants.NODEPATH).get(PreferenceConstants.EPSILON, null));
+		double variation = 1.0;
+		
+		List<ArrayList<ArrayList<Double>>> all_membership = new ArrayList<ArrayList<ArrayList<Double>>>();
+		
+		List<ClusterFPR> clusters = generateClustersForEachAlternative(alternatives, previousClusters);
+		
+		int iteration = 0, expertID;
+		do {
+
+			// Step 3: Compute membership degrees between experts and centroids
+			ArrayList<ArrayList<Double>> degreesMatrix = new ArrayList<ArrayList<Double>>();
+
+			for (String expert : experts) {
+				ArrayList<Double> degreesList = new ArrayList<Double>();
+				expertID = ConsensusEngine.getExpertId(experts, expert);
+				degreesList = computeExpertMembershipDegrees(expertID, preferences[expertID], parameterDist, clusters);
+				degreesMatrix.add(degreesList);
+
+				double maxValue = 0;
+				int idCluster = 0;
+				double degree;
+				for (int pos = 0; pos < degreesList.size(); pos++) {
+					degree = degreesList.get(pos);
+					if (degree > maxValue) {
+						maxValue = degree;
+						idCluster = pos;
+					}
+				}
+				// Step 4: Assign the expert to the cluster whose
+				// membership degree to its centroid is maximum
+				for (Cluster cluster : clusters) {
+					if (cluster.getId() == idCluster) {
+						if (!cluster.containExpert(expertID)) {
+							boolean found = false;
+							Iterator iterOtherCluster = clusters.iterator();
+							while (iterOtherCluster.hasNext() && !found) {
+								Cluster otherCluster = (Cluster) iterOtherCluster.next();
+								if (otherCluster.containExpert(expertID)) {
+									otherCluster.removeExpertCluster(expertID);
+									found = true;
+								}
+							}
+							cluster.addExpertCluster(expertID, preferences[expertID]);
+						}
+					}
+				}
+			}
+			all_membership.add(iteration, degreesMatrix);
+
+			if (iteration > 0) {
+				// compute variation
+				variation = compareMembershipDegrees(all_membership.get(iteration), all_membership.get(iteration - 1));
+			}
+			// Step 5: Update centroids
+			if (variation > epsilon) {
+				for (ClusterFPR cluster : clusters) {
+					if (!cluster.getExperts().isEmpty()) {
+						// cluster.updateCentroidFuzzyCMeans(degreesMatrix,
+						// alternatives.length);
+						cluster.updateCentroidKMeans(alternatives.length);
+					}
+				}
+			}
+			iteration++;
+		} while (variation > epsilon);
+
+		return clusters;
+	}
+	
+	private static List<ClusterFPR> generateClustersForEachAlternative(String[] alternatives, List<ClusterFPR> previousClusters) {
+		List<ClusterFPR> clusters = new LinkedList<>();
+		int alternativeID;
+		
+		// Step 1: Generate a cluster for each alternative
+		// Step 2: Initialization of centroids
+		if (previousClusters == null) {// round = 0, tecnique of initialization
+			for (String alternative : alternatives) {
+				alternativeID = ConsensusEngine.getAlternativeId(alternatives, alternative);
+				ClusterFPR cluster = new ClusterFPR();
+				cluster.generateCluster(alternativeID, alternativeID, alternatives.length);
+				clusters.add(cluster);
+
+			}
+		} else { // round > 0, initialization of centroids from previous round
+			for (ClusterFPR c : previousClusters) {
+				ClusterFPR cluster = new ClusterFPR(c);
+				clusters.add(cluster);
+			}
+		}
+		return clusters;
+	}
+
+	public static ArrayList<Double> computeExpertMembershipDegrees(int expert, FPR preferences, int parameter, List<ClusterFPR> clusters) {
+		
+		double FUZZYNESS = Double.parseDouble(InstanceScope.INSTANCE.getNode(PreferenceConstants.NODEPATH).get(PreferenceConstants.FUZZINESS, null));
+		
+		ArrayList<Double> degreesList = new ArrayList<Double>();
+		double dist_cluster, degree_Pi;
+
+		for (ClusterFPR cluster : clusters) {
+			dist_cluster = ConsensusEngine.distanceMinkowski(preferences, (FPR) cluster.getCentroid(), parameter);
+			double numerator = Math.pow((1.0 / dist_cluster), (1 / (FUZZYNESS - 1)));
+			double denominator = 0;
+			for (ClusterFPR c : clusters) {
+				double dist_c = ConsensusEngine.distanceMinkowski(preferences, (FPR) c.getCentroid(), parameter);
+				denominator += Math.pow((1.0 / dist_c), (1.0 / (FUZZYNESS - 1)));
+			}
+
+			if (dist_cluster == 0) {
+				degree_Pi = 1.0;
+			} else {
+				degree_Pi = numerator / denominator;
+			}
+			degreesList.add(degree_Pi);
+		}
+
+		return degreesList;
+	}
+	
+	public static double compareMembershipDegrees(ArrayList<ArrayList<Double>> current, ArrayList<ArrayList<Double>> previous) {
+		double result;
+		double sum = 0;
+		int num = 0;
+		for (int i = 0; i < current.size(); i++) {
+			for (int j = 0; j < current.get(0).size(); j++) {
+				sum += Math.abs(current.get(i).get(j) - previous.get(i).get(j));
+				num++;
+			}
+		}
+		result = sum / num;
+		return result;
+	}
+	
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/clustering/FuzzyCMeansFPRKatsavounidis.java

@@ -0,0 +1,173 @@
+package afryca.consensusmodel.clustering;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.core.runtime.preferences.InstanceScope;
+
+import afryca.consensusmodel.ConsensusEngine;
+import afryca.consensusmodel.cluster.Cluster;
+import afryca.consensusmodel.cluster.ClusterFPR;
+import afryca.consensusmodel.preferences.PreferenceConstants;
+import afryca.fpr.FPR;
+import afryca.structure.Structure;
+
+/**
+ *  Fuzzy C-Means Algorithm based on the proposal presented by Katsavounidis
+ * @author Álvaro
+ *
+ */
+public class FuzzyCMeansFPRKatsavounidis {
+
+	@SuppressWarnings({ "rawtypes" })
+	public static List<ClusterFPR> doClusteringFuzzyCMeansKatsavounidis(String[] alternatives, String[] experts, Structure[] preferences, int parameterDist) {
+		
+		double EPSILON = Double.parseDouble(InstanceScope.INSTANCE.getNode(PreferenceConstants.NODEPATH).get(PreferenceConstants.EPSILON, null));
+		
+		double variation = 1.0;
+		List<ClusterFPR> clusters = new LinkedList<ClusterFPR>(); // Clusters
+		List<ArrayList<ArrayList<Double>>> all_membership = new ArrayList<ArrayList<ArrayList<Double>>>();
+		List<Integer> expertsAsigns = new LinkedList<Integer>(); // Experts
+																	// asigned
+																	// to a
+																	// cluster,
+																	// not being
+																	// computed
+																	// in others
+																	// cluster
+
+		/////////////////////////////////////// Initialize
+		/////////////////////////////////////// centroids/////////////////////////
+
+		// Initialize first centroid cluster with collective
+		ClusterFPR cluster1 = new ClusterFPR();
+		cluster1.setId(0);
+		cluster1.setCentroid((FPR) preferences[experts.length]);
+		clusters.add(cluster1);
+
+		// Initialize second cluster with farther preference
+		double maxDist = 0;
+		double dist = 0;
+		int furtherExpert = 0;
+
+		for (int i = 0; i < experts.length; i++) {
+			dist = ConsensusEngine.distanceMinkowski((FPR) preferences[i], (FPR) preferences[experts.length], parameterDist);
+			if (maxDist < dist) {
+				furtherExpert = i;
+				maxDist = dist;
+			}
+		}
+
+		ClusterFPR cluster2 = new ClusterFPR();
+		cluster2.setId(1);
+		cluster2.setCentroid((FPR) preferences[furtherExpert]);
+		clusters.add(cluster2);
+		expertsAsigns.add(furtherExpert);
+
+		// Initilize the others clusters
+		for (int i = 2; i < alternatives.length; i++) {
+			Map<Integer, Double> minDistanceExperts = new HashMap<>();
+			for (int j = 0; j < clusters.size(); j++) {
+				int nearestExpert = 0;
+				double minDistance = Double.MAX_VALUE;
+				double distance = 0;
+				for (int k = 0; k < experts.length; k++) { // Search the minimum
+															// distance to each
+															// cluster center
+					if (!ConsensusEngine.existExpert(expertsAsigns, k)) {
+						distance = ConsensusEngine.distanceMinkowski((FPR) preferences[k], (FPR) clusters.get(j).getCentroid(), parameterDist);
+						if (minDistance > distance) {
+							minDistance = distance;
+							nearestExpert = k;
+						}
+					}
+				}
+				minDistanceExperts.put(nearestExpert, minDistance);
+			}
+
+			double max = Double.MIN_VALUE;
+			int nearExpertFar = 0;
+			for (Integer key : minDistanceExperts.keySet()) { // Obtain the
+																// largest
+																// minimum
+																// distance
+				if (max < minDistanceExperts.get(key)) {
+					max = minDistanceExperts.get(key);
+					nearExpertFar = key;
+				}
+			}
+			ClusterFPR clusterN = new ClusterFPR();
+			clusterN.setId(i);
+			clusterN.setCentroid((FPR) preferences[nearExpertFar]);
+			clusters.add(clusterN);
+			expertsAsigns.add(nearExpertFar);
+
+		}
+		///////////////////////////////////// END INITIALIZE
+		///////////////////////////////////// CENTROIDS////////////////////////////////////////////
+
+		int iteration = 0;
+		do {
+
+			// Step 3: Compute membership degrees between experts and centroids
+			ArrayList<ArrayList<Double>> degreesMatrix = new ArrayList<ArrayList<Double>>();
+
+			for (String expert : experts) {
+				ArrayList<Double> degreesList = new ArrayList<Double>();
+				degreesList = FuzzyCMeansFPR.computeExpertMembershipDegrees(ConsensusEngine.getExpertId(experts, expert), (FPR) preferences[ConsensusEngine.getExpertId(experts, expert)], parameterDist, clusters);
+				degreesMatrix.add(degreesList);
+
+				double maxValue = 0;
+				int idCluster = 0;
+				double degree;
+				for (int pos = 0; pos < degreesList.size(); pos++) {
+					degree = degreesList.get(pos);
+					if (degree > maxValue) {
+						maxValue = degree;
+						idCluster = pos;
+					}
+				}
+				// Step 4: Assign the expert to the cluster whose
+				// membershipdegree to its centroid is maximum
+				for (ClusterFPR cluster : clusters) {
+					if (cluster.getId() == idCluster) {
+						if (!cluster.containExpert(ConsensusEngine.getExpertId(experts, expert))) {
+							boolean found = false;
+							Iterator iterOtherCluster = clusters.iterator();
+							while (iterOtherCluster.hasNext() && !found) {
+								Cluster otherCluster = (Cluster) iterOtherCluster.next();
+								if (otherCluster.containExpert(ConsensusEngine.getExpertId(experts, expert))) {
+									otherCluster.removeExpertCluster(ConsensusEngine.getExpertId(experts, expert));
+									found = true;
+								}
+							}
+							cluster.addExpertCluster(ConsensusEngine.getExpertId(experts, expert), (FPR) preferences[ConsensusEngine.getExpertId(experts, expert)]);
+						}
+					}
+				}
+			}
+			all_membership.add(iteration, degreesMatrix);
+
+			if (iteration > 0) {
+				// compute variation
+				variation = FuzzyCMeansFPR.compareMembershipDegrees(all_membership.get(iteration), all_membership.get(iteration - 1));
+			}
+			// Step 5: Update centroids
+			if (variation > EPSILON) {
+				for (int i = 1; i < clusters.size(); i++) {
+					if (!clusters.get(i).getExperts().isEmpty()) {
+						clusters.get(i).updateCentroidFuzzyCMeans(degreesMatrix, alternatives.length);
+					}
+				}
+			}
+			iteration++;
+		} while (variation > EPSILON);
+
+		return clusters;
+	}
+	
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/clustering/FuzzyCMeansHLPR.java

@@ -0,0 +1,211 @@
+package afryca.consensusmodel.clustering;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.eclipse.core.runtime.preferences.InstanceScope;
+
+import afryca.consensusmodel.ConsensusEngine;
+import afryca.consensusmodel.cluster.ClusterHLPR;
+import afryca.consensusmodel.preferences.PreferenceConstants;
+import afryca.domain.fuzzyset.FuzzySet;
+import afryca.domain.fuzzyset.function.types.TrapezoidalFunction;
+import afryca.hlpr.HLPR;
+import afryca.hlpr.valuation.HesitantLinguisticValuation;
+
+/**
+ *  Fuzzy C-Means Algorithm based on the proposal presented in Rodríguez et al (2018): A large scale consensus reaching process managing group hesitation
+ * @author Álvaro
+ *
+ */
+public class FuzzyCMeansHLPR {
+
+	public static List<ClusterHLPR> doClusteringFuzzyCMeansClusterForEachAlternative(String[] alternatives, String[] experts, HLPR[] preferences, 
+			List<ClusterHLPR> previousClusters, float parameterDist) {
+		
+		double epsilon = Double.parseDouble(InstanceScope.INSTANCE.getNode(PreferenceConstants.NODEPATH).get(PreferenceConstants.EPSILON, null));
+		double variation = 1.0;
+		
+		FuzzySet domain = (FuzzySet) preferences[0].getDomain(null, null);
+
+		List<ClusterHLPR> clusters = generateClustersForEachAlternative(alternatives, previousClusters, domain);
+		
+		int iteration = 0, expertID, clusterID;
+		List<ArrayList<ArrayList<Double>>> all_membership = new ArrayList<ArrayList<ArrayList<Double>>>();
+		ArrayList<Double> expertMembershipDegreesByCluster;
+		
+		do {
+			// Step 3: Compute membership degrees between experts and centroids
+			ArrayList<ArrayList<Double>> expertsMembershipDegreeByCluster = new ArrayList<ArrayList<Double>>();
+			for (String expert : experts) {
+				
+				expertID = ConsensusEngine.getExpertId(experts, expert);
+				
+				expertMembershipDegreesByCluster = computeExpertMembershipDegrees(expertID, preferences[expertID], parameterDist, clusters);
+				clusterID = getClusterWithMaximumMembershipDegree(expertMembershipDegreesByCluster); 
+				
+				// Step 4: Assign the expert to the cluster whose
+				// membership degree to its centroid is maximum
+				assigExpertToCluster(clusterID, expertID, preferences, clusters);	
+				
+				expertsMembershipDegreeByCluster.add(expertMembershipDegreesByCluster);
+			}
+			
+			all_membership.add(iteration, expertsMembershipDegreeByCluster);
+			
+			// compute variation
+			if (iteration > 0)
+				variation = compareMembershipDegrees(all_membership.get(iteration), all_membership.get(iteration - 1));
+			
+			// Step 5: Update centroids
+			if (variation > epsilon) {
+				for (ClusterHLPR cluster : clusters) {
+					if (!cluster.getExperts().isEmpty())
+						cluster.updateCentroid(alternatives.length);
+				}
+			}
+			
+			iteration++;
+		
+		} while (variation > epsilon);
+
+		
+		return clusters;
+	}
+	
+	private static List<ClusterHLPR> generateClustersForEachAlternative(String[] alternatives, List<ClusterHLPR> previousClusters, FuzzySet domain) {
+		List<ClusterHLPR> clusters = new LinkedList<>();
+		int alternativeID;
+
+		// Step 1: Generate a cluster for each alternative
+		// Step 2: Initialization of centroids
+		if (previousClusters == null) {// round = 0, technique of initialization
+			for (String alternative : alternatives) {
+				alternativeID = ConsensusEngine.getAlternativeId(alternatives, alternative);
+				ClusterHLPR cluster = new ClusterHLPR(domain);
+				cluster.generateCluster(alternativeID, alternativeID, alternatives.length);
+				clusters.add(cluster);
+			}
+		} else { // round > 0, initialization of centroids from previous round
+			for (ClusterHLPR c : previousClusters) {
+				ClusterHLPR cluster = new ClusterHLPR(domain, c);
+				clusters.add(cluster);
+			}
+		}
+		return clusters;
+	}
+
+	/**
+	 * Maximum membership degree of the expert
+	 * @param expertMembershipDegreesByCluster
+	 * @return
+	 */
+	private static int getClusterWithMaximumMembershipDegree(ArrayList<Double> expertMembershipDegreesByCluster) {
+		double maxValue = 0;
+		int clusterID = -1;
+		
+		double degree;
+		for (int pos = 0; pos < expertMembershipDegreesByCluster.size(); pos++) {
+			degree = expertMembershipDegreesByCluster.get(pos);
+			if (degree > maxValue) {
+				maxValue = degree;
+				clusterID = pos;
+			}
+		}
+		
+		return clusterID;
+	}
+	
+	private static void assigExpertToCluster(int clusterID, int expertID, HLPR[] preferences, List<ClusterHLPR> clusters) {
+		for (ClusterHLPR cluster : clusters) {
+			if (cluster.getId() == clusterID) {
+				if (!cluster.containExpert(expertID)) {
+					boolean found = false;
+					Iterator<ClusterHLPR> iterOtherCluster = clusters.iterator();
+					while (iterOtherCluster.hasNext() && !found) {
+						ClusterHLPR otherCluster = (ClusterHLPR) iterOtherCluster.next();
+						if (otherCluster.containExpert(expertID)) {
+							otherCluster.removeExpertCluster(expertID);
+							found = true;
+						}
+					}
+					cluster.addExpertCluster(expertID, preferences[expertID]);
+				}
+			}
+		}
+	}
+	
+	/*
+	 * Membership degree of one expert to all the clusters
+	 */
+	public static ArrayList<Double> computeExpertMembershipDegrees(int expert, HLPR hlpr, float parameter, List<ClusterHLPR> clusters) {
+		
+		double FUZZYNESS = Double.parseDouble(InstanceScope.INSTANCE.getNode(PreferenceConstants.NODEPATH).get(PreferenceConstants.FUZZINESS, null));
+		double denominator = 0;
+
+		List<Double> distancesToClusters = new LinkedList<>();
+		for (ClusterHLPR c : clusters) {
+			double dist_c =  distance(hlpr,  (TrapezoidalFunction[][]) c.getCentroid(), parameter);
+			denominator += Math.pow((1.0 / dist_c), (1.0 / (FUZZYNESS - 1.0)));
+			
+			distancesToClusters.add(dist_c);
+		}
+		
+		double numerator, degree_Pi;
+		
+		ArrayList<Double> expertMembershipDegreesByCluster = new ArrayList<Double>();
+		for (double dist_cluster : distancesToClusters) {
+
+			numerator = Math.pow((1.0 / dist_cluster), (1.0 / (FUZZYNESS - 1)));
+
+			if (dist_cluster == 0)
+				degree_Pi = 1.0;
+			else
+				degree_Pi = numerator / denominator;
+			
+			expertMembershipDegreesByCluster.add(degree_Pi);
+		}
+
+		return expertMembershipDegreesByCluster;
+	}
+	
+	private static double compareMembershipDegrees(ArrayList<ArrayList<Double>> current, ArrayList<ArrayList<Double>> previous) {
+		double result;
+		double sum = 0;
+		int num = 0;
+		for (int i = 0; i < current.size(); i++) {
+			for (int j = 0; j < current.get(0).size(); j++) {
+				sum += Math.abs(current.get(i).get(j) - previous.get(i).get(j));
+				num++;
+			}
+		}
+		result = sum / num;
+		return result;
+	}
+	
+	/**
+	 * Get the distance between a HLPR and centroid
+	 * 
+	 * @param hlpr1
+	 *            Hesitant linguistic preference relation 1
+	 * @param centroid
+	 *           Centroid
+	 * @return The distance between a HFLPR and centroid
+	 */
+	public static double distance(HLPR hlpr1, TrapezoidalFunction[][] centroid, float p) {
+		double result;
+		double sum = 0;
+		for (int i = 0; i < hlpr1.getNumberOfAlternatives() - 1; i++) {
+			for (int j = i + 1; j < hlpr1.getNumberOfAlternatives(); j++) {
+				TrapezoidalFunction env1 = ConsensusEngine.calculateFuzzyEnvelope((FuzzySet) hlpr1.getDomain(null, null), (HesitantLinguisticValuation) hlpr1.getValue(i, j));
+				TrapezoidalFunction env2 = centroid[i][j];
+				sum += env1.distance(env2, p);
+			}
+		}
+		sum = sum / ((hlpr1.getNumberOfAlternatives() * (hlpr1.getNumberOfAlternatives() - 1d)) / 2d);
+		result = Math.pow(sum, 1.0 / p);
+		return result;
+	}
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/clustering/FuzzyKMeansFPR.java

@@ -0,0 +1,85 @@
+package afryca.consensusmodel.clustering;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+import afryca.consensusmodel.ConsensusEngine;
+import afryca.consensusmodel.cluster.ClusterFPR;
+import afryca.fpr.FPR;
+
+public class FuzzyKMeansFPR {
+
+	public static List<ClusterFPR> doClusteringKMeans(String[] alternatives, String[] experts, FPR[] preferences, List<ClusterFPR> previousClusters) {
+		List<ClusterFPR> clusters = new LinkedList<ClusterFPR>();
+		// Step 1: Generate a cluster for each alternative
+		// Step 2: Initialization of centroids
+		if (previousClusters == null) {// round = 0, tecnique of initialization
+			for (String alternative : alternatives) {
+				ClusterFPR cluster = new ClusterFPR();
+				cluster.generateCluster(ConsensusEngine.getAlternativeId(alternatives, alternative), ConsensusEngine.getAlternativeId(alternatives, alternative), alternatives.length);
+				clusters.add(cluster);
+
+			}
+		} else { // round > 0, initialization of centroids from previous round
+			for (ClusterFPR c : previousClusters) {
+				ClusterFPR cluster = new ClusterFPR(c);
+				clusters.add(cluster);
+			}
+		}
+		int changes;
+		do {
+			double dist;
+			changes = 0;
+			// Step 3: Compute the distances between experts and centroids
+			for (String expert : experts) {
+				ArrayList<Double> distances = new ArrayList<Double>();
+				for (ClusterFPR cluster : clusters) {
+					dist = ConsensusEngine.distanceEuclidean(preferences[ConsensusEngine.getExpertId(experts, expert)], (FPR) cluster.getCentroid());
+					distances.add(dist);
+				}
+
+				double minValue = distances.get(0);
+				int idCluster = 0;
+				for (int pos = 1; pos < distances.size(); pos++) {
+					dist = distances.get(pos);
+					if (dist < minValue) {
+						minValue = dist;
+						idCluster = pos;
+					}
+				}
+				// Step 4: Assign the expert to the cluster whose distance to
+				// its centroid is minimum
+				for (ClusterFPR cluster : clusters) {
+					if (cluster.getId() == idCluster) {
+						if (!cluster.containExpert(ConsensusEngine.getExpertId(experts, expert))) {
+							boolean found = false;
+							Iterator<ClusterFPR> iterOtherCluster = clusters.iterator();
+							while (iterOtherCluster.hasNext() && !found) {
+								ClusterFPR otherCluster = (ClusterFPR) iterOtherCluster.next();
+								if (otherCluster.containExpert(ConsensusEngine.getExpertId(experts, expert))) {
+									otherCluster.removeExpertCluster(ConsensusEngine.getExpertId(experts, expert));
+									found = true;
+								}
+							}
+							cluster.addExpertCluster(ConsensusEngine.getExpertId(experts, expert), preferences[ConsensusEngine.getExpertId(experts, expert)]);
+							changes++;
+						}
+					}
+				}
+			}
+			// Step 5: Update centroids
+			if (changes != 0) {
+				for (ClusterFPR cluster : clusters) {
+					if (!cluster.getExperts().isEmpty())
+						cluster.updateCentroidKMeans(alternatives.length);
+				}
+			}
+			// Repeat steps 3-5 until no changes
+		} while (changes != 0);
+
+		return clusters;
+	}
+	
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/command/OpenConfiguration.java

@@ -0,0 +1,104 @@
+package afryca.consensusmodel.command;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.net.URISyntaxException;
+import java.net.URL;
+
+import javax.inject.Inject;
+import javax.inject.Named;
+
+import org.apache.commons.io.IOUtils;
+import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.e4.core.di.annotations.Execute;
+import org.eclipse.e4.core.services.log.ILoggerProvider;
+import org.eclipse.e4.core.services.log.Logger;
+import org.eclipse.e4.core.services.nls.Translation;
+
+import afryca.consensusmodel.Configuration;
+import afryca.consensusmodel.l10n.Messages;
+
+/**
+ * Command for open consensus model configuration
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+@SuppressWarnings("restriction")
+public class OpenConfiguration {
+
+	public static final String ID = "afryca.consensusmodel.command.open_configuration"; //$NON-NLS-1$
+
+	public static final String FILE_PARAMETER = "file"; //$NON-NLS-1$
+
+	private Logger logger;
+
+	@Inject
+	@Translation
+	Messages messages;
+
+	@Inject
+	public void instantiateLogger(ILoggerProvider loggerProvider) {
+		logger = loggerProvider.getClassLogger(this.getClass());
+	}
+
+	@Execute
+	public Configuration execute(@Named(FILE_PARAMETER) String file) throws Exception {
+		logger.info(messages.command_executed, ID);
+		return readConfiguration(file);
+	}
+
+	private Configuration readConfiguration(String file) throws ExecutionException {
+		Configuration configuration = null;
+		if (file != null) {
+			InputStream inputStream = null;
+			try {
+				if (isValidFile(file)) {
+					inputStream = new FileInputStream(file);
+				} else if (isValidURL(file)) {
+					inputStream = new URL(file).openStream();
+				} else {
+					throw new ExecutionException(messages.wrong_file);
+				}
+				configuration = Configuration.parseConfiguration(IOUtils.toString(inputStream, "UTF-8")); //$NON-NLS-1$
+				configuration.setFile(file);
+				inputStream.close();
+			} catch (IOException es) {
+				if (inputStream != null) {
+					try {
+						inputStream.close();
+					} catch (Exception e) {
+					}
+				}
+				throw new ExecutionException(messages.wrong_file);
+			}
+		}
+		return configuration;
+	}
+
+	private static boolean isValidFile(String fileName) {
+		File file = new File(fileName);
+		return (file.exists() && file.canRead());
+	}
+
+	private static boolean isValidURL(String url) {
+		URL u = null;
+
+		try {
+			u = new URL(url);
+		} catch (MalformedURLException e) {
+			return false;
+		}
+
+		try {
+			u.toURI();
+		} catch (URISyntaxException e) {
+			return false;
+		}
+
+		return true;
+	}
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/command/SaveConfiguration.java

@@ -0,0 +1,49 @@
+package afryca.consensusmodel.command;
+
+import java.io.File;
+import javax.inject.Inject;
+import javax.inject.Named;
+
+import org.apache.commons.io.FileUtils;
+import org.eclipse.e4.core.di.annotations.Execute;
+import org.eclipse.e4.core.services.log.ILoggerProvider;
+import org.eclipse.e4.core.services.log.Logger;
+import org.eclipse.e4.core.services.nls.Translation;
+
+import afryca.consensusmodel.Configuration;
+import afryca.consensusmodel.l10n.Messages;
+
+/**
+ * Command for save consensus model configuration
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+@SuppressWarnings("restriction")
+public class SaveConfiguration {
+
+	public static final String ID = "afryca.consensusmodel.command.save_configuration"; //$NON-NLS-1$
+
+	private Logger logger;
+
+	@Inject
+	@Translation
+	Messages messages;
+
+	@Inject
+	public void instantiateLogger(ILoggerProvider loggerProvider) {
+		logger = loggerProvider.getClassLogger(this.getClass());
+	}
+
+	@Execute
+	public void execute(@Named(Configuration.ID) Configuration configuration) throws Exception {
+		logger.info(messages.command_executed, ID);
+		try {
+			Configuration copy = configuration.copy();
+			copy.setFile(null);
+			FileUtils.writeStringToFile(new File(configuration.getFile()), copy.toString(), "UTF-8"); //$NON-NLS-1$
+		} catch (Exception e) {
+			throw new Exception(messages.wrong_file);
+		}
+	}
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/command/parameter/ConfigurationParameterValueConverter.java

@@ -0,0 +1,15 @@
+package afryca.consensusmodel.command.parameter;
+
+import afryca.parametervalueconverterhelper.AbstractParameterValueConverterHelper;
+
+/**
+ * Configuration parameter value converter
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class ConfigurationParameterValueConverter extends AbstractParameterValueConverterHelper {
+	public ConfigurationParameterValueConverter() {
+		helper = new ConfigurationParameterValueConverterHelper();
+	}
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/command/parameter/ConfigurationParameterValueConverterHelper.java

@@ -0,0 +1,50 @@
+package afryca.consensusmodel.command.parameter;
+
+import static afryca.consensusmodel.Configuration.*;
+
+import java.util.Map;
+
+import afryca.consensusmodel.Configuration;
+import afryca.parametervalueconverterhelper.ParameterValueConverterHelper;
+import afryca.parametervalueconverterhelper.ParameterValueConverterHelperException;
+
+/**
+ * Configuration parameter value converter helper
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class ConfigurationParameterValueConverterHelper extends ParameterValueConverterHelper {
+
+	public static final String KEY_MARK = "configurationValueKey"; //$NON-NLS-1$
+	public static final String VALUE_MARK = "configurationValueValue"; //$NON-NLS-1$
+
+	@Override
+	public Object convertToObject(String parameterValue) throws ParameterValueConverterHelperException {
+		Configuration result = new Configuration();
+		setElements(result, parameterValue);
+		return result;
+	}
+
+	private void setElements(Configuration configuration, String parameterValue)
+			throws ParameterValueConverterHelperException {
+		Map<String, String> fields = extractFieldsValue(parameterValue,
+				new String[] { FIELD_FILE, FIELD_CONSENSUS_MODEL, FIELD_VALUES });
+		configuration.setFile(getString(fields, FIELD_FILE));
+		configuration.setConsensusModel(getString(fields, FIELD_CONSENSUS_MODEL));
+		configuration.setValues(getObjectMap(fields, FIELD_VALUES, singular(FIELD_VALUES), KEY_MARK, VALUE_MARK,
+				ValueParameterValueConverterHelper.class, Object.class));
+	}
+
+	@Override
+	public String convertToString(Object parameterValue) throws ParameterValueConverterHelperException {
+		Configuration configuration = (Configuration) parameterValue;
+		String file = marker(configuration.getFile(), FIELD_FILE);
+		String consensusModel = marker(configuration.getConsensusModel(), FIELD_CONSENSUS_MODEL);
+		String values = markMap(configuration.getValues(), FIELD_VALUES, singular(FIELD_VALUES), KEY_MARK, VALUE_MARK,
+				ValueParameterValueConverterHelper.class);
+		return marker(new String[] { file, consensusModel, values }, ID);
+
+	}
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/command/parameter/ValueParameterValueConverter.java

@@ -0,0 +1,15 @@
+package afryca.consensusmodel.command.parameter;
+
+import afryca.parametervalueconverterhelper.AbstractParameterValueConverterHelper;
+
+/**
+ * Configuration value parameter value converter
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class ValueParameterValueConverter extends AbstractParameterValueConverterHelper {
+	public ValueParameterValueConverter() {
+		helper = new ValueParameterValueConverterHelper();
+	}
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/command/parameter/ValueParameterValueConverterHelper.java

@@ -0,0 +1,207 @@
+package afryca.consensusmodel.command.parameter;
+
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import afryca.fpr.FPR;
+import afryca.parametervalueconverterhelper.ParameterValueConverterHelper;
+import afryca.parametervalueconverterhelper.ParameterValueConverterHelperException;
+
+/**
+ * Value parameter value converter helper
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class ValueParameterValueConverterHelper extends ParameterValueConverterHelper {
+
+	public static final String ID_MARK = "selfDescribedValue"; //$NON-NLS-1
+	public static final String TYPE_MARK = "configurationValueType"; //$NON-NLS-1$
+	public static final String STRING_VALUE_MARK = "configurationValueStringValue"; //$NON-NLS-1$
+	public static final String STRING_VALUE_ELEMENT_MARK = "configurationValueStringValueElement"; //$NON-NLS-1$
+	
+	@Override
+	public Object convertToObject(String parameterValue) throws ParameterValueConverterHelperException {
+		Map<String, String> fields = extractFieldsValue(parameterValue,	new String[] { TYPE_MARK, STRING_VALUE_MARK });
+		String type = getString(fields, TYPE_MARK);
+		if (type == null || type.isEmpty()) {
+			return null;
+		}
+		
+		if (Integer.class.getName().equals(type)) {
+			return getInteger(fields, STRING_VALUE_MARK);
+		}
+		
+		if (Integer[].class.getName().equals(type)) {
+			List<String> out = getList(fields, STRING_VALUE_MARK, STRING_VALUE_ELEMENT_MARK);
+			List<Integer> result = new ArrayList<>();
+			out.forEach(v -> result.add(Integer.parseInt(v)));
+			return result.toArray(new Integer[0]);
+		}
+		
+		if (Double.class.getName().equals(type)) {
+			return Double.parseDouble(getString(fields, STRING_VALUE_MARK));
+		}
+		
+		if (Double[].class.getName().equals(type)) {
+			List<String> out = getList(fields, STRING_VALUE_MARK, STRING_VALUE_ELEMENT_MARK);
+			List<Double> result = new ArrayList<>();
+			out.forEach(v -> result.add(Double.parseDouble(v)));
+			return result.toArray(new Double[0]);
+		}
+		
+		if (Float.class.getName().equals(type)) {
+			return Float.parseFloat(getString(fields, STRING_VALUE_MARK));
+		}
+		
+		if (Float[].class.getName().equals(type)) {
+			List<String> out = getList(fields, STRING_VALUE_MARK, STRING_VALUE_ELEMENT_MARK);
+			List<Float> result = new ArrayList<>();
+			out.forEach(v -> result.add(Float.parseFloat(v)));
+			return result.toArray(new Float[0]);
+		}
+		
+		if (Long.class.getName().equals(type)) {
+			return Long.parseLong(getString(fields, STRING_VALUE_MARK));
+		}
+		
+		if (Long[].class.getName().equals(type)) {
+			List<String> out = getList(fields, STRING_VALUE_MARK, STRING_VALUE_ELEMENT_MARK);
+			List<Long> result = new ArrayList<>();
+			out.forEach(v -> result.add(Long.parseLong(v)));
+			return result.toArray(new Long[0]);
+		}
+		
+		if (Boolean.class.getName().equals(type)) {
+			return getBoolean(fields, STRING_VALUE_MARK);
+		}
+		
+		if (Boolean[].class.getName().equals(type)) {
+			List<String> out = getList(fields, STRING_VALUE_MARK, STRING_VALUE_ELEMENT_MARK);
+			List<Boolean> result = new ArrayList<>();
+			out.forEach(v -> result.add(Boolean.parseBoolean(v)));
+			return result.toArray(new Boolean[0]);
+		}
+		
+		if (FPR.class.getName().equals(type)) {
+			return FPR.parseFPR(getString(fields, STRING_VALUE_MARK));
+		}
+		
+		if (FPR[].class.getName().equals(type)) {
+			List<String> out = getList(fields, STRING_VALUE_MARK, STRING_VALUE_ELEMENT_MARK);
+			List<FPR> result = new ArrayList<>();
+			out.forEach(v -> result.add(FPR.parseFPR(v)));
+			return result.toArray(new FPR[0]);
+		}
+		
+		if (String.class.getName().equals(type)) {
+			return getString(fields, STRING_VALUE_MARK);
+		}
+		
+		if (String[].class.getName().equals(type)) {
+			List<String> out = getList(fields, STRING_VALUE_MARK, STRING_VALUE_ELEMENT_MARK);
+			return out.toArray(new String[0]);
+		}
+		
+		return null;
+	}
+
+	@Override
+	public String convertToString(Object parameterValue) throws ParameterValueConverterHelperException {
+		String type = null;
+		String stringValue = null;
+		if (parameterValue == null) {
+			type = marker(TYPE_MARK);
+			stringValue = marker(STRING_VALUE_MARK);
+		}
+
+		if (parameterValue instanceof Integer) {
+			type = marker(Integer.class.getName(), TYPE_MARK);
+			stringValue = marker(Integer.toString((Integer) parameterValue), STRING_VALUE_MARK);
+		}
+
+		if (parameterValue instanceof Integer[]) {
+			List<String> out = new ArrayList<>();
+			Arrays.stream((Integer[]) parameterValue).forEach(v -> out.add(Integer.toString(v)));
+			type = marker(Integer[].class.getName(), TYPE_MARK);
+			stringValue = markList(out, STRING_VALUE_MARK, STRING_VALUE_ELEMENT_MARK);
+		}
+
+		if (parameterValue instanceof Double) {
+			type = marker(Double.class.getName(), TYPE_MARK);
+			stringValue = marker(Double.toString((Double) parameterValue), STRING_VALUE_MARK);
+		}
+
+		if (parameterValue instanceof Double[]) {
+			List<String> out = new ArrayList<>();
+			Arrays.stream((Double[]) parameterValue).forEach(v -> out.add(Double.toString(v)));
+			type = marker(Double[].class.getName(), TYPE_MARK);
+			stringValue = markList(out, STRING_VALUE_MARK, STRING_VALUE_ELEMENT_MARK);
+		}
+
+		if (parameterValue instanceof Float) {
+			type = marker(Float.class.getName(), TYPE_MARK);
+			stringValue = marker(Float.toString((Float) parameterValue), STRING_VALUE_MARK);
+		}
+
+		if (parameterValue instanceof Float[]) {
+			List<String> out = new ArrayList<>();
+			Arrays.stream((Float[]) parameterValue).forEach(v -> out.add(Float.toString(v)));
+			type = marker(Float[].class.getName(), TYPE_MARK);
+			stringValue = markList(out, STRING_VALUE_MARK, STRING_VALUE_ELEMENT_MARK);
+		}
+
+		if (parameterValue instanceof Long) {
+			type = marker(Long.class.getName(), TYPE_MARK);
+			stringValue = marker(Long.toString((Long) parameterValue), STRING_VALUE_MARK);
+		}
+
+		if (parameterValue instanceof Long[]) {
+			List<String> out = new ArrayList<>();
+			Arrays.stream((Long[]) parameterValue).forEach(v -> out.add(Long.toString(v)));
+			type = marker(Long[].class.getName(), TYPE_MARK);
+			stringValue = markList(out, STRING_VALUE_MARK, STRING_VALUE_ELEMENT_MARK);
+		}
+
+		if (parameterValue instanceof Boolean) {
+			type = marker(Boolean.class.getName(), TYPE_MARK);
+			stringValue = marker(Boolean.toString((Boolean) parameterValue), STRING_VALUE_MARK);
+		}
+
+		if (parameterValue instanceof Boolean[]) {
+			List<String> out = new ArrayList<>();
+			Arrays.stream((Boolean[]) parameterValue).forEach(v -> out.add(Boolean.toString(v)));
+			type = marker(Boolean[].class.getName(), TYPE_MARK);
+			stringValue = markList(out, STRING_VALUE_MARK, STRING_VALUE_ELEMENT_MARK);
+		}
+
+		if (parameterValue instanceof FPR) {
+			type = marker(FPR.class.getName(), TYPE_MARK);
+			stringValue = marker(((FPR) parameterValue).toString(), STRING_VALUE_MARK);
+		}
+
+		if (parameterValue instanceof FPR[]) {
+			List<String> out = new ArrayList<>();
+			Arrays.stream((FPR[]) parameterValue).forEach(v -> out.add(((FPR) v).toString()));
+			type = marker(FPR[].class.getName(), TYPE_MARK);
+			stringValue = markList(out, STRING_VALUE_MARK, STRING_VALUE_ELEMENT_MARK);
+		}
+
+		if (parameterValue instanceof String) {
+			type = marker(String.class.getName(), TYPE_MARK);
+			stringValue = marker((String) parameterValue, STRING_VALUE_MARK);
+		}
+
+		if (parameterValue instanceof String[]) {
+			List<String> out = new ArrayList<>();
+			Arrays.stream((String[]) parameterValue).forEach(v -> out.add(v));
+			type = marker(String[].class.getName(), TYPE_MARK);
+			stringValue = markList(out, STRING_VALUE_MARK, STRING_VALUE_ELEMENT_MARK);
+		}
+		
+		return marker(new String[] { type, stringValue }, ID_MARK);
+	}
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/definition/ConsensusModelRegistry.java

@@ -0,0 +1,100 @@
+package afryca.consensusmodel.definition;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import org.eclipse.core.runtime.IConfigurationElement;
+
+import afryca.consensusmodel.variable.definition.EVariableElements;
+import afryca.consensusmodel.variable.definition.VariableRegistry;
+
+/**
+ * Registry for the extension point of Consensus Model
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class ConsensusModelRegistry {
+
+	private IConfigurationElement configuration;
+	private Map<String, VariableRegistry> variables;
+
+	/**
+	 * Default builder
+	 */
+	private ConsensusModelRegistry() {
+		configuration = null;
+		variables = new LinkedHashMap<>();
+	}
+
+	/**
+	 * Builder
+	 * 
+	 * @param element
+	 *            ConsensusModel configuration element
+	 */
+	public ConsensusModelRegistry(IConfigurationElement element) {
+		this();
+		configuration = element;
+		loadVariables();
+	}
+
+	/**
+	 * Return consensus model configuration
+	 * 
+	 * @return Consensus model configuration
+	 */
+	public IConfigurationElement getConfiguration() {
+		return configuration;
+	}
+
+	/**
+	 * Return Consensus model element value
+	 * 
+	 * @param element
+	 *            element key
+	 * @return element value
+	 */
+	public String getElement(EElements element) {
+
+		String result = null;
+
+		if (configuration != null) {
+			result = configuration.getAttribute(element.toString());
+		}
+
+		return result;
+	}
+
+	private void loadVariables() {
+		IConfigurationElement[] configurations = configuration.getChildren();
+		VariableRegistry registry;
+
+		for (IConfigurationElement configuration : configurations) {
+			registry = new VariableRegistry(configuration);
+			variables.put(registry.getElement(EVariableElements.id), registry);
+		}
+	}
+
+	
+	/**
+	 * Return all variables registers IDs
+	 * 
+	 * @return Variables registers IDs
+	 */
+	public String[] getVariablesIDs() {
+		return variables.keySet().toArray(new String[0]);
+	}
+	
+
+	/**
+	 * Return a VariableRegistry
+	 * 
+	 * @param ID
+	 *            ID of the VariableRegistry
+	 * @return VariableRegistry
+	 */
+	public VariableRegistry getVariableRegistry(String ID) {
+		return variables.get(ID);
+	}
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/definition/EElements.java

@@ -0,0 +1,37 @@
+package afryca.consensusmodel.definition;
+
+/**
+ * Consensus model elements
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public enum EElements {
+
+	// Consensus model id
+	id,
+
+	// Consensus model class
+	ConsensusModel,
+
+	// Consensus model name
+	Name,
+
+	// Consensus model information
+	Information,
+
+	// Consensus model main features
+	MainFeatures,
+
+	// Consensus model observations
+	Observations,
+
+	// Consensus model uses feedback
+	WithFeedback,
+	
+	// Structure
+	Structure,
+	
+	//Multicriteria
+	Multicriteria
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/definition/EResultElements.java

@@ -0,0 +1,62 @@
+package afryca.consensusmodel.definition;
+
+/**
+ * Results elements
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public enum EResultElements {
+
+	// Selected consensus model
+	consensus_model,
+
+	// Number of experts
+	number_of_experts,
+
+	// Number of alternatives
+	number_of_alternatives,
+
+	// Number of criteria
+	number_of_criteria,
+	
+	// Experts
+	experts,
+
+	// Alternatives
+	alternatives,
+	
+	// Criteria
+	criteria,
+
+	// Consensus threshold
+	consensus_threshold,
+
+	// Max rounds
+	maxround,
+
+	// Initial consensus degree
+	initial_consensus_degree,
+
+	// Consensus degree achieved
+	consensus_degree_achieved,
+
+	// Number of rounds required
+	number_of_rounds_required,
+
+	// Ranking of alternatives
+	ranking_of_alternatives,
+	
+	// Classification of alternatives
+	classification_of_alternatives,
+
+	// Solution set of alternatives
+	solution_set_of_alternatives,
+
+	// Preferences
+	preferences,
+
+	// Rounds results
+	rounds_results;
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/definition/ERoundResult.java

@@ -0,0 +1,47 @@
+package afryca.consensusmodel.definition;
+
+/**
+ * Results elements
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public enum ERoundResult {
+
+	// Round
+	round,
+
+	// Pre consensus degree achieved
+	pre_consensus_degree_achieved,
+
+	// Pos consensus degree achieved
+	pos_consensus_degree_achieved,
+
+	// Pre ranking of alternatives
+	pre_ranking_of_alternatives,
+
+	// Pos ranking of alternatives
+	pos_ranking_of_alternatives,
+
+	// Pre preferences
+	pre_preferences,
+
+	// Pos preferences
+	pos_preferences,
+	
+	//Pre preferences group for visualization
+	pre_preferencesGroupVisualization,
+	
+	//Pos preferences group for visualization
+	pos_preferencesGroupVisualization,
+
+	// Number of advices
+	advices,
+	
+	//Clusters
+	clusters,
+	
+	//HPR preferences (Rodriguez 20017 consensus model)
+	hprs;
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/l10n/Messages.java

@@ -0,0 +1,23 @@
+package afryca.consensusmodel.l10n;
+
+/**
+ * Localization messages
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class Messages {
+	public String alternatives_description;
+	public String command_executed;
+	public String consensus_model_configuration_updated;
+	public String consensus_model_selected_x;
+	public String criteria_description;
+	public String experts_description;
+	public String invalid_arguments;
+	public String preferences_x_flush_fail;
+	public String preferences_description;
+	public String with_feedback_consensus_model_loaded_x;
+	public String without_feedback_consensus_model_loaded_x;
+	public String wrong_file;
+	public String x_defined_consensus_models;
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/l10n/Messages.properties

@@ -0,0 +1,14 @@
+alternatives_description=Alternatives
+command_can_executed_result={0} can be executed? {1}
+command_executed={0} executed
+consensus_model_configuration_updated=Consensus model configuration updated
+consensus_model_selected_x=Consensus model selected: {0}
+criteria_description=Criteria
+experts_description=Experts
+invalid_arguments=Invalid arguments
+preferences_description=Experts' preferences
+preferences_x_flush_fail=Preferences ''{0}'' flush fail
+with_feedback_consensus_model_loaded_x=With feedback consensus model loaded: {0}
+without_feedback_consensus_model_loaded_x=Without feedback consensus model loaded: {0}
+wrong_file=wrong file
+x_defined_consensus_models={0} defined consensus models

plugins/afryca.consensusmodel/src/afryca/consensusmodel/l10n/Messages_es.properties

@@ -0,0 +1,14 @@
+alternatives_description=Alternativas
+command_can_executed_result=¿{0} puede ser ejecutado? {1}
+command_executed={0} ejecutado
+consensus_model_configuration_updated=Configuración de modelo de consenso actualizada
+consensus_model_selected_x=Modelo de consenso seleccionado: {0}
+criteria_description=Criterios
+experts_description=Expertos
+invalid_arguments=Argumentos inválidos
+preferences_description=Preferencias de los expertos
+preferences_x_flush_fail=El guardado de las preferencias ''{0}'' falló
+with_feedback_consensus_model_loaded_x=Modelo de consenso con generación de recomendaciones cargado: {0}
+without_feedback_consensus_model_loaded_x=Modelo de consenso sin generación de recomendaciones cargado: {0}
+wrong_file=archivo inválido
+x_defined_consensus_models={0} modelos de consenso definidos

plugins/afryca.consensusmodel/src/afryca/consensusmodel/preferences/PreferenceConstants.java

@@ -0,0 +1,18 @@
+package afryca.consensusmodel.preferences;
+
+/**
+ * Preference constants
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public interface PreferenceConstants {
+	public static final String NODEPATH = "afryca.consensusmodel"; //$NON-NLS-1$
+	public static final String EPSILON = "epsilon.consensusmodel.value"; //$NON-NLS-1$
+	public static final String FUZZINESS = "fuzziness.consensusmodel.value"; //$NON-NLS-1$
+	public static final String EPSILON_HONGBIN = "epsilonhongbin.consensusmodel.value"; //$NON-NLS-1$
+	public static final String COST_HONGBIN = "costhongbin.consensusmodel.value"; //$NON-NLS-1$
+	public static final String WEIGHT_HONGBIN = "weighthongbin.consensusmodel.value"; //$NON-NLS-1$
+	public static final String MEASUREMENT_HONGBIN = "measurementhongbin.consensusmodel.value"; //$NON-NLS-1$
+	public static final String CONSTANT_K = "khongbin.consensusmodel.value"; //$NON-NLS-1$
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/provider/IConfigurationProvider.java

@@ -0,0 +1,25 @@
+package afryca.consensusmodel.provider;
+
+import java.util.Map;
+
+import afryca.consensusmodel.Configuration;
+
+/**
+ * Configuration provider
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public interface IConfigurationProvider {
+
+	/**
+	 * Generate configuration using map of values
+	 * 
+	 * @param file
+	 *            Configuration file name
+	 * @param values
+	 *            Map of values
+	 * @return Generated configuration
+	 */
+	Configuration createConfiguration(String file, Map<String, String> values);
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/provider/IConsensusModelProvider.java

@@ -0,0 +1,31 @@
+package afryca.consensusmodel.provider;
+
+import afryca.consensusmodel.ConsensusModel;
+
+/**
+ * Consensus model provider
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public interface IConsensusModelProvider {
+
+	/**
+	 * Get consensus model
+	 * 
+	 * @param consensusModelId
+	 *            Consensus model id
+	 * @return Consensus model
+	 */
+	ConsensusModel getConsensusModel(String consensusModelId);
+
+	/**
+	 * Return consensus model
+	 * 
+	 * @param consensusModelId
+	 *            Consensus model id
+	 * @return Consensus model
+	 */
+	ConsensusModel createConsensusModel(String consensusModelId);
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/provider/IVariablesProvider.java

@@ -0,0 +1,30 @@
+package afryca.consensusmodel.provider;
+
+import afryca.consensusmodel.Variables;
+
+/**
+ * Variables provider
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public interface IVariablesProvider {
+
+	/**
+	 * Return consensus model variables
+	 * 
+	 * @param consensusModelId
+	 *            Consensus model id
+	 * @return Consensus model variables
+	 */
+	Variables getVariables(String consensusModelId);
+
+	/**
+	 * Create consensus model variables
+	 * 
+	 * @param consensusModelId
+	 *            Consensus model id
+	 * @return Consensus model variables
+	 */
+	Variables createVariables(String consensusModelId);
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/provider/internal/ConfigurationDefaultProvider.java

@@ -0,0 +1,83 @@
+package afryca.consensusmodel.provider.internal;
+
+import java.util.Map;
+
+import javax.inject.Inject;
+
+import org.eclipse.e4.core.contexts.IEclipseContext;
+import org.eclipse.e4.ui.model.application.MApplication;
+
+import afryca.consensusmodel.Configuration;
+import afryca.consensusmodel.ConsensusModel;
+import afryca.consensusmodel.Variables;
+import afryca.consensusmodel.provider.IConfigurationProvider;
+import afryca.consensusmodel.provider.IConsensusModelProvider;
+import afryca.consensusmodel.service.IConsensusModelService;
+import afryca.consensusmodel.variable.Variable;
+import afryca.consensusmodel.variable.definition.EVariableTypes;
+
+/**
+ * Configuration default provider
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class ConfigurationDefaultProvider implements IConfigurationProvider {
+
+	@Inject
+	private IConsensusModelProvider consensusModelProvider;
+	
+	@Inject
+	private IEclipseContext context;
+
+	@Override
+	public Configuration createConfiguration(String file, Map<String, String> values) {
+		Configuration configuration = parseConfiguration(values);
+		if (configuration != null) {
+			configuration.setFile(file);
+		}
+		return configuration;
+	}
+
+	private Configuration parseConfiguration(Map<String, String> values) {
+		String selection = getConsensusModelService().getSelection();
+		if ((selection != null) && (values != null)) {
+			ConsensusModel consensusModel = consensusModelProvider.getConsensusModel(selection);
+			if(consensusModel!=null){
+				Variables variables = consensusModel.getVariables();
+				Configuration configuration = new Configuration();
+				configuration.setConsensusModel(selection);
+	
+				String value;
+				EVariableTypes type;
+				boolean isArray;
+				Variable variable;
+				for (String variableId : variables.getVariablesIDs()) {
+					variable = variables.getVariable(variableId);
+					value = values.get(variableId);
+					type = variable.getType();
+					isArray = variable.getIsArray();
+					try {
+						configuration.setValue(variableId, type, value, isArray);
+					} catch (Exception e) {
+						configuration.setValue(variableId, type, null, isArray);
+					}
+				}
+				return configuration;
+			}
+		} else {
+			return null;
+		}
+		return null;
+	}
+	
+	private IConsensusModelService getConsensusModelService() {
+		return getApplicationContext().get(IConsensusModelService.class);
+	}
+
+	private IEclipseContext getApplicationContext() {
+		MApplication application = context.get(MApplication.class);
+		return application.getContext();
+	}
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/provider/internal/ConfigurationProviderContextFunction.java

@@ -0,0 +1,27 @@
+package afryca.consensusmodel.provider.internal;
+
+import org.eclipse.e4.core.contexts.ContextFunction;
+import org.eclipse.e4.core.contexts.ContextInjectionFactory;
+import org.eclipse.e4.core.contexts.IEclipseContext;
+import org.eclipse.e4.ui.model.application.MApplication;
+
+import afryca.consensusmodel.provider.IConfigurationProvider;
+
+/**
+ * Configuration provider context function
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class ConfigurationProviderContextFunction extends ContextFunction {
+	@Override
+	public Object compute(IEclipseContext context, String contextKey) {
+		IConfigurationProvider configurationProvider = ContextInjectionFactory.make(ConfigurationDefaultProvider.class,
+				context);
+		MApplication application = context.get(MApplication.class);
+		IEclipseContext applicationContext = application.getContext();
+		applicationContext.set(IConfigurationProvider.class, configurationProvider);
+		return configurationProvider;
+	}
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/provider/internal/ConsensusModelDefaultProvider.java

@@ -0,0 +1,85 @@
+package afryca.consensusmodel.provider.internal;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.annotation.PostConstruct;
+import javax.inject.Inject;
+
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.e4.core.contexts.ContextInjectionFactory;
+import org.eclipse.e4.core.contexts.IEclipseContext;
+
+import afryca.consensusmodel.ConsensusModel;
+import afryca.consensusmodel.definition.ConsensusModelRegistry;
+import afryca.consensusmodel.definition.EElements;
+import afryca.consensusmodel.provider.IConsensusModelProvider;
+import afryca.consensusmodel.provider.IVariablesProvider;
+import afryca.consensusmodel.service.IConsensusModelService;
+
+/**
+ * ConsensusModelProvider default implementation
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class ConsensusModelDefaultProvider implements IConsensusModelProvider {
+
+	@Inject
+	private IConsensusModelService consensusModelService;
+
+	@Inject
+	private IVariablesProvider variablesProvider;
+
+	@Inject
+	private IEclipseContext context;
+
+	private Map<String, ConsensusModel> templates;
+
+	@PostConstruct
+	private void initialize() {
+		templates = new HashMap<>();
+	}
+
+	@Override
+	public ConsensusModel getConsensusModel(String consensusModelId) {
+		ConsensusModel result = templates.get(consensusModelId);
+		if (result == null) {
+			result = createConsensusModelTemplate(consensusModelId);
+			templates.put(consensusModelId, result);
+		}
+		return result;
+	}
+
+	private ConsensusModel createConsensusModelTemplate(String consensusModelId) {
+		ConsensusModel result = buildConsensusModel(consensusModelId);
+		if (result != null) {
+			result.setVariables(variablesProvider.getVariables(consensusModelId));
+		}
+		return result;
+	}
+
+	private ConsensusModel buildConsensusModel(String consensusModelId) {
+		ConsensusModel result = null;
+		try {
+			ConsensusModelRegistry consensusModelRegistry = consensusModelService.getRegistry(consensusModelId);
+			IConfigurationElement configuration = consensusModelRegistry.getConfiguration();
+			String className = EElements.ConsensusModel.toString();
+			result = (ConsensusModel) configuration.createExecutableExtension(className);
+			ContextInjectionFactory.inject(result, context);
+		} catch (Exception e) {
+			result = null;
+		}
+		return result;
+	}
+
+	@Override
+	public ConsensusModel createConsensusModel(String consensusModelId) {
+		ConsensusModel result = buildConsensusModel(consensusModelId);
+		if (result != null) {
+			result.setVariables(variablesProvider.getVariables(consensusModelId));
+		}
+		return result;
+	}
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/provider/internal/ConsensusModelProviderContextFunction.java

@@ -0,0 +1,28 @@
+package afryca.consensusmodel.provider.internal;
+
+import org.eclipse.e4.core.contexts.ContextFunction;
+import org.eclipse.e4.core.contexts.ContextInjectionFactory;
+import org.eclipse.e4.core.contexts.IEclipseContext;
+import org.eclipse.e4.ui.model.application.MApplication;
+
+import afryca.consensusmodel.provider.IConsensusModelProvider;
+
+/**
+ * Consensus model provider context function
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class ConsensusModelProviderContextFunction extends ContextFunction {
+	@Override
+	public Object compute(IEclipseContext context, String contextKey) {
+		IConsensusModelProvider consensusModelProvider = ContextInjectionFactory.make(
+				ConsensusModelDefaultProvider.class,
+				context);
+		MApplication application = context.get(MApplication.class);
+		IEclipseContext applicationContext = application.getContext();
+		applicationContext.set(IConsensusModelProvider.class, consensusModelProvider);
+		return consensusModelProvider;
+	}
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/provider/internal/VariablesDefaultProvider.java

@@ -0,0 +1,85 @@
+package afryca.consensusmodel.provider.internal;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.annotation.PostConstruct;
+import javax.inject.Inject;
+
+import org.eclipse.e4.core.contexts.ContextInjectionFactory;
+import org.eclipse.e4.core.contexts.EclipseContextFactory;
+import org.eclipse.e4.core.contexts.IEclipseContext;
+
+import afryca.consensusmodel.Variables;
+import afryca.consensusmodel.definition.ConsensusModelRegistry;
+import afryca.consensusmodel.provider.IVariablesProvider;
+import afryca.consensusmodel.service.IConsensusModelService;
+import afryca.consensusmodel.variable.Variable;
+import afryca.consensusmodel.variable.definition.VariableRegistry;
+import afryca.gdmp.service.IGDMPService;
+
+/**
+ * IVariablesProvider default implementation
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class VariablesDefaultProvider implements IVariablesProvider {
+
+	@Inject
+	private IConsensusModelService consensusModelService;
+	
+	@Inject
+	private IGDMPService gdmpService;
+
+	@Inject
+	private IEclipseContext context;
+
+	private Map<String, Variables> templates;
+
+	@PostConstruct
+	private void initialize() {
+		templates = new HashMap<>();
+	}
+
+	@Override
+	public Variables getVariables(String consensusModelId) {
+		Variables result = templates.get(consensusModelId);
+		if (result == null) {
+			result = createVariablesTemplate(consensusModelId);
+			templates.put(consensusModelId, result);
+		}
+		return result;
+	}
+	
+	private Variables createVariablesTemplate(String consensusModelId) {
+		ConsensusModelRegistry consensusModelRegistry = consensusModelService.getRegistry(consensusModelId);
+		Variables variables = new Variables();
+		Arrays.stream(consensusModelRegistry.getVariablesIDs())
+				.map(consensusModelRegistry::getVariableRegistry)
+				.forEach(variableRegistry -> addVariable(variables, variableRegistry));
+		return variables;
+	}
+
+	private void addVariable(Variables variables, VariableRegistry variableRegistry) {
+		IEclipseContext staticContext = EclipseContextFactory.create();
+		injectAndSetInContext(variableRegistry, staticContext);
+		staticContext.set(IConsensusModelService.class, consensusModelService);
+		staticContext.set(IGDMPService.class, gdmpService);
+		Variable variable = ContextInjectionFactory.make(Variable.class, context, staticContext);
+		staticContext.dispose();
+		variables.addVariable(variable);
+	}
+
+	private void injectAndSetInContext(Object element, IEclipseContext context) {
+		ContextInjectionFactory.inject(element, context);
+		context.set(element.getClass().getName(), element);
+	}
+
+	@Override
+	public Variables createVariables(String consensusModelId) {
+		return getVariables(consensusModelId).copy();
+	}
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/provider/internal/VariablesProviderContextFunction.java

@@ -0,0 +1,27 @@
+package afryca.consensusmodel.provider.internal;
+
+import org.eclipse.e4.core.contexts.ContextFunction;
+import org.eclipse.e4.core.contexts.ContextInjectionFactory;
+import org.eclipse.e4.core.contexts.IEclipseContext;
+import org.eclipse.e4.ui.model.application.MApplication;
+
+import afryca.consensusmodel.provider.IVariablesProvider;
+
+/**
+ * Variables provider context function
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class VariablesProviderContextFunction extends ContextFunction {
+	@Override
+	public Object compute(IEclipseContext context, String contextKey) {
+		IVariablesProvider variablesProvider = ContextInjectionFactory.make(VariablesDefaultProvider.class,
+				context);
+		MApplication application = context.get(MApplication.class);
+		IEclipseContext applicationContext = application.getContext();
+		applicationContext.set(IVariablesProvider.class, variablesProvider);
+		return variablesProvider;
+	}
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/service/IConsensusModelService.java

@@ -0,0 +1,123 @@
+package afryca.consensusmodel.service;
+
+import java.util.Map;
+
+import afryca.consensusmodel.Configuration;
+import afryca.consensusmodel.definition.ConsensusModelRegistry;
+
+/**
+ * Consensus model service interface
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public interface IConsensusModelService {
+
+	public static final String CONTEXT = "consensus.model.service.context"; //$NON-NLS-1$
+	public static final String CONFIGURATIONS = "consensus.model.service.configurations"; //$NON-NLS-1$
+
+	// Selected consensus model
+	public static final String SELECTED_CONSENSUS_MODEL = "SELECTED CONSENSUS MODEL"; //$NON-NLS-1$
+
+	/**
+	 * Return all registers id
+	 * 
+	 * @return Registers id
+	 */
+	String[] getIds();
+
+	/**
+	 * Return all registers id of consensus models that uses feedback
+	 * 
+	 * @return Registers id of consensus models that uses feedback
+	 */
+	String[] getWithFeedbackConsensusModelsIds();
+
+	/**
+	 * Return all registers id of consensus models that not uses feedback
+	 * 
+	 * @return Registers id of consensus models that not uses feedback
+	 */
+	String[] getWithoutFeedbackConsensusModelsIds();
+	
+	/**
+	 * Return the structure supported by the consensus model
+	 * @param name
+	 *            Name of the ConsensusModelRegistry
+	 * @return id of the structure supported by the consensus model
+	 */
+	String getSupportedStructure(String name);
+	
+	/**
+	 * Return if consensus model supports multicriteria
+	 * @param name
+	 *            Name of the ConsensusModelRegistry
+	 * @return true/false if consensus model supports multicriteria
+	 */
+	boolean getSupportedMulticriteria(String name);
+	
+	/**
+	 * Return a ConsensusModelRegistry
+	 * 
+	 * @param id
+	 *            Id of the ConsensusModelRegistry
+	 * @return ConsensusModelRegistry
+	 */
+	ConsensusModelRegistry getRegistry(String id);
+
+	/**
+	 * Set consensus model selection id
+	 * 
+	 * @param id
+	 *            Consensus model selection id
+	 */
+	void setSelection(String id);
+
+	/**
+	 * Return consensus model selection id
+	 * 
+	 * @return Consensus model selection id
+	 */
+	String getSelection();
+
+	/**
+	 * Return configurations
+	 * 
+	 * @return Configurations
+	 */
+	public Map<String, Configuration> getConfigurations();
+
+	/**
+	 * Set consensus model configuration
+	 * 
+	 * @param configuration
+	 *            Consensus model configuration
+	 */
+	void setConfiguration(Configuration configuration);
+
+	/**
+	 * Return current configuration
+	 * 
+	 * @return current configuration
+	 */
+	Configuration getConfiguration();
+
+	/**
+	 * Set consensus model default configuration
+	 * 
+	 * @param configuration
+	 *            Consensus model default configuration
+	 */
+	void setDefaultConfiguration(String id, Configuration configuration);
+	
+	/**
+	 * Return default configuration
+	 * 
+	 * @param id
+	 * 			Consensus model id
+	 * 
+	 * @return default configuration
+	 */
+	Configuration getDefaultConfiguration(String id);
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/service/events/IConsensusModelServiceEvents.java

@@ -0,0 +1,29 @@
+package afryca.consensusmodel.service.events;
+
+import afryca.consensusmodel.definition.EElements;
+
+/**
+ * IConsensusModelService events
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ * 
+ * @noimplement Only used for constant definition
+ */
+public interface IConsensusModelServiceEvents {
+	String TOPIC_BASE = "CONSENSUS_MODELS"; //$NON-NLS-1$
+	
+	String CONSENSUS_MODEL_GROUP_UPDATES = TOPIC_BASE + "/GROUP_UPDATES"; //$NON-NLS-1$
+	
+	String TOPIC_CONSENSUS_MODEL = "CONSENSUS_MODEL"; //$NON-NLS-1$
+
+	String CONSENSUS_MODELS_ALL = TOPIC_BASE + "/*"; //$NON-NLS-1$
+
+	String CONSENSUS_MODEL_SELECTION_UPDATED = TOPIC_BASE + "/" + TOPIC_CONSENSUS_MODEL + "/SELECTION"; //$NON-NLS-1$ //$NON-NLS-2$
+	String CONSENSUS_MODEL_CONFIGURATION_UPDATED = TOPIC_BASE + "/" + TOPIC_CONSENSUS_MODEL + "/CONFIGURATION"; //$NON-NLS-1$ //$NON-NLS-2$
+	
+	String CONSENSUS_MODELS_UPDATED = TOPIC_BASE + "/UPDATED"; //$NON-NLS-1$
+
+	String FIELD_ID = EElements.id.name();
+	String FIELD_GROUPED = "grouped"; //$NON-NLS-1$
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/service/provider/ConsensusModelServiceContextFunction.java

@@ -0,0 +1,27 @@
+package afryca.consensusmodel.service.provider;
+
+import org.eclipse.e4.core.contexts.ContextFunction;
+import org.eclipse.e4.core.contexts.ContextInjectionFactory;
+import org.eclipse.e4.core.contexts.IEclipseContext;
+import org.eclipse.e4.ui.model.application.MApplication;
+
+import afryca.consensusmodel.service.IConsensusModelService;
+
+/**
+ * Consensus model service context function
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class ConsensusModelServiceContextFunction extends ContextFunction {
+	@Override
+	public Object compute(IEclipseContext context, String contextKey) {
+		IConsensusModelService consensusModelService = ContextInjectionFactory.make(ConsensusModelServiceProvider.class,
+				context);
+		MApplication application = context.get(MApplication.class);
+		IEclipseContext applicationContext = application.getContext();
+		applicationContext.set(IConsensusModelService.class, consensusModelService);
+		return consensusModelService;
+	}
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/service/provider/ConsensusModelServiceProvider.java

@@ -0,0 +1,316 @@
+package afryca.consensusmodel.service.provider;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.annotation.PostConstruct;
+import javax.inject.Inject;
+import javax.inject.Named;
+
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.IExtensionRegistry;
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.e4.core.contexts.IEclipseContext;
+import org.eclipse.e4.core.di.annotations.Optional;
+import org.eclipse.e4.core.services.events.IEventBroker;
+import org.eclipse.e4.core.services.log.ILoggerProvider;
+import org.eclipse.e4.core.services.log.Logger;
+import org.eclipse.e4.core.services.nls.Translation;
+import org.eclipse.e4.ui.model.application.MApplication;
+import org.eclipse.e4.ui.workbench.UIEvents;
+
+import afryca.consensusmodel.Configuration;
+import afryca.consensusmodel.ConsensusModel;
+import afryca.consensusmodel.definition.ConsensusModelRegistry;
+import afryca.consensusmodel.definition.EElements;
+import afryca.consensusmodel.l10n.Messages;
+import afryca.consensusmodel.provider.IConfigurationProvider;
+import afryca.consensusmodel.provider.IConsensusModelProvider;
+import afryca.consensusmodel.provider.IVariablesProvider;
+import afryca.consensusmodel.service.IConsensusModelService;
+import afryca.consensusmodel.service.events.IConsensusModelServiceEvents;
+import afryca.gdmp.GDMP;
+
+/**
+ * Consensus model service provider
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+@SuppressWarnings("restriction")
+public class ConsensusModelServiceProvider implements IConsensusModelService {
+
+	private Logger logger;
+
+	private Map<String, Configuration> configurations;
+	private Map<String, Configuration> defaultConfigurations;
+
+	private boolean groupUpdates;
+	private boolean needEnablementUpdate;
+
+	private Map<String, ConsensusModelRegistry> registers;
+	private Map<String, ConsensusModelRegistry> withFeedback;
+	private Map<String, ConsensusModelRegistry> withoutFeedback;
+
+	@Inject
+	private IEclipseContext context;
+	
+	@Inject
+	@Optional
+	private GDMP gdmp;
+
+	@Inject
+	@Translation
+	private Messages messages;
+
+	@Inject
+	private IEventBroker eventBroker;
+
+	@Inject
+	public void instantiateLogger(ILoggerProvider loggerProvider) {
+		logger = loggerProvider.getClassLogger(this.getClass());
+	}
+
+	@Inject
+	private void setConfigurations(@Optional @Named(CONFIGURATIONS) Map<String, Configuration> configurations) {
+		this.configurations = configurations;
+	}
+
+	@Inject
+	public ConsensusModelServiceProvider() {
+		registers = new HashMap<>();
+		withFeedback = new HashMap<>();
+		withoutFeedback = new HashMap<>();
+		groupUpdates = false;
+		needEnablementUpdate = false;
+		defaultConfigurations = new HashMap<>();
+	}
+
+	@PostConstruct
+	private void initialize() {
+		loadProviders();
+		loadRegisters();
+		setEclipseContext();
+	}
+
+	private void loadProviders() {
+		// It's not set until @PostConstruct does not end
+		context.set(IConsensusModelService.class, this);
+
+		// Force providers' context function invoked in this context
+		context.get(IVariablesProvider.class);
+		context.get(IConsensusModelProvider.class);
+		context.get(IConfigurationProvider.class);
+	}
+
+	private void loadRegisters() {
+		IExtensionRegistry extensionRegistry = Platform.getExtensionRegistry();
+		IConfigurationElement[] extensionElements = extensionRegistry
+				.getConfigurationElementsFor(ConsensusModel.EXTENSION_POINT);
+		logger.info(messages.x_defined_consensus_models, extensionElements.length);
+		Arrays.stream(extensionElements).forEach(this::loadRegistry);
+		eventBroker.post(IConsensusModelServiceEvents.CONSENSUS_MODELS_UPDATED, new HashMap<String, String>());
+	}
+
+	private void loadRegistry(IConfigurationElement extensionElement) {
+		ConsensusModelRegistry registry = new ConsensusModelRegistry(extensionElement);
+		registers.put(registry.getElement(EElements.id), registry);
+
+		String id = registry.getElement(EElements.id);
+		String withFeedbackValue = registry.getElement(EElements.WithFeedback);
+		boolean isWithFeedback = (withFeedbackValue != null) ? Boolean.parseBoolean(withFeedbackValue) : false;
+		if (isWithFeedback) {
+			withFeedback.put(id, registry);
+			logger.info(messages.with_feedback_consensus_model_loaded_x, id);
+		} else {
+			withoutFeedback.put(id, registry);
+			logger.info(messages.without_feedback_consensus_model_loaded_x, id);
+		}
+	}
+
+	private void setEclipseContext() {
+		adaptContextForTracking();
+		getApplicationContext().set(CONTEXT, context);
+	}
+
+	private void adaptContextForTracking() {
+		context.declareModifiable(CONFIGURATIONS);
+	}
+
+	@Override
+	public String[] getIds() {
+		return registers.keySet().toArray(new String[0]);
+	}
+
+	@Override
+	public String[] getWithFeedbackConsensusModelsIds() {
+		return withFeedback.keySet().toArray(new String[0]);
+	}
+
+	@Override
+	public String[] getWithoutFeedbackConsensusModelsIds() {
+		return withoutFeedback.keySet().toArray(new String[0]);
+	}
+
+	@Override
+	public ConsensusModelRegistry getRegistry(String id) {
+		return registers.get(id);
+	}
+
+	@Override
+	public String getSupportedStructure(String element) {
+		for(String id: registers.keySet()) {
+			if(id.equals(element) || registers.get(id).getElement(EElements.Name).equals(element)) {
+				return registers.get(id).getElement(EElements.Structure);
+			}
+		}
+		return null;
+	}
+	
+	@Override
+	public boolean getSupportedMulticriteria(String element) {
+		for(String id: registers.keySet()) {
+			if(id.equals(element) || registers.get(id).getElement(EElements.Name).equals(element)) {
+				return Boolean.parseBoolean(registers.get(id).getElement(EElements.Multicriteria));
+			}
+		}
+		return false;
+	}
+	
+	@Override
+	public void setSelection(String id) {
+		if (isNewSelection(id)) {
+			doGroupUpdateStep(() -> {
+				if (getConfiguration() != null) {
+					setConfiguration(null);
+				}
+				getApplicationContext().set(SELECTED_CONSENSUS_MODEL, id);
+				logger.info(messages.consensus_model_selected_x, id);
+				eventBroker.send(IConsensusModelServiceEvents.CONSENSUS_MODEL_SELECTION_UPDATED,
+						createEventData(IConsensusModelServiceEvents.CONSENSUS_MODEL_SELECTION_UPDATED,
+								IConsensusModelServiceEvents.FIELD_ID, id));
+				needEnablementUpdate = true;
+			});
+		}
+	}
+
+	private boolean isNewSelection(String newSelection) {
+		String oldSelection = getSelection();
+		if ((oldSelection == null) && (newSelection == null)) {
+			return false;
+		}
+
+		if ((oldSelection == null) || (newSelection == null)) {
+			return true;
+		}
+
+		return (!oldSelection.equals(newSelection));
+	}
+
+	private void doGroupUpdateStep(Runnable step) {
+		if (groupUpdates) {
+			step.run();
+		} else {
+			groupUpdatesActive(true);
+			step.run();
+			groupUpdatesActive(false);
+		}
+	}
+
+	private void groupUpdatesActive(boolean active) {
+		if (groupUpdates != active) {
+			groupUpdates = active;
+			eventBroker.send(
+					IConsensusModelServiceEvents.CONSENSUS_MODEL_GROUP_UPDATES,
+					createEventData(
+							IConsensusModelServiceEvents.CONSENSUS_MODEL_GROUP_UPDATES,
+							IConsensusModelServiceEvents.FIELD_GROUPED,
+							Boolean.toString(groupUpdates)));
+			updateEnablement();
+		}
+	}
+
+	private Map<String, String> createEventData(String topic, String field, String value) {
+		Map<String, String> map = new HashMap<>();
+		map.put(IConsensusModelServiceEvents.TOPIC_BASE, topic);
+		map.put(field, value);
+		return map;
+	}
+
+	private void updateEnablement() {
+		if (!groupUpdates && needEnablementUpdate) {
+			eventBroker.send(UIEvents.REQUEST_ENABLEMENT_UPDATE_TOPIC, UIEvents.ALL_ELEMENT_ID);
+			needEnablementUpdate = false;
+		}
+	}
+
+	@Override
+	public String getSelection() {
+		try {
+			return (String) getApplicationContext().get(SELECTED_CONSENSUS_MODEL);
+		} catch (Exception e) {
+			return null;
+		}
+	}
+
+	private IEclipseContext getApplicationContext() {
+		MApplication application = context.get(MApplication.class);
+		return application.getContext();
+	}
+
+	@Override
+	public Map<String, Configuration> getConfigurations() {
+		return configurations;
+	}
+
+	@Override
+	public void setConfiguration(Configuration configuration) {
+		if (isNewConfiguration(configuration)) {
+			doGroupUpdateStep(() -> {
+				getApplicationContext().set(Configuration.class, configuration);
+				logger.info(messages.consensus_model_configuration_updated);
+				eventBroker.send(
+						IConsensusModelServiceEvents.CONSENSUS_MODEL_CONFIGURATION_UPDATED,
+						createEventData(
+								IConsensusModelServiceEvents.CONSENSUS_MODEL_CONFIGURATION_UPDATED,
+								null,
+								null));
+				needEnablementUpdate = true;
+			});
+		}
+	}
+
+	private boolean isNewConfiguration(Configuration newConfiguration) {
+		Configuration currentConfiguration = getConfiguration();
+		if ((currentConfiguration == null) && (newConfiguration == null)) {
+			return false;
+		}
+
+		if ((currentConfiguration == null) || (newConfiguration == null)) {
+			return true;
+		}
+
+		return !currentConfiguration.equals(newConfiguration);
+	}
+
+	@Override
+	public Configuration getConfiguration() {
+		try {
+			return (Configuration) getApplicationContext().get(Configuration.class);
+		} catch (Exception e) {
+			return null;
+		}
+	}
+
+	@Override
+	public void setDefaultConfiguration(String id, Configuration configuration) {
+		defaultConfigurations.put(id, configuration);
+	}
+
+	@Override
+	public Configuration getDefaultConfiguration(String id) {
+		return defaultConfigurations.get(id);
+	}
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/ArrayRelations.java

@@ -0,0 +1,46 @@
+package afryca.consensusmodel.variable;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import afryca.consensusmodel.variable.array_relation.ArrayRelation;
+
+/**
+ * Array variable's relations
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class ArrayRelations {
+
+	private Set<ArrayRelation> arrayRelations = new HashSet<>();
+
+	/**
+	 * Add array variable's relation
+	 * 
+	 * @param arrayRelation
+	 *            Relation
+	 */
+	public void addArrayRelation(ArrayRelation arrayRelation) {
+		arrayRelations.add(arrayRelation);
+	}
+
+	/**
+	 * Set array variable's relations
+	 * 
+	 * @param arrayRelations
+	 *            Set of array variable's relations
+	 */
+	public void setArrayRelations(Set<ArrayRelation> arrayRelations) {
+		this.arrayRelations = arrayRelations;
+	}
+
+	/**
+	 * Get all array variable's relations
+	 * 
+	 * @return Set of all array variable's relations
+	 */
+	public Set<ArrayRelation> getArrayRelations() {
+		return arrayRelations;
+	}
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/ArrayRestrictions.java

@@ -0,0 +1,46 @@
+package afryca.consensusmodel.variable;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import afryca.consensusmodel.variable.array_restriction.ArrayRestriction;
+
+/**
+ * Array variable's restrictions
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class ArrayRestrictions {
+
+	private Set<ArrayRestriction> arrayRestrictions = new HashSet<>();
+
+	/**
+	 * Add array variable's restriction
+	 * 
+	 * @param arrayRestriction
+	 *            Restriction
+	 */
+	public void addArrayRestriction(ArrayRestriction arrayRestriction) {
+		arrayRestrictions.add(arrayRestriction);
+	}
+
+	/**
+	 * Set array variable's restrictions
+	 * 
+	 * @param arrayRestrictions
+	 *            Set of array variable's restrictions
+	 */
+	public void setArrayRestrictions(Set<ArrayRestriction> arrayRestrictions) {
+		this.arrayRestrictions = arrayRestrictions;
+	}
+
+	/**
+	 * Get all array variable's restrictions
+	 * 
+	 * @return Set of all array variable's restrictions
+	 */
+	public Set<ArrayRestriction> getArrayRestrictions() {
+		return arrayRestrictions;
+	}
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/Relations.java

@@ -0,0 +1,46 @@
+package afryca.consensusmodel.variable;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import afryca.consensusmodel.variable.relation.Relation;
+
+/**
+ * Variable's relations
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class Relations {
+
+	private Set<Relation> relations = new HashSet<>();
+
+	/**
+	 * Add variable's relation
+	 * 
+	 * @param relation
+	 *            Relation
+	 */
+	public void addRelation(Relation relation) {
+		relations.add(relation);
+	}
+
+	/**
+	 * Set all variable's relations
+	 * 
+	 * @param relations
+	 *            Set of variable's relations
+	 */
+	public void setRelations(Set<Relation> relations) {
+		this.relations = relations;
+	}
+
+	/**
+	 * Get all variable's relations
+	 * 
+	 * @return Set of all variable's relations
+	 */
+	public Set<Relation> getRelations() {
+		return relations;
+	}
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/Restrictions.java

@@ -0,0 +1,46 @@
+package afryca.consensusmodel.variable;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import afryca.consensusmodel.variable.restriction.Restriction;
+
+/**
+ * Variable's restrictions
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class Restrictions {
+
+	private Set<Restriction> restrictions = new HashSet<>();
+
+	/**
+	 * Add variable's restriction
+	 * 
+	 * @param restriction
+	 *            Restriction
+	 */
+	public void addRestriction(Restriction restriction) {
+		restrictions.add(restriction);
+	}
+
+	/**
+	 * Set all variable's restrictions
+	 * 
+	 * @param relations
+	 *            Set of variable's restrictions
+	 */
+	public void setRestrictions(Set<Restriction> restrictions) {
+		this.restrictions = restrictions;
+	}
+
+	/**
+	 * Get all variable's restrictions
+	 * 
+	 * @return Set of all variable's restrictions
+	 */
+	public Set<Restriction> getRestrictions() {
+		return restrictions;
+	}
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/Variable.java

@@ -0,0 +1,357 @@
+package afryca.consensusmodel.variable;
+
+import javax.annotation.PostConstruct;
+import javax.inject.Inject;
+
+import org.eclipse.e4.core.contexts.ContextInjectionFactory;
+import org.eclipse.e4.core.contexts.EclipseContextFactory;
+import org.eclipse.e4.core.contexts.IEclipseContext;
+import org.eclipse.e4.core.services.nls.Translation;
+
+import afryca.consensusmodel.l10n.Messages;
+import afryca.consensusmodel.service.IConsensusModelService;
+import afryca.consensusmodel.variable.array_relation.ArrayRelation;
+import afryca.consensusmodel.variable.array_relation.definition.ArrayRelationRegistry;
+import afryca.consensusmodel.variable.array_restriction.ArrayRestriction;
+import afryca.consensusmodel.variable.array_restriction.definition.ArrayRestrictionRegistry;
+import afryca.consensusmodel.variable.definition.EVariableElements;
+import afryca.consensusmodel.variable.definition.EVariableTypes;
+import afryca.consensusmodel.variable.definition.VariableRegistry;
+import afryca.consensusmodel.variable.relation.Relation;
+import afryca.consensusmodel.variable.relation.definition.RelationRegistry;
+import afryca.consensusmodel.variable.restriction.Restriction;
+import afryca.consensusmodel.variable.restriction.definition.RestrictionRegistry;
+import afryca.gdmp.service.IGDMPService;
+
+/**
+ * Variable
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class Variable {
+
+	private String id;
+	private String description;
+	private EVariableTypes type;
+	private Object defaultValue;
+	private Object arrayDefaultElementValue;
+	private Object dialog;
+	private boolean isArray;
+	private boolean isInternal;
+	private Restrictions restrictions;
+	private Relations relations;
+	private ArrayRelations arrayRelations;
+	private ArrayRestrictions arrayRestrictions;
+	
+	@Inject
+	private VariableRegistry registry;
+	
+	@Inject
+	@Translation
+	private Messages messages;
+	
+	@Inject
+	private IEclipseContext context;
+	
+	private Variable() {
+		id = null;
+		description = null;
+		type = null;
+		defaultValue = null;
+		arrayDefaultElementValue = null;
+		dialog = null;
+		isArray = false;
+		isInternal = false;
+		restrictions = null;
+		relations = null;
+		arrayRelations = null;
+		arrayRestrictions = null;
+		registry = null;
+		messages = null;
+		context = null;
+	}
+	
+	private Variable(String id, String description, String type, String defaultValue, String arrayDefaultElementValue,
+			boolean isArray, boolean isInternal, Object dialog, Messages messages) {
+		this();
+
+		if (!validate(type, defaultValue, arrayDefaultElementValue, isArray)) {
+			throw new IllegalArgumentException(messages.invalid_arguments);
+		}
+
+		setId(id);
+		setDescription(description);
+		setType(type);
+		setIsArray(isArray);
+		setDefaultValue(defaultValue);
+		setArrayDefaultElementValue(arrayDefaultElementValue);
+		setIsInternal(isInternal);	
+		setDialog(dialog);
+
+		restrictions = new Restrictions();
+		relations = new Relations();
+		arrayRelations = new ArrayRelations();
+		arrayRestrictions = new ArrayRestrictions();
+	}
+	
+	private Variable(String id, String description, String type, String defaultValue, String arrayDefaultElementValue,
+			String isArray, String isInternal, Object dialog, Messages messages) {
+		this(id, description, type, defaultValue, arrayDefaultElementValue, Boolean.parseBoolean(isArray),
+				Boolean.parseBoolean(isInternal), dialog, messages);
+	}
+	
+	@Inject
+	public Variable(VariableRegistry registry, @Translation Messages messages) {
+		this(registry.getElement(EVariableElements.id), registry.getElement(EVariableElements.description),
+				registry.getElement(EVariableElements.type), registry.getElement(EVariableElements.default_value),
+				registry.getElement(EVariableElements.array_default_element_value),
+				registry.getElement(EVariableElements.is_array), registry.getElement(EVariableElements.is_internal),
+				registry.loadDialog(EVariableElements.dialog),
+				messages);
+	}
+
+	@PostConstruct
+	private void initialize() {
+		EVariableTypes.setConsensusServiceProvider(context.get(IConsensusModelService.class));
+		EVariableTypes.setGDMPServiceProvider(context.get(IGDMPService.class));
+		
+		registry.getRestrictionsRegisters().forEach((r) -> addRestriction(r, context));
+		registry.getRelationsRegisters().forEach((r) -> addRelation(r, context));
+		registry.getArrayRelationsRegisters().forEach((r) -> addArrayRelation(r, context));
+		registry.getArrayRestrictionsRegisters().forEach((r) -> addArrayRestriction(r, context));
+		
+		if(dialog != null)
+		injectAndSetInContext(dialog, context.createChild());
+	}
+
+	private void addRestriction(RestrictionRegistry registry, IEclipseContext context) {
+		restrictions.addRestriction(createVariableElement(Restriction.class, registry, context));
+	}
+
+	private <T> T createVariableElement(Class<T> type, Object registry, IEclipseContext context) {
+		IEclipseContext staticContext = EclipseContextFactory.create();
+		injectAndSetInContext(registry, staticContext);
+		T result = ContextInjectionFactory.make(type, context, staticContext);
+		staticContext.dispose();
+		return result;
+	}
+
+	private void injectAndSetInContext(Object element, IEclipseContext context) {
+		ContextInjectionFactory.inject(element, context);
+		context.set(element.getClass().getName(), element);
+	}
+
+	private void addRelation(RelationRegistry registry, IEclipseContext context) {
+		relations.addRelation(createVariableElement(Relation.class, registry, context));
+	}
+
+	private void addArrayRelation(ArrayRelationRegistry registry, IEclipseContext context) {
+		arrayRelations.addArrayRelation(createVariableElement(ArrayRelation.class, registry, context));
+	}
+
+	private void addArrayRestriction(ArrayRestrictionRegistry registry, IEclipseContext context) {
+		arrayRestrictions.addArrayRestriction(createVariableElement(ArrayRestriction.class, registry, context));
+	}
+
+	/**
+	 * Validate variable
+	 * 
+	 * @param type
+	 *            Type
+	 * @param defaultValue
+	 *            Default value
+	 * @param arrayDefaultElementValue
+	 *            Array default element value
+	 * @param isArray
+	 *            Is an array
+	 * @return True if variable is valid, False in other case
+	 */
+	public boolean validate(String type, String defaultValue, String arrayDefaultElementValue, boolean isArray) {
+
+		try {
+			if (isArray) {
+				if (notIsEmpty(defaultValue)) {
+					EVariableTypes.parseArray(EVariableTypes.valueOf(type), defaultValue);
+				}
+			} else {
+				if (notIsEmpty(arrayDefaultElementValue)) {
+					EVariableTypes.parseValue(EVariableTypes.valueOf(type), defaultValue, null);
+				}
+			}
+		} catch (Exception e) {
+			return false;
+		}
+
+		return true;
+	}
+
+	private static boolean notIsEmpty(String value) {
+		return (value != null) ? !value.isEmpty() : false;
+	}
+
+	private void setId(String id) {
+		this.id = id;
+	}
+
+	/**
+	 * Return identifier
+	 * 
+	 * @return Identifier
+	 */
+	public String getId() {
+		return id;
+	}
+
+	private void setDescription(String description) {
+		this.description = description;
+	}
+
+	/**
+	 * Return description
+	 * 
+	 * @return Description
+	 */
+	public String getDescription() {
+		return description;
+	}
+
+	private void setType(String type) {
+		setType(EVariableTypes.valueOf(type));
+	}
+
+	private void setType(EVariableTypes type) {
+		this.type = type;
+	}
+
+	/**
+	 * Return type
+	 * 
+	 * @return Type
+	 */
+	public EVariableTypes getType() {
+		return type;
+	}
+
+	private void setDefaultValue(String defaultValue) {
+		if (notIsEmpty(defaultValue)) {
+			this.defaultValue = (isArray) ? EVariableTypes.parseArray(type, defaultValue)
+					: EVariableTypes.parseValue(type, defaultValue, id);
+		}
+	}
+
+	/**
+	 * Return default value
+	 * 
+	 * @return Default value
+	 */
+	public Object getDefaultValue() {
+		return defaultValue;
+	}
+
+	/**
+	 * Set array default element value
+	 * 
+	 * @param arrayDefaultElementValue
+	 *            Array default element value
+	 */
+	public void setArrayDefaultElementValue(String arrayDefaultElementValue) {
+		if (notIsEmpty(arrayDefaultElementValue)) {
+			this.arrayDefaultElementValue = EVariableTypes.parseValue(type, arrayDefaultElementValue, null);
+		}
+	}
+
+	/**
+	 * Return array default element value
+	 * 
+	 * @return Array default element value
+	 */
+	public Object getArrayDefaultElementValue() {
+		return arrayDefaultElementValue;
+	}
+
+	private void setIsArray(boolean isArray) {
+		this.isArray = isArray;
+	}
+
+	/**
+	 * Return information about if the variable is an array
+	 * 
+	 * @return True if variable is an array, False in other case
+	 */
+	public boolean getIsArray() {
+		return isArray;
+	}
+
+	private void setIsInternal(boolean isInternal) {
+		this.isInternal = isInternal;
+	}
+	
+	public Object getDialog() {
+		return dialog;
+	}
+	
+	public void setDialog(Object dialog) {
+		this.dialog = dialog;
+	}
+
+	/**
+	 * Return information about if the variable is internal
+	 * 
+	 * @return True if variable is internal, False in other case
+	 */
+	public boolean getIsInternal() {
+		return isInternal;
+	}
+
+	/**
+	 * Return variable's restrictions
+	 * 
+	 * @return Variable's restrictions
+	 */
+	public Restrictions getRestrictions() {
+		return restrictions;
+	}
+
+	/**
+	 * Return variable's relations
+	 * 
+	 * @return Variable's relations
+	 */
+	public Relations getRelations() {
+		return relations;
+	}
+
+	/**
+	 * Return variable's array relations
+	 * 
+	 * @return Variable's array relations
+	 */
+	public ArrayRelations getArrayRelations() {
+		return arrayRelations;
+	}
+
+	/**
+	 * Return variable's array restrictions
+	 * 
+	 * @return Variable's array restrictions
+	 */
+	public ArrayRestrictions getArrayRestrictions() {
+		return arrayRestrictions;
+	}
+	
+	/**
+	 * Copy variable
+	 * 
+	 * @return Variable
+	 */
+	public Variable copy() {
+		IEclipseContext	staticContext = EclipseContextFactory.create();
+		injectAndSetInContext(registry, staticContext);
+		injectAndSetInContext(messages, staticContext);
+		injectAndSetInContext(context, staticContext);
+		Variable variable = ContextInjectionFactory.make(Variable.class, context, staticContext);
+		staticContext.dispose();
+		return variable;
+	}
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/array_relation/ArrayRelation.java

@@ -0,0 +1,198 @@
+package afryca.consensusmodel.variable.array_relation;
+
+import javax.inject.Inject;
+
+import org.eclipse.e4.core.services.nls.Translation;
+
+import afryca.consensusmodel.l10n.Messages;
+import afryca.consensusmodel.variable.array_relation.definition.ArrayRelationRegistry;
+import afryca.consensusmodel.variable.array_relation.definition.EArrayRelationElements;
+import afryca.consensusmodel.variable.array_relation.definition.EArrayRelationTypes;
+
+/**
+ * Array relation
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class ArrayRelation {
+
+	public static final String CONFIGURATION_ELEMENT_NAME = "Array_relation"; //$NON-NLS-1$
+	public final static String ARRAY_SEPARATOR = ";"; //$NON-NLS-1$
+
+	private EArrayRelationTypes type;
+	private String variableId;
+
+	private ArrayRelation() {
+		type = null;
+		variableId = null;
+	}
+
+	private ArrayRelation(String type, String variableId, Messages messages) {
+		this();
+
+		if (!validate(type, variableId)) {
+			throw new IllegalArgumentException(messages.invalid_arguments);
+		}
+
+		setType(type);
+		setVariableId(variableId);
+	}
+
+	@Inject
+	public ArrayRelation(ArrayRelationRegistry registry, @Translation Messages messages) {
+		this(registry.getElement(EArrayRelationElements.type), registry.getElement(EArrayRelationElements.variable),
+				messages);
+	}
+
+	/**
+	 * Validate if relation arguments are valid
+	 * 
+	 * @param type
+	 *            Type
+	 * @param variableId
+	 *            Variable's identifier
+	 * @return True if arguments are valid, False in other case
+	 */
+	public boolean validate(String type, String variableId) {
+		if (!validVariableId(variableId)) {
+			return false;
+		}
+
+		if (!validType(type)) {
+			return false;
+		}
+
+		return true;
+	}
+
+	private static boolean validVariableId(String variableId) {
+		return notIsEmpty(variableId);
+	}
+
+	private static boolean notIsEmpty(String value) {
+		if (value != null) {
+			if (!value.isEmpty()) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	private static boolean validType(String type) {
+		if (notIsEmpty(type)) {
+			if (EArrayRelationTypes.valueOf(type) != null) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	private void setType(String type) {
+		setType(EArrayRelationTypes.valueOf(type));
+	}
+
+	private void setType(EArrayRelationTypes type) {
+		this.type = type;
+	}
+
+	/**
+	 * Return relation type
+	 * 
+	 * @return Relation type
+	 */
+	public EArrayRelationTypes getType() {
+		return type;
+	}
+
+	private void setVariableId(String variableId) {
+		this.variableId = variableId;
+	}
+
+	/**
+	 * Return variable's identifier
+	 * 
+	 * @return Variable's identifier
+	 */
+	public String getVariableId() {
+		return variableId;
+	}
+
+	/**
+	 * Check if the relation is satisfy
+	 * 
+	 * @param thisValue
+	 *            Value of the array with the relation
+	 * @param variableValue
+	 *            Value of the related variable
+	 * @return True if the relation is satisfy, False in other case
+	 */
+	public boolean check(Object thisValue, Object variableValue) {
+		Float otherFloatValue = extractFloatValueOrArrayLength(variableValue);
+		Integer thisNumberOfElements = countElements(thisValue);
+
+		if ((otherFloatValue == null) || (thisNumberOfElements == null)) {
+			return false;
+		}
+
+		switch (type) {
+		case number_of_elements_equals_to:
+			return (thisNumberOfElements.floatValue() == otherFloatValue);
+
+		default:
+			return false;
+		}
+	}
+
+	private static Float extractFloatValueOrArrayLength(Object value) {
+		try {
+			if (value instanceof String) {
+				return (float) arrayInStringLength((String) value);
+			} else if (value instanceof Number) {
+				return ((Number) value).floatValue();
+			} else if (value instanceof Object[]) {
+				return (float) ((Object[]) value).length;
+			} else if (value instanceof Integer[]) {
+				return (float) ((Integer[]) value).length;
+			} else if (value instanceof Float[]) {
+				return (float) ((Float[]) value).length;
+			} else if (value instanceof String[]) {
+				return (float) ((String[]) value).length;
+			}
+		} catch (Exception e) {
+			return null;
+		}
+		return null;
+	}
+
+	private static Integer countElements(Object value) {
+		if (value instanceof String) {
+			return arrayInStringLength((String) value);
+		} else if (value instanceof Object[]) {
+			return ((Object[]) value).length;
+		} else if (value instanceof Integer[]) {
+			return ((Integer[]) value).length;
+		} else if (value instanceof Float[]) {
+			return ((Float[]) value).length;
+		} else if (value instanceof String[]) {
+			return ((String[]) value).length;
+		} else {
+			return null;
+		}
+	}
+
+	protected static int arrayInStringLength(String array) {
+		if (array.contains(ARRAY_SEPARATOR)) {
+			return array.split(ARRAY_SEPARATOR).length;
+		} else if (array.trim().isEmpty()) {
+			return 0;
+		}
+		return 1;
+	}
+
+	@Override
+	public String toString() {
+		return type.name() + ' ' + variableId;
+	}
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/array_relation/definition/ArrayRelationRegistry.java

@@ -0,0 +1,57 @@
+package afryca.consensusmodel.variable.array_relation.definition;
+
+import org.eclipse.core.runtime.IConfigurationElement;
+
+/**
+ * Registry for array relation of Variable
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class ArrayRelationRegistry {
+
+	private IConfigurationElement arrayRelationConfiguration;
+
+	private ArrayRelationRegistry() {
+		arrayRelationConfiguration = null;
+	}
+
+	/**
+	 * Builder
+	 * 
+	 * @param element
+	 *            Array relation configuration element
+	 */
+	public ArrayRelationRegistry(IConfigurationElement element) {
+		this();
+		arrayRelationConfiguration = element;
+	}
+
+	/**
+	 * Return array relation element value
+	 * 
+	 * @param element
+	 *            element key
+	 * @return element value
+	 */
+	public String getElement(EArrayRelationElements element) {
+
+		String result = null;
+
+		if (arrayRelationConfiguration != null) {
+			result = arrayRelationConfiguration.getAttribute(element.toString());
+		}
+
+		return result;
+	}
+
+	/**
+	 * Return array relation configuration
+	 * 
+	 * @return array relation configuration
+	 */
+	public IConfigurationElement getConfiguration() {
+		return arrayRelationConfiguration;
+	}
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/array_relation/definition/EArrayRelationElements.java

@@ -0,0 +1,16 @@
+package afryca.consensusmodel.variable.array_relation.definition;
+
+/**
+ * Array relation elements
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public enum EArrayRelationElements {
+
+	// Relation type
+	type,
+
+	// Relation variable
+	variable
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/array_relation/definition/EArrayRelationTypes.java

@@ -0,0 +1,13 @@
+package afryca.consensusmodel.variable.array_relation.definition;
+
+/**
+ * Array relation types
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public enum EArrayRelationTypes {
+
+	// Number of elements equals to
+	number_of_elements_equals_to;
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/array_restriction/ArrayRestriction.java

@@ -0,0 +1,307 @@
+package afryca.consensusmodel.variable.array_restriction;
+
+import javax.inject.Inject;
+
+import org.eclipse.e4.core.services.nls.Translation;
+
+import afryca.consensusmodel.l10n.Messages;
+import afryca.consensusmodel.variable.array_restriction.definition.ArrayRestrictionRegistry;
+import afryca.consensusmodel.variable.array_restriction.definition.EArrayRestrictionElements;
+import afryca.consensusmodel.variable.array_restriction.definition.EArrayRestrictionTypes;
+
+/**
+ * Array restriction restriction
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class ArrayRestriction {
+
+	public static final String CONFIGURATION_ELEMENT_NAME = "Array_restriction"; //$NON-NLS-1$
+	public final static String ARRAY_SEPARATOR = ";"; //$NON-NLS-1$
+
+	private EArrayRestrictionTypes type;
+	private Float value;
+
+	private ArrayRestriction() {
+		type = null;
+		value = null;
+	}
+
+	private ArrayRestriction(String type, String value, Messages messages) {
+		this();
+
+		if (!validate(type, value)) {
+			throw new IllegalArgumentException(messages.invalid_arguments);
+		}
+
+		setType(type);
+		setValue(value);
+	}
+
+	@Inject
+	public ArrayRestriction(ArrayRestrictionRegistry registry, @Translation Messages messages) {
+		this(registry.getElement(EArrayRestrictionElements.type), registry.getElement(EArrayRestrictionElements.value),
+				messages);
+	}
+
+	/**
+	 * Validate if restriction arguments are valid
+	 * 
+	 * @param type
+	 *            Type
+	 * @param value
+	 *            Value of restriction
+	 * @return True if arguments are valid, False in other case
+	 */
+	public boolean validate(String type, String value) {
+		if (!validValue(value)) {
+			return false;
+		}
+
+		if (!validType(type)) {
+			return false;
+		}
+
+		return true;
+	}
+
+	private static boolean validValue(String value) {
+		try {
+			if (notIsEmpty(value)) {
+				Float.parseFloat(value);
+				return true;
+			}
+		} catch (Exception e) {
+			return false;
+		}
+		return false;
+	}
+
+	private static boolean notIsEmpty(String value) {
+		if (value != null) {
+			if (!value.isEmpty()) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	private static boolean validType(String type) {
+		if (notIsEmpty(type)) {
+			if (EArrayRestrictionTypes.valueOf(type) != null) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	private void setType(String type) {
+		setType(EArrayRestrictionTypes.valueOf(type));
+	}
+
+	private void setType(EArrayRestrictionTypes type) {
+		this.type = type;
+	}
+
+	/**
+	 * Return restriction type
+	 * 
+	 * @return Restriction type
+	 */
+	public EArrayRestrictionTypes getType() {
+		return type;
+	}
+
+	private void setValue(String value) {
+		this.value = Float.parseFloat(value);
+	}
+
+	/**
+	 * Return restriction value
+	 * 
+	 * @return Restriction value
+	 */
+	public Float getValue() {
+		return value;
+	}
+
+	/**
+	 * Check if restriction is satisfy
+	 * 
+	 * @param t
+	 *            Object to test
+	 * @return True if object satisfy restriction, False in other case
+	 */
+	public boolean check(Object t) {
+
+		Float[] currentValues = null;
+
+		try {
+			currentValues = extractValues(t);
+		} catch (Exception e) {
+			return false;
+		}
+
+		if (currentValues == null) {
+			return false;
+		}
+
+		if (containsNaN(currentValues) && (!nanIsAValidValue())) {
+			return false;
+		}
+
+		switch (type) {
+		case element_lower_limit:
+			return checkElementLowerLimit(currentValues);
+
+		case element_upper_limit:
+			return checkElementUpperLimit(currentValues);
+
+		case elements_sum_value:
+			return checkElementsSumValue(currentValues);
+
+		case elements_sum_lower_limit:
+			return checkElementsSumLowerLimit(currentValues);
+
+		case elements_sum_upper_limit:
+			return checkElementsSumUpperLimit(currentValues);
+
+		case number_of_elements:
+			return checkNumberOfElements(currentValues);
+			
+		case number_of_elements_greater_than:
+			return checkNumberOfElementsGreaterThan(currentValues);
+
+		default:
+			return true;
+		}
+
+	}
+
+	private static Float[] extractValues(Object t) {
+
+		Float[] result = null;
+
+		if (t instanceof String) {
+			if (((String) t).contains(ARRAY_SEPARATOR)) {
+				String[] tokens = ((String) t).split(ARRAY_SEPARATOR);
+				result = new Float[tokens.length];
+				for (int i = 0; i < tokens.length; i++) {
+					try {
+						result[i] = Float.parseFloat(tokens[i].trim());
+					} catch (Exception e) {
+						result[i] = Float.NaN;
+					}
+				}
+			} else {
+				if (!((String) t).trim().isEmpty()) {
+					result = new Float[1];
+					try {
+						result[0] = Float.parseFloat(((String) t).trim());
+					} catch (Exception e) {
+						result[0] = Float.NaN;
+					}
+				}
+			}
+		} else if (t instanceof Number) {
+			result = new Float[1];
+			result[0] = ((Number) t).floatValue();
+		} else if (t instanceof Object[]) {
+			Object[] array = (Object[]) t;
+			result = new Float[array.length];
+			for (int i = 0; i < result.length; i++) {
+				try {
+					result[i] = extractFloatValue(array[i]);
+				} catch (Exception e) {
+					result[i] = Float.NaN;
+				}
+			}
+		}
+
+		return result;
+	}
+
+	private static Float extractFloatValue(Object value) {
+		if (value instanceof String) {
+			return Float.parseFloat(((String) value).trim());
+		} else if (value instanceof Number) {
+			return ((Number) value).floatValue();
+		} else {
+			throw new IllegalArgumentException();
+		}
+	}
+
+	private static boolean containsNaN(Float[] values) {
+		for (Float value : values) {
+			if (value.isNaN()) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	private boolean nanIsAValidValue() {
+		switch (type) {
+		case number_of_elements:
+			return true;
+		case number_of_elements_greater_than:
+			return true;
+		default:
+			return false;
+		}
+	}
+
+	private boolean checkElementLowerLimit(Float[] values) {
+		for (int i = 0; i < values.length; i++) {
+			if (value > values[i]) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	private boolean checkElementUpperLimit(Float[] values) {
+		for (int i = 0; i < values.length; i++) {
+			if (value < values[i]) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	private boolean checkElementsSumValue(Float[] values) {
+		return (value == sum(values));
+	}
+
+	private static float sum(Float[] values) {
+		float result = 0f;
+		for (Float value : values) {
+			result += value;
+		}
+		result=(float)Math.round(result*100)/100;
+		return result;
+	}
+
+	private boolean checkElementsSumLowerLimit(Float[] values) {
+		return (value <= sum(values));
+	}
+
+	private boolean checkElementsSumUpperLimit(Float[] values) {
+		return (value >= sum(values));
+	}
+
+	private boolean checkNumberOfElements(Float[] values) {
+		return (values.length == value);
+	}
+	
+	private boolean checkNumberOfElementsGreaterThan(Float[] values) {
+		return (values.length > value);
+	}
+
+	@Override
+	public String toString() {
+		return type.name() + " " + value; //$NON-NLS-1$
+	}
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/array_restriction/definition/ArrayRestrictionRegistry.java

@@ -0,0 +1,57 @@
+package afryca.consensusmodel.variable.array_restriction.definition;
+
+import org.eclipse.core.runtime.IConfigurationElement;
+
+/**
+ * Array registry for restriction of Variable
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class ArrayRestrictionRegistry {
+
+	private IConfigurationElement arrayRestrictionConfiguration;
+
+	private ArrayRestrictionRegistry() {
+		arrayRestrictionConfiguration = null;
+	}
+
+	/**
+	 * Builder
+	 * 
+	 * @param element
+	 *            Array restriction configuration element
+	 */
+	public ArrayRestrictionRegistry(IConfigurationElement element) {
+		this();
+		arrayRestrictionConfiguration = element;
+	}
+
+	/**
+	 * Return array restriction element value
+	 * 
+	 * @param element
+	 *            element key
+	 * @return element value
+	 */
+	public String getElement(EArrayRestrictionElements element) {
+
+		String result = null;
+
+		if (arrayRestrictionConfiguration != null) {
+			result = arrayRestrictionConfiguration.getAttribute(element.toString());
+		}
+
+		return result;
+	}
+
+	/**
+	 * Return array restriction configuration
+	 * 
+	 * @return array restriction configuration
+	 */
+	public IConfigurationElement getConfiguration() {
+		return arrayRestrictionConfiguration;
+	}
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/array_restriction/definition/EArrayRestrictionElements.java

@@ -0,0 +1,16 @@
+package afryca.consensusmodel.variable.array_restriction.definition;
+
+/**
+ * Array restriction elements
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public enum EArrayRestrictionElements {
+
+	// Array restriction type
+	type,
+
+	// Array restriction value
+	value
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/array_restriction/definition/EArrayRestrictionTypes.java

@@ -0,0 +1,31 @@
+package afryca.consensusmodel.variable.array_restriction.definition;
+
+/**
+ * Array restriction types
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public enum EArrayRestrictionTypes {
+
+	// Element lower limit
+	element_lower_limit,
+
+	// Element upper limit
+	element_upper_limit,
+
+	// Elements sum value
+	elements_sum_value,
+
+	// Elements sum lower limit
+	elements_sum_lower_limit,
+
+	// Elements sum upper limit
+	elements_sum_upper_limit,
+
+	// Number of elements
+	number_of_elements,
+	
+	// Number of elements greater than
+	number_of_elements_greater_than;
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/definition/EVariableElements.java

@@ -0,0 +1,37 @@
+package afryca.consensusmodel.variable.definition;
+
+/**
+ * Variable elements
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public enum EVariableElements {
+
+	// Variable id
+	id,
+
+	// Variable description
+	description,
+
+	// Variable type
+	type,
+
+	// Variable default value
+	default_value,
+
+	// Variable array default element value
+	array_default_element_value,
+
+	// Variable is an array
+	is_array,
+
+	// Interval variable
+	is_internal,
+	
+	//Operation default value
+	operation,
+	
+	//Dialog
+	dialog
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/definition/EVariableTypes.java

@@ -0,0 +1,245 @@
+package afryca.consensusmodel.variable.definition;
+
+import java.util.List;
+
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+
+import org.eclipse.jface.dialogs.TitleAreaDialog;
+
+import afryca.consensusmodel.service.IConsensusModelService;
+import afryca.fpr.FPR;
+import afryca.gdmp.GDMP;
+import afryca.gdmp.service.IGDMPService;
+
+/**
+ * Variable types
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public enum EVariableTypes {
+
+	// Boolean
+	Boolean,
+
+	// Integer
+	Integer,
+
+	// Float
+	Float,
+	
+	//Operation
+	Operation,
+	
+	//Dialog
+	Dialog,
+	
+	// FPR
+	FPR,
+	
+	//HPR
+	HPR,
+	
+	//LPR
+	LPR,
+	
+	//HLPR
+	HLPR,
+	
+	//MPR
+	MPR,
+	
+	//DM
+	DecisionMatrix,
+
+	// String
+	String;
+	
+	private static IConsensusModelService consensusServiceProvider;
+	
+	private static IGDMPService GDMPService;
+	
+	public final static String ARRAY_SEPARATOR = ";"; //$NON-NLS-1$
+	
+	public static void setConsensusServiceProvider(IConsensusModelService _consensusServiceProvider) {
+		consensusServiceProvider = _consensusServiceProvider;
+	}
+	
+	public static void setGDMPServiceProvider(IGDMPService _GDMPService) {
+		GDMPService = _GDMPService;
+	}
+
+	/**
+	 * Return Class of EVariableTypes
+	 * 
+	 * @param type
+	 *            EVariableTypes
+	 * @return Class of EVariableTypes
+	 */
+	public static Class<?> getClass(EVariableTypes type) {
+		switch (type) {
+		case Boolean:
+			return Boolean.class;
+		case Integer:
+			return Integer.class;
+		case Float:
+			return Float.class;
+		case Operation:
+			return Float.class;
+		case FPR:
+			return FPR.class;
+		case String:
+			return String.class;
+		case Dialog:
+			return TitleAreaDialog.class;
+		default:
+			break;
+		}
+		return null;
+	}
+
+	/**
+	 * Return Class of string value of EVariableType
+	 * 
+	 * @param type
+	 *            String value of EVariableType
+	 * @return Class of string value of EVariableType
+	 */
+	public static Class<?> getClass(String type) {
+		return getClass(valueOf(type));
+	}
+
+	/**
+	 * Parse a variable
+	 * 
+	 * @param type
+	 *            Variable type
+	 * @param value
+	 *            String value of variable
+	 * @param id 
+	 * @param variable 
+	 * @param gdmp 
+	 * @return Variable value
+	 */
+	public static Object parseValue(EVariableTypes type, String value, String id) {
+		switch (type) {
+		case Boolean:
+			return java.lang.Boolean.parseBoolean(value);
+		case Integer:
+			// FIXME fix for windows
+			try {
+				return java.lang.Integer.parseInt(value);
+			} catch (Exception e) {
+				return (int) java.lang.Float.parseFloat(value);
+			}
+		case Float:
+			return java.lang.Float.parseFloat(value);
+		case Operation:
+			return parseOperation(value, id);
+		case FPR:
+			return afryca.fpr.FPR.parseFPR(value);
+		case String:
+			return value;
+		case Dialog:
+			break;
+		default:
+			break;
+		}
+		return null;
+	}
+
+	private static Float parseOperation(String equation, java.lang.String id) {
+		try {
+			return java.lang.Float.parseFloat(equation);
+		} catch(NumberFormatException e) {
+			return checkEquation(equation, id);
+		}
+	}
+	
+	private static java.lang.Float checkEquation(String equation, java.lang.String id) {
+		GDMP gdmp = GDMPService.getSelection();
+		if(gdmp == null) {
+			return 0f;
+		} else {
+			if(equation.contains(GDMP.FIELD_EXPERTS)) {
+				equation = transformEquation(equation, GDMP.FIELD_EXPERTS, gdmp);
+			}
+			
+			if(equation.contains(GDMP.FIELD_ALTERNATIVES)) {
+				equation = transformEquation(equation, GDMP.FIELD_ALTERNATIVES, gdmp);
+			}
+		
+			if(equation.contains(GDMP.FIELD_CRITERIA)) {
+				equation = transformEquation(equation, GDMP.FIELD_CRITERIA, gdmp);
+			}
+		}
+		return computeEquation(equation, id);
+	}
+
+	@SuppressWarnings("unchecked")
+	private static String transformEquation(String equation, String equationElement, GDMP gdmp) {
+		equation = equation.replace(equationElement, java.lang.Float.toString((float) ((List<String>) gdmp.get(equationElement)).size()));
+		return equation;
+	}
+	
+	private static java.lang.Float computeEquation(java.lang.String equation, java.lang.String id) {
+		ScriptEngineManager mgr = new ScriptEngineManager();
+	    ScriptEngine engine = mgr.getEngineByName("JavaScript");  
+	    try {
+	    	Float result = ((Number) engine.eval(equation)).floatValue();
+	    	String selection = consensusServiceProvider.getSelection();
+			if(selection != null) {
+				consensusServiceProvider.getDefaultConfiguration(selection).setValue(id, result);
+			}
+			return result;
+		} catch (ScriptException e) {
+			return 0f;
+		}
+	}
+	
+	/**
+	 * Parse array value of a variable
+	 * 
+	 * @param type
+	 *            Array type
+	 * @param value
+	 *            String value of array
+	 * @return Array value
+	 */
+	public static Object parseArray(EVariableTypes type, String value) {
+
+		// Split values
+		String[] values = value.split(ARRAY_SEPARATOR);
+
+		// Generate array
+		Object[] result = null;
+		switch (type) {
+		case Boolean:
+			result = new Boolean[values.length];
+			break;
+		case Integer:
+			result = new Integer[values.length];
+			break;
+		case Float:
+			result = new Float[values.length];
+			break;
+		case FPR:
+			result = new FPR[values.length];
+			break;
+		case String:
+			result = new String[values.length];
+			break;
+		default:
+			result = new Object[values.length];
+			break;
+		}
+
+		// Parse values
+		for (int i = 0; i < values.length; i++) {
+			result[i] = parseValue(type, values[i], null);
+		}
+		return result;
+	}
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/definition/MockVariableConfigurationElement.java

@@ -0,0 +1,133 @@
+package afryca.consensusmodel.variable.definition;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.IContributor;
+import org.eclipse.core.runtime.IExtension;
+import org.eclipse.core.runtime.InvalidRegistryObjectException;
+
+/**
+ * Mock configuration element for AFRYCA runtime variables
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class MockVariableConfigurationElement implements IConfigurationElement {
+
+	private Map<String, String> attributes;
+
+	/**
+	 * Default builder
+	 */
+	public MockVariableConfigurationElement() {
+		super();
+		attributes = new HashMap<>();
+	}
+
+	/**
+	 * Add attribute
+	 * 
+	 * @param key
+	 *            Attribute key
+	 * @param value
+	 *            Attribute value
+	 */
+	public void addAttribute(String key, String value) {
+		attributes.put(key, value);
+	}
+
+	@Override
+	public Object createExecutableExtension(String propertyName) throws CoreException {
+		return null;
+	}
+
+	@Override
+	public String getAttribute(String name) throws InvalidRegistryObjectException {
+		return attributes.get(name);
+	}
+
+	@Override
+	public String getAttribute(String attrName, String locale) throws InvalidRegistryObjectException {
+		return null;
+	}
+
+	@Override
+	public String getAttributeAsIs(String name) throws InvalidRegistryObjectException {
+		return null;
+	}
+
+	@Override
+	public String[] getAttributeNames() throws InvalidRegistryObjectException {
+		return null;
+	}
+
+	@Override
+	public IConfigurationElement[] getChildren() throws InvalidRegistryObjectException {
+		return null;
+	}
+
+	@Override
+	public IConfigurationElement[] getChildren(String name) throws InvalidRegistryObjectException {
+		return new IConfigurationElement[0];
+	}
+
+	@Override
+	public IExtension getDeclaringExtension() throws InvalidRegistryObjectException {
+		return null;
+	}
+
+	@Override
+	public String getName() throws InvalidRegistryObjectException {
+		return null;
+	}
+
+	@Override
+	public Object getParent() throws InvalidRegistryObjectException {
+		return null;
+	}
+
+	@Override
+	public String getValue() throws InvalidRegistryObjectException {
+		return null;
+	}
+
+	@Override
+	public String getValue(String locale) throws InvalidRegistryObjectException {
+		return null;
+	}
+
+	@Override
+	public String getValueAsIs() throws InvalidRegistryObjectException {
+		return null;
+	}
+
+	@Override
+	public String getNamespace() throws InvalidRegistryObjectException {
+		return null;
+	}
+
+	@Override
+	public String getNamespaceIdentifier() throws InvalidRegistryObjectException {
+		return null;
+	}
+
+	@Override
+	public IContributor getContributor() throws InvalidRegistryObjectException {
+		return null;
+	}
+
+	@Override
+	public boolean isValid() {
+		return false;
+	}
+
+	@Override
+	public int getHandleId() {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/definition/VariableDialogRegistry.java

@@ -0,0 +1,59 @@
+package afryca.consensusmodel.variable.definition;
+
+import org.eclipse.core.runtime.IConfigurationElement;
+
+/**
+ * Registry for variable of Consensus Model
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class VariableDialogRegistry {
+
+	private IConfigurationElement configuration;
+
+	/**
+	 * Default builder
+	 */
+	private VariableDialogRegistry() {
+		configuration = null;
+	}
+
+	/**
+	 * Builder
+	 * 
+	 * @param element
+	 *            Variable configuration element
+	 */
+	public VariableDialogRegistry(IConfigurationElement element) {
+		this();
+		configuration = element;
+	}
+
+	/**
+	 * Return variable element value
+	 * 
+	 * @param element
+	 *            element key
+	 * @return element value
+	 */
+	public String getElement(EVariableElements element) {
+
+		String result = null;
+
+		if (configuration != null) {
+			result = configuration.getAttribute(element.toString());
+		}
+
+		return result;
+	}
+
+	/**
+	 * Return variable configuration
+	 * 
+	 * @return variable configuration
+	 */
+	public IConfigurationElement getConfiguration() {
+		return configuration;
+	}
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/definition/VariableRegistry.java

@@ -0,0 +1,176 @@
+package afryca.consensusmodel.variable.definition;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IConfigurationElement;
+
+import afryca.consensusmodel.variable.array_relation.ArrayRelation;
+import afryca.consensusmodel.variable.array_relation.definition.ArrayRelationRegistry;
+import afryca.consensusmodel.variable.array_restriction.ArrayRestriction;
+import afryca.consensusmodel.variable.array_restriction.definition.ArrayRestrictionRegistry;
+import afryca.consensusmodel.variable.relation.Relation;
+import afryca.consensusmodel.variable.relation.definition.RelationRegistry;
+import afryca.consensusmodel.variable.restriction.Restriction;
+import afryca.consensusmodel.variable.restriction.definition.RestrictionRegistry;
+
+/**
+ * Registry for variable of Consensus Model
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class VariableRegistry {
+	
+	private static final String CONFIGURATION_DIALOG_ELEMENT_NAME = "Dialog";
+
+	private IConfigurationElement configuration;
+	private Set<RestrictionRegistry> restrictions;
+	private Set<RelationRegistry> relations;
+	private Set<ArrayRelationRegistry> arrayRelations;
+	private Set<ArrayRestrictionRegistry> arrayRestrictions;
+	
+	
+	/**
+	 * Default builder
+	 */
+	private VariableRegistry() {
+		configuration = null;
+		restrictions = new HashSet<>();
+		relations = new HashSet<>();
+		arrayRelations = new HashSet<>();
+		arrayRestrictions = new HashSet<>();
+	}
+
+	/**
+	 * Builder
+	 * 
+	 * @param element
+	 *            Variable configuration element
+	 */
+	public VariableRegistry(IConfigurationElement element) {
+		this();
+		configuration = element;
+		loadRestrictions();
+		loadRelations();
+		loadArrayRelations();
+		loadArrayRestrictions();
+	}
+
+	/**
+	 * Return variable element value
+	 * 
+	 * @param element
+	 *            element key
+	 * @return element value
+	 */
+	public String getElement(EVariableElements element) {
+
+		String result = null;
+
+		if (configuration != null) {
+			result = configuration.getAttribute(element.toString());
+		}
+
+		return result;
+	}
+
+	public Object loadDialog(EVariableElements element) {
+		IConfigurationElement[] configurations = configuration.getChildren(CONFIGURATION_DIALOG_ELEMENT_NAME);
+		for (IConfigurationElement configuration : configurations) {
+			try {
+				return configuration.createExecutableExtension(element.toString());
+			} catch (CoreException e) {
+				e.printStackTrace();
+			}
+		}
+		return null;
+	}
+	
+	private void loadRestrictions() {
+		IConfigurationElement[] configurations = configuration.getChildren(Restriction.CONFIGURATION_ELEMENT_NAME);
+		RestrictionRegistry registry;
+
+		for (IConfigurationElement configuration : configurations) {
+			registry = new RestrictionRegistry(configuration);
+			restrictions.add(registry);
+		}
+	}
+
+	private void loadRelations() {
+		IConfigurationElement[] configurations = configuration.getChildren(Relation.CONFIGURATION_ELEMENT_NAME);
+		RelationRegistry registry;
+
+		for (IConfigurationElement configuration : configurations) {
+			registry = new RelationRegistry(configuration);
+			relations.add(registry);
+		}
+	}
+
+	private void loadArrayRelations() {
+		IConfigurationElement[] configurations = configuration.getChildren(ArrayRelation.CONFIGURATION_ELEMENT_NAME);
+		ArrayRelationRegistry registry;
+
+		for (IConfigurationElement configuration : configurations) {
+			registry = new ArrayRelationRegistry(configuration);
+			arrayRelations.add(registry);
+		}
+	}
+
+	private void loadArrayRestrictions() {
+		IConfigurationElement[] configurations = configuration.getChildren(ArrayRestriction.CONFIGURATION_ELEMENT_NAME);
+		ArrayRestrictionRegistry registry;
+
+		for (IConfigurationElement configuration : configurations) {
+			registry = new ArrayRestrictionRegistry(configuration);
+			arrayRestrictions.add(registry);
+		}
+	}
+
+	/**
+	 * Return variable configuration
+	 * 
+	 * @return variable configuration
+	 */
+	public IConfigurationElement getConfiguration() {
+		return configuration;
+	}
+
+	/**
+	 * Return restrictions registers
+	 * 
+	 * @return Restrictions registers
+	 */
+	public Set<RestrictionRegistry> getRestrictionsRegisters() {
+		return restrictions;
+	}
+
+	/**
+	 * Return relations registers
+	 * 
+	 * @return Relations registers
+	 */
+	public Set<RelationRegistry> getRelationsRegisters() {
+		return relations;
+	}
+
+	/**
+	 * Return array relations registers
+	 * 
+	 * @return Array relations registers
+	 */
+	public Set<ArrayRelationRegistry> getArrayRelationsRegisters() {
+		return arrayRelations;
+	}
+
+	/**
+	 * Return array restrictions registers
+	 * 
+	 * @return Array restrictions registers
+	 */
+	public Set<ArrayRestrictionRegistry> getArrayRestrictionsRegisters() {
+		return arrayRestrictions;
+	}
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/relation/Relation.java

@@ -0,0 +1,177 @@
+package afryca.consensusmodel.variable.relation;
+
+import javax.inject.Inject;
+
+import org.eclipse.e4.core.services.nls.Translation;
+
+import afryca.consensusmodel.l10n.Messages;
+import afryca.consensusmodel.variable.relation.definition.ERelationElements;
+import afryca.consensusmodel.variable.relation.definition.ERelationTypes;
+import afryca.consensusmodel.variable.relation.definition.RelationRegistry;
+
+/**
+ * Relation
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class Relation {
+
+	public static final String CONFIGURATION_ELEMENT_NAME = "Relation"; //$NON-NLS-1$
+
+	private ERelationTypes type;
+	private String variableId;
+
+	private Relation() {
+		type = null;
+		variableId = null;
+	}
+
+	private Relation(String type, String variableId, Messages messages) {
+		this();
+
+		if (!validate(type, variableId)) {
+			throw new IllegalArgumentException(messages.invalid_arguments);
+		}
+
+		setType(type);
+		setVariableId(variableId);
+	}
+
+	@Inject
+	public Relation(RelationRegistry registry, @Translation Messages messages) {
+		this(registry.getElement(ERelationElements.type), registry.getElement(ERelationElements.variable), messages);
+	}
+
+	/**
+	 * Validate if relation arguments are valid
+	 * 
+	 * @param type
+	 *            Type
+	 * @param variableId
+	 *            Variable's identifier
+	 * @return True if arguments are valid, False in other case
+	 */
+	public boolean validate(String type, String variableId) {
+		if (!validVariableId(variableId)) {
+			return false;
+		}
+
+		if (!validType(type)) {
+			return false;
+		}
+
+		return true;
+	}
+
+	private static boolean validVariableId(String variableId) {
+		return notIsEmpty(variableId);
+	}
+
+	private static boolean notIsEmpty(String value) {
+		if (value != null) {
+			if (!value.isEmpty()) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	private static boolean validType(String type) {
+		if (notIsEmpty(type)) {
+			if (ERelationTypes.valueOf(type) != null) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	private void setType(String type) {
+		setType(ERelationTypes.valueOf(type));
+	}
+
+	private void setType(ERelationTypes type) {
+		this.type = type;
+	}
+
+	/**
+	 * Return relation type
+	 * 
+	 * @return Relation type
+	 */
+	public ERelationTypes getType() {
+		return type;
+	}
+
+	private void setVariableId(String variable_id) {
+		this.variableId = variable_id;
+	}
+
+	/**
+	 * Return related variable identifier
+	 * 
+	 * @return Related variable identifier
+	 */
+	public String getVariableId() {
+		return variableId;
+	}
+
+	/**
+	 * Check if the relation is satisfy
+	 * 
+	 * @param thisValue
+	 *            Value of the array with the relation
+	 * @param variableValue
+	 *            Value of the related variable
+	 * @return True if the relation is satisfy, False in other case
+	 */
+	public boolean check(Object thisValue, Object variableValue) {
+
+		Float otherFloatValue = extractFloatValue(variableValue);
+		Float thisFloatValue = extractFloatValue(thisValue);
+		
+		if ((otherFloatValue == null) || (thisFloatValue == null)) {
+			return false;
+		}
+
+		switch (type) {
+		case equals_to:
+			return (thisFloatValue.equals(otherFloatValue));
+
+		case lower_than:
+			return (thisFloatValue < otherFloatValue);
+
+		case greater_than:
+			return (thisFloatValue > otherFloatValue);
+
+		case at_least:
+			return (thisFloatValue >= otherFloatValue);
+
+		case at_most:
+			return (thisFloatValue <= otherFloatValue);
+
+		default:
+			return false;
+		}
+
+	}
+
+	private static Float extractFloatValue(Object value) {
+		try {
+			if (value instanceof String) {
+				return Float.parseFloat((String) value);
+			} else if (value instanceof Number) {
+				return ((Number) value).floatValue();
+			}
+		} catch (Exception e) {
+			return null;
+		}
+		return null;
+	}
+
+	@Override
+	public String toString() {
+		return type.name() + ' ' + variableId;
+	}
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/relation/definition/ERelationElements.java

@@ -0,0 +1,16 @@
+package afryca.consensusmodel.variable.relation.definition;
+
+/**
+ * Relation elements
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public enum ERelationElements {
+
+	// Relation type
+	type,
+
+	// Relation variable
+	variable
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/relation/definition/ERelationTypes.java

@@ -0,0 +1,26 @@
+package afryca.consensusmodel.variable.relation.definition;
+
+/**
+ * Relation types
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public enum ERelationTypes {
+
+	// Equals to
+	equals_to,
+
+	// Lower than
+	lower_than,
+
+	// Greater than
+	greater_than,
+
+	// At least
+	at_least,
+
+	// At most
+	at_most;
+	
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/relation/definition/RelationRegistry.java

@@ -0,0 +1,57 @@
+package afryca.consensusmodel.variable.relation.definition;
+
+import org.eclipse.core.runtime.IConfigurationElement;
+
+/**
+ * Registry for relation of Variable
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class RelationRegistry {
+
+	private IConfigurationElement relationConfiguration;
+
+	private RelationRegistry() {
+		relationConfiguration = null;
+	}
+
+	/**
+	 * Builder
+	 * 
+	 * @param element
+	 *            Relation configuration element
+	 */
+	public RelationRegistry(IConfigurationElement element) {
+		this();
+		relationConfiguration = element;
+	}
+
+	/**
+	 * Return relation element value
+	 * 
+	 * @param element
+	 *            element key
+	 * @return element value
+	 */
+	public String getElement(ERelationElements element) {
+
+		String result = null;
+
+		if (relationConfiguration != null) {
+			result = relationConfiguration.getAttribute(element.toString());
+		}
+
+		return result;
+	}
+
+	/**
+	 * Return relation configuration
+	 * 
+	 * @return relation configuration
+	 */
+	public IConfigurationElement getConfiguration() {
+		return relationConfiguration;
+	}
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/restriction/Restriction.java

@@ -0,0 +1,172 @@
+package afryca.consensusmodel.variable.restriction;
+
+import javax.inject.Inject;
+
+import org.eclipse.e4.core.services.nls.Translation;
+
+import afryca.consensusmodel.l10n.Messages;
+import afryca.consensusmodel.variable.restriction.definition.ERestrictionElements;
+import afryca.consensusmodel.variable.restriction.definition.ERestrictionTypes;
+import afryca.consensusmodel.variable.restriction.definition.RestrictionRegistry;
+
+/**
+ * Restriction
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class Restriction {
+
+	public static final String CONFIGURATION_ELEMENT_NAME = "Restriction"; //$NON-NLS-1$
+
+	private ERestrictionTypes type;
+	private Float value;
+
+	private Restriction() {
+		type = null;
+		value = null;
+	}
+
+	private Restriction(String type, String value, Messages messages) {
+		this();
+
+		if (!validate(type, value)) {
+			throw new IllegalArgumentException(messages.invalid_arguments);
+		}
+
+		setType(type);
+		setValue(value);
+	}
+
+	@Inject
+	public Restriction(RestrictionRegistry registry, @Translation Messages messages) {
+		this(registry.getElement(ERestrictionElements.type), registry.getElement(ERestrictionElements.value), messages);
+	}
+
+	/**
+	 * Validate if restriction arguments are valid
+	 * 
+	 * @param type
+	 *            Type
+	 * @param value
+	 *            Restriction value
+	 * @return True if arguments are valid, False in other case
+	 */
+	public boolean validate(String type, String value) {
+		if (!validValue(value)) {
+			return false;
+		}
+
+		if (!validType(type)) {
+			return false;
+		}
+
+		return true;
+	}
+
+	private static boolean validValue(String value) {
+		try {
+			if (notIsEmpty(value)) {
+				Float.parseFloat(value);
+				return true;
+			}
+		} catch (Exception e) {
+			return false;
+		}
+		return false;
+	}
+
+	private static boolean notIsEmpty(String value) {
+		if (value != null) {
+			if (!value.isEmpty()) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	private static boolean validType(String type) {
+		if (notIsEmpty(type)) {
+			if (ERestrictionTypes.valueOf(type) != null) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	private void setType(String type) {
+		setType(ERestrictionTypes.valueOf(type));
+	}
+
+	private void setType(ERestrictionTypes type) {
+		this.type = type;
+	}
+
+	/**
+	 * Return restriction type
+	 * 
+	 * @return Restriction type
+	 */
+	public ERestrictionTypes getType() {
+		return type;
+	}
+
+	private void setValue(String value) {
+		this.value = Float.parseFloat(value);
+	}
+
+	/**
+	 * Return restriction value
+	 * 
+	 * @return Restriction value
+	 */
+	public Float getValue() {
+		return value;
+	}
+
+	/**
+	 * Check if restriction is satisfy
+	 * 
+	 * @param t
+	 *            Object to test
+	 * @return True if object satisfy restriction, False in other case
+	 */
+	public boolean check(Object t) {
+
+		Float currentValue = extractFloatValue(t);
+		if (currentValue == null) {
+			return false;
+		}
+
+		switch (type) {
+		case lower_limit:
+			return (value <= currentValue);
+
+		case upper_limit:
+			return (value >= currentValue);
+
+		default:
+			return false;
+		}
+
+	}
+
+	private static Float extractFloatValue(Object value) {
+		try {
+			if (value instanceof String) {
+				return Float.parseFloat((String) value);
+			} else if (value instanceof Number) {
+				return ((Number) value).floatValue();
+			}
+		} catch (Exception e) {
+			return null;
+		}
+		return null;
+	}
+
+	@Override
+	public String toString() {
+		return type.name() + ' ' + value;
+	}
+
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/restriction/definition/ERestrictionElements.java

@@ -0,0 +1,16 @@
+package afryca.consensusmodel.variable.restriction.definition;
+
+/**
+ * Restriction elements
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public enum ERestrictionElements {
+
+	// Restriction type
+	type,
+
+	// Restriction value
+	value
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/restriction/definition/ERestrictionTypes.java

@@ -0,0 +1,16 @@
+package afryca.consensusmodel.variable.restriction.definition;
+
+/**
+ * Restriction types
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public enum ERestrictionTypes {
+
+	// Lower limit
+	lower_limit,
+
+	// Upper limit
+	upper_limit;
+}

plugins/afryca.consensusmodel/src/afryca/consensusmodel/variable/restriction/definition/RestrictionRegistry.java

@@ -0,0 +1,63 @@
+package afryca.consensusmodel.variable.restriction.definition;
+
+import org.eclipse.core.runtime.IConfigurationElement;
+
+/**
+ * Registry for restriction of Variable
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class RestrictionRegistry {
+
+	/**
+	 * Restriction configuration
+	 */
+	private IConfigurationElement restrictionConfiguration;
+
+	/**
+	 * Default builder
+	 */
+	private RestrictionRegistry() {
+		restrictionConfiguration = null;
+	}
+
+	/**
+	 * Builder
+	 * 
+	 * @param element
+	 *            Restriction configuration element
+	 */
+	public RestrictionRegistry(IConfigurationElement element) {
+		this();
+		restrictionConfiguration = element;
+	}
+
+	/**
+	 * Return restriction element value
+	 * 
+	 * @param element
+	 *            element key
+	 * @return element value
+	 */
+	public String getElement(ERestrictionElements element) {
+
+		String result = null;
+
+		if (restrictionConfiguration != null) {
+			result = restrictionConfiguration.getAttribute(element.toString());
+		}
+
+		return result;
+	}
+
+	/**
+	 * Return restriction configuration
+	 * 
+	 * @return restriction configuration
+	 */
+	public IConfigurationElement getConfiguration() {
+		return restrictionConfiguration;
+	}
+
+}

plugins/afryca.consensusmodel/target/MANIFEST.MF

@@ -0,0 +1,33 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: %Bundle-Name
+Bundle-SymbolicName: afryca.consensusmodel;singleton:=true
+Bundle-Version: 1.0.0.202101221157
+Bundle-Vendor: %Bundle-Vendor
+Export-Package: afryca.consensumodel.addon,afryca.consensusmodel,afryca.
+ consensusmodel.cluster,afryca.consensusmodel.clustering,afryca.consensu
+ smodel.command,afryca.consensusmodel.definition,afryca.consensusmodel.p
+ references,afryca.consensusmodel.provider,afryca.consensusmodel.service
+ ,afryca.consensusmodel.service.events,afryca.consensusmodel.variable,af
+ ryca.consensusmodel.variable.array_relation,afryca.consensusmodel.varia
+ ble.array_relation.definition,afryca.consensusmodel.variable.array_rest
+ riction,afryca.consensusmodel.variable.array_restriction.definition,afr
+ yca.consensusmodel.variable.definition,afryca.consensusmodel.variable.r
+ elation,afryca.consensusmodel.variable.relation.definition,afryca.conse
+ nsusmodel.variable.restriction,afryca.consensusmodel.variable.restricti
+ on.definition
+Require-Bundle: afryca.ase,afryca.gdmp;visibility:=reexport,afryca.cm;vi
+ sibility:=reexport,afryca.behavior,afryca.parametervalueconverterhelper
+ ,afryca.workspace.service.events,afryca.elicit,javax.inject,org.apache.
+ commons.io,org.eclipse.core.runtime,org.eclipse.core.commands,org.eclip
+ se.e4.core.di,org.eclipse.e4.core.services,org.eclipse.e4.core.contexts
+ ,org.eclipse.e4.ui.workbench,org.eclipse.e4.ui.model.workbench,org.ecli
+ pse.ui,org.eclipse.e4.core.di.extensions;visibility:=reexport
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Service-Component: OSGI-INF/consensus_model_service_context_function.xml
+ ,OSGI-INF/variables_provider_context_function.xml,OSGI-INF/configuratio
+ n_provider_context_function.xml,OSGI-INF/consensus_model_provider_conte
+ xt_function.xml
+Bundle-ActivationPolicy: lazy
+Automatic-Module-Name: afryca.consensusmodel
+