models/epidemiology/org.eclipse.stem.diseasemodels.externaldatasource/src/org/eclipse/stem/diseasemodels/externaldatasource/impl/ExternalDataSourceDiseaseModelImpl.java

// ExternalDataSourceDiseaseModelImpl
package org.eclipse.stem.diseasemodels.externaldatasource.impl;


/*******************************************************************************
 * Copyright (c) 2007, 2008 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.io.IOException;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.impl.ENotificationImpl;
import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
import org.eclipse.emf.edit.provider.IItemPropertySource;
import org.eclipse.emf.edit.ui.provider.PropertySource;
import org.eclipse.stem.analysis.LogInitializationException;
import org.eclipse.stem.analysis.util.CSVScenarioStreamer;
import org.eclipse.stem.core.Utility;
import org.eclipse.stem.core.common.Identifiable;
import org.eclipse.stem.core.graph.DynamicLabel;
import org.eclipse.stem.core.graph.LabelValue;
import org.eclipse.stem.core.graph.NodeLabel;
import org.eclipse.stem.core.model.STEMTime;
import org.eclipse.stem.definitions.labels.AreaLabel;
import org.eclipse.stem.definitions.labels.PopulationLabel;
import org.eclipse.stem.diseasemodels.Activator;
import org.eclipse.stem.diseasemodels.externaldatasource.ExternalDataSourceDiseaseModel;
import org.eclipse.stem.diseasemodels.externaldatasource.ExternalDataSourcePackage;
import org.eclipse.stem.diseasemodels.standard.impl.StandardDiseaseModelImpl;
import org.eclipse.stem.diseasemodels.standard.DiseaseModelLabel;
import org.eclipse.stem.diseasemodels.standard.DiseaseModelLabelValue;
import org.eclipse.stem.diseasemodels.standard.Infector;
import org.eclipse.stem.diseasemodels.standard.SEIRLabelValue;
import org.eclipse.stem.diseasemodels.standard.SILabelValue;
import org.eclipse.stem.diseasemodels.standard.SIRLabelValue;
import org.eclipse.stem.diseasemodels.standard.StandardDiseaseModelLabel;
import org.eclipse.stem.diseasemodels.standard.StandardDiseaseModelLabelValue;
import org.eclipse.stem.diseasemodels.standard.StandardFactory;
import org.eclipse.stem.diseasemodels.standard.StandardPackage;
import org.eclipse.stem.diseasemodels.standard.impl.SEIRLabelValueImpl;
import org.eclipse.stem.diseasemodels.standard.impl.SILabelValueImpl;
import org.eclipse.stem.diseasemodels.standard.impl.SIRLabelValueImpl;
import org.eclipse.stem.diseasemodels.standard.provider.StandardItemProviderAdapterFactory;


/**
 * <!-- begin-user-doc -->
 * An implementation of the model object '<em><b>Disease Model</b></em>'.
 * <!-- end-user-doc -->
 * <p>
 * The following features are implemented:
 * <ul>
 *   <li>{@link org.eclipse.stem.diseasemodels.externaldatasource.impl.ExternalDataSourceDiseaseModelImpl#getDataPath <em>Data Path</em>}</li>
 *   <li>{@link org.eclipse.stem.diseasemodels.externaldatasource.impl.ExternalDataSourceDiseaseModelImpl#getDiseaseType <em>Disease Type</em>}</li>
 * </ul>
 * </p>
 *
 * @generated
 */
public class ExternalDataSourceDiseaseModelImpl extends StandardDiseaseModelImpl implements ExternalDataSourceDiseaseModel {

	/**
	 * The default value of the '{@link #getDataPath() <em>Data Path</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see #getDataPath()
	 * @generated
	 * @ordered
	 */
	protected static final String DATA_PATH_EDEFAULT = null;
	/**
	 * The cached value of the '{@link #getDataPath() <em>Data Path</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see #getDataPath()
	 * @generated
	 * @ordered
	 */
	protected String dataPath = DATA_PATH_EDEFAULT;

	//private final static String URI_PREFIX_PATTERN = "geo/region/";

