def get_policy_7_storage(ts, eta_in, eta_out, storage_capacity): storage_part = pos(ts) - pos(neg(ts) - constant.policy_7_capacity) if storage_part.min() >= 0: return ts, 0 remainder = ts - storage_part storage_ts, used_storage = get_policy_2_storage(storage_part, eta_in, eta_out, storage_capacity) return storage_ts + remainder, used_storage
def get_policy_9_storage(ts, eta_in, eta_out, storage_capacity): if pos(ts).sum() * eta_in * eta_out < neg(ts).sum(): beta = (pos(ts).sum() * eta_in * eta_out) / neg(ts).sum() else: beta = 1. storage_part = pos(ts) - beta * neg(ts) remainder = ts - storage_part storage_ts, used_storage = get_policy_2_storage(storage_part, eta_in, eta_out, storage_capacity) print used_storage return storage_ts + remainder, used_storage
def old_storage(ts, eta_in = 1., eta_out = 1., storage_capacity = NaN): indices, integrals = get_indices_and_integrals(ts) storing_potential = eta_in * eta_out * sum(integrals * (integrals > 0)) extracting_potential = -sum(integrals * (integrals < 0)) storage_start, used_storage = get_storage_start(integrals, eta_in, eta_out, storage_capacity, storing_potential > extracting_potential) storage_usage_ts = get_storage_usage_ts(integrals, storage_start, eta_in, eta_out, storage_capacity, storing_potential > extracting_potential) extracting = zeros_like(ts) storing = zeros_like(ts) end_to_start_slice = concatenate((ts[indices[-1] + 1:],ts[:indices[0] + 1])) if storage_usage_ts[0] < 0: end_to_start_extracting = pos(-end_to_start_slice - find_height(-end_to_start_slice, -storage_usage_ts[0])) extracting[indices[-1] + 1:] = -end_to_start_extracting[:len(extracting[indices[-1] + 1:])] extracting[:indices[0] + 1] = -end_to_start_extracting[len(extracting[indices[-1] + 1:]):] else: end_to_start_storing = pos(end_to_start_slice - find_height(end_to_start_slice, storage_usage_ts[0])) storing[indices[-1] + 1:] = end_to_start_storing[:len(extracting[indices[-1] + 1:])] storing[:indices[0] + 1] = end_to_start_storing[len(extracting[indices[-1] + 1:]):] for x in arange(len(indices)-1) + 1: #print x if storage_usage_ts[x] < 0: #print storage_usage_ts[x] #print indices[x] extracting[indices[x - 1] + 1: indices[x] + 1] = -pos(-ts[indices[x - 1] + 1: indices[x] + 1] - find_height(-ts[indices[x - 1] + 1: indices[x] + 1], -storage_usage_ts[x])) else: storing[indices[x - 1] + 1: indices[x] + 1] = pos(ts[indices[x - 1] + 1: indices[x] + 1] - find_height(ts[indices[x - 1] + 1: indices[x] + 1], storage_usage_ts[x])) #plot(storing, lw = 2) #plot(extracting, lw = 2) #plot(ts) #plot(ts - storing - extracting+ 1) return(ts - storing - extracting)
def get_storage_data(gamma, alpha, storage_capacity, eta_in = 1., eta_out = 1., policy = 3, quantile = .99, mismatch = None): if not isnan(gamma): mismatch = get_mismatch(gamma, alpha) if mismatch.max() < 0 or mismatch.min() > 0: print "Warning!" new_mismatch = mismatch elif policy == 4: new_mismatch = get_mismatch_after_policy_4_storage(mismatch, eta_in, eta_out, storage_capacity) elif policy == 2: new_mismatch = get_mismatch_after_policy_2_storage(mismatch, eta_in, eta_out, storage_capacity) elif policy == 1: new_mismatch = get_mismatch_after_policy_1_storage(mismatch, eta_in, eta_out, storage_capacity) elif policy == 5: new_mismatch = get_mismatch_after_policy_5_storage(mismatch, eta_in, eta_out, storage_capacity) elif policy == 7: new_mismatch = get_mismatch_after_policy_7_storage(mismatch, eta_in, eta_out, storage_capacity) elif policy == 8: new_mismatch = get_mismatch_after_policy_8_storage(mismatch, eta_in, eta_out, storage_capacity) elif policy == 9: new_mismatch = get_mismatch_after_policy_9_storage(mismatch, eta_in, eta_out, storage_capacity) else: new_mismatch = get_mismatch_after_policy_3_storage(mismatch, eta_in, eta_out, storage_capacity) storage_transactions = mismatch - new_mismatch storage_filling = eta_in * pos(storage_transactions).cumsum() - neg(storage_transactions).cumsum() / eta_out storage_filling = storage_filling - storage_filling.min() storage_capacity = storage_filling.max() balancing = neg(new_mismatch) if policy == 8: balancing = balancing * (balancing > constant.policy_8_capacity) + constant.policy_8_capacity * (balancing <= constant.policy_8_capacity) #plot(storage_filling) excess = pos(new_mismatch) return storage_capacity, excess.mean(), mquantiles(excess, quantile), pos(storage_transactions).mean(), mquantiles(pos(storage_transactions), quantile), neg(storage_transactions).mean(), mquantiles(neg(storage_transactions), quantile), balancing.mean(), mquantiles(balancing, quantile), storage_filling.mean()
def find_equilibrium(K_B): storage_part = pos(mismatch) - pos(neg(mismatch) - K_B) return storage_part.sum()