Example #1
0
 def __init__(self, cache_file_location, observed_data,
              base_year=0,  prefix='run_', package_order=['core'], additional_datasets={},
              overwrite_cache_directories_file=False):
     """ Class used in the Bayesian melding analysis.
     'cache_file_location' is location (either file or directory) with information about all caches
     (see doc string for MultipleRuns).
     'observed_data' is an object of ObservedData that contains all the information about observed data.
     """
     MultipleRuns.__init__(self, cache_file_location, prefix=prefix, package_order=package_order, 
                           additional_datasets=additional_datasets,
                           overwrite_cache_directories_file=overwrite_cache_directories_file)
     self.output_directory = os.path.join(os.path.split(self.full_cache_file_name)[0], 'bm_output')
     logger.log_status('Output directory set to %s.' % self.output_directory)
     if not os.path.exists(self.output_directory):
         os.mkdir(self.output_directory)
     self.observed_data = observed_data
     self.base_year = base_year
     self.propagation_factor = None
     self.y = {}
     self.mu = {}
     self.ahat = {}
     self.v = {}
     self.weight_components = {}
     self.simulated_values = None
     self.weights = None
Example #2
0
 def _compute_variable_for_one_run(self,
                                   run_index,
                                   variable,
                                   dataset_name,
                                   year,
                                   dummy=None):
     return MultipleRuns._compute_variable_for_one_run(
         self, run_index, variable, dataset_name, year)
Example #3
0
    write_to_text_file(os.path.join(directory, file_name), all_dirs)
    logger.end_block()


def setup_environment(cache_directory,
                      year,
                      package_order,
                      additional_datasets={}):
    gc.collect()
    ss = SimulationState(new_instance=True)
    ss.set_cache_directory(cache_directory)
    ss.set_current_time(year)
    ac = AttributeCache()
    storage = ac.get_flt_storage_for_year(year)
    sc = SessionConfiguration(new_instance=True,
                              package_order=package_order,
                              in_storage=ac)
    logger.log_status(
        "Setup environment for year %s. Use cache directory %s." %
        (year, storage.get_storage_location()))
    dp = sc.get_dataset_pool()
    for name, ds in additional_datasets.iteritems():
        dp.replace_dataset(name, ds)
    return dp


if __name__ == '__main__':
    from opus_core.multiple_runs import MultipleRuns
    mr = MultipleRuns('/Users/hana/urbansim_cache/psrc/parcel/bm/0416')
    mr.set_values_from_mr(2005, ['urbansim_parcel.zone.number_of_households'])
    if not prefix.startswith('.'):
        all_dirs = [x for x in all_dirs if not x.startswith('.')]

    for i in range(len(all_dirs)):
        all_dirs[i] = os.path.join(directory, all_dirs[i])
        
    write_to_text_file(os.path.join(directory, file_name), all_dirs)
    logger.end_block()
               
def setup_environment(cache_directory, year, package_order, additional_datasets={}):
    gc.collect()
    ss = SimulationState(new_instance=True)
    ss.set_cache_directory(cache_directory)
    ss.set_current_time(year)
    ac = AttributeCache()
    storage = ac.get_flt_storage_for_year(year)
    sc = SessionConfiguration(new_instance=True,
                         package_order=package_order,
                         in_storage=ac)
    logger.log_status("Setup environment for year %s. Use cache directory %s." % (year, storage.get_storage_location()))
    dp = sc.get_dataset_pool()
    for name, ds in additional_datasets.iteritems():
        dp.replace_dataset(name, ds)
    return dp

if __name__=='__main__':
    from opus_core.multiple_runs import MultipleRuns
    mr = MultipleRuns('/Users/hana/urbansim_cache/psrc/parcel/bm/0416')
    mr.set_values_from_mr(2005, ['urbansim_parcel.zone.number_of_households'])
    
 def _compute_variable_for_one_run(self, run_index, variable, dataset_name, year, dummy=None):
     return MultipleRuns._compute_variable_for_one_run(self, run_index, variable, dataset_name, year)