@Override public Id<ActivityFacility> getId() { return this.activityFacility.getId(); }
@Override public final TreeMap<Id<ActivityFacility>, ActivityFacility> getFacilitiesForActivityType(final String act_type) { TreeMap<Id<ActivityFacility>, ActivityFacility> facs = new TreeMap<>(); Iterator<ActivityFacility> iter = this.facilities.values().iterator(); while (iter.hasNext()){ ActivityFacility f = iter.next(); Map<String, ? extends ActivityOption> a = f.getActivityOptions(); if(a.containsKey(act_type)){ facs.put(f.getId(),f); } } return facs; }
private final void writeF2LFile(final ActivityFacilities facilities, final String file) { log.info(" writing f<-->l connections to "+CONFIG_F2L_OUTPUTF2LFile+"="+file); try (BufferedWriter bw = IOUtils.getBufferedWriter(file)) { bw.write("fid\tlid\n"); for (ActivityFacility f : facilities.getFacilities().values()) { bw.write(f.getId().toString()+"\t"+f.getLinkId().toString()+"\n"); } } catch (IOException e) { throw new RuntimeException("Error while writing given outputF2LFile='"+file+"'.", e); } log.info(" done. (writing f<-->l connections to "+CONFIG_F2L_OUTPUTF2LFile+"="+file+")"); }
public EventsToFacilityLoad(final ActivityFacilities facilities, double scaleNumberOfPersons, TreeMap<Id, FacilityPenalty> facilityPenalties, DestinationChoiceConfigGroup config) { super(); this.facilityPenalties = facilityPenalties; log.info("facilities size: " + facilities.getFacilities().values().size()); int counter = 0; int nextMsg = 1; for (ActivityFacility f : facilities.getFacilities().values()) { counter++; if (counter % nextMsg == 0) { nextMsg *= 2; log.info(" facility # " + counter); } double capacity = Double.MAX_VALUE; Iterator<? extends ActivityOption> iter_act = f.getActivityOptions().values().iterator(); while (iter_act.hasNext()){ ActivityOption act = iter_act.next(); if (act.getCapacity() < capacity) { capacity = act.getCapacity(); } } this.facilityPenalties.put(f.getId(), new FacilityPenalty(capacity, scaleNumberOfPersons, config)); } log.info("finished init"); }
/** * Parses a given <i>OpenStreetMap</i> file for data in it that can be converted into MATSim facilities. */ public void parseOsmFileAndAddFacilities(Map<String, String> osmToMatsimTypeMap, String osmKey) { OsmPoiSink sink = new OsmPoiSink(this.ct, osmToMatsimTypeMap, osmKey, useGeneralTypeIsSpecificTypeUnknown); XmlReader xmlReader = new XmlReader(inputFile, false, CompressionMethod.None); xmlReader.setSink(sink); xmlReader.run(); for (ActivityFacility af : sink.getFacilities().getFacilities().values()) { if (!this.facilities.getFacilities().containsKey(af.getId())) { this.facilities.addActivityFacility(af); } else { for (ActivityOption activityOption : af.getActivityOptions().values()) { ActivityFacility activityFacility = this.facilities.getFacilities().get(af.getId()); if (!activityFacility.getActivityOptions().containsKey(activityOption.getType())) { this.facilities.getFacilities().get(af.getId()).addActivityOption(activityOption); } } } } }
private void assignKValuesAlternatives() { for (ActivityFacility facility : this.scenario.getActivityFacilities().getFacilities().values()) { this.facilitiesKValues.putAttribute(facility.getId().toString(), "k", rnd.getUniform(1.0)); } ObjectAttributesXmlWriter attributesWriter = new ObjectAttributesXmlWriter(this.facilitiesKValues); attributesWriter.writeFile(config.controler().getOutputDirectory() + fkValuesFile); }
throw new RuntimeException("Neither coordinate nor linkId are available for facility id "+ activityFacility.getId()+". Aborting...."); } else if (activityFacility.getLinkId()==null){ if (linkNullWarn==0) {
protected boolean modifyLocation(Activity act, Coord startCoord, Coord endCoord, double radius, int trialNr) { ArrayList<ActivityFacility> choiceSet = this.computeChoiceSetCircle(startCoord, endCoord, radius, act.getType()); if (choiceSet.size()>1) { //final Facility facility=(Facility)choiceSet.toArray()[ // MatsimRandom.random.nextInt(choiceSet.size())]; final ActivityFacility facility = choiceSet.get(super.random.nextInt(choiceSet.size())); act.setFacilityId(facility.getId()); act.setLinkId(NetworkUtils.getNearestLink(((Network) this.scenario.getNetwork()), facility.getCoord()).getId()); act.setCoord(facility.getCoord()); return true; } // else ... return false; }
public static void combineDifferentActivityOptionTypes(final Scenario scenario, String combinedType, final List<String> activityOptionsToBeIncluded) { ActivityOption markerOption = new ActivityOptionImpl(combinedType); // Memorize all facilities that have certain activity options in a activity facilities container final ActivityFacilities consideredFacilities = FacilitiesUtils.createActivityFacilities(); for (ActivityFacility facility : scenario.getActivityFacilities().getFacilities().values()) { for (ActivityOption option : facility.getActivityOptions().values()) { if (activityOptionsToBeIncluded.contains(option.getType())) { // if (!option.getType().equals(FacilityTypes.HOME) && !option.getType().equals(FacilityTypes.WORK) && !option.getType().equals("minor")) { if (!consideredFacilities.getFacilities().containsKey(facility.getId())) { consideredFacilities.addActivityFacility(facility); } } } } // Add marker option to facilities to be considered for (ActivityFacility facility : consideredFacilities.getFacilities().values()) { facility.addActivityOption(markerOption); } }
private void readOrCreateKVals(long seed) { ReadOrCreateKVals computer = new ReadOrCreateKVals(seed, this.scenario); this.arekValsRead = computer.run(); ObjectAttributes personsKValues = computer.getPersonsKValues(); ObjectAttributes facilitiesKValues = computer.getFacilitiesKValues(); this.personIndices = new TObjectIntHashMap<>(); this.personsKValuesArray = new double[this.scenario.getPopulation().getPersons().size()]; int personIndex = 0; for (Id<Person> personId : this.scenario.getPopulation().getPersons().keySet()) { this.personIndices.put(personId, personIndex); this.personsKValuesArray[personIndex] = (Double) personsKValues.getAttribute(personId.toString(), "k"); personIndex++; } this.facilityIndices = new TObjectIntHashMap<>(); this.faciliesWithIndexMap = new HashMap<>(); this.facilitiesKValuesArray = new double[this.scenario.getActivityFacilities().getFacilities().size()]; int facilityIndex = 0; for (ActivityFacility facility : this.scenario.getActivityFacilities().getFacilities().values()) { Id<ActivityFacility> facilityId = facility.getId(); this.facilityIndices.put(facilityId, facilityIndex); this.facilitiesKValuesArray[facilityIndex] = (Double) facilitiesKValues.getAttribute(facilityId.toString(), "k"); this.faciliesWithIndexMap.put(facilityId, new ActivityFacilityWithIndex(facility, facilityIndex)); facilityIndex++; } }
protected final boolean modifyLocation(Activity act, Coord startCoord, Coord endCoord, double radius) { double midPointX = (startCoord.getX() + endCoord.getX()) / 2.0; double midPointY = (startCoord.getY() + endCoord.getY()) / 2.0; ArrayList<ActivityFacility> facilitySet = (ArrayList<ActivityFacility>) this.quadTreesOfType.get(this.defineFlexibleActivities.getConverter().convertType(act.getType())). getDisk(midPointX, midPointY, radius); ActivityFacility facility = null; if (facilitySet.size() > 1) { facility = facilitySet.get(super.random.nextInt(facilitySet.size())); } else { return false; } act.setFacilityId(facility.getId()); act.setLinkId(NetworkUtils.getNearestLink(((Network) this.scenario.getNetwork()), facility.getCoord()).getId()); act.setCoord(facility.getCoord()); return true; }
public ComputeMaxDCScoreMultiThreatedModule(String type, DestinationChoiceContext lcContext, DestinationSampler sampler) { super(lcContext.getScenario().getConfig().global().getNumberOfThreads()); this.type = type; this.lcContext = lcContext; /* * Get ActivityFacilies for type and then replace them with ActivityFacilityWithIndex * objects due to performance reasons. */ Map<Id<ActivityFacility>, ActivityFacility> map = lcContext.getScenario().getActivityFacilities().getFacilitiesForActivityType(lcContext.getConverter().convertType(type)); this.typedFacilities = new ActivityFacilityWithIndex[map.size()]; int i = 0; for (ActivityFacility activityFacility : map.values()) { int index = this.lcContext.getFacilityIndex(activityFacility.getId()); this.typedFacilities[i] = new ActivityFacilityWithIndex(activityFacility, index); i++; } if (this.typedFacilities.length == 0) { log.warn("There are no facilities for type : " + type); } this.sampler = sampler; }
private void mutateLocations( final String type, final List<Activity> activitiesToMutate) { final Coord coordBarycenter = calcBarycenterCoord( activitiesToMutate ); final double angle = random.nextDouble() * Math.PI; final double distance = nextNormalDouble() * config.getStandardDeviation(); final ActivityFacility fac = getFacility( type, coordBarycenter, angle, distance ); for ( Activity act : activitiesToMutate ) { ((Activity) act).setFacilityId( fac.getId() ); ((Activity) act).setLinkId( fac.getLinkId() ); ((Activity) act).setCoord( fac.getCoord() ); } }
private static void changeLocation( final Collection<Subchain> subchains, final ActivityFacility facility) { for ( Subchain subchain : subchains ) { ((Activity) subchain.getToMove()).setFacilityId( facility.getId() ); ((Activity) subchain.getToMove()).setLinkId( facility.getLinkId() ); ((Activity) subchain.getToMove()).setCoord( facility.getCoord() ); } }
static Plan createPlanFromFacilities(ActivityFacilitiesImpl layer, Person person, String mode, String facString) { Plan plan = PopulationUtils.createPlan(person); String[] locationIdSequence = facString.split(" "); for (int aa=0; aa < locationIdSequence.length; aa++) { ActivityFacility location = layer.getFacilities().get(Id.create(locationIdSequence[aa], ActivityFacility.class)); Activity act; act = PopulationUtils.createAndAddActivity(plan, "actAtFacility" + locationIdSequence[aa]); act.setFacilityId(location.getId()); act.setEndTime(10*3600); if (aa != (locationIdSequence.length - 1)) { PopulationUtils.createAndAddLeg( plan, mode ); } } return plan; }
private Tuple<QuadTree<ActivityFacilityWithIndex>, ActivityFacilityImpl[]> getTuple(String activityType) { TreesBuilder treesBuilder = new TreesBuilder(CollectionUtils.stringToSet(activityType), this.scenario.getNetwork(), this.dccg); treesBuilder.setActTypeConverter(this.getConverter()); treesBuilder.createTrees(scenario.getActivityFacilities()); ActivityFacilityImpl[] facilities = treesBuilder.getFacilitiesOfType().get(activityType); /* * Create a copy of the treesBuilder.getQuadTreesOfType() outcome where the * ActivityFacility objects are replaced by ActivityFacilityWithIndex objects. * TODO: let the TreeBuilder use ActivityFacilityWithIndex objects directly? */ QuadTree<ActivityFacilityWithIndex> quadTree = null; QuadTree<ActivityFacility> qt = treesBuilder.getQuadTreesOfType().get(activityType); if (qt != null) { double minX = qt.getMinEasting(); double maxX = qt.getMaxEasting(); double minY = qt.getMinNorthing(); double maxY = qt.getMaxNorthing(); quadTree = new QuadTree<ActivityFacilityWithIndex>(minX, minY, maxX, maxY); for (ActivityFacility activityFacility : qt.values()) { quadTree.put(activityFacility.getCoord().getX(), activityFacility.getCoord().getY(), this.faciliesWithIndexMap.get(activityFacility.getId())); } } return new Tuple<QuadTree<ActivityFacilityWithIndex>, ActivityFacilityImpl[]>(quadTree, facilities); }
@Test public void testCreateActivityFacility() { ActivityFacilitiesFactoryImpl factory = new ActivityFacilitiesFactoryImpl(); ActivityFacility facility = factory.createActivityFacility(Id.create(1980, ActivityFacility.class), new Coord((double) 5, (double) 11)); Assert.assertEquals("1980", facility.getId().toString()); Assert.assertEquals(5.0, facility.getCoord().getX(), 1e-9); Assert.assertEquals(11.0, facility.getCoord().getY(), 1e-9); }
@Override protected void setUp() throws Exception { super.setUp(); final Config config = ConfigUtils.createConfig(); final Scenario scenario = ScenarioUtils.createScenario( config ); this.facilities = scenario.getActivityFacilities() ; // create facilities, activities in it and open times final ActivityFacilitiesFactory facilitiesFactory = this.facilities.getFactory(); Coord defaultCoord = new Coord(0.0, 0.0); ActivityFacility testFacility = facilitiesFactory.createActivityFacility(Id.create(0, ActivityFacility.class), defaultCoord) ; this.facilities.addActivityFacility(testFacility); ActivityOption ao = facilitiesFactory.createActivityOption("shop") ; testFacility.addActivityOption(ao); ao.addOpeningTime(new OpeningTimeImpl(6.0 * 3600, 11.0 * 3600)); ao.addOpeningTime(new OpeningTimeImpl(13.0 * 3600, 19.0 * 3600)); // here, we don't test the scoring function itself, but just the method to retrieve opening times // we don't really need persons and plans, they're just used to initialize the ScoringFunction object final PopulationFactory pf = scenario.getPopulation().getFactory(); this.person = pf.createPerson(Id.create(1, Person.class)); Plan plan = pf.createPlan() ; this.person.addPlan(plan); Activity act = pf.createActivityFromCoord("shop", defaultCoord ) ; plan.addActivity(act); act.setFacilityId(testFacility.getId()); act.setStartTime(8.0 * 3600); act.setEndTime(16.0 * 3600); }