tests/org.eclipse.stem.tests.diseasemodels.forcing/src/org/eclipse/stem/diseasemodels/forcing/tests/GaussianDiseaseModelTestUtil.java

// DiseaseModelTestUtil.java
package org.eclipse.stem.diseasemodels.forcing.tests;

/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

import org.eclipse.emf.common.util.URI;
import org.eclipse.stem.core.STEMURI;
import org.eclipse.stem.core.common.DublinCore;
import org.eclipse.stem.core.graph.Edge;
import org.eclipse.stem.core.graph.Graph;
import org.eclipse.stem.core.graph.GraphFactory;
import org.eclipse.stem.core.graph.Node;
import org.eclipse.stem.core.model.Model;
import org.eclipse.stem.core.model.ModelFactory;
import org.eclipse.stem.core.model.NodeDecorator;
import org.eclipse.stem.core.model.STEMTime;
import org.eclipse.stem.definitions.adapters.spatial.geo.InlineLatLongDataProvider;
import org.eclipse.stem.definitions.adapters.spatial.geo.LatLong;
import org.eclipse.stem.definitions.adapters.spatial.geo.LatLong.SegmentBuilder;
import org.eclipse.stem.definitions.labels.AreaLabel;
import org.eclipse.stem.definitions.labels.LabelsFactory;
import org.eclipse.stem.definitions.labels.PopulationLabel;
import org.eclipse.stem.definitions.labels.TransportRelationshipLabel;
import org.eclipse.stem.definitions.labels.impl.PopulationLabelImpl;
import org.eclipse.stem.definitions.labels.impl.TransportRelationshipLabelImpl;
import org.eclipse.stem.definitions.nodes.NodesFactory;
import org.eclipse.stem.definitions.nodes.Region;
import org.eclipse.stem.diseasemodels.standard.DiseaseModelLabel;
import org.eclipse.stem.diseasemodels.standard.SIRLabel;
import org.eclipse.stem.diseasemodels.standard.StandardFactory;


/**
 * This class contains a number of utilities for creating artifacts useful for
 * testing disease model.
 */
public class GaussianDiseaseModelTestUtil {
	
	

	/**
	 * This is the rate at which population members (on average) transition from
	 * all of the other states (except <em>Pre-Born</em>) to the state
	 * <em>Dead</em>, per time period. Units: population members
	 * 
	 * @see StandardDiseaseModel#getBackgroundMortalityRate()
	 */
	public static final double MORTALITY_RATE = 0.01;
	public static final double MODULATION_FLOUR = 0.5;
	public static final double IMMUNITY_LOSS_RATE = 0.001;
	public static final double TRANSMISSION_RATE = 1.0+MODULATION_FLOUR;
	public static final double RECOVERY_RATE = 0.1;
	public static final long TIME_PERIOD = STEMTime.Units.DAY.getMilliseconds();

	/**
	 * The minimum latitude value of the rectangular area to which node spatial
	 * data is mapped.
	 */
	public final static double MIN_LATITUDE_VALUE = 0.0;

	/**
	 * The maximum latitude value of the rectangular area to which node spatial
	 * data is mapped.
	 */
	public final static double MAX_LATITUDE_VALUE = 50.0;

	/**
	 * The minimum longitude value of the rectangular area to which node spatial
	 * data is mapped.
	 */
	public final static double MIN_LONGITUDE_VALUE = 0.0;

	/**
	 * The maximum longitude value of the rectangular area to which node spatial
	 * data is mapped.
	 */
	public final static double MAX_LONGITUDE_VALUE = 100.0;

	/**
	 * The number of degrees of latitude of the area on the Earth's surface to
	 * which the nodes are mapped.
	 */
	public final static double LATITUDE_HEIGHT = MAX_LATITUDE_VALUE
			- MIN_LATITUDE_VALUE;

	/**
	 * The number of degrees of longitude of the area on the Earth's surface to
	 * which the nodes are mapped.
	 */
	public final static double LONGITUDE_WIDTH = MAX_LONGITUDE_VALUE
			- MIN_LONGITUDE_VALUE;

	/**
	 * The value used for the population of a node.
	 */
	public final static double TEST_POPULATION_COUNT = 100;

	/**
	 * The value used for area of a node.
	 */
	public final static double TEST_AREA = 100.0;