	/**
	 * The default value of the '{@link #getDiseaseType() <em>Disease Type</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @see #getDiseaseType()
	 * @generated
	 * @ordered
	 */
	protected static final String DISEASE_TYPE_EDEFAULT = null;
	/**
	 * This prefix precedes the node id and must be removed in the 
	 * filterFilename method to auto-generate the output file name.
	 */
	public static final String LOCATIONID_PREFIX = "/node/geo/region/";


	/**
	 * Directory containing the scenario to import and play back
	 */
	public String dirName = DEFAULT_DIR;

	/**
	 * a false (Hidden) time counter used for this toy example
	 */
	private int fileLineCounter = 0;

	protected Set<String> S_KEY_SET = new HashSet<String>();
	protected Set<String> E_KEY_SET = new HashSet<String>();
	protected Set<String> I_KEY_SET = new HashSet<String>();	
	protected Set<String> R_KEY_SET = new HashSet<String>();
	protected Set<String> INCIDENCE_KEY_SET = new HashSet<String>();
	
	public static String labelS  = null ;
	public static String labelE  = null ;
	public static String labelI = null ;  // for display only
	public static String labelR  = null ;
	public static String labelIncidence = null;
	

	// We need this to determine when a simulation is restarted so we 
	// can reset the file line counter. Also needed to keep track of the line number in the file
	private STEMTime firstSTEMTime = null;
	
	// The streamer
	
	CSVScenarioStreamer streamer;
	
	/**
	 * not used
	 */
	private double totalPopulationCount = 0.0;
	private double totalArea = 0.0;

	private String diseaseType;

	
	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated NOT
	 */
	public ExternalDataSourceDiseaseModelImpl() {
		super();
	}




	/**
	 * @see org.eclipse.stem.core.model.impl.DecoratorImpl#updateLabels(org.eclipse.stem.core.graph.Graph,
	 *      org.eclipse.stem.core.model.STEMTime)
	 */
	@Override
	public void updateLabels(final STEMTime time, final long timeDelta, int cycle) {


		// MAD 10/29/2009
		// Commented out code, moved to "calculateDelta" for IntegrationDecorator.
		// Not sure what updates need to happen to "updateLabels".

		/*
		// Iterate through each of the labels we need to update.
		for (final Iterator<DynamicLabel> currentStateLabelIter = getLabelsToUpdate()
				.iterator(); currentStateLabelIter.hasNext();) {
			final StandardDiseaseModelLabel diseaseLabel = (StandardDiseaseModelLabel) currentStateLabelIter
					.next();

			assert diseaseLabel.getPopulationLabel().getPopulationIdentifier()
					.equals(getPopulationIdentifier());

			// This is the current state of the disease for this label
			final StandardDiseaseModelLabelValue currentState = (StandardDiseaseModelLabelValue)diseaseLabel
					.getCurrentValue();


			// 2) Compute the state transitions
			final StandardDiseaseModelLabelValue nullAdditions = importDiseaseData(currentState, diseaseLabel, time, timeDelta);


			// This will be the state that we compute.
			final StandardDiseaseModelLabelValue nextState = (StandardDiseaseModelLabelValue)diseaseLabel.getNextValue();

			// Initialize the next state from the current state and then we'll
			// make the changes to that.
			nextState.set(currentState);



			assert nextState.sane():"disease state is insane after subtracting deaths: "+nextState.toString();


			// The next value is valid now.
			diseaseLabel.setNextValueValid(true);


		} // for
		++fileLineCounter;
		 */
	} // updateLabels

