public code v1

plugins/afryca.consensusmodel.zhang2012/src/afryca/consensusmodel/zhang2012/Zhang2012.java

@@ -0,0 +1,165 @@
+package afryca.consensusmodel.zhang2012;
+
+import java.util.ArrayList;
+
+import afryca.ase.RunnableScript;
+import afryca.consensusmodel.ConsensusEngine;
+import afryca.consensusmodel.ConsensusModel;
+import afryca.consensusmodel.definition.EResultElements;
+import afryca.fpr.FPR;
+import afryca.structure.Structure;
+import afryca.consensumodel.addon.E4DIAddon;
+public class Zhang2012 extends ConsensusModel {
+
+	private static final String CONSENSUS_MODEL_NAME = "G. Zhang et al. (2011)"; //$NON-NLS-1$
+
+	private static final String CL = "cl"; //$NON-NLS-1$
+	private static final String CCL = "ccl"; //$NON-NLS-1$
+
+	private Float cl;
+	private Float ccl;
+
+	@Override
+	protected void setModelConfiguration() {
+	}
+
+	@Override
+	protected void obtainConfigurationValues() {
+		cl = (Float) configuration.getValue(CL);
+		ccl = (Float) configuration.getValue(CCL);
+	}
+	
+	@Override
+	protected Float[][][] obtainVisualizeValues() {
+		Structure[] auxPreferences = clonePreferencesUnion(preferences, ConsensusEngine.groupPreferences(numberOfExperts, numberOfAlternatives, preferences));
+
+		Float[][][] preferencesGroupVisualization = new Float[numberOfExperts + 1][numberOfAlternatives][numberOfAlternatives];
+		for (int k = 0; k < numberOfExperts+1; k++) {
+			preferencesGroupVisualization[k] =  auxPreferences[k].obtainVisualizeValues();
+		}
+		
+		return preferencesGroupVisualization;
+	}
+
+	@Override
+	protected void preFirstSaveRoundResults() {
+		Structure[] auxPreferences = clonePreferencesUnion(preferences, ConsensusEngine.groupPreferences(numberOfExperts, numberOfAlternatives, preferences));
+		preSaveRoundResult(1, auxPreferences,obtainVisualizeValues(), computeConsensusConsistencyLevel(auxPreferences));
+
+		result.put(EResultElements.initial_consensus_degree, computeConsensusConsistencyLevel(auxPreferences));
+		result.put(EResultElements.maxround, 1);
+		result.put(EResultElements.consensus_threshold, ccl);
+		result.put(EResultElements.consensus_model, CONSENSUS_MODEL_NAME);
+	}
+
+	@Override
+	protected void preSaveRoundResults() {
+		computeCollective();	
+		preSaveRoundResult(1, preferences,obtainVisualizeValues(), computeConsensusConsistencyLevel((Structure[]) preferences));
+	}
+
+	@Override
+	protected void posSaveRoundResults() {
+		computeCollective();	
+		posSaveRoundResult(preferences,obtainVisualizeValues(), computeConsensusConsistencyLevel((Structure[]) preferences), null);
+	}
+
+	@Override
+	protected boolean mustBeCarriedOutAnotherRound() {
+		return false;
+	}
+
+	@Override
+	protected void saveExecutionResults() {
+		this.configuration.setValue(PREFERENCES, preferences);
+		result.put(EResultElements.number_of_rounds_required, 1);
+		result.put(EResultElements.consensus_degree_achieved, computeConsensusConsistencyLevel((Structure[]) preferences));
+	}
+
+	@Override
+	@SuppressWarnings("unchecked")
+	protected void consensusRound() {
+		Float[] totalPreferences = preparePreferences();
+		
+		ArrayList<FPR> preferencesResult = (ArrayList<FPR>) ((RunnableScript) E4DIAddon.aseService.createExecutionBuilder()
+				.setFunction("Zhang2011LinearOptimizationFunction")
+				.putVariable("cl", cl)
+				.putVariable("ccl", ccl)
+				.putVariable("prefs", totalPreferences)
+				.putVariable("numAlternatives", numberOfAlternatives)
+				.putVariable("numExperts", numberOfExperts)
+				.execute())
+				.getResult();
+
+		int cont = 0;
+		for(FPR fpr: preferencesResult) {
+			preferences[cont] = fpr;
+			cont++;
+		}	
+	}
+
+	private Float[] preparePreferences() {
+		int numberOfAlternatives = preferences[0].getNumberOfAlternatives(), cont = 0;
+		Float[] totalPreferences = new Float[numberOfAlternatives * numberOfAlternatives * (preferences.length - 1)];
+		for(int p = 0; p < numberOfExperts; ++p) {
+			for(int i = 0; i < preferences[p].getNumberOfAlternatives(); ++i) {
+				for(int j = 0; j < preferences[p].getNumberOfAlternatives(); ++j) {
+					if(i == j) {
+						totalPreferences[cont] = 0.5f;
+					} else {
+						totalPreferences[cont] = (Float) preferences[p].getValue(i, j);
+					}
+					cont++;
+				}
+			}
+		}
+		return totalPreferences;
+	}
+	
+	private void computeCollective() {
+		preferences[numberOfExperts] = ConsensusEngine.groupPreferences(numberOfExperts, numberOfAlternatives, preferences);
+	}
+
+	@SuppressWarnings("unused")
+	private Float computeConsistencyLevel(FPR fpr) {
+		float acum = 0;
+
+		for (int i = 0; i < numberOfAlternatives; ++i) {
+			for (int k = 0; k < numberOfAlternatives; ++k) {
+				if (k != i) {
+					for (int j = 0; j < numberOfAlternatives; ++j) {
+						if (j != i && j != k) {
+							acum += Math.abs((Float) fpr.getValue(i, j) + (Float) fpr.getValue(j, k) - (Float) fpr.getValue(i, k) - 0.5);
+						}
+					}
+				}
+			}
+		}
+
+		float value = (2f / ((3f * numberOfAlternatives) * (numberOfAlternatives - 1f) * (numberOfAlternatives - 2f)));
+
+		return 1f - (value * acum);
+	}
+
+	private Float computeConsensusConsistencyLevel(Structure[] fprs) {
+		float ccl = 2f / ((numberOfAlternatives * numberOfExperts) * (numberOfExperts - 1f) * (numberOfAlternatives - 1f));
+		float acum = 0;
+
+		for (int i = 0; i < numberOfAlternatives; ++i) {
+			for (int j = 0; j < numberOfAlternatives; ++j) {
+				if (j != i) {
+					for (int t = 0; t < numberOfExperts; ++t) {
+						for (int r = 0; r < numberOfExperts; ++r) {
+							if (t >= r) {
+								acum += Math.abs((Float) fprs[r].getValue(i, j) - (Float) fprs[t].getValue(i, j));
+							}
+						}
+					}
+				}
+			}
+		}
+		ccl = 1f - ccl * acum;
+
+		return ccl;
+	}
+}