	/**
	 * The population used for the disease model tests.
	 */
	public static final String TEST_POPULATION_IDENTIFIER = PopulationLabel.HUMAN;

	/**
	 * This is the time period between successive computations of label values.
	 */
	public static final long TEST_TRANSPORT_RATE_TIME_PERIOD = STEMTime.Units.DAY.getMilliseconds();

	/**
	 * The number of humans that travel by air from one node to another.
	 */
	public static final int AIR_TRANSPORT_MAX_CAPACITY = 5;

	/**
	 * The number of humans that travel by road 1 from one node to another.
	 */
	public static final int ROAD1_TRANSPORT_MAX_CAPACITY = 3;

	/**
	 * The number of humans that travel by road 2 from one node to another.
	 */
	public static final int ROAD2_TRANSPORT_MAX_CAPACITY = 2;

	/**
	 * The name of a road connecting two nodes together in the graph.
	 */
	public static final String ROAD1_TRANSPORT_ID = "road1";

	/**
	 * The name of a road connecting two nodes together in the graph.
	 */
	public static final String ROAD2_TRANSPORT_ID = "road2";

	/**
	 * The number of kilometers of common border that two nodes share.
	 */
	public static final int COMMON_BORDER_LENGTH = 10;

	/**
	 * The identifier used for air transport
	 */
	public static final String AIR_TRANSPORT_ID = "aircanada";

	/**
	 * The difference between two double values that constitutes inequality
	 */
	public static final double DOUBLE_EQUALITY_TOLERANCE = 0.02;
	
	// Disease Model Test URI's
	public static final String MODEL = "DISEASEMODEL";
	public static final URI DEFAULT_URI = STEMURI.createURI(MODEL + "/" + "defaultTestURI");
	public static long TIME_ONE_DAY = 1;
	public static long TIME_TWO_DAY = 2;
	
	/**
	 * URI for the Solver
	 */
	public static URI SOLVER_URI = STEMURI.createURI("solver/solverTest.solver");
	
	public static STEMTime getSTEMTime() {
		return ModelFactory.eINSTANCE.createSTEMTime();
	}


	/**
	 * @param v1
	 *            a double
	 * @param v2
	 *            a double
	 * @return <code>true</code> if the two double values differ than by less
	 *         than {@link #DOUBLE_EQUALITY_TOLERANCE} and so should be
	 *         considered to be equal.
	 */
	public static final boolean closeEnough(final double v1, final double v2) {
		return Math.abs(v1 - v2) < DOUBLE_EQUALITY_TOLERANCE;
	} // closeEnough

	

	
	/**
	 * This method creates a Model where the nodes are interconnected as in a
	 * lattice.
	 * 
	 * @param nodeDecorators
	 *            the node decorators for the model
	 * @param numRows
	 *            the number of rows of nodes in the lattice
	 * @param numColumns
	 *            the number of columns of nodes in the lattice
	 * @param populationCount
	 *            the (Default: human) population at each node
	 * @param area
	 *            the area (km^2) of each node
	 * @return the model
	 */
	public static Model createLatticeModel(
			final Collection<NodeDecorator> nodeDecorators, final int numRows,
			final int numColumns, final double populationCount,
			final double area) {
		final Model retValue = ModelFactory.eINSTANCE.createModel();
		final DublinCore dc = retValue.getDublinCore();
		dc.populate();
		dc.setTitle(createModelTitle(nodeDecorators, numRows, numColumns,
				populationCount, area));

		retValue.getNodeDecorators().addAll(nodeDecorators);
		final Graph latticeGraph = createLatticeGraph(numRows, numColumns,
				populationCount, area);
		retValue.getGraphs().add(latticeGraph);

		assert retValue.sane();

		return retValue;
	} // createLatticeModel

