private void storeWeeklyMetrics(LocalDate crc) {
// Store weekly demand metrics
Years yr = Years.years(crc.getYear());
Map<LocalDate, Demand> currDemandMap = demandMap.get(yr);
if (currDemandMap == null) {
currDemandMap = new TreeMap<LocalDate, Demand>();
}
Demand d = currDemandMap.get(crc);
if (d == null) {
d = new Demand();
}
d.setRcAvgDemand(rcAvgDemand);
d.setRcAvgDemandActual(rcAvgDemandActual);
currDemandMap.put(crc, d);
demandMap.put(yr, currDemandMap);
// Store weekly sales metrics
Map<LocalDate, Sales> currSalesMap = salesMap.get(yr);
if (currSalesMap == null) {
currSalesMap = new TreeMap<LocalDate, Sales>();
}
Sales s = currSalesMap.get(crc);
if (s == null) {
s = new Sales();
}
s.setRcAvgSalesActual(rcAvgSalesActual);
s.setRcAvgSales(rcAvgSales);
currSalesMap.put(crc, s);
salesMap.put(yr, currSalesMap);
}
private void performDailyLearning() {
updateStatusCode();
if (statusCd != STATUS_CD.LEARNING || disableLearning == true) {
return;
}
if (onRange && (rcBopInv > 0 || hasSale == true || rcInvIn > 0)) {
initLearningMetrics();
// Daily learning only applies to RC_AVG_DEMAND and begins immediately when the PL comes on
// range
double lastWeekLift = getDemandUplift(SystemDao.getReviewCycleStartDate());
double defaultWeight = SystemDao.getDefaultWeight();
Demand beginOfRunCycleDemand = getDemand(SystemDao.getReviewCycleStartDate());
double beginOfRunCycleRcAvgDemand = 0;
if (beginOfRunCycleDemand != null) {
beginOfRunCycleRcAvgDemand = beginOfRunCycleDemand.getRcAvgDemand();
}
if (onRange && !disableLearning) {
rcAvgDemand =
getWeightedWeight1(learningWeekCounter, defaultWeight) * rcDemand / lastWeekLift
+ (1 - getWeightedWeight1(learningWeekCounter, defaultWeight))
* beginOfRunCycleRcAvgDemand;
}
}
}
private void processInventory() {
LocalDate crc = SystemDao.getCrc();
if (isStockedOut) {
Demand d = getDemand(SystemDao.getCrc());
if (crc.getDayOfWeek() == DateTimeConstants.SUNDAY) {
d = getDemand(SystemDao.getReviewCycleStartDate());
}
int targetInv = (int) d.getRcAvgDemand() - inventory;
setInventory(targetInv > 0 ? targetInv : (int) d.getRcAvgDemand());
isStockedOut = false;
}
if (crc.getDayOfWeek() == DateTimeConstants.SUNDAY) {
rcBopInv = inventory;
}
// daily inventory updates
updateEpEopInv();
epEopInv = inventory;
rcInvOut += epInvOut;
rcInvIn += epInvIn;
ProductInventory p = getInventory(SystemDao.getReviewCycleStartDate());
double beginOfPeriodEpAvgInv = 0;
if (p != null) {
beginOfPeriodEpAvgInv = p.getEpAvgInv();
}
double weight_5 = SystemDao.getWeight_5();
epAvgInv =
weight_5 * ((epEopInv >= 0) ? epEopInv : 0) + (((1 - weight_5) * beginOfPeriodEpAvgInv));
epAvgInv = Math.max(0, epAvgInv);
}
/**
* Pass prices down and compute demand for the power system.
*
* @param theta_R real power demand multiplier
* @param theta_I reactive power demand multiplier
* @param pi_R price of real power demand
* @param pi_I price of reactive power demand
* @return the demand for the customers supported by this lateral
*/
public Demand compute(double theta_R, double theta_I, double pi_R, double pi_I) {
// generate the new prices and pass them down to the customers
double new_pi_R = pi_R + alpha * (theta_R + (theta_I * X) / R);
double new_pi_I = pi_I + beta * (theta_I + (theta_R * R) / X);
Demand a1;
if (next_lateral != null) a1 = next_lateral.compute(theta_R, theta_I, new_pi_R, new_pi_I);
else a1 = null;
Demand a2 = branch.compute(theta_R, theta_I, new_pi_R, new_pi_I);
if (next_lateral != null) {
D.add(a1, a2);
} else {
D.assign(a2);
}
// compute the new power demand values P,Q
double a = R * R + X * X;
double b = 2 * R * X * D.Q - 2 * X * X * D.P - R;
double c = R * D.Q - X * D.P;
c = c * c + R * D.P;
double root = (-b - Math.sqrt(b * b - 4 * a * c)) / (2 * a);
D.Q = D.Q + ((root - D.P) * X) / R;
D.P = root;
// compute alpha, beta
a = 2 * R * D.P;
b = 2 * X * D.Q;
alpha = a / (1 - a - b);
beta = b / (1 - a - b);
return D;
}
private String demandToString() {
Iterator<Years> yrItr = demandMap.keySet().iterator();
Map<LocalDate, Demand> currDemandMap;
Years currYr;
LocalDate currDate;
Demand currDemand;
StringBuffer epDemandBf = new StringBuffer();
epDemandBf.append("epDemand|");
StringBuffer rcActualDemandBf = new StringBuffer();
rcActualDemandBf.append("rcActualDemand|");
StringBuffer rcDemandBf = new StringBuffer();
rcDemandBf.append("rcDemand|");
StringBuffer rcAvgDemandBf = new StringBuffer();
rcAvgDemandBf.append("rcAvgDemand|");
StringBuffer rcAvgDemandActualBf = new StringBuffer();
rcAvgDemandActualBf.append("rcAvgDemandActual|");
while (yrItr.hasNext()) {
currYr = yrItr.next();
currDemandMap = demandMap.get(currYr);
Iterator<LocalDate> itr = currDemandMap.keySet().iterator();
while (itr.hasNext()) {
currDate = itr.next();
currDemand = currDemandMap.get(currDate);
// ep demand
epDemandBf.append(currDate);
epDemandBf.append(":");
epDemandBf.append(currDemand.getEpDemand());
epDemandBf.append("|");
// actual demand
rcActualDemandBf.append(currDate);
rcActualDemandBf.append(":");
rcActualDemandBf.append(currDemand.getRcDemandActual());
rcActualDemandBf.append("|");
// rc demand
rcDemandBf.append(currDate);
rcDemandBf.append(":");
rcDemandBf.append(currDemand.getRcDemand());
rcDemandBf.append("|");
// rc average demand
rcAvgDemandBf.append(currDate);
rcAvgDemandBf.append(":");
rcAvgDemandBf.append(currDemand.getRcAvgDemand());
rcAvgDemandBf.append("|");
// rc average demand actual
rcAvgDemandActualBf.append(currDate);
rcAvgDemandActualBf.append(":");
rcAvgDemandActualBf.append(currDemand.getRcAvgDemandActual());
rcAvgDemandActualBf.append("|");
}
}
rcActualDemandBf.append(";\n");
epDemandBf.append(";\n");
rcDemandBf.append(";\n");
rcAvgDemandBf.append(";\n");
rcAvgDemandActualBf.append(";\n");
StringBuffer retBf = new StringBuffer();
retBf.append(epDemandBf.toString());
retBf.append(rcActualDemandBf.toString());
retBf.append(rcDemandBf.toString());
retBf.append(rcAvgDemandBf.toString());
retBf.append(rcAvgDemandActualBf.toString());
retBf.append("\n");
return retBf.toString();
}
private void processWeeklyMetrics() {
// On the end of the review cycle (Sat night) the rcAvgDemand does not undergo weekly learning
// For this exercise we do not have time granulity so weekly processing is done Sunday for the
// prior week
LocalDate crc = SystemDao.getCrc();
LocalDate prevCRCStartDate = SystemDao.getReviewCycleStartDate(); // getPreviousCRCStartDate();
Sales salesData = getSales(crc);
Sales beginOfPeriodSalesData = getSales(prevCRCStartDate);
double beginOfPeriodRcAvgSales = 0;
double beginOfPeriodRcActualAvgSales = 0;
if (beginOfPeriodSalesData != null) {
beginOfPeriodRcAvgSales = beginOfPeriodSalesData.getRcAvgSales();
beginOfPeriodRcActualAvgSales = beginOfPeriodSalesData.getRcAvgSalesActual();
}
Demand demandData = getDemand(crc);
Demand beginOfPeriodDemandData = getDemand(prevCRCStartDate);
double beginOfPeriodRcAvgDemand = 0;
double beginOfPeriodRcAvgActualDemand = 0;
if (beginOfPeriodDemandData != null) {
beginOfPeriodRcAvgDemand = beginOfPeriodDemandData.getRcAvgDemand();
beginOfPeriodRcAvgActualDemand = beginOfPeriodDemandData.getRcAvgDemandActual();
}
double defaultWeight = SystemDao.getDefaultWeight();
double lastWeekLift = getDemandUplift(prevCRCStartDate);
double weight = 1.0;
if (statusCd == STATUS_CD.LEARNING) {
weight = getWeightedWeight1(learningWeekCounter, defaultWeight);
} else if (statusCd == STATUS_CD.ACTIVE) {
weight = getWeight1(learningWeekCounter);
}
rcAvgSalesActual =
(weight * (salesData.getRcSalesActual() / lastWeekLift))
+ ((1 - weight) * beginOfPeriodRcActualAvgSales);
rcAvgSales =
(weight * (salesData.getRcSales() / lastWeekLift))
+ ((1 - weight) * beginOfPeriodRcAvgSales);
rcAvgDemand =
(weight * (demandData.getRcDemand() / lastWeekLift))
+ ((1 - weight) * beginOfPeriodRcAvgDemand);
rcAvgDemandActual =
(weight * (demandData.getRcDemandActual() / lastWeekLift))
+ ((1 - weight) * beginOfPeriodRcAvgActualDemand);
// error checking
if (rcAvgDemand == 0 && statusCd != STATUS_CD.INACTIVE) {
System.out.println("Error: 0 demand when product status is not inactive");
}
if (rcAvgDemand >= 4 * rcAvgSales) {
rcAvgSales = 4 * rcAvgSalesActual;
System.out.println("Error: RC Actual Sales greater then 4 times RC Average Sales");
}
if (rcAvgDemand >= 3 * rcAvgSalesActual) {
rcAvgSales = 3 * rcAvgSalesActual;
System.out.println("Error: RC Actual Sales greater then 3 times RC Actual Average Sales");
}
storeWeeklyMetrics(crc);
this.learningWeekCounter++;
// this is the end of the review cycle reset hasBeenOffRange
if (hasBeenOffRange) {
hasBeenOffRange = false;
}
resetRcAccumulators();
}
/** Outlier filtering has been done prior to processing daily metrics * */
private void processDailyMetrics() {
LocalDate crc = SystemDao.getCrc();
double lostSales = getLostSales();
rcSalesActual = rcSalesActual + epSalesActual;
// rcSales is outlier filtered sales and has been calculated in outlier processing
rcSales = rcSales + epSales;
Years yr = Years.years(crc.getYear());
Map<LocalDate, Sales> currSalesMap = salesMap.get(yr);
if (currSalesMap == null) {
currSalesMap = new TreeMap<LocalDate, Sales>();
}
Sales s = currSalesMap.get(crc);
if (s == null) {
s = new Sales();
}
s.setEpSalesActual(epSalesActual);
s.setEpSales(epSales);
s.setRcSales(rcSales);
s.setRcSalesActual(rcSalesActual);
s.setLostSales(lostSales);
currSalesMap.put(crc, s);
salesMap.put(yr, currSalesMap);
/** * Daily Demand Calculations **** */
// daily demand
epDemand = getEpDemand();
// demand = sales + lostsales
// outlier filtered sales used for rcDemand
rcDemand = rcSales + lostSales;
rcDemandActual += (epSalesActual + lostSales);
Map<LocalDate, Demand> currDemandMap = demandMap.get(yr);
if (currDemandMap == null) {
currDemandMap = new TreeMap<LocalDate, Demand>();
}
Demand d = currDemandMap.get(crc);
if (d == null) {
d = new Demand();
}
d.setEpDemand(epDemand);
d.setRcDemand(rcDemand);
d.setRcDemandActual(rcDemandActual);
currDemandMap.put(crc, d);
demandMap.put(yr, currDemandMap);
/** **** Daily Inventory Calculations ****** */
processInventory();
if (epSales > rcMaxSales) {
rcMaxSales = epSales;
weekSinceMaxSales = 0;
}
if (epEopInv > demoStock) {
daysSinceWalk = daysSinceWalk + 1;
} else {
daysSinceWalk = 0;
}
if (epSalesActual == 0) {
daysSinceSale = daysSinceSale + 1;
} else {
daysSinceSale = 0;
}
Map<LocalDate, ProductInventory> currInventoryMap = inventoryMap.get(yr);
if (currInventoryMap == null) {
currInventoryMap = new TreeMap<LocalDate, ProductInventory>();
}
ProductInventory inv = currInventoryMap.get(crc);
if (inv == null) {
inv = new ProductInventory();
}
inv.setEpAvgInv(epAvgInv);
inv.setEpEopInv(epEopInv);
inv.setEpInvOut(epInvOut);
inv.setEpInvIn(epInvIn);
inv.setRcBopInv(rcBopInv);
inv.setRcBopInv(rcBopInv);
inv.setRcInvIn(rcInvIn);
inv.setRcInvOut(rcInvOut);
inv.setInventory(inventory);
currInventoryMap.put(crc, inv);
inventoryMap.put(yr, currInventoryMap);
if (statusCd == STATUS_CD.LEARNING) {
performDailyLearning();
}
resetEpAccumulators();
}
