Ejemplo n.º 1
0
 // We have to ensure that there are enough batteries to
 // support the shift schedule. There must be at least enough batteries to
 // supply the two largest adjacent shifts, and there must also be enough
 // to power the two largest adjacent shifts, in case a single battery
 // cannot power an entire shift.
 void validateBatteries() {
   int minBatteries = 0;
   Shift s1 = null;
   Shift s2 = null;
   for (int i = 0; i < shiftSchedule.length; i++) {
     Shift s = shiftSchedule[i];
     if (null == s) {
       s1 = s2;
     } else if (s2 != s) {
       s1 = s2;
       s2 = s;
       if (null != s1) {
         int n1 = s1.getTrucks();
         int d1 = s1.getDuration();
         int n2 = s2.getTrucks();
         int d2 = s2.getDuration();
         double neededBatteries = (n1 * d1 + n2 * d2) * truckKW / getBatteryCapacity();
         minBatteries = (int) Math.max(minBatteries, (n1 + n2));
         minBatteries = (int) Math.max(minBatteries, Math.ceil(neededBatteries));
       }
     }
   }
   int neededBatteries = minBatteries - nBatteries;
   if (neededBatteries > 0) {
     log.error("Not enough batteries (" + nBatteries + ") for " + getName());
     // Add discharged batteries to fill out battery complement
     log.warn("Adding " + neededBatteries + " batteries for " + getName());
     setNBatteries(getNBatteries() + neededBatteries);
   }
 }
Ejemplo n.º 2
0
  // ======== per-timeslot activities ========
  @Override
  public void step() {
    // check for end-of-shift
    Shift newShift = shiftSchedule[indexOfShift(getNowInstant())];
    if (newShift != currentShift) {
      log.info(getName() + " start of shift");
      // Take all batteries out of service
      double totalEnergy = getEnergyCharging() + getEnergyInUse();
      setEnergyCharging(getEnergyCharging() + getEnergyInUse());
      setCapacityInUse(0.0);
      setEnergyInUse(0.0);

      // Put the strongest batteries in trucks for the next shift
      if (null != newShift) {
        setCapacityInUse(newShift.getTrucks() * batteryCapacity);
        setEnergyInUse(Math.min(getCapacityInUse(), totalEnergy));
        setEnergyCharging(totalEnergy - getEnergyInUse());
      }
      log.info(
          getName()
              + ": new shift cInUse "
              + capacityInUse
              + ", eInUse "
              + energyInUse
              + ", eCharging "
              + energyCharging);
      currentShift = newShift;
    }

    // discharge batteries on active trucks
    if (null != currentShift) {
      double usage = Math.max(0.0, normal.sample() * truckStd + truckKW * currentShift.getTrucks());
      double deficit = usage - getEnergyInUse();
      log.debug(getName() + ": trucks use " + usage + " kWh");
      if (deficit > 0.0) {
        log.warn(getName() + ": trucks use more energy than available by " + deficit + " kWh");
        addEnergyInUse(deficit);
        addEnergyCharging(-deficit);
      }
      addEnergyInUse(-usage);
    }

    // use energy on chargers, accounting for regulation
    double regulation = getSubscription().getRegulation();
    log.info(getName() + ": regulation " + regulation);
    double energyUsed = useEnergy(regulation);

    // Record energy used
    getSubscription().usePower(energyUsed);
    log.info(
        getName()
            + " cInUse "
            + capacityInUse
            + ", eInUse "
            + energyInUse
            + ", eCharging "
            + energyCharging);
  }
Ejemplo n.º 3
0
 ShiftEnergy(Instant start, int end, int duration) {
   super();
   this.start = start;
   this.endIndex = end;
   Shift next = shiftSchedule[end];
   if (null != next) {
     energyNeeded = next.getTrucks() * next.getDuration() * getTruckKW();
   }
   this.duration = duration;
 }
