def run(self, run_choice_model=True, choose_job_only_in_residence_zone=False, *args, **kwargs): agent_set = kwargs['agent_set'] if run_choice_model: choices = ChoiceModel.run(self, *args, **kwargs) #prob_work_at_home = self.upc_sequence.probabilities[:, 0] agent_set.set_values_of_one_attribute(self.choice_attribute_name, choices, index=kwargs['agents_index']) at_home_worker_index = kwargs['agents_index'][choices==1] logger.log_status("%s workers choose to work at home, %s workers chose to work out of home." % (where(agent_set.get_attribute_by_index(self.choice_attribute_name, kwargs['agents_index']) == 1)[0].size, where(agent_set.get_attribute_by_index(self.choice_attribute_name, kwargs['agents_index']) == 0)[0].size)) else: at_home_worker_index = where(logical_and( agent_set.get_attribute(self.choice_attribute_name) == 1, agent_set.get_attribute('job_id') <= 0 ) )[0] if self.filter is not None: jobs_set_index = where( self.job_set.compute_variables(self.filter) )[0] else: jobs_set_index = arange( self.job_set.size() ) logger.log_status("Total: %s workers work at home, (%s workers work out of home), will try to assign %s workers to %s jobs." % (where(agent_set.get_attribute(self.choice_attribute_name) == 1)[0].size, where(agent_set.get_attribute(self.choice_attribute_name) == 0)[0].size, at_home_worker_index.size, jobs_set_index.size )) if not choose_job_only_in_residence_zone: assigned_worker_index, assigned_job_index = self._assign_job_to_worker(at_home_worker_index, jobs_set_index) else: agent_set.compute_variables("urbansim_parcel.person.zone_id") self.job_set.compute_variables("urbansim_parcel.job.zone_id") agent_zone_ids = agent_set.get_attribute_by_index('zone_id', at_home_worker_index) job_zone_ids = self.job_set.get_attribute_by_index('zone_id', jobs_set_index) unique_zones = unique(job_zone_ids) assigned_worker_index = array([], dtype="int32") assigned_job_index = array([], dtype="int32") for this_zone in unique_zones: logger.log_status("zone_id: %s" % this_zone) if this_zone <= 0: continue at_home_worker_in_this_zone = where(agent_zone_ids == this_zone)[0] job_set_in_this_zone = where(job_zone_ids == this_zone)[0] assigned_worker_in_this_zone, assigned_job_set_in_this_zone = self._assign_job_to_worker(at_home_worker_in_this_zone, job_set_in_this_zone) assigned_worker_index = concatenate((assigned_worker_index, at_home_worker_index[assigned_worker_in_this_zone])) assigned_job_index = concatenate((assigned_job_index, jobs_set_index[assigned_job_set_in_this_zone])) ## each worker can only be assigned to 1 job #assert assigned_worker_index.size == unique(assigned_worker_index).size agent_set.set_values_of_one_attribute(self.job_set.get_id_name()[0], self.job_set.get_id_attribute()[assigned_job_index], index=assigned_worker_index) agent_set.compute_variables([self.location_id_name], dataset_pool=self.dataset_pool) self.job_set.modify_attribute(name=VariableName(self.location_id_name).get_alias(), data=agent_set.get_attribute_by_index(self.location_id_name, assigned_worker_index), index=assigned_job_index)
def run(self, specification, coefficients, agent_set, agents_index=None, **kwargs): choices = ChoiceModel.run(self, specification, coefficients, agent_set, agents_index=agents_index, **kwargs) if agents_index is None: agents_index = arange(agent_set.size()) movers_indices = agents_index[where(choices > 0)] if self.movers_ratio is not None: n = rint(self.movers_ratio * agents_index.size) if n < movers_indices.size: movers_indices = sample_noreplace(movers_indices, n) # add unplaced agents unplaced_agents = agents_index[agent_set.get_attribute_by_index( self.location_id_name, agents_index) <= 0] logger.log_status( "%s agents selected by the logit model; %s agents without %s." % (movers_indices.size, unplaced_agents.size, self.location_id_name)) movers_indices = unique(concatenate((movers_indices, unplaced_agents))) logger.log_status("Number of movers: " + str(movers_indices.size)) return movers_indices
def run(self, zones, run_choice_model=True, choose_job_only_in_residence_zone=True, **kwargs): agent_set = kwargs['agent_set'] agents_index = kwargs.get('agents_index', None) if agents_index is None: agents_index = arange(agent_set.size()) cond_array = zeros(agent_set.size(), dtype="bool8") cond_array[agents_index] = True zone_ids = zones.get_id_attribute() agents_zones = agent_set.compute_variables(['urbansim_parcel.%s.%s' % (agent_set.get_dataset_name(), zones.get_id_name()[0])], dataset_pool=self.dataset_pool) if self.filter is not None: jobs_set_index = where( self.job_set.compute_variables(self.filter) )[0] else: jobs_set_index = arange( self.job_set.size() ) #self.job_set.compute_variables("urbansim_parcel.job.zone_id") agent_set.compute_variables("urbansim_parcel.person.zone_id") # remove job links from all workers agent_set.set_values_of_one_attribute(self.choice_attribute_name, -1*ones(agents_index.size, dtype='int32'), index=agents_index) for zone_id in zone_ids: new_index = where(logical_and(cond_array, agents_zones == zone_id))[0] logger.log_status("%s for zone %s" % (self.model_short_name, zone_id)) if run_choice_model: kwargs['agents_index'] = new_index choices = ChoiceModel.run(self, **kwargs) prob_work_at_home = self.upc_sequence.get_probabilities()[:, 1] job_set_in_this_zone = jobs_set_index[self.job_set['zone_id'][jobs_set_index] == zone_id] number_of_hb_jobs = job_set_in_this_zone.size # sample workers for the number of jobs draw = probsample_noreplace(kwargs['agents_index'], min(kwargs['agents_index'].size, number_of_hb_jobs), prob_work_at_home) agent_set.set_values_of_one_attribute(self.choice_attribute_name, ones(draw.size, dtype=agent_set[self.choice_attribute_name].dtype), index=draw) logger.log_status("%s workers choose to work at home, %s workers chose to work out of home." % (where(agent_set.get_attribute_by_index(self.choice_attribute_name, kwargs['agents_index']) == 1)[0].size, where(agent_set.get_attribute_by_index(self.choice_attribute_name, kwargs['agents_index']) == 0)[0].size)) at_home_worker_in_this_zone = kwargs['agents_index'][agent_set[self.choice_attribute_name][kwargs['agents_index']] == 1] assigned_worker_in_this_zone, assigned_job_set_in_this_zone = self._assign_job_to_worker(at_home_worker_in_this_zone, job_set_in_this_zone) agent_set.set_values_of_one_attribute(self.job_set.get_id_name()[0], self.job_set.get_id_attribute()[assigned_job_set_in_this_zone], index=assigned_worker_in_this_zone) agent_set.compute_variables([self.location_id_name], dataset_pool=self.dataset_pool) self.job_set.modify_attribute(name=VariableName(self.location_id_name).get_alias(), data=agent_set.get_attribute_by_index(self.location_id_name, assigned_worker_in_this_zone), index=assigned_job_set_in_this_zone) agent_set.flush_dataset() self.job_set.flush_dataset() logger.log_status("Total: %s workers work at home, %s workers work out of home." % (where(agent_set.get_attribute(self.choice_attribute_name) == 1)[0].size, where(agent_set.get_attribute(self.choice_attribute_name) == 0)[0].size ))
def run(self, specification, coefficients, agent_set, agents_index=None, chunk_specification=None, data_objects=None, run_config=None, debuglevel=0): """ Run a simulation and return a numpy array of length agents_index, giving agent choices (ids of locations). 'specification' is of type EquationSpecification, 'coefficients' is of type Coefficients, 'agent_set' is of type Dataset, 'agent_index' are indices of individuals in the agent_set for which the model runs. If it is None, the whole agent_set is considered. 'chunk_specification' determines number of chunks in which the simulation is processed. Default is to use 300 rows per chunk. 'data_objects' is a dictionary where each key is the name of an data object ('zone', ...) and its value is an object of class Dataset. 'run_config' is of type Resources, it gives additional arguments for the run. 'debuglevel' overwrites the constructor 'debuglevel'. """ if run_config == None: run_config = Resources() self.run_config = run_config.merge_with_defaults(self.run_config) if data_objects is not None: self.dataset_pool.add_datasets_if_not_included(data_objects) self.dataset_pool.add_datasets_if_not_included({agent_set.get_dataset_name():agent_set}) ## what is the use of compute location_id string in run? it gets new values anyway #if self.location_id_string is not None: # location_id = agent_set.compute_variables(self.location_id_string, dataset_pool=self.dataset_pool) ## done in choice_model #location_id_name = self.choice_set.get_id_name()[0] #if (location_id_name not in agent_set.get_known_attribute_names()): # agent_set.add_attribute(name=location_id_name, data=resize(array([-1]), agent_set.size())) if self.run_config.get("agent_units_string", None): # used when agents take different amount of capacity from the total capacity agent_set.compute_variables([self.run_config["agent_units_string"]], dataset_pool=self.dataset_pool) self.compute_capacity_flag = self.run_config.get("compute_capacity_flag", False) capacity_string = None self.capacity = None if self.compute_capacity_flag: capacity_string = self.run_config.get("capacity_string", None) if capacity_string is None: raise KeyError, \ "Entry 'capacity_string' has to be specified in 'run_config' if 'compute_capacity_flag' is True" ## if weights is None, use capacity for weights if self.run_config.get("weights_for_simulation_string", None) is None and capacity_string is not None: self.run_config.merge({"weights_for_simulation_string" : capacity_string}) return ChoiceModel.run(self,specification, coefficients, agent_set, agents_index=agents_index, chunk_specification=chunk_specification, run_config=self.run_config, debuglevel=debuglevel)
def run(self, specification, coefficients, agent_set, agents_index=None, **kwargs): hh_to_init_workers = agent_set.compute_variables("_hh_to_init = ((household.workers)==-1)") idx_to_init = where(hh_to_init_workers)[0] if idx_to_init.size > 0: results = ChoiceModel.run(self, specification, coefficients, agent_set, agents_index=idx_to_init, **kwargs) agent_set.modify_attribute('workers', results, idx_to_init) #Ensure that predicted workers does not exceed # persons who are eligible to work workeligible = agent_set.compute_variables('_work_eligible = household.aggregate(person.age>15)') agent_set.add_attribute(name='work_eligible', data=agent_set.compute_variables('household.aggregate(person.age>15)')) workers_exceeds_eligible = agent_set.compute_variables("_overpredict_workers = ((household.workers) > _work_eligible)") idx_excess_workers = where(logical_and(workers_exceeds_eligible,hh_to_init_workers))[0] if idx_excess_workers.size > 0: agent_set.modify_attribute('workers', workeligible[idx_excess_workers], idx_excess_workers) #When a household with 4+ eligible workers is assigned "3+ workers", a more specific number of workers needs to be assigned #When household with 4 eligible workers is predicted to have 3+ workers, the household can be assigned 3 workers or 4 workers four_eligible_three_predicted = agent_set.compute_variables('_four_eligible_three_predicted = (_work_eligible==4)*((household.workers)==3)') idx_four_elig = where(logical_and(four_eligible_three_predicted,hh_to_init_workers))[0] if idx_four_elig.size > 0: four_numworker_prob = ([.62,.38]) #probabilities from crosstab of base-year workers vs. base-year persons eligible to work four_cum_prob = cumsum(four_numworker_prob) for hh in idx_four_elig: r = uniform(0,1) agent_set['workers'][hh] = searchsorted(four_cum_prob, r) + 3 #When household with 5 eligible workers is predicted to have 3+ workers, the household can be assigned 3, 4, or 5 workers five_eligible_three_predicted = agent_set.compute_variables('_five_eligible_three_predicted = (_work_eligible==5)*((household.workers)==3)') idx_five_elig = where(logical_and(five_eligible_three_predicted,hh_to_init_workers))[0] if idx_five_elig.size > 0: five_numworker_prob = ([.44,.33,.23]) five_cum_prob = cumsum(five_numworker_prob) for hh in idx_five_elig: r = uniform(0,1) agent_set['workers'][hh] = searchsorted(five_cum_prob, r) + 3 #When household with 6 eligible workers is predicted to have 3+ workers, the household can be assigned 3, 4, 5, or 6 workers six_eligible_three_predicted = agent_set.compute_variables('_six_eligible_three_predicted = (_work_eligible==6)*((household.workers)==3)') idx_six_elig = where(logical_and(six_eligible_three_predicted,hh_to_init_workers))[0] if idx_six_elig.size > 0: six_numworker_prob = ([.32,.23,.24,.21]) six_cum_prob = cumsum(six_numworker_prob) for hh in idx_six_elig: r = uniform(0,1) agent_set['workers'][hh] = searchsorted(six_cum_prob, r) + 3 #When household with 7+ eligible workers is predicted to have 3+ workers, the household is randomly asssigned a number of workers no less than 3 and no greater than the number of persons eligible to work many_eligible_three_predicted = agent_set.compute_variables('_many_eligible_three_predicted = (_work_eligible>6)*((household.workers)==3)') idx_many_elig = where(logical_and(many_eligible_three_predicted,hh_to_init_workers))[0] if idx_many_elig.size > 0: for hh in idx_many_elig: agent_set['workers'][hh] = randint(3, ((agent_set['work_eligible'][hh])+1)) if 'numworker_id' in agent_set.get_primary_attribute_names(): agent_set.delete_one_attribute('numworker_id') agent_set.delete_one_attribute('work_eligible')
def run(self, specification, coefficients, agent_set, agents_index=None, **kwargs): choices = ChoiceModel.run(self, specification, coefficients, agent_set, agents_index=agents_index, **kwargs) if agents_index is None: agents_index=arange(agent_set.size()) movers_indices = agents_index[where(choices>0)] if self.movers_ratio is not None: n = rint(self.movers_ratio*agents_index.size) if n < movers_indices.size: movers_indices = sample_noreplace(movers_indices, n) # add unplaced agents unplaced_agents = agents_index[agent_set.get_attribute_by_index(self.location_id_name, agents_index) <= 0] logger.log_status("%s agents selected by the logit model; %s agents without %s." % (movers_indices.size, unplaced_agents.size, self.location_id_name)) movers_indices = unique(concatenate((movers_indices, unplaced_agents))) logger.log_status("Number of movers: " + str(movers_indices.size)) return movers_indices
def run(self, agents_index=None, n=500, *args, **kwargs): agent_set = self.proposal_set if self.filter is not None: agents_index = where( self.proposal_set.compute_variables(self.filter) )[0] choices = ChoiceModel.run(self, agent_set=agent_set, agents_index=agents_index, *args, **kwargs) #logger.log_status("%s workers chose to work at home, %s workers chose to work out of home." % #(where(agent_set.get_attribute_by_index(self.choice_attribute_name, kwargs['agents_index']) == 1)[0].size, #where(agent_set.get_attribute_by_index(self.choice_attribute_name, kwargs['agents_index']) == 2)[0].size)) #logger.log_status("Total: %s workers work at home, %s workers work out of home." % #(where(agent_set.get_attribute(self.choice_attribute_name) == 1)[0].size, #where(agent_set.get_attribute(self.choice_attribute_name) == 2)[0].size)) self.proposal_set.set_values_of_one_attribute('is_chosen', choices, index=agents_index)
def run(self, specification, coefficients, agent_set, agents_index=None, chunk_specification=None, data_objects=None, run_config=None, debuglevel=0): self.lct_probabilities = {} for ichoice in range(self.choice_set.size()): probname = "probs_" + str(self.choice_set.get_id_attribute()[ichoice]) if probname not in agent_set.get_known_attribute_names(): agent_set.add_attribute(name=probname, data=zeros(agent_set.size(), dtype=float32)) result = ChoiceModel.run(self,specification, coefficients, agent_set, agents_index=agents_index, chunk_specification=chunk_specification, data_objects=data_objects, run_config=run_config, debuglevel=debuglevel) ## next four lines creates recoded lct (shifts index).... changed_idx = where(result>0)[0] if agents_index is None: agents_index = arange(agent_set.size()) agent_set.modify_attribute(data=result[changed_idx].astype(int8), name=self.choice_attribute_name.get_alias(), index=agents_index[changed_idx]) ## <-------------- lct recode occurs here agent_set.compute_variables("biocomplexity.land_cover.lct_recoded") return result
]) ) households.add_primary_attribute(data=[1,2,2,2,1,3,3,1,2,1], name="choice_id") coefficients, other_results = choicemodel.estimate(specification, households, procedure="opus_core.bhhh_mnl_estimation") # # Uncomment to output mycoef.tab # #coefficients.write(out_storage=storage, out_table_name="mycoef") from numpy.random import seed seed(1) choices = choicemodel.run( specification, coefficients, households, debuglevel=1) households.modify_attribute(name="choice_id", data=choices) from opus_core.coefficients import Coefficients coefficients = Coefficients( names=array(["beta01", "beta12", "beta03", "beta13"]), values=array([0.5, 0.2, -5.0, 1.3])) # LCM locations = Dataset(in_storage = storage, in_table_name = 'locations', id_name='location', dataset_name='gridcell') coefficients = Coefficients(names=("costcoef", ), values=(-0.01,))
def run(self, run_choice_model=True, choose_job_only_in_residence_zone=False, residence_id='zone_id', *args, **kwargs): agent_set = kwargs['agent_set'] agents_index = kwargs.get('agents_index', None) if agents_index is None: agents_index = arange(agent_set.size()) if agents_index.size <= 0: logger.log_status("Nothing to be done.") return if self.filter is not None: jobs_set_index = where( self.job_set.compute_variables(self.filter) )[0] else: jobs_set_index = arange( self.job_set.size() ) if run_choice_model: choices = ChoiceModel.run(self, *args, **kwargs) if self.match_number_of_jobs: prob_work_at_home = self.upc_sequence.probabilities[:, 1] # sample as many workers as there are jobs draw = probsample_noreplace(arange(agents_index.size), min(agents_index.size, jobs_set_index.size), prob_work_at_home) choices = zeros(agents_index.size, dtype='int32') choices[draw] = 1 agent_set.set_values_of_one_attribute(self.choice_attribute_name, choices, index=agents_index) at_home_worker_index = agents_index[choices==1] logger.log_status("%s workers choose to work at home, %s workers chose to work out of home." % (where(agent_set.get_attribute_by_index(self.choice_attribute_name, agents_index) == 1)[0].size, where(agent_set.get_attribute_by_index(self.choice_attribute_name, agents_index) == 0)[0].size)) else: at_home_worker_index = where(logical_and( agent_set.get_attribute(self.choice_attribute_name) == 1, agent_set.get_attribute('job_id') <= 0 ) )[0] logger.log_status("Total: %s workers work at home, (%s workers work out of home), will try to assign %s workers to %s jobs." % (where(agent_set.get_attribute(self.choice_attribute_name) == 1)[0].size, where(agent_set.get_attribute(self.choice_attribute_name) == 0)[0].size, at_home_worker_index.size, jobs_set_index.size )) if not choose_job_only_in_residence_zone: assigned_worker_index, assigned_job_index = self._assign_job_to_worker(at_home_worker_index, jobs_set_index) else: agent_set.compute_one_variable_with_unknown_package(residence_id, dataset_pool=self.dataset_pool) self.job_set.compute_one_variable_with_unknown_package(residence_id, dataset_pool=self.dataset_pool) agent_zone_ids = agent_set.get_attribute_by_index(residence_id, at_home_worker_index) job_zone_ids = self.job_set.get_attribute_by_index(residence_id, jobs_set_index) unique_zones = unique(job_zone_ids) assigned_worker_index = array([], dtype="int32") assigned_job_index = array([], dtype="int32") for this_zone in unique_zones: logger.log_status("%s: %s" % (residence_id, this_zone)) if this_zone <= 0: continue at_home_worker_in_this_zone = where(agent_zone_ids == this_zone)[0] job_set_in_this_zone = where(job_zone_ids == this_zone)[0] assigned_worker_in_this_zone, assigned_job_set_in_this_zone = self._assign_job_to_worker(at_home_worker_in_this_zone, job_set_in_this_zone) assigned_worker_index = concatenate((assigned_worker_index, at_home_worker_index[assigned_worker_in_this_zone])) assigned_job_index = concatenate((assigned_job_index, jobs_set_index[assigned_job_set_in_this_zone])) ## each worker can only be assigned to 1 job #assert assigned_worker_index.size == unique(assigned_worker_index).size agent_set.set_values_of_one_attribute(self.job_set.get_id_name()[0], self.job_set.get_id_attribute()[assigned_job_index], index=assigned_worker_index) agent_set.compute_variables([self.location_id_name], dataset_pool=self.dataset_pool) self.job_set.modify_attribute(name=VariableName(self.location_id_name).get_alias(), data=agent_set.get_attribute_by_index(self.location_id_name, assigned_worker_index), index=assigned_job_index)
def run(self, run_choice_model=True, choose_job_only_in_residence_zone=False, *args, **kwargs): agent_set = kwargs['agent_set'] if run_choice_model: choices = ChoiceModel.run(self, *args, **kwargs) #prob_work_at_home = self.upc_sequence.probabilities[:, 0] agent_set.set_values_of_one_attribute(self.choice_attribute_name, choices, index=kwargs['agents_index']) at_home_worker_index = kwargs['agents_index'][choices == 1] logger.log_status( "%s workers choose to work at home, %s workers chose to work out of home." % (where( agent_set.get_attribute_by_index( self.choice_attribute_name, kwargs['agents_index']) == 1)[0].size, where( agent_set.get_attribute_by_index( self.choice_attribute_name, kwargs['agents_index']) == 0)[0].size)) else: at_home_worker_index = where( logical_and( agent_set.get_attribute(self.choice_attribute_name) == 1, agent_set.get_attribute('job_id') <= 0))[0] if self.filter is not None: jobs_set_index = where(self.job_set.compute_variables( self.filter))[0] else: jobs_set_index = arange(self.job_set.size()) logger.log_status( "Total: %s workers work at home, (%s workers work out of home), will try to assign %s workers to %s jobs." % (where(agent_set.get_attribute(self.choice_attribute_name) == 1)[0].size, where(agent_set.get_attribute(self.choice_attribute_name) == 0) [0].size, at_home_worker_index.size, jobs_set_index.size)) if not choose_job_only_in_residence_zone: assigned_worker_index, assigned_job_index = self._assign_job_to_worker( at_home_worker_index, jobs_set_index) else: agent_set.compute_variables("urbansim_parcel.person.zone_id") self.job_set.compute_variables("urbansim_parcel.job.zone_id") agent_zone_ids = agent_set.get_attribute_by_index( 'zone_id', at_home_worker_index) job_zone_ids = self.job_set.get_attribute_by_index( 'zone_id', jobs_set_index) unique_zones = unique(job_zone_ids) assigned_worker_index = array([], dtype="int32") assigned_job_index = array([], dtype="int32") for this_zone in unique_zones: logger.log_status("zone_id: %s" % this_zone) if this_zone <= 0: continue at_home_worker_in_this_zone = where( agent_zone_ids == this_zone)[0] job_set_in_this_zone = where(job_zone_ids == this_zone)[0] assigned_worker_in_this_zone, assigned_job_set_in_this_zone = self._assign_job_to_worker( at_home_worker_in_this_zone, job_set_in_this_zone) assigned_worker_index = concatenate( (assigned_worker_index, at_home_worker_index[assigned_worker_in_this_zone])) assigned_job_index = concatenate( (assigned_job_index, jobs_set_index[assigned_job_set_in_this_zone])) ## each worker can only be assigned to 1 job #assert assigned_worker_index.size == unique(assigned_worker_index).size agent_set.set_values_of_one_attribute( self.job_set.get_id_name()[0], self.job_set.get_id_attribute()[assigned_job_index], index=assigned_worker_index) agent_set.compute_variables([self.location_id_name], dataset_pool=self.dataset_pool) self.job_set.modify_attribute( name=VariableName(self.location_id_name).get_alias(), data=agent_set.get_attribute_by_index(self.location_id_name, assigned_worker_index), index=assigned_job_index)
def run(self, specification, coefficients, agent_set, agents_index=None, chunk_specification=None, data_objects=None, run_config=None, debuglevel=0): """ Run a simulation and return a numpy array of length agents_index, giving agent choices (ids of locations). 'specification' is of type EquationSpecification, 'coefficients' is of type Coefficients, 'agent_set' is of type Dataset, 'agent_index' are indices of individuals in the agent_set for which the model runs. If it is None, the whole agent_set is considered. 'chunk_specification' determines number of chunks in which the simulation is processed. Default is to use 300 rows per chunk. 'data_objects' is a dictionary where each key is the name of an data object ('zone', ...) and its value is an object of class Dataset. 'run_config' is of type Resources, it gives additional arguments for the run. 'debuglevel' overwrites the constructor 'debuglevel'. """ if run_config == None: run_config = Resources() self.run_config = run_config.merge_with_defaults(self.run_config) if data_objects is not None: self.dataset_pool.add_datasets_if_not_included(data_objects) self.dataset_pool.add_datasets_if_not_included( {agent_set.get_dataset_name(): agent_set}) ## what is the use of compute location_id string in run? it gets new values anyway #if self.location_id_string is not None: # location_id = agent_set.compute_variables(self.location_id_string, dataset_pool=self.dataset_pool) ## done in choice_model #location_id_name = self.choice_set.get_id_name()[0] #if (location_id_name not in agent_set.get_known_attribute_names()): # agent_set.add_attribute(name=location_id_name, data=resize(array([-1]), agent_set.size())) if self.run_config.get( "agent_units_string", None ): # used when agents take different amount of capacity from the total capacity agent_set.compute_variables( [self.run_config["agent_units_string"]], dataset_pool=self.dataset_pool) self.compute_capacity_flag = self.run_config.get( "compute_capacity_flag", False) capacity_string = None self.capacity = None if self.compute_capacity_flag: capacity_string = self.run_config.get("capacity_string", None) if capacity_string is None: raise KeyError, \ "Entry 'capacity_string' has to be specified in 'run_config' if 'compute_capacity_flag' is True" ## if weights is None, use capacity for weights if self.run_config.get("weights_for_simulation_string", None) is None and capacity_string is not None: self.run_config.merge( {"weights_for_simulation_string": capacity_string}) return ChoiceModel.run(self, specification, coefficients, agent_set, agents_index=agents_index, chunk_specification=chunk_specification, run_config=self.run_config, debuglevel=debuglevel)