	/**
	 * This method creates a graph where the nodes are interconnected as in a
	 * lattice.
	 * 
	 * @param numRows
	 *            the number of rows of nodes in the lattice
	 * @param numColumns
	 *            the number of columns of nodes in the lattice
	 * @param populationCount
	 *            the (Default: human) population at each node
	 * @param area
	 *            the area (km^2) of each node
	 * @return graph that is a lattice of nodes.
	 */
	public static Graph createLatticeGraph(final int numRows,
			final int numColumns, final double populationCount,
			final double area) {

		final Node nodeHolder[][] = new Node[numRows][numColumns];
		final Graph retValue = GraphFactory.eINSTANCE.createGraph();

		final DublinCore dc = retValue.getDublinCore();
		dc.populate();
		dc
				.setTitle(createGraphTitle(numRows, numColumns,
						populationCount, area));

		// Create the nodes and put them into the graph
		for (int row = 0; row < numRows; row++) {
			for (int column = 0; column < numColumns; column++) {
				final Region regionNode = createRegionNode(row, column);
				nodeHolder[row][column] = regionNode;
				retValue.putNode(regionNode);
			} // for each column
		} // for each row

		// Add the Population and Area labels
		for (int row = 0; row < numRows; row++) {
			for (int column = 0; column < numColumns; column++) {
				final Node node = nodeHolder[row][column];

				// Population
				retValue.putNodeLabel(createPopulationLabel(
						TEST_POPULATION_IDENTIFIER, populationCount, node));

				// Area
				retValue.putNodeLabel(createAreaLabel(area, node));
			} // for each column
		} // for each row

		// Now add relationships

	
		// Add the spatial specification to the spatial attribute of each node's
		// dublin core instance and for each edge. The value for the nodes will
		// be a rectangular area expressed as a set of lat/long points that
		// layout a polygon. The position of the polygon will at position that
		// matches the position (row, column) of the node in the lattice.
		addSpatialSpecifications(nodeHolder);

		assert retValue.sane();

		return retValue;
	} // createLatticeGraph

	/**
	 * Add the spatial specification to the spatial attribute of each node's
	 * dublin core instance. The value will be a retangular area expressed as a
	 * set of lat/long points that layout a polygon. The position of the polygon
	 * will at position that matches the position (row, column) of the node in
	 * the lattice. Node at position [0][0] will be in the upper left while the
	 * node at positon [numrows][numcolumns] will be in the lower right of the
	 * rectangular area.
	 * 
	 * @param nodeHolder
	 *            the array that holds the nodes of the lattic
	 */
	private static void addSpatialSpecifications(final Node[][] nodeHolder) {

		// First run through all of the nodes creating a polygon for their
		// border and adding the data as an inline value in the spatial
		// attribute of the node's dublin core.
		for (int row = 0; row < nodeHolder.length; row++) {
			for (int column = 0; column < nodeHolder[row].length; column++) {
				final Node node = nodeHolder[row][column];
				final LatLong nodeSegments = createNodeBorderLatLongSegments(
						row, nodeHolder.length, column, nodeHolder[row].length);
				final String spatialURIString = InlineLatLongDataProvider
						.createSpatialInlineURIString(nodeSegments);
				node.getDublinCore().setSpatial(spatialURIString);
			} // for each column
		} // for each row

		// Now do all the edges, we'll start in the upper right and do edges
		// between successive pairs of nodes.
		for (int row = 0; row < nodeHolder.length - 1; row++) {
			for (int column = 0; column < nodeHolder[row].length - 1; column++) {

				// First do the edges to the right
				final LatLong edgeSegmentsRight = createEdgeLatLongSegments(
						row, column, row, column + 1, nodeHolder.length,
						nodeHolder[row].length);

				final String edgeSpatialAttributeRight = InlineLatLongDataProvider
						.createSpatialInlineURIString(edgeSegmentsRight);

				for (Edge edge : getEdgesBetweenNodes(nodeHolder[row][column],
						nodeHolder[row][column + 1])) {
					edge.getDublinCore().setSpatial(edgeSpatialAttributeRight);
				}

				// Then do the edges below
				final LatLong edgeSegmentsBelow = createEdgeLatLongSegments(
						row, column, row + 1, column, nodeHolder.length,
						nodeHolder[row].length);

				final String edgeSpatialAttributeBelow = InlineLatLongDataProvider
						.createSpatialInlineURIString(edgeSegmentsBelow);

				for (Edge edge : getEdgesBetweenNodes(nodeHolder[row][column],
						nodeHolder[row + 1][column])) {
					edge.getDublinCore().setSpatial(edgeSpatialAttributeBelow);
				}
			} // for each column
		} // for each row

	} // addSpatialSpecifications

