boolean isMarketOrder () { return (order.getLimitPrice() == null); }
OrderWrapper(Order order) { super(); this.order = order; this.adjustedMWh = order.getMWh(); }
Broker getBroker () { return order.getBroker(); }
public boolean validateOrder (Order order) { if (order.getMWh().equals(Double.NaN) || order.getMWh().equals(Double.POSITIVE_INFINITY) || order.getMWh().equals(Double.NEGATIVE_INFINITY)) { log.warn("Order from " + order.getBroker().getUsername() + " with invalid quantity " + order.getMWh()); return false; } double minQuantity = Competition.currentCompetition().getMinimumOrderQuantity(); if (Math.abs(order.getMWh()) < minQuantity) { log.warn("Order from " + order.getBroker().getUsername() + " with quantity " + order.getMWh() + " < minimum quantity " + minQuantity); return false; } if (!timeslotRepo.isTimeslotEnabled(order.getTimeslot())) { OrderStatus status = new OrderStatus(order.getBroker(), order.getId()); brokerProxyService.sendMessage(order.getBroker(), status); log.warn("Order from " + order.getBroker().getUsername() +" for disabled timeslot " + order.getTimeslot()); return false; } return true; }
/** * Generates buy orders. Price is distributed exponentially with a mean value * of priceBeta. Quantity is mwh/price. */ @Override public void generateOrders (Instant now, List<Timeslot> openSlots) { log.info("generate orders for " + getUsername()); for (Timeslot slot : openSlots) { int slotNum = slot.getSerialNumber(); double price = - priceBeta * Math.log(1.0 - seed.nextDouble()); double qty = mwh / price; if (Math.abs(qty) < Competition.currentCompetition() .getMinimumOrderQuantity()) return; Order offer = new Order(this, slotNum, qty, -price); log.debug(getUsername() + " wants " + qty + " in " + slotNum + " for " + price); brokerProxyService.routeMessage(offer); } }
&& Math.signum(amountNeeded) == Math.signum(lastTry.getMWh())) oldLimitPrice = lastTry.getLimitPrice();
Timeslot getTimeslot () { return order.getTimeslot(); }
/** * Receives, validates, and queues an incoming Order message. Processing the incoming * marketOrders happens during Phase 2 in each timeslot. */ public void handleMessage (Order msg) { if (validateOrder(msg)) { // queue incoming message synchronized(incoming) { incoming.add(msg); } log.info("Received " + msg.toString()); } }
private void submitOrder (double neededKWh, Timeslot timeslot) { double neededMWh = neededKWh / 1000.0; if (Math.abs(neededMWh) < competition.getMinimumOrderQuantity()) { // don't bother return; } Double limitPrice; MarketPosition posn = face.findMarketPositionByTimeslot(timeslot.getSerialNumber()); if (posn != null) neededMWh -= posn.getOverallBalance(); log.debug("needed mWh=" + neededMWh); if (Math.abs(neededMWh) < minMWh) { log.info("no power required in timeslot " + timeslot.getSerialNumber()); return; } else { limitPrice = computeLimitPrice(timeslot, neededMWh); } log.info("new order for " + neededMWh + " at " + limitPrice + " in timeslot " + timeslot.getSerialNumber()); Order result = new Order(face, timeslot.getSerialNumber(), neededMWh, limitPrice); lastOrder.put(timeslot, result); brokerProxyService.routeMessage(result); }
/** * Generates Orders in the market to sell remaining available capacity. */ public void generateOrders (Instant now, List<Timeslot> openSlots) { log.info("Generate orders for " + getUsername()); double[] tempCorrections = computeWeatherCorrections(); int i = 0; for (Timeslot slot: openSlots) { int index = slot.getSerialNumber(); MarketPosition posn = findMarketPositionByTimeslot(index); double start = 0.0; double demand = computeScaledValue(index, tempCorrections[i++]); if (posn != null) { // posn.overallBalance is negative if we have sold power in this slot start = posn.getOverallBalance(); } double needed = demand - start; Order offer = new Order(this, index, needed, null); log.info(getUsername() + " orders " + needed + " ts " + index); brokerProxyService.routeMessage(offer); } }
boolean isBuyOrder () { return (order.getMWh() > 0.0); }
Double getLimitPrice () { return order.getLimitPrice(); }
.getMinimumOrderQuantity()) { Order offer = new Order(this, slotNum, -availableCapacity, cost); log.debug(getUsername() + " offers " + availableCapacity + " in " + slotNum + " for " + cost);
/** * Receives a new MarketTransaction. In bootstrapMode, we need to record * these as they arrive in order to be able to compute delivered price of * power purchased in the wholesale market. Note that this computation will * ignore balancing cost. This is intentional. */ public void handleMessage (MarketTransaction tx) { // Save all transactions in bootstrapMode if (bootstrapMode) { ArrayList<MarketTransaction> txs = marketTxMap.get(tx.getTimeslot()); if (txs == null) { txs = new ArrayList<MarketTransaction>(); marketTxMap.put(tx.getTimeslot(), txs); } txs.add(tx); } // reset price escalation when a trade fully clears. Order lastTry = lastOrder.get(tx.getTimeslot()); if (lastTry == null) // should not happen log.error("order corresponding to market tx " + tx + " is null"); else if (tx.getMWh() == lastTry.getMWh()) // fully cleared lastOrder.put(tx.getTimeslot(), null); }
double std = dx * getQSigma(); dx = Math.max(0.0, ran[1] * std + dx); // don't go backward Order offer = new Order(this, slot.getSerialNumber(), -dx, price); log.debug("new order (ts, qty, price): (" + slot.getSerialNumber() + ", " + (-dx) + ", " + price + ")");