void Simulator::run() {
boost::posix_time::ptime time_runStart, time_cycleStart;
time_runStart = boost::posix_time::microsec_clock::local_time();
while(!currTime.isLaterThan(finishTime)) {
time_cycleStart = boost::posix_time::microsec_clock::local_time();
std::cout << "-------------------------------------------" << std::endl;
currTime.display();
std::cout << std::endl;
// Update electricity spot price
// spotPrice.update(currTime);
// Update traffic model
trafficModel.update(currTime, gridModel.vehicles);
// Update vehicles' battery SOC based on distance driven / charging
gridModel.updateVehicleBatteries();
// Determine EV charging rates
charger->setChargeRates(currTime, gridModel);
// Update grid model - generate household loads & apply charge rates
gridModel.generateLoads(currTime, householdDemand);
// Show some results
if(showDebug) {
//spotPrice.display();
trafficModel.displaySummary(gridModel.vehicles);
gridModel.displayVehicleSummary();
gridModel.displayLoadSummary();
}
// Provide quick update on timing to output
timingUpdate();
// Run load flow (typically the bottleneck)
gridModel.runLoadFlow(currTime);
// Log data
log.update(currTime, gridModel, charger, spotPrice);
// Add optional user specified delay into cycle
// while(utility::timediff(boost::posix_time::microsec_clock::local_time(), time_cycleStart) < delay);
// Estimate timing
lastIteration = long(utility::timeElapsed(time_cycleStart));
std::cout << "Cycle complete" << std::endl; //, took: " << utility::timeDisplay(lastIteration) << std::endl;
currTime.increment(simInterval);
}
std::cout << "-------------------------------------------" << std::endl;
std::cout << "Simulation complete, took " << utility::timeDisplay(utility::timeElapsed(time_runStart)) << std::endl;
std::cout << "Generating report ..." << std::endl;
if(generateReport)
loadflow->generateReport(log.getDir(), currTime.month, currTime.isWeekday(), simInterval);
std::cout << "Report written to " << log.getDir() << std::endl;
std::cout << "-------------------------------------------" << std::endl;
}
// Run simulation
void Simulator::run() {
// Several variables to keep track of how long cycle / full simulation took
boost::posix_time::ptime timerRun, timerCycle;
boost::posix_time::time_duration lastCycleLength;
utility::startTimer(timerRun);
utility::startTimer(timerCycle);
std::cout << "Starting Simulation ... " << std::endl;
// Outer simulation loop
while(!currTime.isLaterThan(finishTime)) {
std::cout << "-------------------------------------------" << std::endl;
currTime.display();
std::cout << std::endl;
// Update electricity spot price
spotPrice.update(currTime);
// Update traffic model
trafficModel.update(currTime, gridModel.vehicles);
// Update vehicles' battery SOC based on distance driven / charging
gridModel.updateVehicleBatteries();
// Update grid model - generate household loads & reset vehicle loads
gridModel.generateAllHouseholdLoads(currTime);
gridModel.resetVehicleLoads();
// Depending on charge update model, apply charge rate updates and run load flow
if(chargeRateOrder == "random")
std::random_shuffle(vehicleIDs.begin(), vehicleIDs.end());
// Determine EV charging rates
if(chargeRateUpdate == "batch") {
charger->setAllChargeRates(currTime, gridModel);
gridModel.generateAllVehicleLoads();
gridModel.runLoadFlow(currTime);
}
else if(chargeRateUpdate == "individual") {
gridModel.runLoadFlow(currTime);
for(int i=0; i<vehicleIDs.size(); i++) {
charger->setOneChargeRate(currTime, gridModel, vehicleIDs.at(i));
gridModel.generateOneVehicleLoad(vehicleIDs.at(i));
gridModel.runLoadFlow(currTime);
}
}
else { // "grouped"
gridModel.runLoadFlow(currTime);
for(int i=0; i<vehicleIDs.size(); i+=chargeRateGroupSize) {
for(int j=i; j<std::min((int)gridModel.vehicles.size(), (int)(i+chargeRateGroupSize)); j++) {
charger->setOneChargeRate(currTime, gridModel, vehicleIDs.at(i));
gridModel.generateOneVehicleLoad(vehicleIDs.at(i));
}
gridModel.runLoadFlow(currTime);
}
}
// If desired, show some results
if(showDebug) {
spotPrice.display();
trafficModel.displaySummary(gridModel.vehicles);
gridModel.displayVehicleSummary();
gridModel.displayLoadSummary(currTime);
}
// Provide quick update on timing to output
timingUpdate(lastCycleLength);
// Log data
log.update(currTime, gridModel, charger, spotPrice);
// Add optional user specified delay into cycle
// while(utility::timediff(boost::posix_time::microsec_clock::local_time(), time_cycleStart) < config->getInt("intervaldelay"));
// Estimate timing
lastCycleLength = boost::posix_time::microsec_clock::local_time() - timerCycle;
std::cout << "Cycle complete, took: " << utility::updateTimer(timerCycle) << std::endl;
currTime.increment(config->getInt("simulationinterval"));
}
// Simulation complete, provide some output, generate report.
std::cout << "-------------------------------------------" << std::endl
<< "Simulation complete, took " << utility::endTimer(timerRun) << std::endl;
if(config->getBool("generatereport")) {
std::cout << "Generating report ..." << std::endl;
loadflow->generateReport(log.getDir(), currTime.month, currTime.isWeekday(), config->getInt("simulationinterval"));
std::cout << "Report written to " << log.getDir() << std::endl;
}
std::cout << "-------------------------------------------" << std::endl;
}