	/**
	 * @param node1
	 * @param node2
	 * @return all the edges between the two nodes
	 */
	private static List<Edge> getEdgesBetweenNodes(Node node1, Node node2) {
		final List<Edge> retValue = new ArrayList<Edge>();
		for (Iterator<Edge> edgeIterator = node1.getEdges().iterator(); edgeIterator
				.hasNext();) {
			final Edge edge = (Edge) edgeIterator.next();
			if (edge.getOtherNode(node1) == node2) {
				retValue.add(edge);
			}
		}
		return retValue;
	} // getEdgesBetweenNodes

	/**
	 * @param row
	 *            the row in the lattice of the node
	 * @param numRows
	 *            the total number of rows in the lattice
	 * @param column
	 *            the column in the lattice of the node
	 * @param numColumns
	 *            the total number of columns in the lattice
	 * @return a list of lat/long polygons/lines for the node
	 */
	private static LatLong createNodeBorderLatLongSegments(final int row,
			final int numRows, final int column, final int numColumns) {
		final LatLong retValue = new LatLong();
		final double nodeLatHeight = LATITUDE_HEIGHT / numRows;
		final double nodeLongWidth = LONGITUDE_WIDTH / numColumns;

		final double lowerLeftLat = MIN_LATITUDE_VALUE + (numRows - row - 1)
				* nodeLatHeight;
		final double lowerLeftLong = MIN_LONGITUDE_VALUE + column
				* nodeLongWidth;

		final double upperRightLat = lowerLeftLat + nodeLatHeight;
		final double upperRightLong = lowerLeftLong + nodeLongWidth;

		final SegmentBuilder sb = new SegmentBuilder();

		// We just make a rectangle...
		sb.add(lowerLeftLat, lowerLeftLong);
		sb.add(upperRightLat, lowerLeftLong);
		sb.add(upperRightLat, upperRightLong);
		sb.add(lowerLeftLat, upperRightLong);
		sb.add(lowerLeftLat, lowerLeftLong);
		retValue.add(sb.toSegment());

		return retValue;
	} // createNodeBorderLatLongSegments

	/**
	 * @param node1Row
	 * @param node1Column
	 * @param node2Row
	 * @param node2Column
	 * @param length
	 * @param length2
	 * @return a list of a lat/long line between the centers of the two nodes.
	 */
	private static LatLong createEdgeLatLongSegments(int node1Row,
			int node1Column, int node2Row, int node2Column, int numRows,
			int numColumns) {
		final LatLong retValue = new LatLong();
		final double nodeLatHeight = LATITUDE_HEIGHT / numColumns;
		final double nodeLongWidth = LONGITUDE_WIDTH / numRows;

		final double relativeNodeCenterLat = nodeLatHeight / 2.0;
		final double relativeNodeCenterLong = nodeLongWidth / 2.0;

		final double node1LowerLeftLat = MIN_LATITUDE_VALUE
				+ (numRows - node1Row - 1) * nodeLatHeight;
		final double node1LowerLeftLong = MIN_LONGITUDE_VALUE + node1Column
				* nodeLongWidth;

		final double node2LowerLeftLat = MIN_LATITUDE_VALUE
				+ (numRows - node2Row - 1) * nodeLatHeight;
		final double node2LowerLeftLong = MIN_LONGITUDE_VALUE + node2Column
				* nodeLongWidth;

		final SegmentBuilder sb = new SegmentBuilder();
		// We just make a straight line between the centers...
		sb.add(node1LowerLeftLat + relativeNodeCenterLat, node1LowerLeftLong
				+ relativeNodeCenterLong);
		sb.add(node2LowerLeftLat + relativeNodeCenterLat, node2LowerLeftLong
				+ relativeNodeCenterLong);

		retValue.add(sb.toSegment());

		return retValue;
	} // createEdgeLatLongSegments

	

	
	/**
	 * @param area
	 *            the area of the node
	 * @param node
	 *            the node
	 * @return an AreaLabel for the node
	 */
	private static AreaLabel createAreaLabel(final double area, final Node node) {
		final AreaLabel retValue = LabelsFactory.eINSTANCE.createAreaLabel();
		retValue.getCurrentAreaValue().setArea(area);
		node.getLabels().add(retValue);
		return retValue;
	} // createAreaLabel

