bool Job::download()
{
changeStatus(Downloading, "Downloading data.");
qDebug() << "Saving file to " << osmFile().absoluteFilePath();
if (osmFile().exists()) {
QDateTime now = QDateTime::currentDateTime();
if (osmFile().lastModified().daysTo(now) > 7) {
qDebug() << "Old file is outdated, re-downloading " << osmFile().absoluteFilePath();
QFile::remove(osmFile().absoluteFilePath());
} else {
qDebug() << "Old file is still ok, reusing" << osmFile().absoluteFilePath();
return true;
}
}
QProcess wget;
QStringList arguments;
QString url = m_region.pbfFile();
arguments << "-O" << osmFile().absoluteFilePath() << url;
qDebug() << "Downloading " << url;
wget.start("wget", arguments);
wget.waitForFinished(1000 * 60 * 60 * 12); // wait up to 12 hours for download to complete
if (wget.exitStatus() == QProcess::NormalExit && wget.exitCode() == 0) {
return true;
} else {
qDebug() << "Failed to download " << url;
QFile::remove(osmFile().absoluteFilePath());
changeStatus(Error, "Error downloading .osm.pbf file: " + wget.readAllStandardError());
return false;
}
}
bool Job::monav()
{
QString const status = QString("Generating offline routing map from %1 (%2).").arg(osmFile().fileName()).arg(Region::fileSize(osmFile()));
changeStatus(Routing, status);
QStringList arguments;
arguments << "-s=" + m_monavSettings;
arguments << "-i=" + osmFile().absoluteFilePath();
arguments << "-o=" + monavDir().absoluteFilePath();
arguments << "-pi=OpenStreetMap Importer" << "-pro=Contraction Hierarchies";
arguments << "-pg=GPS Grid" << "-di";
arguments << "-dro=" + m_transport;
arguments << "--profile=" + m_profile;
arguments << "-dd" /*<< "-dc"*/;
QProcess monav;
monav.start("monav-preprocessor", arguments);
monav.waitForFinished(1000 * 60 * 60 * 6); // wait up to 6 hours for monav to convert the data
if (monav.exitStatus() == QProcess::NormalExit && monav.exitCode() == 0) {
qDebug() << "Processed osm file for monav";
} else {
qDebug() << "monav exiting with status " << monav.exitCode();
changeStatus(Error, "Routing map conversion failed: " + monav.readAllStandardError());
return false;
}
QFile pluginsFile(monavDir().absoluteFilePath() + "/plugins.ini");
pluginsFile.open(QFile::WriteOnly | QFile::Truncate);
QTextStream pluginsStream(&pluginsFile);
pluginsStream << "[General]\nrouter=Contraction Hierarchies\nrenderer=Mapnik Renderer\ngpsLookup=GPS Grid\naddressLookup=Unicode Tournament Trie\n";
pluginsFile.close();
QFileInfo subdir = QFileInfo(monavDir().absoluteFilePath() + "/routing_" + m_transport.toLower());
if (subdir.exists() && subdir.isDir()) {
QFileInfoList files = QDir(subdir.absoluteFilePath()).entryInfoList(QDir::Files);
foreach(const QFileInfo &file, files) {
if (!QFile::rename(file.absoluteFilePath(), monavDir().absoluteFilePath() + '/' + file.fileName())) {
changeStatus(Error, "Unable to move monav files to target directory.");
return false;
}
}
QDir("/").rmdir(subdir.absoluteFilePath());
} else {
void OpenStudioPostProcessJob::startImpl(const boost::shared_ptr<ProcessCreator> &)
{
QWriteLocker l(&m_mutex);
JobErrors errors;
errors.result = ruleset::OSResultValue::Success;
try {
m_sql = sqlFile();
m_osm = osmFile();
resetFiles(m_files, m_sql, m_osm);
} catch (const std::exception &e) {
JobErrors error;
error.result = ruleset::OSResultValue::Fail;
error.addError(ErrorType::Error, e.what());
errors = error;
}
if (m_sql)
{
LOG(Info, "OpenStudioPostProcess starting, filename: " << toString(m_sql->fullPath));
}
LOG(Info, "OpenStudioPostProcess starting, outdir: " << toString(outdir()));
l.unlock();
emitStatusChanged(AdvancedStatus(AdvancedStatusEnum::Starting));
emitStarted();
emitStatusChanged(AdvancedStatus(AdvancedStatusEnum::Processing));
if (errors.result == ruleset::OSResultValue::Fail)
{
setErrors(errors);
return;
}
try {
SqlFile sqlFile(m_sql->fullPath);
boost::optional<openstudio::model::Model> model = model::Model::load(m_osm->fullPath);
if (!model)
{
throw std::runtime_error("Unable to load model file from " + openstudio::toString(m_osm->fullPath));
}
model->setSqlFile(sqlFile);
boost::filesystem::create_directories(outdir(true));
std::vector<Attribute> attributes = PostProcessReporting::go(sqlFile);
// ETH@20140219 - Not great to add an object here either, but needed for
// Facility, and Building is really the same case. (If get this far with
// simulation, no harm in accessing data through Building, which has
// smart defaults for all fields.)
model::Building building = model->getUniqueModelObject<model::Building>();
LOG(Debug,"Extracting attributes from model::Building.");
boost::optional<Attribute> attribute;
boost::optional<double> value = building.floorArea();
if (value){
attribute = Attribute("floorArea", *value, "m^2");
attribute->setDisplayName("Floor Area");
attributes.push_back(*attribute);
}
value = building.conditionedFloorArea();
if (value){
attribute = Attribute("conditionedFloorArea", *value, "m^2");
attribute->setDisplayName("Conditioned Floor Area");
attributes.push_back(*attribute);
}
// ETH@20140218 - Not great to add an object here, but otherwise, do not get
// calibration results table in PAT.
model::Facility facility = model->getUniqueModelObject<model::Facility>();
LOG(Debug,"Extracting attributes from model::Facility.");
value = facility.economicsCapitalCost();
if (value){
attribute = Attribute("economicsCapitalCost", *value, "$");
attribute->setDisplayName("Capital Cost");
attributes.push_back(*attribute);
}
value = facility.economicsTLCC();
if (value){
attribute = Attribute("economicsTLCC", *value, "$");
attribute->setDisplayName("Total Life Cycle Cost");
attributes.push_back(*attribute);
}
value = facility.annualWaterTotalCost();
if (value){
attribute = Attribute("annualWaterTotalCost", *value, "$");
attribute->setDisplayName("Annual Water Total Cost");
attributes.push_back(*attribute);
}
attribute = facility.endUsesAttribute();
if (attribute){
attributes.push_back(*attribute);
}
attribute = facility.calibrationResultAttribute();
if (attribute){
attributes.push_back(*attribute);
}
boost::optional<model::TimeDependentValuation> timeDependentValuation = model->getOptionalUniqueModelObject<model::TimeDependentValuation>();
if (timeDependentValuation){
LOG(Debug,"Extracting attributes from model::TimeDependentValuation.");
boost::optional<Attribute> attribute;
boost::optional<double> value = timeDependentValuation->energyTimeDependentValuation();
if (value){
attribute = Attribute("energyTimeDependentValuation", *value, "J");
attribute->setDisplayName("Energy Time Dependent Valuation");
attributes.push_back(*attribute);
}
value = timeDependentValuation->costTimeDependentValuation();
if (value){
attribute = Attribute("costTimeDependentValuation", *value, "$");
attribute->setDisplayName("Cost Time Dependent Valuation");
attributes.push_back(*attribute);
}
}
if (attributes.empty())
{
LOG(Warn, "No attributes loaded for report");
}
Attribute report("Report", attributes);
bool result = report.saveToXml(outdir() / openstudio::toPath("report.xml"));
if (!result){
LOG_AND_THROW("Failed to write report.xml");
}
} catch (const std::exception &e) {
LOG(Error, "Error with OpenStudioPostProcessJob: " + std::string(e.what()));
errors.addError(ErrorType::Error, "Error with OpenStudioPostProcessJob: " + std::string(e.what()));
errors.result = ruleset::OSResultValue::Fail;
}
// Change this to whatever output files you generate
emitOutputFileChanged(RunManager_Util::dirFile(outdir() / openstudio::toPath("report.xml")));
setErrors(errors);
}
void ModelToRadPreProcessJob::startImpl(const std::shared_ptr<ProcessCreator> &)
{
openstudio::path outpath = outdir(true);
QWriteLocker l(&m_mutex);
JobErrors errors;
errors.result = ruleset::OSResultValue::Success;
try {
m_osm = osmFile();
resetFiles(m_files, m_osm);
} catch (const std::exception &e) {
errors.result = ruleset::OSResultValue::Fail;
errors.addError(ErrorType::Error, e.what());
}
LOG(Info, "ModelToRadPreProcess starting, loading model file: " << toString(m_osm->fullPath));
openstudio::model::OptionalModel model = openstudio::model::Model::load(m_osm->fullPath);
if (!model)
{
errors.result = ruleset::OSResultValue::Fail;
errors.addError(ErrorType::Error, "Unable to load model file");
}
LOG(Info, "ModelToRadPreProcess starting, outdir: " << toString(outpath));
l.unlock();
emitStatusChanged(AdvancedStatus(AdvancedStatusEnum::Starting));
emitStarted();
emitStatusChanged(AdvancedStatus(AdvancedStatusEnum::Processing));
if (errors.result == ruleset::OSResultValue::Fail)
{
setErrors(errors);
return;
}
try {
boost::filesystem::create_directories(outpath);
openstudio::path path = outpath / openstudio::toPath("out.osm");
openstudio::model::Model outmodel;
outmodel.getUniqueModelObject<openstudio::model::Building>(); // implicitly create building object
outmodel.getUniqueModelObject<openstudio::model::Timestep>(); // implicitly create timestep object
outmodel.getUniqueModelObject<openstudio::model::RunPeriod>(); // implicitly create runperiod object
if (model->getOptionalUniqueModelObject<openstudio::model::WeatherFile>())
{
outmodel.addObject(model->getUniqueModelObject<openstudio::model::WeatherFile>());
}
std::map<std::string, openstudio::model::ThermalZone> thermalZones;
std::vector<openstudio::model::Space> spaces = model->getConcreteModelObjects<openstudio::model::Space>();
for (auto & space : spaces)
{
space.hardApplyConstructions();
space.hardApplySpaceType(true);
space.hardApplySpaceLoadSchedules();
// make all surfaces with surface boundary condition adiabatic
std::vector<openstudio::model::Surface> surfaces = space.surfaces();
for (auto & surf_it : surfaces){
boost::optional<openstudio::model::Surface> adjacentSurface = surf_it.adjacentSurface();
if (adjacentSurface){
// make sure to hard apply constructions in other space before messing with surface in other space
boost::optional<openstudio::model::Space> adjacentSpace = adjacentSurface->space();
if (adjacentSpace){
adjacentSpace->hardApplyConstructions();
}
// resets both surfaces
surf_it.resetAdjacentSurface();
// set both to adiabatic
surf_it.setOutsideBoundaryCondition("Adiabatic");
adjacentSurface->setOutsideBoundaryCondition("Adiabatic");
// remove interior windows
for (openstudio::model::SubSurface subSurface : surf_it.subSurfaces()){
subSurface.remove();
}
for (openstudio::model::SubSurface subSurface : adjacentSurface->subSurfaces()){
subSurface.remove();
}
}
}
openstudio::model::Space new_space = space.clone(outmodel).optionalCast<openstudio::model::Space>().get();
boost::optional<openstudio::model::ThermalZone> thermalZone = space.thermalZone();
if (thermalZone && thermalZone->name())
{
if (thermalZones.find(*thermalZone->name()) == thermalZones.end())
{
openstudio::model::ThermalZone newThermalZone(outmodel);
newThermalZone.setName(*thermalZone->name());
newThermalZone.setUseIdealAirLoads(true);
thermalZones.insert(std::make_pair(*thermalZone->name(), newThermalZone));
}
auto itr = thermalZones.find(*thermalZone->name());
OS_ASSERT(itr != thermalZones.end()); // We just added it above if we needed it
new_space.setThermalZone(itr->second);
} else if (thermalZone && !thermalZone->name()) {
errors.addError(ErrorType::Warning, "Space discovered in un-named thermalZone, not translating");
}
}
std::vector<openstudio::model::ShadingSurfaceGroup> shadingsurfacegroups = outmodel.getConcreteModelObjects<openstudio::model::ShadingSurfaceGroup>();
for (auto & shadingSurfaceGroup : shadingsurfacegroups)
{
shadingSurfaceGroup.remove();
}
std::vector<openstudio::model::SpaceItem> spaceitems = outmodel.getModelObjects<openstudio::model::SpaceItem>();
for (auto & spaceItem : spaceitems)
{
if (spaceItem.optionalCast<openstudio::model::People>()){
// keep people
}else if (spaceItem.optionalCast<openstudio::model::Lights>()){
// keep lights
}else if (spaceItem.optionalCast<openstudio::model::Luminaire>()){
// keep luminaires
}else{
spaceItem.remove();
}
}
std::vector<openstudio::model::OutputVariable> outputVariables = outmodel.getConcreteModelObjects<openstudio::model::OutputVariable>();
for (auto & outputVariable : outputVariables)
{
outputVariable.remove();
}
openstudio::model::OutputVariable outputVariable("Site Exterior Horizontal Sky Illuminance", outmodel);
outputVariable.setReportingFrequency("Hourly");
outputVariable = openstudio::model::OutputVariable("Site Exterior Beam Normal Illuminance", outmodel);
outputVariable.setReportingFrequency("Hourly");
outputVariable = openstudio::model::OutputVariable("Site Solar Altitude Angle", outmodel);
outputVariable.setReportingFrequency("Hourly");
outputVariable = openstudio::model::OutputVariable("Site Solar Azimuth Angle", outmodel);
outputVariable.setReportingFrequency("Hourly");
outputVariable = openstudio::model::OutputVariable("Site Sky Diffuse Solar Radiation Luminous Efficacy", outmodel);
outputVariable.setReportingFrequency("Hourly");
outputVariable = openstudio::model::OutputVariable("Site Beam Solar Radiation Luminous Efficacy", outmodel);
outputVariable.setReportingFrequency("Hourly");
outputVariable = openstudio::model::OutputVariable("Zone People Occupant Count", outmodel);
outputVariable.setReportingFrequency("Hourly");
outputVariable = openstudio::model::OutputVariable("Zone Lights Electric Power", outmodel);
outputVariable.setReportingFrequency("Hourly");
// only report weather periods
openstudio::model::SimulationControl simulation_control = outmodel.getUniqueModelObject<openstudio::model::SimulationControl>();
simulation_control.setRunSimulationforSizingPeriods(false);
simulation_control.setRunSimulationforWeatherFileRunPeriods(true);
simulation_control.setSolarDistribution("MinimalShadowing");
outmodel.save(path, true);
} catch (const std::exception &e) {
LOG(Error, "Error with ModelToRadPreProcessJob: " + std::string(e.what()));
errors.addError(ErrorType::Error, "Error with ModelToRadPreProcessJob: " + std::string(e.what()));
errors.result = ruleset::OSResultValue::Fail;
}
// Change this to whatever output files you generate
emitOutputFileChanged(RunManager_Util::dirFile(outpath / openstudio::toPath("out.osm")));
setErrors(errors);
}
void OpenStudioPostProcessJob::startImpl(const boost::shared_ptr<ProcessCreator> &)
{
QWriteLocker l(&m_mutex);
JobErrors errors;
errors.result = ruleset::OSResultValue::Success;
try {
m_sql = sqlFile();
m_osm = osmFile();
resetFiles(m_files, m_sql, m_osm);
} catch (const std::exception &e) {
JobErrors error;
error.result = ruleset::OSResultValue::Fail;
error.addError(ErrorType::Error, e.what());
errors = error;
}
if (m_sql)
{
LOG(Info, "OpenStudioPostProcess starting, filename: " << toString(m_sql->fullPath));
}
LOG(Info, "OpenStudioPostProcess starting, outdir: " << toString(outdir()));
l.unlock();
emitStatusChanged(AdvancedStatus(AdvancedStatusEnum::Starting));
emitStarted();
emitStatusChanged(AdvancedStatus(AdvancedStatusEnum::Processing));
if (errors.result == ruleset::OSResultValue::Fail)
{
setErrors(errors);
return;
}
try {
SqlFile sqlFile(m_sql->fullPath);
boost::optional<openstudio::model::Model> model = model::Model::load(m_osm->fullPath);
if (!model)
{
throw std::runtime_error("Unable to load model file from " + openstudio::toString(m_osm->fullPath));
}
model->setSqlFile(sqlFile);
boost::filesystem::create_directories(outdir(true));
std::vector<Attribute> attributes = PostProcessReporting::go(sqlFile);
boost::optional<model::Building> building = model->getOptionalUniqueModelObject<model::Building>();
if (building)
{
LOG(Debug,"Extracting attributes from model::Building.");
boost::optional<Attribute> attribute = building->getAttribute("floorArea");
if (attribute){
attribute->setDisplayName("Floor Area");
attribute->setUnits("m^2");
attributes.push_back(*attribute);
}
attribute = building->getAttribute("conditionedFloorArea");
if (attribute){
attribute->setDisplayName("Conditioned Floor Area");
attribute->setUnits("m^2");
attributes.push_back(*attribute);
}
}
boost::optional<model::Facility> facility = model->getOptionalUniqueModelObject<model::Facility>();
if (facility){
LOG(Debug,"Extracting attributes from model::Facility.");
boost::optional<Attribute> attribute = facility->getAttribute("economicsCapitalCost");
if (attribute){
attribute->setDisplayName("Capital Cost");
attribute->setUnits("$");
attributes.push_back(*attribute);
}
attribute = facility->getAttribute("economicsTLCC");
if (attribute){
attribute->setDisplayName("Total Life Cycle Cost");
attribute->setUnits("$");
attributes.push_back(*attribute);
}
attribute = facility->getAttribute("annualWaterTotalCost");
if (attribute){
attribute->setDisplayName("Annual Water Total Cost");
attribute->setUnits("$");
attributes.push_back(*attribute);
}
attribute = facility->getAttribute("endUsesAttribute");
if (attribute){
attributes.push_back(*attribute);
}
}
boost::optional<model::TimeDependentValuation> timeDependentValuation = model->getOptionalUniqueModelObject<model::TimeDependentValuation>();
if (timeDependentValuation){
LOG(Debug,"Extracting attributes from model::TimeDependentValuation.");
boost::optional<Attribute> attribute = timeDependentValuation->getAttribute("energyTimeDependentValuation");
if (attribute){
attribute->setDisplayName("Energy Time Dependent Valuation");
attribute->setUnits("J");
attributes.push_back(*attribute);
}
attribute = timeDependentValuation->getAttribute("costTimeDependentValuation");
if (attribute){
attribute->setDisplayName("Cost Time Dependent Valuation");
attribute->setUnits("$");
attributes.push_back(*attribute);
}
}
if (attributes.empty())
{
LOG(Warn, "No attributes loaded for report");
}
Attribute report("Report", attributes);
bool result = report.saveToXml(outdir() / openstudio::toPath("report.xml"));
if (!result){
LOG_AND_THROW("Failed to write report.xml");
}
} catch (const std::exception &e) {
LOG(Error, "Error with OpenStudioPostProcessJob: " + std::string(e.what()));
errors.addError(ErrorType::Error, "Error with OpenStudioPostProcessJob: " + std::string(e.what()));
errors.result = ruleset::OSResultValue::Fail;
}
// Change this to whatever output files you generate
emitOutputFileChanged(RunManager_Util::dirFile(outdir() / openstudio::toPath("report.xml")));
setErrors(errors);
}