	/**
	 * get the constants which identify the disease label state variables
	 * @param diseaseLabel
	 */
	private static void setPropertyLabels() {
		SEIRLabelValue diseaseLabel = (SEIRLabelValue) StandardFactory.eINSTANCE.createSEIRLabel().getCurrentValue();
		StandardItemProviderAdapterFactory itemProviderFactory = new StandardItemProviderAdapterFactory();
		IItemPropertySource propertySource = (IItemPropertySource) itemProviderFactory.adapt(diseaseLabel, PropertySource.class);
		List<IItemPropertyDescriptor> properties = propertySource.getPropertyDescriptors(null);

		IItemPropertyDescriptor propertyS = properties.get(StandardPackage.SEIR_LABEL_VALUE__S);
		IItemPropertyDescriptor propertyE = properties.get(StandardPackage.SEIR_LABEL_VALUE__E);
		IItemPropertyDescriptor propertyI = properties.get(StandardPackage.SEIR_LABEL_VALUE__I);
		IItemPropertyDescriptor propertyR = properties.get(StandardPackage.SEIR_LABEL_VALUE__R);
		IItemPropertyDescriptor propertyIncidence = properties.get(StandardPackage.SEIR_LABEL_VALUE__INCIDENCE);
		labelS = propertyS.getDisplayName(propertyS);
		labelE = propertyE.getDisplayName(propertyE);
		labelI = propertyI.getDisplayName(propertyI);
		labelR = propertyR.getDisplayName(propertyR);
		labelIncidence = propertyIncidence.getDisplayName(propertyIncidence);
	}// setPropertyLabels

	
/**
 * 
 */
	private synchronized void setupStreaming() {
		if(streamer == null) {
			try {
				streamer = new CSVScenarioStreamer(this.dataPath);
				streamer.prepareForStreaming(-1);
				// Set the disease type here since we don't need that
				// input from the end-user any longer
				this.diseaseType = streamer.getType().name();
				this.S_KEY_SET = streamer.getsKeySet();
				this.E_KEY_SET = streamer.geteKeySet();
				this.I_KEY_SET = streamer.getiKeySet();
				this.R_KEY_SET = streamer.getrKeySet();
				this.INCIDENCE_KEY_SET = streamer.getIncidenceKeySet();
			} catch(LogInitializationException sie) {
				Activator.logError("Error reading scenario files", sie);
			} catch(IOException ioe) {
				Activator.logError("IOExceptopn reading scenario files", ioe);
			}
		}
	}