	/**
	 * @param populationCount
	 *            number of (Default: human) population members at the node
	 * @param node
	 *            the node
	 * @return a population label
	 */
	private static PopulationLabel createPopulationLabel(
			final String populationIdentifier, final double populationCount,
			final Node node) {
		final PopulationLabel retValue = LabelsFactory.eINSTANCE
				.createPopulationLabel();
		retValue.setPopulationIdentifier(populationIdentifier);
		retValue.getCurrentPopulationValue().setCount(populationCount);
		node.getLabels().add(retValue);
		return retValue;
	} // createPopulationLabel

	/**
	 * Create a single populated node. This is used by the JUnit tests for
	 * disease models which need to have a disease model label that has an
	 * associated node.
	 * 
	 * 
	 * @return a node
	 */
	public static Region createPopulationRegionNode() {
		return createPopulationRegionNode(TEST_POPULATION_IDENTIFIER);
	} // createPopulationRegionNode

	/**
	 * Create a single populated node. This is used by the JUnit tests for
	 * disease models which need to have a disease model label that has an
	 * associated node.
	 * 
	 * @param populationIdentifier
	 *            the identifier of the population
	 * 
	 * 
	 * @return a node
	 */
	public static Region createPopulationRegionNode(
			final String populationIdentifier) {
		return createPopulationRegionNode(populationIdentifier,
				TEST_POPULATION_COUNT, TEST_AREA);
	} // createPopulationRegionNode

	/**
	 * Create a single populated node. This is used by the JUnit tests for
	 * disease models which need to have a disease model label that has an
	 * associated node.
	 * 
	 * @param populationIdentifier
	 *            the identifier of the population
	 * 
	 * @param populationCount
	 *            the number of population members
	 * @param area
	 *            the area of the node (km^2)
	 * @return a node
	 */
	public static Region createPopulationRegionNode(
			final String populationIdentifier, final double populationCount,
			final double area) {
		return createPopulationRegionNode(0, 0, populationIdentifier,
				populationCount, area);
	} // createPopulationRegionNode

	/**
	 * Create a single populated node. This is used by the JUnit tests for
	 * disease models which need to have a disease model label that has an
	 * associated node.
	 * 
	 * @param row
	 *            the row index of the node
	 * @param column
	 *            the column index of the node
	 * @param populationIdentifier
	 *            the identifier of the population
	 * @param populationCount
	 *            the number of population members
	 * @param area
	 *            the area of the node (km^2)
	 * @return a node
	 */
	public static Region createPopulationRegionNode(final int row,
			final int column, final String populationIdentifier,
			final double populationCount, final double area) {
		final Region retValue = createRegionNode(row, column);

		// Population
		createPopulationLabel(populationIdentifier, populationCount, retValue);

		// Area
		createAreaLabel(area, retValue);
		return retValue;
	} // createPopulationRegionNode

	/**
	 * @param row
	 *            the row of the node in the lattice
	 * @param column
	 *            the column of the node in the lattice
	 * @return a node
	 */
	private static Region createRegionNode(int row, int column) {
		final Region retValue = NodesFactory.eINSTANCE.createRegion();

		final DublinCore dc = retValue.getDublinCore();
		dc.setTitle(createNodeTitle(row, column));
		retValue.setURI(createRegionNodeURI(row, column));
		return retValue;
	} // createRegionNode

	/**
	 * @param row
	 *            the row of the region in the lattice
	 * @param column
	 *            the column of the region in the lattice
	 * @return a URI for the region node
	 */
	public static URI createRegionNodeURI(int row, int column) {
		URI retValue = STEMURI.createURI(Region.URI_TYPE_REGION_NODE_SEGMENT
				+ "/" + row + "_" + column);
		return retValue;
	} // createRegionNodeURI

	/**
	 * @param row
	 *            the row of the node in the lattice
	 * @param column
	 *            the column of the node in the lattice
	 * @return a title for a node
	 */
	public static String createNodeTitle(int row, int column) {
		final StringBuilder sb = new StringBuilder("Node[");
		sb.append(Integer.toString(row));
		sb.append(", ");
		sb.append(Integer.toString(column));
		sb.append("]");
		return sb.toString();
	} // createNodeTitle

	/**
	 * @param numRows
	 *            the number of rows of nodes in the lattice
	 * @param numColumns
	 *            the number of columns of nodes in the lattice
	 * @param populationCount
	 *            the (Default: human) population at each node
	 * @param area
	 *            the area (km^2) of each node
	 * @return a title for a graph
	 */
	private static String createGraphTitle(int numRows, int numColumns,
			double populationCount, double area) {
		final StringBuilder sb = new StringBuilder("Graph");
		sb.append(Integer.toString(numRows));
		sb.append("x");
		sb.append(Integer.toString(numColumns));
		sb.append("[");
		sb.append(Double.toString(populationCount));
		sb.append(", ");
		sb.append(area);
		sb.append("]");
		return sb.toString();
	} // createGraphTitle

