void FllImporter::processOutputVariable(const std::string& block, Engine* engine) const { std::istringstream reader(block); std::string line; FL_unique_ptr<OutputVariable> outputVariable(new OutputVariable); while (std::getline(reader, line)) { std::pair<std::string, std::string> keyValue = parseKeyValue(line, ':'); if ("OutputVariable" == keyValue.first) { outputVariable->setName(Op::validName(keyValue.second)); } else if ("enabled" == keyValue.first) { outputVariable->setEnabled(parseBoolean(keyValue.second)); } else if ("range" == keyValue.first) { std::pair<scalar, scalar> range = parseRange(keyValue.second); outputVariable->setRange(range.first, range.second); } else if ("default" == keyValue.first) { outputVariable->setDefaultValue(Op::toScalar(keyValue.second)); } else if ("lock-previous" == keyValue.first or "lock-valid" == keyValue.first) { outputVariable->setLockPreviousValue(parseBoolean(keyValue.second)); } else if ("lock-range" == keyValue.first) { outputVariable->setLockValueInRange(parseBoolean(keyValue.second)); } else if ("defuzzifier" == keyValue.first) { outputVariable->setDefuzzifier(parseDefuzzifier(keyValue.second)); } else if ("aggregation" == keyValue.first) { outputVariable->fuzzyOutput()->setAggregation(parseSNorm(keyValue.second)); } else if ("accumulation" == keyValue.first) { outputVariable->fuzzyOutput()->setAggregation(parseSNorm(keyValue.second)); FL_LOG("[warning] obsolete usage of identifier <accumulation: SNorm> in OutputVariable"); FL_LOG("[information] from version 6.0, the identifier <aggregation: SNorm> should be used"); FL_LOG("[backward compatibility] assumed " "<aggregation: " << keyValue.second << "> " "instead of <accumulation: " << keyValue.second << ">"); } else if ("term" == keyValue.first) { outputVariable->addTerm(parseTerm(keyValue.second, engine)); } else { throw Exception("[import error] key <" + keyValue.first + "> not " "recognized in pair <" + keyValue.first + ":" + keyValue.second + ">", FL_AT); } } engine->addOutputVariable(outputVariable.release()); }
OptionalModelObject ReverseTranslator::translateOutputVariable( const WorkspaceObject & workspaceObject ) { OptionalString s = workspaceObject.getString(Output_VariableFields::VariableName); if(!s){ return boost::none; } openstudio::model::OutputVariable outputVariable( *s, m_model ); s = workspaceObject.getString(Output_VariableFields::KeyValue); if(s){ outputVariable.setKeyValue(*s); } s = workspaceObject.getString(Output_VariableFields::VariableName); if(s){ outputVariable.setVariableName(*s); } s = workspaceObject.getString(Output_VariableFields::ReportingFrequency); if(s){ outputVariable.setReportingFrequency(*s); } OptionalWorkspaceObject target = workspaceObject.getTarget(Output_VariableFields::ScheduleName); if (target){ OptionalModelObject modelObject = translateAndMapWorkspaceObject( *target ); if (modelObject){ OptionalSchedule schedule = modelObject->optionalCast<Schedule>(); if (schedule){ outputVariable.setSchedule(*schedule); } } } return outputVariable; }
void VariableListItem::onOffClicked(bool t_on) { LOG(Debug, "onOffClicked " << t_on); m_combobox->setEnabled(t_on); if (t_on) { if (!m_variable) { openstudio::model::OutputVariable outputVariable(m_name, m_model); outputVariable.setReportingFrequency("Hourly"); outputVariable.setKeyValue(m_keyValue); m_variable = outputVariable; m_combobox->bind(*m_variable, "reportingFrequency"); } } else { if (m_variable) { m_combobox->unbind(); m_variable->remove(); m_variable = boost::none; } } }
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); }