def __init__(self, config, model=None, model_group=None, specification=None, scenario_name=None):
self.factory = VariableFactory()
lib = config.get_expression_library()
self.factory.set_expression_library(lib)
self.model = model
self.model_group = model_group
if model is not None:
if specification is None:
specification_dict = config.get_estimation_specification(model, model_group)
if model_group is not None:
specification_dict = specification_dict[model_group]
spec = get_specification_for_estimation(specification_dict)
else:
spec = specification
model_prefix = ''
if model_group is not None:
model_prefix = '%s_' % model_group
self.model_name = '%s%s' % (model_prefix, model)
self.var_list = spec.get_distinct_long_variable_names().tolist()
#check other model nodes, such as agents_filter, submodel_string or filter
# config_node_path = "model_manager/models/model[@name='%s']" % self.model
# model_node = config._find_node(config_node_path)
# controller = config._convert_model_to_dict(model_node)
# addvars = []
# addvars.append(controller.get('init', {}).get('arguments', {}).get('filter', None))
# addvars.append(controller.get('init', {}).get('arguments', {}).get('submodel_string', None))
# addvars.append(controller.get('init', {}).get('arguments', {}).get('choice_attribute_name', None))
# addvars.append(controller.get('prepare_for_run', {}).get('arguments', {}).get('agent_filter', None))
# This assumes that xml nodes contain the tag 'model_dependency_type'
self.model_structure_dependencies = config.model_dependencies(self.model)
self.var_list = self.var_list + self.model_structure_dependencies.get('variable', [])
# for var in addvars:
# if isinstance(var, str):
# self.var_list.append(eval(var)) # eval because these entries are in double quotes, e.g. "'attribute'"
self.var_tree = []
l = []
for var in self.var_list:
l.append((var, []))
self.var_tree.append((self.model_name, l))
else:
# this is meant to be for all models but is not working yet
#self.config = config.get_run_configuration(scenario_name)
self.var_list = []
self.var_tree = []
def prepare_for_estimate(self,specification_dict = None,
specification_storage=None,
specification_table=None,
events_for_estimation_storage=None,
events_for_estimation_table=None):
from opus_core.models.model import get_specification_for_estimation
specification = get_specification_for_estimation(specification_dict,
specification_storage,
specification_table)
development = None
# create agents for estimation
if events_for_estimation_storage is not None:
event_set = DevelopmentEventDataset(in_storage = events_for_estimation_storage,
in_table_name= events_for_estimation_table)
development = create_landuse_developments_from_history(event_set)
return (specification, development)
def prepare_for_estimate(self, specification_dict = None, specification_storage=None,
specification_table=None, agent_set=None,
agents_for_estimation_storage=None,
agents_for_estimation_table=None, join_datasets=False,
index_to_unplace=None, portion_to_unplace=1.0,
agent_filter=None,
data_objects={}):
from opus_core.models.model import get_specification_for_estimation
specification = get_specification_for_estimation(specification_dict,
specification_storage,
specification_table)
if (agent_set is not None) and (index_to_unplace is not None):
if self.location_id_string is not None:
agent_set.compute_variables(self.location_id_string, resources=Resources(data_objects))
if portion_to_unplace < 1:
unplace_size = int(portion_to_unplace*index_to_unplace.size)
end_index_to_unplace = sample_noreplace(index_to_unplace, unplace_size)
else:
end_index_to_unplace = index_to_unplace
logger.log_status("Unplace " + str(end_index_to_unplace.size) + " agents.")
agent_set.modify_attribute(self.choice_set.get_id_name()[0],
-1*ones(end_index_to_unplace.size), end_index_to_unplace)
# create agents for estimation
if agents_for_estimation_storage is not None:
estimation_set = Dataset(in_storage = agents_for_estimation_storage,
in_table_name=agents_for_estimation_table,
id_name=agent_set.get_id_name(), dataset_name=agent_set.get_dataset_name())
if agent_filter is not None:
estimation_set.compute_variables(agent_filter, resources=Resources(data_objects))
index = where(estimation_set.get_attribute(agent_filter) > 0)[0]
estimation_set.subset_by_index(index, flush_attributes_if_not_loaded=False)
if join_datasets:
agent_set.join_by_rows(estimation_set, require_all_attributes=False,
change_ids_if_not_unique=True)
index = arange(agent_set.size()-estimation_set.size(),agent_set.size())
else:
index = agent_set.get_id_index(estimation_set.get_id_attribute())
else:
index = arange(agent_set.size())
return (specification, index)
def prepare_for_estimate(self, add_member_prefix=True,
specification_dict=None,
specification_storage=None,
specification_table=None,
building_set=None,
buildings_for_estimation_storage=None,
buildings_for_estimation_table=None,
constants=None, base_year=0,
building_categories=None,
location_id_variable=None,
join_datasets=False,
data_objects=None, **kwargs):
# buildings = None
if (building_set is not None):
if location_id_variable is not None:
building_set.compute_variables(location_id_variable, resources=Resources(data_objects))
# create agents for estimation
if buildings_for_estimation_storage is not None:
estimation_set = Dataset(in_storage=buildings_for_estimation_storage,
in_table_name=buildings_for_estimation_table,
id_name=building_set.get_id_name(),
dataset_name=building_set.get_dataset_name())
if location_id_variable:
estimation_set.compute_variables(location_id_variable,
resources=Resources(data_objects))
# needs to be a primary attribute because of the join method below
estimation_set.add_primary_attribute(estimation_set.get_attribute(location_id_variable),
VariableName(location_id_variable).alias())
years = estimation_set.get_attribute("scheduled_year")
recent_years = constants['recent_years']
indicator = zeros(estimation_set.size())
for year in range(base_year-recent_years, base_year+1):
indicator = logical_or(indicator, years==year)
idx = where(logical_not(indicator))[0]
estimation_set.remove_elements(idx)
#if filter:
#estimation_set.compute_variables(filter, resources=Resources(data_objects))
#index = where(estimation_set.get_attribute(filter) > 0)[0]
#estimation_set.subset_by_index(index, flush_attributes_if_not_loaded=False)
if join_datasets:
building_set.join_by_rows(estimation_set,
require_all_attributes=False,
change_ids_if_not_unique=True)
index = arange(building_set.size()-estimation_set.size(), building_set.size())
else:
index = building_set.get_id_index(estimation_set.get_id_attribute())
else:
if building_set is not None:
index = arange(building_set.size())
else:
index = None
if add_member_prefix:
specification_table = self.group_member.add_member_prefix_to_table_names([specification_table])
from opus_core.models.model import get_specification_for_estimation
#from urbansim.functions import compute_supply_and_add_to_location_set
specification = get_specification_for_estimation(specification_dict,
specification_storage,
specification_table)
#specification, dummy = AgentLocationChoiceModelMember.prepare_for_estimate(self, add_member_prefix,
#specification_dict, specification_storage,
#specification_table,
#location_id_variable=location_id_variable,
#data_objects=data_objects, **kwargs)
return (specification, index)