	/**
	 * @param nodeDecorators
	 * @param numRows
	 * @param numColumns
	 * @param populationCount
	 * @param area
	 * @return the title of the model
	 */
	private static String createModelTitle(
			final Collection<NodeDecorator> nodeDecorators, int numRows,
			int numColumns, double populationCount, double area) {
		final StringBuilder sb = new StringBuilder("Model");
		sb.append(Integer.toString(numRows));
		sb.append("x");
		sb.append(Integer.toString(numColumns));
		for (Iterator<NodeDecorator> nodeDecoratorIter = nodeDecorators
				.iterator(); nodeDecoratorIter.hasNext();) {
			final NodeDecorator nodeDecorator = nodeDecoratorIter.next();
			sb.append(nodeDecorator.getDublinCore().getTitle());
		} // for

		sb.append("[");
		sb.append(Double.toString(populationCount));
		sb.append(", ");
		sb.append(area);
		sb.append("]");
		return sb.toString();
	} // createModelTitle

	

	
	/**
	 * @param graph
	 * @param row
	 * @param column
	 * @return the indexed region from the graph
	 */
	public static Region getRegion(final Graph graph, final int row,
			final int column) {
		Region retValue = null;

		for (Iterator<Node> nodeIter = graph.getNodes().values().iterator(); nodeIter
				.hasNext();) {
			final Region region = (Region) nodeIter.next();
			final String name = region.getDublinCore().getTitle();
			// Is this the region we're looking for?
			if (name.equals(GaussianDiseaseModelTestUtil.createNodeTitle(row, column))) {
				// Yes
				retValue = region;
				break;
			}
		}
		return retValue;
	} // getRegion

	/**
	 * Examine the transportation edges coming into nodeA from nodeB and return
	 * the one with the specified identifier.
	 * 
	 * @param nodeA
	 * @param nodeB
	 * @param transportId
	 * @return the transportation edge between two nodes with a specific
	 *         transport id
	 */
	public static Edge getTransportEdge(final Node nodeA, final Node nodeB,
			final String transportId) {
		Edge retValue = null;

		for (Edge transportEdge : TransportRelationshipLabelImpl
				.getTransportEdgesToNode(nodeA,
						GaussianDiseaseModelTestUtil.TEST_POPULATION_IDENTIFIER)) {
			// Is this edge from nodeB?
			if (transportEdge.getOtherNode(nodeA) == nodeB) {
				// Yes
				final TransportRelationshipLabel trl = (TransportRelationshipLabel) transportEdge
						.getLabel();
				// Does this edge have the transport id we're looking for?
				if (trl.getTransportIdentifier().equalsIgnoreCase(transportId)) {
					// Yes
					retValue = transportEdge;
					break;
				}
			}
		} // for each transport edge
		return retValue;
	} // getTransportEdge
	
	/**
	 * @return an SILabel instance
	 */
	public static SIRLabel createLabel() {
		final SIRLabel retValue = StandardFactory.eINSTANCE.createSIRLabel();
		final Region node = GaussianDiseaseModelTestUtil.createPopulationRegionNode(GaussianDiseaseModelTestUtil.TEST_POPULATION_IDENTIFIER);

		labelRegion(retValue,GaussianDiseaseModelTestUtil.TEST_POPULATION_IDENTIFIER, node);
		return retValue;	
	} // createLabel() 

	/**
	 * 
	 * @param diseaseLabel
	 * @param populationIdentifier
	 * @param region
	 */
	protected static void labelRegion(final DiseaseModelLabel diseaseLabel,
			final String populationIdentifier, final Region region) {
		diseaseLabel.setURIOfIdentifiableToBeLabeled(region.getURI());
		final PopulationLabel populationLabel = PopulationLabelImpl
				.getPopulationLabel(populationIdentifier, region);
		diseaseLabel.setPopulationLabel(populationLabel);
		region.getLabels().add(diseaseLabel);
	} // labelRegion

} // DiseaseModelTestUtil