	/**
	 * 
	 * This method reads the next state data from the external dataFile
	 * 
	 * @param deltaState
	 * @param diseaseLabel
	 * @param time
	 * @param timeDelta
	 * @param streamNextRow True if we should fetch the next row from stream
	 * @return
	 */
	public StandardDiseaseModelLabelValue importDiseaseData(
			final StandardDiseaseModelLabelValue deltaState,
			final StandardDiseaseModelLabel diseaseLabel, 
			final STEMTime time, 
			final long timeDelta,
			boolean streamNextRow) {

		try {
			
			// Will only be set up first time called
			setupStreaming();
			
			if(labelS==null) setPropertyLabels();
	
			// TODO
			// the filename actually comes from the node itself
			// we need to regen the code with a scenarioDirectory 
			// specification as every node maps to a different data file. for now we will test
			// with only one node and one file
			// need a map of maps keyed by location name
	
	
			Identifiable ident = diseaseLabel.getIdentifiable();
			String fileName = ident.getURI().toString();
			int last = fileName.lastIndexOf(LOCATIONID_PREFIX);
			last += LOCATIONID_PREFIX.length();
			String location = fileName.substring(last,fileName.length());
	
			int adminLevel = Utility.keyLevel(location);
			
			// if no data
	/*		if((data==null)||(data.size() == 0)) {
				// no data for location in questions
				if (diseaseType.equals(IMPORT_TYPE_SI)) {
					return new SILabelValueImpl(0.0 , 0.0, 0.0, 0.0);
				} else if (diseaseType.equals(IMPORT_TYPE_SIR)) {
					return new SIRLabelValueImpl(0.0, 0.0 , 0.0, 0.0, 0.0);
				} else if (diseaseType.equals(IMPORT_TYPE_SEIR)) {
					return new SEIRLabelValueImpl( 0.0, 0.0, 0.0 , 0.0, 0.0, 0.0);
				} else {
					throw new UnsupportedOperationException("ExternalDataSource Invalid Type "+diseaseType+" must be SI, SIR, or SEIR");
				}
			}
	*/
			// JHK Notes: HOW DO I GET THE CURRENT STEP??
			//  
			// node >> graph
			// graph >> scenario using SimulationManger method
			// SimulationManger.getManger()
			// then call manager.mapGraphToSimulation(final Graph graph) {
			// to get the rvhp you just have to adapt it again.
	
			// csv diseases read from file know their own
			// time period property in millisecs
			// This method is called by "updateLabels"
			// should really override that instead fo compute transitions
			// updateLabels has the TIME.
	
			// TODO
			// remove filter in StandardRelativeValueProviderAdapterFactory 
			// which is preventing disease deaths from being logged.
			// method is StandardRelativeValueProviderAdapterFactory List<IItemPropertyDescriptor> getProperties()
	
			double deltaS  = 0.0;
			double deltaE  = 0.0;
			double deltaI = 0.0;
			double deltaR  = 0.0;
			double incidence = 0.0;
	
			StandardDiseaseModelLabelValue currentValue = (StandardDiseaseModelLabelValue)diseaseLabel.getCurrentValue();
			//		String id = ident.getURI().toString();
			//		int strt = id.indexOf(URI_PREFIX_PATTERN);
			//		if(strt>=0) {
			//			id = id.substring(strt+URI_PREFIX_PATTERN.length(),id.length());
			//		}
	
			//		if((dataInstance!=null)&&(dataInstance.instance.containsKey(id))) {
	
			//if(dataInstance!=null) {
			// compute the changes
			if(adminLevel > -1) {
				List<Double>data = null;
				if(streamer.getCurrentRow(adminLevel, labelS) < fileLineCounter)
					data = streamer.streamRow(adminLevel, labelS);
				else data = streamer.getLastFetchedRow(adminLevel, labelS);
				
				int pos = streamer.getDataPosition(adminLevel, location);
				
				if(data != null && pos >=0) {
					double d = data.get(pos);
					deltaS = d - currentValue.getS();
				}// S 
		
				// Incidence
				if(streamer.getCurrentRow(adminLevel, labelIncidence) < fileLineCounter)
					data = streamer.streamRow(adminLevel, labelIncidence);
				else data = streamer.getLastFetchedRow(adminLevel, labelIncidence);
				
				if(data != null && pos >=0) {
					double d = data.get(pos);
					incidence = d;
				}// S 
				
				if (diseaseType.equals(IMPORT_TYPE_SEIR)) {
					if(streamer.getCurrentRow(adminLevel, labelE) < fileLineCounter)
						data = streamer.streamRow(adminLevel, labelE);
					else data = streamer.getLastFetchedRow(adminLevel, labelE);
					if(data != null && pos >=0) {
						double d = data.get(pos);
						deltaE = d- ((SEIRLabelValue)currentValue).getE();
					}// E
				}
				
				//////////////////////////////////////////////////////
				// I
				// May be more than one type of I state (Ia, Il, etc)
				// for now just add them all up
				//
				int numIstates = I_KEY_SET.size();
				if(I_KEY_SET!=null) {
					Iterator<String> iter = I_KEY_SET.iterator();
					double dI = 0;
					while(iter.hasNext()) {
						String iKey = iter.next();
						if(streamer.getCurrentRow(adminLevel, iKey) < fileLineCounter)
							data = streamer.streamRow(adminLevel, iKey);
						else data = streamer.getLastFetchedRow(adminLevel, iKey);
		
						if(data != null && pos >=0) {	
							double d = data.get(pos);
							dI += d;
						}
					}
					deltaI = dI - ((SILabelValue)currentValue).getI();
				} else {
					Activator.logInformation("I Keys are all Null !!");
				}
				//i
				//////////////////////////////////////////////////////
				
		
				if (diseaseType.equals(IMPORT_TYPE_SIR) || diseaseType.equals(IMPORT_TYPE_SEIR)) {
					if(streamer.getCurrentRow(adminLevel, labelR) < fileLineCounter)
						data = streamer.streamRow(adminLevel, labelR);
					else data = streamer.getLastFetchedRow(adminLevel, labelR);
		
					if(data != null && pos >=0) {
						double d = data.get(pos);
						deltaR = d - ((SIRLabelValue)currentValue).getR();
					}// R
				}
			} // admin level > -1
			
			if (diseaseType.equals(IMPORT_TYPE_SI)) {
				((SILabelValue)deltaState).setS(deltaS);
				((SILabelValue)deltaState).setI(deltaI);
				((SILabelValue)deltaState).setIncidence(incidence);
				return new SILabelValueImpl( 0.0 , 0.0, 0.0, 0.0);
			} else if (diseaseType.equals(IMPORT_TYPE_SIR)) {
				((SIRLabelValue)deltaState).setS(deltaS);
				((SIRLabelValue)deltaState).setI(deltaI);
				((SIRLabelValue)deltaState).setR(deltaR);
				((SIRLabelValue)deltaState).setIncidence(incidence);
				return new SIRLabelValueImpl(0.0, 0.0 , 0.0, 0.0, 0.0);
			} else if (diseaseType.equals(IMPORT_TYPE_SEIR)) {
				((SEIRLabelValue)deltaState).setS(deltaS);
				((SEIRLabelValue)deltaState).setE(deltaE);
				((SEIRLabelValue)deltaState).setI(deltaI);
				((SEIRLabelValue)deltaState).setR(deltaR);
				((SEIRLabelValue)deltaState).setIncidence(incidence);
				return new SEIRLabelValueImpl(0.0, 0.0, 0.0 , 0.0, 0.0, 0.0);
			} else {
				throw new UnsupportedOperationException("ExternalDataSource Invalid Type "+diseaseType+" must be SI, SIR, or SEIR");
			}
			//		}else {
			//			// if data == null
			//			// no data for location in questions
			//			if (diseaseType.equals(IMPORT_TYPE_SI)) {
			//				return new SILabelValueImpl(0.0 , 0.0, 0.0, 0.0);
			//			} else if (diseaseType.equals(IMPORT_TYPE_SIR)) {
			//				return new SIRLabelValueImpl(0.0, 0.0 , 0.0, 0.0, 0.0);
			//			} else if (diseaseType.equals(IMPORT_TYPE_SEIR)) {
			//				return new SEIRLabelValueImpl( 0.0, 0.0, 0.0 , 0.0, 0.0, 0.0);
			//			} else {
			//				throw new UnsupportedOperationException("ExternalDataSource Invalid Type "+diseaseType+" must be SI, SIR, or SEIR");
			//			}
			//		}

		} catch(IOException ioe) {
			Activator.logError("Exception streaming data", ioe);
		}
		return null;
	} // importDiseaseData


