/** Adds an existing subscription to the repo. */ public TariffSubscription add (TariffSubscription subscription) { storeSubscription(subscription, subscription.getCustomer(), subscription.getTariff()); return subscription; }
private void consumePower (double[] loads, TariffSubscription sub) { sub.usePower(loads[0] + loads[1]); try { charge(loads[0] + loads[1]); } catch (ChargeException ce) { log.error(ce.getMessage()); } }
@Override public boolean apply (TariffSubscription sub) { return (null != tariffRepo.findTariffById(sub.getTariff().getId()) && sub.getTariff().getState() == Tariff.State.KILLED && sub.getCustomersCommitted() > 0); } });
/** * Removes customerCount customers (at most) from this subscription, * posts early-withdrawal fees if appropriate. */ public void unsubscribe (int customerCount) { getTariffMarket().subscribeToTariff(getTariff(), getCustomer(), -customerCount); pendingUnsubscribeCount += customerCount; }
originators = allOriginators.subList(lastOriginator, lastOriginator + subscription.getCustomersCommitted()); lastOriginator += subscription.getCustomersCommitted(); if (Config.getInstance().isUsageChargesLogging()) { double charge = subscription.getTariff().getUsageCharge(currCapacity, subscription .getTotalUsage(), false); totalUsageCharge += charge; subscription.usePower(currCapacity); subscription.setRegulationCapacity(new RegulationCapacity(subscription, ca.getUpRegulationCapacity(), ca.getDownRegulationCapacity()));
double regulation = subscription.getRegulation(); log.info(getName() + ": regulation " + regulation); if (regulation > 0) { double down = -((Math.min((capacityKWh - stateOfCharge) / chargeEfficiency, maxChargeKW * timeslotLength))); subscription.setRegulationCapacity(new RegulationCapacity(subscription, up, down)); subscription.usePower(0.0);
private void addSupersedingTariffs (HashSet<Tariff> newTariffs) { List<TariffSubscription> revokedSubscriptions = getTariffSubscriptionRepo().getRevokedSubscriptionList(customerInfo); for (TariffSubscription sub : revokedSubscriptions) { Tariff supTariff = sub.getTariff().getIsSupersededBy(); if (null != supTariff && supTariff.isSubscribable()) newTariffs.add(supTariff); } }
: getTariffSubscriptionRepo(). findActiveSubscriptionsForCustomer(customerInfo)) { Tariff subTariff = subscription.getTariff(); int committedCount = subscription.getCustomersCommitted(); int expiredCount = subscription.getExpiredCustomerCount(); if (withdrawCost == 0.0 || (expiredCount > 0 && expiredCount == committedCount)) {
if (customerCount == customersCommitted) { setRegulationCap(new RegulationAccumulator(0.0, 0.0)); setRegulation(0.0); int freeAgentCount = getExpiredCustomerCount(); int penaltyCount = Math.max (customerCount - freeAgentCount, 0); setCustomersCommitted(getCustomersCommitted() - customerCount); if (0 == getCustomersCommitted()) { regulationAccumulator.setDownRegulationCapacity(0.0); regulationAccumulator.setUpRegulationCapacity(0.0); withdrawPayment = 0.0; getAccounting().addTariffTransaction(TariffTransaction.Type.WITHDRAW, tariff, customer, customerCount, 0.0, penaltyCount * withdrawPayment); if (tariff.getSignupPayment() < 0.0) { getAccounting().addTariffTransaction(TariffTransaction.Type.REFUND, tariff, customer, customerCount, 0.0,
@Override public boolean apply (TariffSubscription sub) { return (sub.getCustomersCommitted() > 0); } });
double regulation = getSubscription().getRegulation(); log.info(getName() + ": regulation " + regulation); double energyUsed = useEnergy(regulation); getSubscription().usePower(energyUsed); log.info(getName() + " cInUse " + capacityInUse + ", eInUse " + energyInUse + ", eCharging " + energyCharging);
double useEnergy (double regulation) Tariff tariff = subscription.getTariff(); ensureCapacityPlan(tariff); getSubscription().setRegulationCapacity(regCapacity); log.info(getName() + " uses " + used + "kWh, reg cap (" + regCapacity.getUpRegulationCapacity() + ", "
setCustomersCommitted(getCustomersCommitted() + customerCount); Instant start = getTimeService().getCurrentTime(); if (expirations.size() > 0 && expirations.get(expirations.size() - 1).getHorizon() == start.getMillis() + minDuration) { getAccounting().addTariffTransaction(TariffTransaction.Type.SIGNUP, tariff, customer, customerCount, 0.0,
tariffSubscriptionRepo.findActiveSubscriptionsForBroker(broker); for (TariffSubscription sub: subs) { if (CustomerClass.LARGE == sub.getCustomer().getCustomerClass()) { nLarge += sub.getCustomersCommitted(); nSmall += sub.getCustomersCommitted();
/** Unsubscribing a certain population amount from a certain subscription */ void unsubscribe (TariffSubscription subscription, int customerCount) { subscription.unsubscribe(customerCount); log.info(this.toString() + " " + subscription.getTariff().getPowerType().toString() + ": " + customerCount + " were unsubscribed from tariff " + subscription.getTariff().getId()); } }
setRegulation(0.0); double result = 0.0; if (getTariff().hasRegulationRate()) { if (pendingRegulationRatio < 0.0) { log.info("Economic control of {} by {}", customer.getName(), result); addRegulation(result); // saved until next timeslot pendingRegulationRatio = 0.0; return result;
private double adjustCapacityForTariffRates ( int timeslot, double baseCapacity, TariffSubscription subscription) { if ((baseCapacity - 0.0) < 0.01) { return baseCapacity; } double chargeForBase = subscription.getTariff().getUsageCharge( timeslotRepo.getTimeForIndex(timeslot), baseCapacity, subscription.getTotalUsage()); double rateForBase = chargeForBase / baseCapacity; double benchmarkRate = capacityStructure.getBenchmarkRate(timeService.getHourOfDay()); double rateRatio = rateForBase / benchmarkRate; double tariffRatesFactor = determineTariffRatesFactor(rateRatio); logCapacityDetails(logIdentifier + ": tariff rates factor = " + tariffRatesFactor); return baseCapacity * tariffRatesFactor; }
new HashMap<TariffSubscription, Double>(); for (TariffSubscription sub : subs) { if (sub.getCustomersCommitted() > 0) { RegulationAccumulator value = sub.getRemainingRegulationCapacity(); if (kwh > 0) { if (sub.getCustomersCommitted() > 0) sub.postBalancingControl(kwh * amts.get(sub) / available);
private TariffSubscription findSubscriptionForCustomer (List<TariffSubscription> subs, CustomerInfo customer) { if (subs == null) return null; for (TariffSubscription sub : subs) { if (sub.getCustomer() == customer) return sub; } return null; }
private void handleRegulation (int day, int hour, TariffSubscription sub) { if (null == sub) return; // check for non-zero regulation request double actualRegulation = sub.getRegulation() * customerInfo.getPopulation(); if (Math.abs(actualRegulation) < capacityEpsilon) { return; } // compute the regulation factor and do the regulation log.info("{} regulate: {}", name, actualRegulation); double startCapacity = currentCapacity; try { if (actualRegulation > capacityEpsilon) { discharge(actualRegulation); } else if (actualRegulation < -capacityEpsilon) { charge(-1 * actualRegulation); } } catch (ChargeException ce) { log.error(name +" : "+ ce); } if (Math.abs(startCapacity - currentCapacity) > capacityEpsilon) { log.info(String.format("%s regulated from %.1f to %.1f", name, startCapacity, currentCapacity)); } }