| package org.eclipse.stem.populationmodels.standard.impl; | |
| /******************************************************************************* | |
| * Copyright (c) 2009 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.HashMap; | |
| import java.util.List; | |
| import java.util.Map; | |
| import org.eclipse.emf.common.notify.Notification; | |
| import org.eclipse.emf.common.util.ECollections; | |
| import org.eclipse.emf.common.util.EList; | |
| import org.eclipse.emf.common.util.URI; | |
| import org.eclipse.emf.ecore.EClass; | |
| import org.eclipse.emf.ecore.impl.ENotificationImpl; | |
| import org.eclipse.emf.ecore.util.EcoreUtil; | |
| import org.eclipse.stem.core.graph.DynamicLabel; | |
| import org.eclipse.stem.core.graph.Edge; | |
| import org.eclipse.stem.core.graph.Exchange; | |
| import org.eclipse.stem.core.graph.ExchangeType; | |
| import org.eclipse.stem.core.graph.Graph; | |
| import org.eclipse.stem.core.graph.GraphFactory; | |
| import org.eclipse.stem.core.graph.IntegrationLabelValue; | |
| import org.eclipse.stem.core.graph.LabelValue; | |
| import org.eclipse.stem.core.graph.Node; | |
| import org.eclipse.stem.core.graph.NodeLabel; | |
| import org.eclipse.stem.core.model.STEMTime; | |
| import org.eclipse.stem.core.scenario.ScenarioInitializationException; | |
| import org.eclipse.stem.definitions.labels.PopulationLabelValue; | |
| import org.eclipse.stem.definitions.transport.PipeStyleTransportSystem; | |
| import org.eclipse.stem.definitions.transport.PipeTransportEdge; | |
| import org.eclipse.stem.definitions.transport.PipeTransportEdgeLabelValue; | |
| import org.eclipse.stem.populationmodels.standard.PopulationModelLabel; | |
| import org.eclipse.stem.populationmodels.standard.PopulationModelLabelValue; | |
| import org.eclipse.stem.populationmodels.standard.StandardFactory; | |
| import org.eclipse.stem.populationmodels.standard.StandardPackage; | |
| import org.eclipse.stem.populationmodels.standard.StandardPopulationModel; | |
| import org.eclipse.stem.populationmodels.standard.StandardPopulationModelLabel; | |
| import org.eclipse.stem.populationmodels.standard.StandardPopulationModelLabelValue; | |
| /** | |
| * <!-- begin-user-doc --> | |
| * An implementation of the model object '<em><b>Population Model</b></em>'. | |
| * <!-- end-user-doc --> | |
| * <p> | |
| * The following features are implemented: | |
| * <ul> | |
| * <li>{@link org.eclipse.stem.populationmodels.standard.impl.StandardPopulationModelImpl#getBirthRate <em>Birth Rate</em>}</li> | |
| * <li>{@link org.eclipse.stem.populationmodels.standard.impl.StandardPopulationModelImpl#getDeathRate <em>Death Rate</em>}</li> | |
| * <li>{@link org.eclipse.stem.populationmodels.standard.impl.StandardPopulationModelImpl#getTimePeriod <em>Time Period</em>}</li> | |
| * </ul> | |
| * </p> | |
| * | |
| * @generated | |
| */ | |
| public class StandardPopulationModelImpl extends PopulationModelImpl implements StandardPopulationModel { | |
| /** | |
| * The default value of the '{@link #getBirthRate() <em>Birth Rate</em>}' attribute. | |
| * <!-- begin-user-doc --> | |
| * <!-- end-user-doc --> | |
| * @see #getBirthRate() | |
| * @generated | |
| * @ordered | |
| */ | |
| protected static final double BIRTH_RATE_EDEFAULT = 0.0; | |
| /** | |
| * The cached value of the '{@link #getBirthRate() <em>Birth Rate</em>}' attribute. | |
| * <!-- begin-user-doc --> | |
| * <!-- end-user-doc --> | |
| * @see #getBirthRate() | |
| * @generated | |
| * @ordered | |
| */ | |
| protected double birthRate = BIRTH_RATE_EDEFAULT; | |
| /** | |
| * The default value of the '{@link #getDeathRate() <em>Death Rate</em>}' attribute. | |
| * <!-- begin-user-doc --> | |
| * <!-- end-user-doc --> | |
| * @see #getDeathRate() | |
| * @generated | |
| * @ordered | |
| */ | |
| protected static final double DEATH_RATE_EDEFAULT = 0.0; | |
| /** | |
| * The cached value of the '{@link #getDeathRate() <em>Death Rate</em>}' attribute. | |
| * <!-- begin-user-doc --> | |
| * <!-- end-user-doc --> | |
| * @see #getDeathRate() | |
| * @generated | |
| * @ordered | |
| */ | |
| protected double deathRate = DEATH_RATE_EDEFAULT; | |
| /** | |
| * The default value of the '{@link #getTimePeriod() <em>Time Period</em>}' attribute. | |
| * <!-- begin-user-doc --> | |
| * <!-- end-user-doc --> | |
| * @see #getTimePeriod() | |
| * @generated | |
| * @ordered | |
| */ | |
| protected static final long TIME_PERIOD_EDEFAULT = 86400000L; | |
| /** | |
| * The cached value of the '{@link #getTimePeriod() <em>Time Period</em>}' attribute. | |
| * <!-- begin-user-doc --> | |
| * <!-- end-user-doc --> | |
| * @see #getTimePeriod() | |
| * @generated | |
| * @ordered | |
| */ | |
| protected long timePeriod = TIME_PERIOD_EDEFAULT; | |
| protected Map<Node, List<PipeTransportEdge>> pipeTransportationNodeEdgesMap; | |
| /** | |
| * <!-- begin-user-doc --> | |
| * <!-- end-user-doc --> | |
| * @generated NOT | |
| */ | |
| public StandardPopulationModelImpl() { | |
| super(); | |
| } | |
| /** | |
| * <!-- begin-user-doc --> | |
| * <!-- end-user-doc --> | |
| * @generated | |
| */ | |
| @Override | |
| protected EClass eStaticClass() { | |
| return StandardPackage.Literals.STANDARD_POPULATION_MODEL; | |
| } | |
| /** | |
| * <!-- begin-user-doc --> | |
| * <!-- end-user-doc --> | |
| * @generated | |
| */ | |
| public double getBirthRate() { | |
| return birthRate; | |
| } | |
| /** | |
| * <!-- begin-user-doc --> | |
| * <!-- end-user-doc --> | |
| * @generated | |
| */ | |
| public void setBirthRate(double newBirthRate) { | |
| double oldBirthRate = birthRate; | |
| birthRate = newBirthRate; | |
| if (eNotificationRequired()) | |
| eNotify(new ENotificationImpl(this, Notification.SET, StandardPackage.STANDARD_POPULATION_MODEL__BIRTH_RATE, oldBirthRate, birthRate)); | |
| } | |
| /** | |
| * <!-- begin-user-doc --> | |
| * <!-- end-user-doc --> | |
| * @generated | |
| */ | |
| public double getDeathRate() { | |
| return deathRate; | |
| } | |
| /** | |
| * <!-- begin-user-doc --> | |
| * <!-- end-user-doc --> | |
| * @generated | |
| */ | |
| public void setDeathRate(double newDeathRate) { | |
| double oldDeathRate = deathRate; | |
| deathRate = newDeathRate; | |
| if (eNotificationRequired()) | |
| eNotify(new ENotificationImpl(this, Notification.SET, StandardPackage.STANDARD_POPULATION_MODEL__DEATH_RATE, oldDeathRate, deathRate)); | |
| } | |
| /** | |
| * <!-- begin-user-doc --> | |
| * <!-- end-user-doc --> | |
| * @generated | |
| */ | |
| public long getTimePeriod() { | |
| return timePeriod; | |
| } | |
| /** | |
| * <!-- begin-user-doc --> | |
| * <!-- end-user-doc --> | |
| * @generated | |
| */ | |
| public void setTimePeriod(long newTimePeriod) { | |
| long oldTimePeriod = timePeriod; | |
| timePeriod = newTimePeriod; | |
| if (eNotificationRequired()) | |
| eNotify(new ENotificationImpl(this, Notification.SET, StandardPackage.STANDARD_POPULATION_MODEL__TIME_PERIOD, oldTimePeriod, timePeriod)); | |
| } | |
| /** | |
| * Decorate the graph for a standard population model | |
| * | |
| */ | |
| @Override | |
| public void decorateGraph(STEMTime time) throws ScenarioInitializationException { | |
| if(this.isGraphDecorated()) return; | |
| super.decorateGraph(time); | |
| return; | |
| } // decorateGraph | |
| /** | |
| * <!-- begin-user-doc --> | |
| * <!-- end-user-doc --> | |
| * @generated | |
| */ | |
| @Override | |
| public Object eGet(int featureID, boolean resolve, boolean coreType) { | |
| switch (featureID) { | |
| case StandardPackage.STANDARD_POPULATION_MODEL__BIRTH_RATE: | |
| return getBirthRate(); | |
| case StandardPackage.STANDARD_POPULATION_MODEL__DEATH_RATE: | |
| return getDeathRate(); | |
| case StandardPackage.STANDARD_POPULATION_MODEL__TIME_PERIOD: | |
| return getTimePeriod(); | |
| } | |
| return super.eGet(featureID, resolve, coreType); | |
| } | |
| /** | |
| * <!-- begin-user-doc --> | |
| * <!-- end-user-doc --> | |
| * @generated | |
| */ | |
| @Override | |
| public void eSet(int featureID, Object newValue) { | |
| switch (featureID) { | |
| case StandardPackage.STANDARD_POPULATION_MODEL__BIRTH_RATE: | |
| setBirthRate((Double)newValue); | |
| return; | |
| case StandardPackage.STANDARD_POPULATION_MODEL__DEATH_RATE: | |
| setDeathRate((Double)newValue); | |
| return; | |
| case StandardPackage.STANDARD_POPULATION_MODEL__TIME_PERIOD: | |
| setTimePeriod((Long)newValue); | |
| return; | |
| } | |
| super.eSet(featureID, newValue); | |
| } | |
| /** | |
| * <!-- begin-user-doc --> | |
| * <!-- end-user-doc --> | |
| * @generated | |
| */ | |
| @Override | |
| public void eUnset(int featureID) { | |
| switch (featureID) { | |
| case StandardPackage.STANDARD_POPULATION_MODEL__BIRTH_RATE: | |
| setBirthRate(BIRTH_RATE_EDEFAULT); | |
| return; | |
| case StandardPackage.STANDARD_POPULATION_MODEL__DEATH_RATE: | |
| setDeathRate(DEATH_RATE_EDEFAULT); | |
| return; | |
| case StandardPackage.STANDARD_POPULATION_MODEL__TIME_PERIOD: | |
| setTimePeriod(TIME_PERIOD_EDEFAULT); | |
| return; | |
| } | |
| super.eUnset(featureID); | |
| } | |
| /** | |
| * <!-- begin-user-doc --> | |
| * <!-- end-user-doc --> | |
| * @generated | |
| */ | |
| @Override | |
| public boolean eIsSet(int featureID) { | |
| switch (featureID) { | |
| case StandardPackage.STANDARD_POPULATION_MODEL__BIRTH_RATE: | |
| return birthRate != BIRTH_RATE_EDEFAULT; | |
| case StandardPackage.STANDARD_POPULATION_MODEL__DEATH_RATE: | |
| return deathRate != DEATH_RATE_EDEFAULT; | |
| case StandardPackage.STANDARD_POPULATION_MODEL__TIME_PERIOD: | |
| return timePeriod != TIME_PERIOD_EDEFAULT; | |
| } | |
| 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(" (birthRate: "); | |
| result.append(birthRate); | |
| result.append(", deathRate: "); | |
| result.append(deathRate); | |
| result.append(", timePeriod: "); | |
| result.append(timePeriod); | |
| result.append(')'); | |
| return result.toString(); | |
| } | |
| @Override | |
| public PopulationModelLabel createPopulationLabel() { | |
| PopulationModelLabel retValue = StandardFactory.eINSTANCE.createStandardPopulationModelLabel(); | |
| retValue.setTypeURI(PopulationModelLabel.URI_TYPE_DYNAMIC_POPULATION_LABEL); | |
| return retValue; | |
| } | |
| @Override | |
| public PopulationModelLabelValue createPopulationLabelValue() { | |
| return StandardFactory.eINSTANCE.createStandardPopulationModelLabelValue(); | |
| } | |
| /** | |
| * Compute the changes in the population from the birth/death rate | |
| * adjusted for the time period used in the simulation | |
| * @param time | |
| * @param timeDelta | |
| * @param labels | |
| */ | |
| public void calculateDelta(STEMTime time, long timeDelta, | |
| EList<DynamicLabel> labels) { | |
| // We simply calculate the change from the birth/death rate | |
| // adjusted for the time period used in the simulation | |
| double adjustedBirthRate = adjustRate(this.getBirthRate(), this.getTimePeriod(), timeDelta); | |
| double adjustedDeathRate = adjustRate(this.getDeathRate(), this.getTimePeriod(), timeDelta); | |
| for(DynamicLabel label:labels) { | |
| StandardPopulationModelLabelImpl slabel = (StandardPopulationModelLabelImpl)label; | |
| StandardPopulationModelLabelValueImpl delta = (StandardPopulationModelLabelValueImpl)slabel.getDeltaValue(); | |
| StandardPopulationModelLabelValue current = (StandardPopulationModelLabelValue)slabel.getProbeValue(); | |
| double currentPopulation = current.getCount(); | |
| double births = currentPopulation * adjustedBirthRate; | |
| double deaths = currentPopulation * adjustedDeathRate; | |
| delta.setCount(births-deaths); | |
| delta.setBirths(births); | |
| delta.setDeaths(deaths); | |
| Exchange birthExchange = GraphFactory.eINSTANCE.createExchange(); | |
| Exchange deathExchange = GraphFactory.eINSTANCE.createExchange(); | |
| birthExchange.setType(ExchangeType.BIRTHS_AND_DEATHS); | |
| birthExchange.setCount(births); | |
| deathExchange.setType(ExchangeType.BIRTHS_AND_DEATHS); | |
| deathExchange.setCount(deaths); | |
| delta.getArrivals().clear(); | |
| delta.getDepartures().clear(); | |
| delta.getArrivals().add(birthExchange); | |
| delta.getDepartures().add(deathExchange); | |
| handleMigration(slabel, delta.getArrivals(),delta.getDepartures(), this.getTimePeriod(), timeDelta, delta); | |
| handlePipeTransport(slabel, delta.getArrivals(),delta.getDepartures(), timeDelta, delta); | |
| ECollections.sort(delta.getArrivals()); | |
| ECollections.sort(delta.getDepartures()); | |
| } | |
| }// calculateDelta | |
| protected void handlePipeTransport(StandardPopulationModelLabelImpl populationLabel, EList<Exchange>arrivals,EList<Exchange>departures, long timeDelta, StandardPopulationModelLabelValueImpl delta) { | |
| // Get the pipe transport edges to/from the node | |
| Node node = populationLabel.getNode(); | |
| List<PipeTransportEdge>pedges = pipeTransportationNodeEdgesMap.get(node); | |
| if(pedges == null) return; // no edges | |
| // Now figure out how many people to actually move between nodes | |
| for(PipeTransportEdge pedge:pedges) { | |
| if(!pedge.getPopulationIdentifier().equals(this.getPopulationIdentifier())) continue; // wrong population | |
| boolean incomming = pedge.getB().equals(node); | |
| if(incomming) { | |
| for(NodeLabel lab: pedge.getA().getLabels()) { | |
| if(lab instanceof StandardPopulationModelLabel && ((StandardPopulationModelLabel)lab).getPopulationIdentifier().equals(populationLabel.getPopulationIdentifier())) { | |
| StandardPopulationModelLabel otherLabel = (StandardPopulationModelLabel)lab; | |
| StandardPopulationModelLabelValue otherValue = (StandardPopulationModelLabelValue)otherLabel.getTempValue(); | |
| StandardPopulationModelLabelValue change = (StandardPopulationModelLabelValue)EcoreUtil.copy(otherValue); | |
| PipeTransportEdgeLabelValue edgeLabelValue = (PipeTransportEdgeLabelValue)pedge.getLabel().getCurrentValue(); | |
| double maxFlow = edgeLabelValue.getMaxFlow(); | |
| double flow = maxFlow; | |
| double popCount = ((StandardPopulationModelLabelValue)otherLabel.getTempValue()).getCount(); | |
| if(flow > popCount) | |
| flow = popCount; // don't move more people than available. | |
| long timePeriod = edgeLabelValue.getTimePeriod(); | |
| double factor = flow / popCount; | |
| factor = factor * timeDelta / timePeriod; | |
| if(Double.isNaN(factor) || Double.isInfinite(factor)) factor = 0.0; | |
| change.scale(factor); | |
| delta.add((IntegrationLabelValue)change); | |
| Exchange migrationExchange = GraphFactory.eINSTANCE.createExchange(); | |
| migrationExchange.setType(ExchangeType.MIGRATION); | |
| migrationExchange.setOtherLabel(otherLabel); | |
| migrationExchange.setCount(change.getCount()); | |
| delta.getArrivals().add(migrationExchange); | |
| break; | |
| } | |
| } | |
| } else { // outgoing edge | |
| for(NodeLabel lab: pedge.getB().getLabels()) { | |
| if(lab instanceof StandardPopulationModelLabel && ((StandardPopulationModelLabel)lab).getPopulationIdentifier().equals(populationLabel.getPopulationIdentifier())) { | |
| StandardPopulationModelLabel otherLabel = (StandardPopulationModelLabel)lab; | |
| StandardPopulationModelLabelValue thisValue = (StandardPopulationModelLabelValue)populationLabel.getTempValue(); | |
| StandardPopulationModelLabelValue change = (StandardPopulationModelLabelValue)EcoreUtil.copy(thisValue); | |
| PipeTransportEdgeLabelValue edgeLabelValue = (PipeTransportEdgeLabelValue)pedge.getLabel().getCurrentValue(); | |
| double maxFlow = edgeLabelValue.getMaxFlow(); | |
| double popCount = ((StandardPopulationModelLabelValue)populationLabel.getTempValue()).getCount(); | |
| double flow = maxFlow; | |
| if(flow > popCount) | |
| flow = popCount; | |
| long timePeriod = edgeLabelValue.getTimePeriod(); | |
| double factor = flow / popCount; | |
| factor = factor * timeDelta / timePeriod; | |
| if(Double.isNaN(factor) || Double.isInfinite(factor)) factor = 0.0; | |
| change.scale(factor); | |
| delta.sub((IntegrationLabelValue)change); | |
| Exchange migrationExchange = GraphFactory.eINSTANCE.createExchange(); | |
| migrationExchange.setType(ExchangeType.MIGRATION); | |
| migrationExchange.setOtherLabel(otherLabel); | |
| migrationExchange.setCount(change.getCount()); | |
| delta.getDepartures().add(migrationExchange); | |
| break; | |
| } | |
| } | |
| } | |
| } // for each edge | |
| } | |
| protected double adjustRate(double rate, long ratePeriod, long actualPeriod) { | |
| return rate * ((double)actualPeriod/(double)ratePeriod); | |
| } | |
| public void doModelSpecificAdjustments(LabelValue label) { | |
| // TODO Auto-generated method stub | |
| } | |
| public boolean isDeterministic() { | |
| return true; | |
| } | |
| @SuppressWarnings("boxing") | |
| protected void populatePipeSystemNodes() { | |
| Graph graph = this.getGraph(); | |
| if(pipeTransportationNodeEdgesMap == null) initPipeTransport(graph); | |
| for(Map.Entry<Node, List<PipeTransportEdge>>entry:pipeTransportationNodeEdgesMap.entrySet()) { | |
| Node n = entry.getKey(); | |
| if(n instanceof PipeStyleTransportSystem) { | |
| // We need to create an initial population here. | |
| // We do this by looking at all incoming pipe edges to the node and add up the total flow. | |
| List<PipeTransportEdge>pipeEdges = entry.getValue(); | |
| double totalPop = 0.0; | |
| for(PipeTransportEdge pedge:pipeEdges) | |
| if(pedge.getB().equals(n)) | |
| totalPop += ((PipeTransportEdgeLabelValue) pedge.getLabel().getCurrentValue()).getMaxFlow(); | |
| for(NodeLabel nlabel:n.getLabels()) { | |
| if(nlabel instanceof StandardPopulationModelLabel && ((StandardPopulationModelLabel)nlabel).getPopulationIdentifier().equals(this.getPopulationIdentifier())) { | |
| StandardPopulationModelLabelValue splv = (StandardPopulationModelLabelValue)((StandardPopulationModelLabel)nlabel).getCurrentValue(); | |
| splv.setCount(totalPop); | |
| PopulationLabelValue plv = (PopulationLabelValue)((StandardPopulationModelLabel)nlabel).getPopulationLabel().getCurrentPopulationValue(); | |
| plv.setCount(totalPop); | |
| } | |
| } | |
| } | |
| } | |
| /*Map<Integer, List<PipeTransportEdge>> map = pipeTransportationUpEdgesMap; | |
| Integer [] levels = new Integer[map.keySet().size()]; | |
| levels = map.keySet().toArray(levels); | |
| Arrays.sort(levels, 0, levels.length, | |
| new Comparator<Integer>() { | |
| public int compare(Integer o1, Integer o2) { | |
| if(o1 < o2) return 1; | |
| else if(o1 > o2) return -1; | |
| return 0; | |
| } | |
| }); | |
| StandardPopulationModelLabelValue currsrclabelval=null, currdestlabelval=null; | |
| PopulationLabelValue staticDestLabelValue=null; | |
| // First, we clear out any existing population in the air transportation system nodes. If we don't do this, we will move more people than we | |
| // expect up into the air the second time we run the same scenario | |
| for(int level : levels) { | |
| List<PipeTransportEdge> edges = map.get(level); | |
| for(PipeTransportEdge ptedge:edges) { | |
| // Move people from source to destination using the flow of the pipe | |
| Node source = ptedge.getA(); | |
| Node dest = ptedge.getB(); | |
| if(source == null || dest == null) continue; // ok, the region or transport system is not part of the model | |
| String popIdSrc=null; | |
| for(NodeLabel nlabel:source.getLabels()) { | |
| if(nlabel instanceof PopulationModelLabel) { | |
| currsrclabelval = (StandardPopulationModelLabelValue)((PopulationModelLabel)nlabel).getCurrentValue(); | |
| popIdSrc = ((PopulationModelLabel)nlabel).getPopulationIdentifier(); | |
| } else continue; | |
| for(NodeLabel nlabel2:dest.getLabels()) { | |
| if(nlabel2 instanceof PopulationModelLabel && | |
| ((PopulationModelLabel)nlabel2).getPopulationIdentifier().equals(popIdSrc)) { | |
| ((StandardPopulationModelLabelValue)((PopulationModelLabel)nlabel2).getCurrentValue()).setCount(0.0); | |
| ((PopulationLabelValue)((PopulationModelLabel)nlabel2).getPopulationLabel().getCurrentValue()).setCount(0.0); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| // Now, move people from the region nodes up into the air transportation nodes. We move exactly a fraction of people corresponding | |
| // to the passenger counts for each air (pipe) transport edge. | |
| for(int level : levels) { | |
| List<PipeTransportEdge> edges = map.get(level); | |
| for(PipeTransportEdge ptedge:edges) { | |
| // Move people from source to destination using the flow of the pipe | |
| Node source = ptedge.getA(); | |
| Node dest = ptedge.getB(); | |
| if(source == null || dest == null) continue; // ok, the region or transport system is not part of the model | |
| PipeTransportEdgeLabelValue label = (PipeTransportEdgeLabelValue) ptedge.getLabel().getCurrentValue(); | |
| double maxflow = label.getMaxFlow(); | |
| String popIdSrc=null; | |
| for(NodeLabel nlabel:source.getLabels()) { | |
| if(nlabel instanceof PopulationModelLabel) { | |
| currsrclabelval = (StandardPopulationModelLabelValue)((PopulationModelLabel)nlabel).getCurrentValue(); | |
| popIdSrc = ((PopulationModelLabel)nlabel).getPopulationIdentifier(); | |
| } else continue; | |
| for(NodeLabel nlabel2:dest.getLabels()) { | |
| if(nlabel2 instanceof PopulationModelLabel && | |
| ((PopulationModelLabel)nlabel2).getPopulationIdentifier().equals(popIdSrc)) { | |
| currdestlabelval = (StandardPopulationModelLabelValue)((PopulationModelLabel)nlabel2).getCurrentValue(); | |
| staticDestLabelValue = (PopulationLabelValue)((PopulationModelLabel)nlabel2).getPopulationLabel().getCurrentValue(); | |
| } | |
| } | |
| if(currsrclabelval == null || currdestlabelval == null) { | |
| continue; // possible for transport pipes connected to regions above the lowest region part of the model | |
| } | |
| // Check, make sure we don't move more people than available | |
| double flow = maxflow; | |
| if(currsrclabelval.getCount() < flow) flow = currsrclabelval.getCount(); // check | |
| double factor = flow / currsrclabelval.getCount(); | |
| if(Double.isNaN(factor)) factor = 0.0; | |
| StandardPopulationModelLabelValue move = null; | |
| move = (StandardPopulationModelLabelValue)EcoreUtil.copy(currsrclabelval); | |
| move.scale(factor); | |
| currdestlabelval.add((IntegrationLabelValue)move); | |
| // Also set the populationlabel to the count of the population model label since it's 0 for air transport nodes when built in STEM. Needed when we reset the value back to the original later | |
| staticDestLabelValue.setCount(currdestlabelval.getCount()+staticDestLabelValue.getCount()); | |
| } // for each label on the source node | |
| } | |
| } | |
| // Check for nodes that have no initial population. Get rid of those | |
| ArrayList<Node>nodesToRemove = new ArrayList<Node>(); | |
| for(Node n:pipeTransportationNodeEdgesMap.keySet()) { | |
| boolean remove = false; | |
| if( (n instanceof PipeStyleTransportSystemImpl)) { | |
| PipeStyleTransportSystemImpl psts = (PipeStyleTransportSystemImpl)n; | |
| for(NodeLabel l:psts.getLabels()) { | |
| if(l instanceof StandardPopulationModelLabel) { | |
| StandardPopulationModelLabel sl = (StandardPopulationModelLabel)l; | |
| StandardPopulationModelLabelValue slv = (StandardPopulationModelLabelValue)sl.getCurrentValue(); | |
| if(slv.getCount() == 0.0) { | |
| remove = true;break; | |
| } | |
| } | |
| if(remove)break; | |
| } | |
| ArrayList<PipeTransportEdge>edgesToRemove = new ArrayList<PipeTransportEdge>(); | |
| if(remove) { | |
| Activator.logInformation("Warning, ignoring air transportation node without population "+n, new Exception()); | |
| nodesToRemove.add(n); | |
| // Remove all air transport edges using the node as well as the node itself | |
| for(List<PipeTransportEdge>l :pipeTransportationDownEdgesMap.values()) { | |
| for(PipeTransportEdge pse:l) { | |
| if(pse.getA() == null || pse.getB() == null) continue; | |
| if(pse.getA().equals(n) || pse.getB().equals(n)) { | |
| if(!edgesToRemove.contains(pse))edgesToRemove.add(pse); | |
| } | |
| } | |
| } | |
| for(List<PipeTransportEdge>l :pipeTransportationUpEdgesMap.values()) { | |
| for(PipeTransportEdge pse:l) { | |
| if(pse.getA() == null || pse.getB() == null) continue; | |
| if(pse.getA().equals(n) || pse.getB().equals(n)) { | |
| if(!edgesToRemove.contains(pse))edgesToRemove.add(pse); | |
| } | |
| } | |
| } | |
| for(PipeTransportEdge pse:edgesToRemove) { | |
| for(List<PipeTransportEdge>l :pipeTransportationDownEdgesMap.values()) | |
| l.remove(pse); | |
| for(List<PipeTransportEdge>l :pipeTransportationUpEdgesMap.values()) | |
| l.remove(pse); | |
| } | |
| for(PipeTransportEdge pse:edgesToRemove) { | |
| for(List<PipeTransportEdge>l :pipeTransportationNodeEdgesMap.values()) | |
| l.remove(pse); | |
| for(List<PipeTransportEdge>l :pipeTransportationNodeEdgesMap.values()) | |
| l.remove(pse); | |
| } | |
| } | |
| } | |
| } | |
| for(Node n:nodesToRemove) pipeTransportationNodeEdgesMap.remove(n); | |
| */ | |
| } | |
| /** | |
| * initialize pipe transport maps organizing pipes by direction (up/down) | |
| * and level | |
| * @param graph | |
| */ | |
| @SuppressWarnings("boxing") | |
| private void initPipeTransport(Graph graph) { | |
| pipeTransportationNodeEdgesMap = new HashMap<Node, List<PipeTransportEdge>>(); | |
| // Traverse all pipe transport edges and determine what | |
| // geographic level their source (A) node is at | |
| for(URI edgeURI : graph.getEdges().keySet()) { | |
| Edge edge = graph.getEdges().get(edgeURI); | |
| if(edge instanceof PipeTransportEdge) { | |
| PipeTransportEdge pedge = (PipeTransportEdge)edge; | |
| Node a = edge.getA(); | |
| Node b = edge.getB(); | |
| if(a != null) | |
| if(pipeTransportationNodeEdgesMap.containsKey(a)) | |
| pipeTransportationNodeEdgesMap.get(a).add(pedge); | |
| else { | |
| ArrayList<PipeTransportEdge> newList = new ArrayList<PipeTransportEdge>(); | |
| newList.add(pedge); | |
| pipeTransportationNodeEdgesMap.put(a, newList); | |
| } | |
| if(b != null) | |
| if(pipeTransportationNodeEdgesMap.containsKey(b)) | |
| pipeTransportationNodeEdgesMap.get(b).add(pedge); | |
| else { | |
| ArrayList<PipeTransportEdge> newList = new ArrayList<PipeTransportEdge>(); | |
| newList.add(pedge); | |
| pipeTransportationNodeEdgesMap.put(b, newList); | |
| } | |
| } | |
| } | |
| /* | |
| pipeTransportationUpEdgesMap = new HashMap<Integer, List<PipeTransportEdge>>(); | |
| pipeTransportationDownEdgesMap = new HashMap<Integer, List<PipeTransportEdge>>(); | |
| pipeTransportationNodeEdgesMap = new HashMap<Node, List<PipeTransportEdge>>(); | |
| // Traverse all pipe transport edges and determine what | |
| // geographic level their source (A) node is at | |
| for(URI edgeURI : graph.getEdges().keySet()) { | |
| Edge edge = graph.getEdges().get(edgeURI); | |
| if(edge instanceof PipeTransportEdge) { | |
| PipeTransportEdge pedge = (PipeTransportEdge)edge; | |
| int beginLevel = Utility.keyLevel(edge.getNodeAURI().lastSegment()); | |
| int endLevel = Utility.keyLevel(edge.getNodeBURI().lastSegment()); | |
| Map<Integer, List<PipeTransportEdge>> map; | |
| if(beginLevel > endLevel) map = pipeTransportationUpEdgesMap; | |
| else map = pipeTransportationDownEdgesMap; | |
| if(map.containsKey(beginLevel)) { | |
| map.get(beginLevel).add(pedge); | |
| } else { | |
| ArrayList<PipeTransportEdge> list = new ArrayList<PipeTransportEdge>(); | |
| list.add(pedge); | |
| map.put(beginLevel, list); | |
| } | |
| Node a = edge.getA(); | |
| Node b = edge.getB(); | |
| if(a != null) | |
| if(pipeTransportationNodeEdgesMap.containsKey(a)) | |
| pipeTransportationNodeEdgesMap.get(a).add(pedge); | |
| else { | |
| ArrayList<PipeTransportEdge> newList = new ArrayList<PipeTransportEdge>(); | |
| newList.add(pedge); | |
| pipeTransportationNodeEdgesMap.put(a, newList); | |
| } | |
| if(b != null) | |
| if(pipeTransportationNodeEdgesMap.containsKey(b)) | |
| pipeTransportationNodeEdgesMap.get(b).add(pedge); | |
| else { | |
| ArrayList<PipeTransportEdge> newList = new ArrayList<PipeTransportEdge>(); | |
| newList.add(pedge); | |
| pipeTransportationNodeEdgesMap.put(b, newList); | |
| } | |
| } | |
| } | |
| */ | |
| } | |
| @Override | |
| public void resetLabels() throws ScenarioInitializationException { | |
| super.resetLabels(); | |
| // Populate the pipe transportation systems | |
| this.populatePipeSystemNodes(); | |
| } | |
| } //StandardPopulationModelImpl |