	/**
	 * @see org.eclipse.stem.diseasemodels.standard.impl.DiseaseModelImpl#createDiseaseModelLabel()
	 */
	@Override
	public DiseaseModelLabel createDiseaseModelLabel(String populationIdentifier) {
		if (diseaseType==IMPORT_TYPE_SI) return StandardFactory.eINSTANCE.createSILabel();
		if (diseaseType==IMPORT_TYPE_SIR) return StandardFactory.eINSTANCE.createSIRLabel();
		// else default
		return StandardFactory.eINSTANCE.createSEIRLabel();
	} // createDiseaseModelLabel

	/**
	 * 
	 */
	@Override
	public DiseaseModelLabelValue createDiseaseModelLabelValue(String populationIdentifier) {
		if(diseaseType==IMPORT_TYPE_SI) return StandardFactory.eINSTANCE.createSILabelValue();
		if(diseaseType==IMPORT_TYPE_SIR) return StandardFactory.eINSTANCE.createSIRLabelValue();
		return StandardFactory.eINSTANCE.createSEIRLabelValue();
	} // createDiseaseModelLabelValue

	
	/**
	 * @see org.eclipse.stem.diseasemodels.standard.impl.DiseaseModelImpl#createInfector()
	 */
	@Override
	public Infector createInfector() {
		throw new UnsupportedOperationException();
	} // createInfector

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 * 
	 * @generated NOT
	 */
	public void addToTotalArea(double area) {
		totalArea += area;
	} // addToTotalArea



	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 * 
	 * @generated NOT
	 */
	public void addToTotalPopulationCount(double populationCount) {
		totalPopulationCount += populationCount;
	} // addToTotalPopulationCount

