Ejemplo n.º 1
0
def inverted_estimation_filter_worker(work_queue,done_queue,G,master_sets,choice_set_config):
	
	for trip_id in iter(work_queue.get,'STOP'):
		if choice_set_config['allow_duplicates_of_chosen_route']:
			chosen_overlap=calc_chosen_overlap(G,master_sets[trip_id][0],master_sets[trip_id][1:],choice_set_config)
			choice_set=ds.filter_master(G,None,master_sets[trip_id][1:],choice_set_config)
			choice_set=[master_sets[trip_id][0]]+choice_set
			done_queue.put((trip_id,choice_set,chosen_overlap))
		else:
			choice_set,chosen_overlap=ds.filter_master(G,master_sets[trip_id][0],master_sets[trip_id][1:],choice_set_config)
			done_queue.put((trip_id,choice_set,chosen_overlap))

	done_queue.put('STOP')
	return True
Ejemplo n.º 2
0
def inverted_estimation_filter_worker(work_queue, done_queue, G, master_sets,
                                      choice_set_config):

    for trip_id in iter(work_queue.get, 'STOP'):
        if choice_set_config['allow_duplicates_of_chosen_route']:
            chosen_overlap = calc_chosen_overlap(G, master_sets[trip_id][0],
                                                 master_sets[trip_id][1:],
                                                 choice_set_config)
            choice_set = ds.filter_master(G, None, master_sets[trip_id][1:],
                                          choice_set_config)
            choice_set = [master_sets[trip_id][0]] + choice_set
            done_queue.put((trip_id, choice_set, chosen_overlap))
        else:
            choice_set, chosen_overlap = ds.filter_master(
                G, master_sets[trip_id][0], master_sets[trip_id][1:],
                choice_set_config)
            done_queue.put((trip_id, choice_set, chosen_overlap))

    done_queue.put('STOP')
    return True
Ejemplo n.º 3
0
def predict_holdback_filter_worker(work_queue,done_queue,G,master_sets,choice_set_config):
	
	for trip_id in iter(work_queue.get,'STOP'):
		if choice_set_config['allow_duplicates_of_chosen_route']:
			choice_set=ds.filter_master(G,None,master_sets[trip_id][1:],choice_set_config)
			chosen_overlap=[1]
			for i in range(len(choice_set)):
				chosen_overlap.append(calc_chosen_overlap(G,master_sets[trip_id][0],[choice_set[i]],choice_set_config))
			choice_set=[master_sets[trip_id][0]]+choice_set
			done_queue.put((trip_id,choice_set,chosen_overlap))
		else:
			raise Exception, 'must allow duplicates of chosen route for predicting a holdback sample'

	done_queue.put('STOP')
	return True
Ejemplo n.º 4
0
def inverted_assignment_load_worker(work_queue, done_queue, network,
                                    master_config, ext_bound, matrix_list):
    this_network = network
    config = master_config.assign_config

    idx = 0
    for source, the_target in iter(work_queue.get, 'STOP'):
        idx = idx + 1
        print time.asctime(time.localtime()), "-", current_process(
        ).name, "-", idx, ". zone: ", source, "Selecting random sample of generated paths..."

        if source in the_target:
            del the_target[source]

        master_sets = {}
        for t in the_target:
            master_sets[t] = []
        to_iter = 1
        if master_config.choice_set_config['randomize_after']:
            to_iter = master_config.choice_set_config['randomize_after_iters']
        while to_iter:
            to_iter = to_iter - 1
            for fname in glob.glob(
                    os.path.join(master_config.assign_config['pickle_path'],
                                 str(source) + '_*')):
                f = open(fname, 'rb')
                target_paths = cPickle.load(f)
                f.close()
                for t in the_target:
                    if t in target_paths:
                        master_sets[t].append(target_paths[t])

        filtered_sets = {}
        for t in master_sets:
            if master_sets[t] != []:
                #filter master set
                filtered_sets[t] = ds.filter_master(
                    this_network, None, master_sets[t],
                    master_config.choice_set_config)

        trace_and_load(this_network, filtered_sets, master_config, matrix_list,
                       source)

    done_queue.put(this_network.orig_network)
    done_queue.put('STOP')
    return True
Ejemplo n.º 5
0
def inverted_assignment_load_worker(work_queue,done_queue,network,master_config,ext_bound,matrix_list):
	this_network=network
	config=master_config.assign_config
	
	idx=0
	for source,the_target in iter(work_queue.get,'STOP'):
		idx=idx+1
		print time.asctime(time.localtime()), "-", current_process().name, "-",idx, ". zone: ", source, "Selecting random sample of generated paths..."
		
		if source in the_target:
			del the_target[source]
		
		master_sets={}
		for t in the_target:
			master_sets[t]=[]
		to_iter=1
		if master_config.choice_set_config['randomize_after']:
			to_iter=master_config.choice_set_config['randomize_after_iters']
		while to_iter:
			to_iter=to_iter-1
			for fname in glob.glob(os.path.join(master_config.assign_config['pickle_path'],str(source)+'_*')):
				f=open(fname,'rb')
				target_paths=cPickle.load(f)
				f.close()
				for t in the_target:
					if t in target_paths:
						master_sets[t].append(target_paths[t])
		
		filtered_sets={}
		for t in master_sets:
			if master_sets[t]!=[]:
				#filter master set
				filtered_sets[t]=ds.filter_master(this_network,None,master_sets[t],master_config.choice_set_config)
			
		trace_and_load(this_network,filtered_sets,master_config,matrix_list,source)
	
	done_queue.put(this_network.orig_network)
	done_queue.put('STOP')
	return True