Ejemplo n.º 4
0
 // Computes constraints on future energy needs
 // Amounts are energy needed to run the chargers. Energy input to trucks
 // will be smaller due to charge efficiency.
 ShiftEnergy[] getFutureEnergyNeeds(Instant start, int horizon, double initialCharging) {
   Instant seStart = start;
   int index = indexOfShift(start);
   // current time is likely to be partway into first shift
   Shift currentShift = shiftSchedule[index]; // might be null
   int duration = 0;
   while (shiftSchedule[index] == currentShift) {
     duration += 1;
     index = nextShiftIndex(index);
   }
   Shift nextShift = shiftSchedule[index];
   // this gives us the info we need to start the sequence
   ArrayList<ShiftEnergy> data = new ArrayList<ShiftEnergy>();
   data.add(new ShiftEnergy(seStart, index, duration));
   seStart = seStart.plus(duration * TimeService.HOUR);
   int elapsed = duration;
   // add shifts until we run off the end of the horizon
   // keep in mind that a shift can be null
   while (elapsed < horizon) {
     duration = 0;
     while (nextShift == shiftSchedule[index]) {
       index = nextShiftIndex(index);
       duration += 1;
     }
     nextShift = shiftSchedule[index];
     data.add(new ShiftEnergy(seStart, index, duration));
     elapsed += duration;
     seStart = seStart.plus(duration * TimeService.HOUR);
   }
   // now we convert to array, then walk backward and fill in energy needs
   ShiftEnergy[] result = data.toArray(new ShiftEnergy[data.size()]);
   double shortage = 0.0;
   for (int i = result.length - 1; i >= 0; i--) {
     int endx = result[i].endIndex;
     int prev = previousShiftIndex(endx);
     currentShift = shiftSchedule[prev];
     Shift end = shiftSchedule[endx];
     double needed = 0.0;
     if (null != end) {
       // Assume we need, at the end of each shift, enough energy to
       // run the next shift
       needed = (end.getTrucks() * end.getDuration() * getTruckKW()) / getChargeEfficiency();
     }
     // chargers is min of charger capacity and battery availability
     int chargers = getNChargers();
     int availableBatteries = nBatteries;
     if (null != currentShift) {
       availableBatteries -= currentShift.getTrucks();
     }
     chargers = (int) Math.min(chargers, availableBatteries);
     double available =
         getMaxChargeKW() * result[i].getDuration() * chargers / getChargeEfficiency();
     double surplus = available - needed - shortage;
     shortage = Math.max(0.0, -(available - needed - shortage));
     result[i].setEnergyNeeded(needed);
     result[i].setMaxSurplus(surplus);
   }
   // finally, we need to update the first element with
   // the current battery charge.
   double finalSurplus = result[0].getMaxSurplus();
   if (finalSurplus > 0.0) {
     result[0].setMaxSurplus(finalSurplus + initialCharging);
   } else if (shortage > 0.0) {
     result[0].setMaxSurplus(initialCharging - shortage);
   }
   return result;
 }
Ejemplo n.º 5
0
  // make sure we have enough charging capacity to support
  // the shift schedule
  void validateChargers() {
    // ToDo -- A single charging should be able to charge a truck worth
    // of batteries in a single shift

    // The total output of the availableChargers should be at least enough
    // to power the trucks over a 24-hour period. Note that the shift schedule
    // starts at midnight, which may not be the start of the current shift.
    double maxNeeded = 0.0;
    int offset = 0;
    while (null == shiftSchedule[offset]) {
      offset += 1;
    }
    Shift currentShift = shiftSchedule[offset];
    int remainingDuration = 0;
    int hoursInShift = (HOURS_DAY - currentShift.getStart()) % HOURS_DAY;
    remainingDuration = currentShift.getDuration() - hoursInShift;

    for (int i = offset; i < (shiftSchedule.length - HOURS_DAY); i++) {
      double totalEnergy = 0.0;
      Shift thisShift = shiftSchedule[i];
      if (thisShift != currentShift) {
        currentShift = thisShift;
        if (null != currentShift) {
          // first block of energy in 24h window starting at i
          remainingDuration = currentShift.getDuration();
        }
      }
      if (null != currentShift) {
        totalEnergy += currentShift.getTrucks() * remainingDuration * truckKW;
      }
      // now run fwd 24h and add energy from future shifts
      Shift current = currentShift;
      // int shiftStart = i;
      for (int j = i + 1; j < (i + HOURS_DAY); j++) {
        Shift newShift = shiftSchedule[j];
        if (null != newShift && current != newShift) {
          int durationInWindow = (int) Math.min((i + HOURS_DAY - j), newShift.getDuration());
          totalEnergy += newShift.getTrucks() * durationInWindow * truckKW;
          current = newShift;
        }
      }
      maxNeeded = Math.max(maxNeeded, totalEnergy);
      remainingDuration -= 1;
    }

    double chargeEnergy = nChargers * maxChargeKW * HOURS_DAY;
    if (maxNeeded > chargeEnergy) {
      double need = (maxNeeded - chargeEnergy) / (maxChargeKW * HOURS_DAY);
      int add = (int) Math.ceil(need);
      log.error(
          "Insufficient charging capacity for "
              + getName()
              + ": have "
              + chargeEnergy
              + ", need "
              + maxNeeded
              + ". Adding "
              + add
              + " availableChargers.");
      setNChargers(getNChargers() + add);
    }
  }