	/**
	 * @param populationLabel
	 *            the population label that labels the node
	 * @return the area of the node associated with the label
	 */
	public double getArea(final PopulationLabel populationLabel) {
		double retValue = 0.0;

		// The population label could have an area specified for the population
		// that we should use instead of the area of the region labeled by the
		// population label. This value would be specified if the population was
		// densely packed into a small area of the larger region, for instance
		// like a city in an otherwise large desert.

		retValue = populationLabel.getPopulatedArea();

		// Is there an area specified for the population?
		if (retValue == 0.0) {
			// No
			// Ok, go find the area label and return the area of the region
			for (final Iterator<NodeLabel> labelIter = populationLabel.getNode()
					.getLabels().iterator(); labelIter.hasNext();) {
				final NodeLabel nodeLabel = labelIter.next();
				// Is this an area label?
				if (nodeLabel instanceof AreaLabel) {
					// Yes
					final AreaLabel areaLabel = (AreaLabel) nodeLabel;
					retValue = areaLabel.getCurrentAreaValue().getArea();
					break;
				}
			} // for
		} // If no population area specified

		return retValue;
	} // getArea


	/**
	 * @param populationLabel
	 * @param area
	 */
	private void reportBadAreaValue(final PopulationLabel populationLabel,
			double area) {
		// The bad value could be specified for the node or be an overide
		// value specified for the population.
		// Is the bad value from the node?
		if (populationLabel.getPopulatedArea() == 0.0) {
			// Yes
			Activator.logError("The area value of \"" + area
					+ "\" specified for \""
					+ populationLabel.getNode().toString()
					+ "\" is not greater than zero (0.0)", null);
		} // if bad value for node area
		else {
			Activator.logError("The area value of \"" + area
					+ "\" specified for the population \""
					+ populationLabel.getName() + "\" for the region \""
					+ populationLabel.getNode().toString()
					+ "\" is not greater than zero (0.0)", null);
		}
	} // reportBadAreaValue

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	protected EClass eStaticClass() {
		return ExternalDataSourcePackage.Literals.EXTERNAL_DATA_SOURCE_DISEASE_MODEL;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public String getDataPath() {
		return dataPath;
	}




	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public void setDataPath(String newDataPath) {
		String oldDataPath = dataPath;
		dataPath = newDataPath;
		if (eNotificationRequired())
			eNotify(new ENotificationImpl(this, Notification.SET, ExternalDataSourcePackage.EXTERNAL_DATA_SOURCE_DISEASE_MODEL__DATA_PATH, oldDataPath, dataPath));
	}




	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public String getDiseaseType() {
		return diseaseType;
	}




	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public void setDiseaseType(String newDiseaseType) {
		String oldDiseaseType = diseaseType;
		diseaseType = newDiseaseType;
		if (eNotificationRequired())
			eNotify(new ENotificationImpl(this, Notification.SET, ExternalDataSourcePackage.EXTERNAL_DATA_SOURCE_DISEASE_MODEL__DISEASE_TYPE, oldDiseaseType, diseaseType));
	}




	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public Object eGet(int featureID, boolean resolve, boolean coreType) {
		switch (featureID) {
			case ExternalDataSourcePackage.EXTERNAL_DATA_SOURCE_DISEASE_MODEL__DATA_PATH:
				return getDataPath();
			case ExternalDataSourcePackage.EXTERNAL_DATA_SOURCE_DISEASE_MODEL__DISEASE_TYPE:
				return getDiseaseType();
		}
		return super.eGet(featureID, resolve, coreType);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void eSet(int featureID, Object newValue) {
		switch (featureID) {
			case ExternalDataSourcePackage.EXTERNAL_DATA_SOURCE_DISEASE_MODEL__DATA_PATH:
				setDataPath((String)newValue);
				return;
			case ExternalDataSourcePackage.EXTERNAL_DATA_SOURCE_DISEASE_MODEL__DISEASE_TYPE:
				setDiseaseType((String)newValue);
				return;
		}
		super.eSet(featureID, newValue);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void eUnset(int featureID) {
		switch (featureID) {
			case ExternalDataSourcePackage.EXTERNAL_DATA_SOURCE_DISEASE_MODEL__DATA_PATH:
				setDataPath(DATA_PATH_EDEFAULT);
				return;
			case ExternalDataSourcePackage.EXTERNAL_DATA_SOURCE_DISEASE_MODEL__DISEASE_TYPE:
				setDiseaseType(DISEASE_TYPE_EDEFAULT);
				return;
		}
		super.eUnset(featureID);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public boolean eIsSet(int featureID) {
		switch (featureID) {
			case ExternalDataSourcePackage.EXTERNAL_DATA_SOURCE_DISEASE_MODEL__DATA_PATH:
				return DATA_PATH_EDEFAULT == null ? dataPath != null : !DATA_PATH_EDEFAULT.equals(dataPath);
			case ExternalDataSourcePackage.EXTERNAL_DATA_SOURCE_DISEASE_MODEL__DISEASE_TYPE:
				return DISEASE_TYPE_EDEFAULT == null ? diseaseType != null : !DISEASE_TYPE_EDEFAULT.equals(diseaseType);
		}
		return super.eIsSet(featureID);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public String toString() {
		if (eIsProxy()) return super.toString();

		StringBuffer result = new StringBuffer(super.toString());
		result.append(" (dataPath: "); //$NON-NLS-1$
		result.append(dataPath);
		result.append(", diseaseType: "); //$NON-NLS-1$
		result.append(diseaseType);
		result.append(')');
		return result.toString();
	}


	/**
	 *  Since data is read from a file we don't have to take into account
	 *   birth/deaths etc from other decorators, the data is already supposed
	 *	 to handle that.
	 */

	public void applyExternalDeltas(STEMTime time, long timeDelta,
			EList<DynamicLabel> labels) {
		// Nothing to do.

	}


	public synchronized void calculateDelta(STEMTime time, long timeDelta,
			EList<DynamicLabel> labels) {

		
		if(firstSTEMTime == null || time.getTime().equals(firstSTEMTime.getTime()))
			fileLineCounter = 0;
		else
			fileLineCounter = (int)((time.getTime().getTime() - firstSTEMTime.getTime().getTime()) / timeDelta);

		if(firstSTEMTime == null) firstSTEMTime = time;

		// Iterate through each of the labels we need to update.
		boolean firstLabel = true;
		for (final DynamicLabel dynLabel : labels) {
			final StandardDiseaseModelLabel diseaseLabel = (StandardDiseaseModelLabel) dynLabel;



			assert diseaseLabel.getPopulationLabel().getPopulationIdentifier()
			.equals(getPopulationIdentifier());

			// This is the current state of the disease for this label
			final StandardDiseaseModelLabelValue deltaState = (StandardDiseaseModelLabelValue)diseaseLabel
			.getDeltaValue();


			// 2) This will set the delta
			final StandardDiseaseModelLabelValue nullAdditions = importDiseaseData(deltaState, diseaseLabel, time, timeDelta, firstLabel);


			// This will be the state that we compute.
			//			final StandardDiseaseModelLabelValue nextState = (StandardDiseaseModelLabelValue)diseaseLabel.getNextValue();

			// Initialize the next state from the current state and then we'll
			// make the changes to that.
			// nextState.set(currentState);



			//			assert nextState.sane():"disease state is insane after subtracting deaths: "+nextState.toString();


			// The next value is valid now.
			//			diseaseLabel.setNextValueValid(true);

			firstLabel = false;
		} // for
	}




	public void doModelSpecificAdjustments(LabelValue label) {
		// TODO Auto-generated method stub

	}


	public boolean isDeterministic() {
		return true;
	}





	@Override
	public StandardDiseaseModelLabelValue computeDiseaseDeltas(STEMTime time,
			StandardDiseaseModelLabelValue currentState,
			StandardDiseaseModelLabel diseaseLabel, long timeDelta,
			DiseaseModelLabelValue returnValue) {
		// Nothing to do
		return (StandardDiseaseModelLabelValue)returnValue;
	}

} //ExternalDataSourceDiseaseModelImpl