@Override
public org.powertac.common.CapacityProfile getCapacityProfile(Tariff tariff) {
double usageSign = bundle.getPowerType().isConsumption() ? +1 : -1;
// New code: shifted prediction - correct for tariff-eval purposes
// ===============================================================
double[] newForecast;
// new code
HashMap<CapacityOriginator, double[]> originator2usage = new HashMap<>();
for (CapacityOriginator capacityOriginator : bundle.getCapacityOriginators()) {
double[] usageForecast = new double[CapacityProfile.NUM_TIMESLOTS];
// BUG FIX: this function is called from forecastCost() and used
// by TariffEvaluationHelper, which assumes the forcast starts
// at the next timeslot
CapacityProfile forecast = capacityOriginator.getForecastForNextTimeslot();
for (int i = 0; i < CapacityProfile.NUM_TIMESLOTS; ++i) {
double hourlyUsage = usageSign * forecast.getCapacity(i);
usageForecast[i] = hourlyUsage; // don't divide yet / bundle.getPopulation();
}
originator2usage.put(capacityOriginator, usageForecast);
}
// Refactored the following code for LearningUtilityOptimizer - shift profile
//
// create dummy subscription for the above usage vector:
// 1 population member under 'tariff', (consuming the sum
// of the originators' usage)
TariffSubscription dummySubscription = new DummyTariffSubscription(getCustomerInfo(), tariff);
newForecast = adjustForecastPerTariff(originator2usage, dummySubscription, bundle);
double[] result = newForecast;
Instant start = service.getTimeService().getCurrentTime().plus(TimeService.HOUR);
return new org.powertac.common.CapacityProfile(result, start);
}
private void usePower(Timeslot timeslot) {
for (CapacityBundle bundle : capacityBundles) {
List<TariffSubscription> subscriptions =
getTariffSubscriptionRepo().findActiveSubscriptionsForCustomer(bundle.getCustomerInfo());
double totalCapacity = 0.0;
double totalUsageCharge = 0.0;
for (TariffSubscription subscription : subscriptions) {
double usageSign = bundle.getPowerType().isConsumption() ? +1 : -1;
double currCapacity = usageSign * useCapacity(subscription, bundle);
if (Config.getInstance().isUsageChargesLogging()) {
double charge =
subscription
.getTariff()
.getUsageCharge(currCapacity, subscription.getTotalUsage(), false);
totalUsageCharge += charge;
}
subscription.usePower(currCapacity);
totalCapacity += currCapacity;
}
log.info(
bundle.getName()
+ ": Total "
+ bundle.getPowerType()
+ " capacity for timeslot "
+ timeslot.getSerialNumber()
+ " = "
+ totalCapacity);
logUsageCharges(
bundle.getName()
+ ": Total "
+ bundle.getPowerType()
+ " usage charge for timeslot "
+ timeslot.getSerialNumber()
+ " = "
+ totalUsageCharge);
}
}
/** @Override hook */
protected void subscribeDefault() {
for (CapacityBundle bundle : capacityBundles) {
PowerType powerType = bundle.getPowerType();
if (getTariffMarket().getDefaultTariff(powerType) != null) {
log.info(
bundle.getName()
+ ": Subscribing "
+ bundle.getPopulation()
+ " customers to default "
+ powerType
+ " tariff");
subscribe(
getTariffMarket().getDefaultTariff(powerType), bundle, bundle.getPopulation(), false);
} else {
log.info(
bundle.getName()
+ ": No default tariff for power type "
+ powerType
+ "; trying generic type");
PowerType genericType = powerType.getGenericType();
if (getTariffMarket().getDefaultTariff(genericType) == null) {
log.error(
bundle.getName()
+ ": No default tariff for generic power type "
+ genericType
+ " either!");
} else {
log.info(
bundle.getName()
+ ": Subscribing "
+ bundle.getPopulation()
+ " customers to default "
+ genericType
+ " tariff");
subscribe(
getTariffMarket().getDefaultTariff(genericType),
bundle,
bundle.getPopulation(),
false);
}
}
}
}