boost::optional<IdfObject> ForwardTranslator::translateInteriorPartitionSurfaceGroup( model::InteriorPartitionSurfaceGroup & modelObject )
{
InteriorPartitionSurfaceVector interiorPartitionSurfaces = modelObject.interiorPartitionSurfaces();
std::sort(interiorPartitionSurfaces.begin(), interiorPartitionSurfaces.end(), WorkspaceObjectNameLess());
for (InteriorPartitionSurface& interiorPartitionSurface : interiorPartitionSurfaces){
translateAndMapModelObject(interiorPartitionSurface);
}
return boost::none;
}
boost::optional<IdfObject> ForwardTranslator::translateShadingSurfaceGroup( model::ShadingSurfaceGroup & modelObject )
{
ShadingSurfaceVector shadingSurfaces = modelObject.shadingSurfaces();
std::sort(shadingSurfaces.begin(), shadingSurfaces.end(), WorkspaceObjectNameLess());
for (ShadingSurface& shadingSurface : shadingSurfaces){
translateAndMapModelObject(shadingSurface);
}
return boost::none;
}
std::vector<model::RefrigerationSystem> RefrigerationSystemListController::systems() const
{
std::vector<model::RefrigerationSystem> result;
if( boost::optional<model::Model> model = OSAppBase::instance()->currentModel() )
{
result = model->getModelObjects<model::RefrigerationSystem>();
}
std::sort(result.begin(), result.end(), WorkspaceObjectNameLess());
return result;
}
boost::optional<IdfObject> ForwardTranslator::translateSite( Site & modelObject )
{
IdfObject site = createAndRegisterIdfObject(openstudio::IddObjectType::Site_Location,
modelObject);
OptionalString optS = modelObject.name();
if(optS) {
site.setName(*optS);
}
OptionalDouble od = modelObject.latitude();
if(od) {
site.setDouble(Site_LocationFields::Latitude, *od);
}
od = modelObject.longitude();
if(od) {
site.setDouble(Site_LocationFields::Longitude, *od);
}
od = modelObject.timeZone();
if(od) {
site.setDouble(Site_LocationFields::TimeZone, *od);
}
od = modelObject.elevation();
if(od) {
site.setDouble(Site_LocationFields::Elevation, *od);
}
// translate shading groups
ShadingSurfaceGroupVector shadingSurfaceGroups = modelObject.shadingSurfaceGroups();
std::sort(shadingSurfaceGroups.begin(), shadingSurfaceGroups.end(), WorkspaceObjectNameLess());
for (ShadingSurfaceGroup& shadingSurfaceGroup : shadingSurfaceGroups){
translateAndMapModelObject(shadingSurfaceGroup);
}
return boost::optional<IdfObject>(site);
}
boost::optional<QDomDocument> ForwardTranslator::translateModel(const openstudio::model::Model& model)
{
QDomDocument doc;
doc.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"utf-8\"");
QDomElement sddElement = doc.createElement("SDDXML");
sddElement.setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
sddElement.setAttribute("xmlns:xsd", "http://www.w3.org/2001/XMLSchema");
doc.appendChild(sddElement);
// set ruleset, where should this data come from?
QDomElement rulesetFilenameElement = doc.createElement("RulesetFilename");
sddElement.appendChild(rulesetFilenameElement);
rulesetFilenameElement.setAttribute("file", "unknown");
// set project, where should this data come from?
QDomElement projectElement = doc.createElement("Proj");
sddElement.appendChild(projectElement);
QDomElement projectNameElement = doc.createElement("Name");
projectElement.appendChild(projectNameElement);
projectNameElement.appendChild( doc.createTextNode( "unknown"));
// site data
QDomElement projectClimateZoneElement = doc.createElement("CliZn");
projectElement.appendChild(projectClimateZoneElement);
projectClimateZoneElement.appendChild( doc.createTextNode( "unknown"));
// set lat, lon, elev
// DLM: do not translate forward, Issue 242: Forward Translator - Remove Proj:Lat/Lon/Elevation translation
/*
boost::optional<model::Site> site = model.getOptionalUniqueModelObject<model::Site>();
if (site){
double latitude = site->latitude();
QDomElement latElement = doc.createElement("Lat");
projectElement.appendChild(latElement);
latElement.appendChild( doc.createTextNode(QString::number(latitude)));
double longitude = site->longitude();
QDomElement longElement = doc.createElement("Long");
projectElement.appendChild(longElement);
longElement.appendChild( doc.createTextNode(QString::number(longitude)));
double elevationSI = site->elevation();
double elevationIP = elevationSI/0.3048;
QDomElement elevationElement = doc.createElement("Elevation");
projectElement.appendChild(elevationElement);
elevationElement.appendChild( doc.createTextNode(QString::number(elevationIP)));
}
*/
// todo: write out epw file path
// todo: write out ddy file and set path
//<DDWeatherFile>C:/svn-CBECC-Com-130521/CBECC-Com13/Data/EPW/SACRAMENTO-EXECUTIVE_724830_CZ2010.ddy</DDWeatherFile>
//<AnnualWeatherFile>C:/svn-CBECC-Com-130521/CBECC-Com13/Data/EPW/SACRAMENTO-EXECUTIVE_724830_CZ2010.epw</AnnualWeatherFile>
//<HVACAutoSizing>1</HVACAutoSizing>
//<SimDsgnDays>1</SimDsgnDays>
//<RunPeriodBeginMonth>0</RunPeriodBeginMonth>
//<RunPeriodBeginDay>0</RunPeriodBeginDay>
//<RunPeriodEndMonth>0</RunPeriodEndMonth>
//<RunPeriodEndDay>0</RunPeriodEndDay>
//<RunPeriodYear>0</RunPeriodYear>
// do materials before constructions
std::vector<model::Material> materials = model.getModelObjects<model::Material>();
std::sort(materials.begin(), materials.end(), WorkspaceObjectNameLess());
if (m_progressBar){
m_progressBar->setWindowTitle(toString("Translating Materials"));
m_progressBar->setMinimum(0);
m_progressBar->setMaximum(materials.size());
m_progressBar->setValue(0);
}
for (const model::Material& material : materials){
boost::optional<QDomElement> materialElement = translateMaterial(material, doc);
if (materialElement){
projectElement.appendChild(*materialElement);
}
if (m_progressBar){
m_progressBar->setValue(m_progressBar->value() + 1);
}
}
// do constructions before geometry
std::vector<model::ConstructionBase> constructions = model.getModelObjects<model::ConstructionBase>();
std::sort(constructions.begin(), constructions.end(), WorkspaceObjectNameLess());
if (m_progressBar){
m_progressBar->setWindowTitle(toString("Translating Constructions"));
m_progressBar->setMinimum(0);
m_progressBar->setMaximum(3*constructions.size()); // three loops below
m_progressBar->setValue(0);
}
std::set<Handle> surfaceConstructions;
for (const model::Surface& surface : model.getConcreteModelObjects<model::Surface>()){
boost::optional<model::ConstructionBase> construction = surface.construction();
if (construction){
surfaceConstructions.insert(construction->handle());
}
}
std::set<Handle> doorConstructions;
std::set<Handle> fenestrationConstructions;
for (const model::SubSurface& subSurface : model.getConcreteModelObjects<model::SubSurface>()){
boost::optional<model::ConstructionBase> construction = subSurface.construction();
if (construction){
std::string subSurfaceType = subSurface.subSurfaceType();
if (istringEqual("Door", subSurfaceType) || istringEqual("OverheadDoor", subSurfaceType)){
doorConstructions.insert(construction->handle());
}else{
fenestrationConstructions.insert(construction->handle());
}
}
}
// translate surface constructions
for (const model::ConstructionBase& constructionBase : constructions){
if (surfaceConstructions.find(constructionBase.handle()) == surfaceConstructions.end()){
continue;
}
boost::optional<QDomElement> constructionElement = translateConstructionBase(constructionBase, doc);
if (constructionElement){
projectElement.appendChild(*constructionElement);
}
if (m_progressBar){
m_progressBar->setValue(m_progressBar->value() + 1);
}
}
// translate door constructions
for (const model::ConstructionBase& constructionBase : constructions){
if (doorConstructions.find(constructionBase.handle()) == doorConstructions.end()){
continue;
}
boost::optional<QDomElement> constructionElement = translateDoorConstruction(constructionBase, doc);
if (constructionElement){
projectElement.appendChild(*constructionElement);
}
if (m_progressBar){
m_progressBar->setValue(m_progressBar->value() + 1);
}
}
// translate fenestration constructions
for (const model::ConstructionBase& constructionBase : constructions){
if (fenestrationConstructions.find(constructionBase.handle()) == fenestrationConstructions.end()){
continue;
}
boost::optional<QDomElement> constructionElement = translateFenestrationConstruction(constructionBase, doc);
if (constructionElement){
projectElement.appendChild(*constructionElement);
}
if (m_progressBar){
m_progressBar->setValue(m_progressBar->value() + 1);
}
}
// translate site shading
std::vector<model::ShadingSurfaceGroup> shadingSurfaceGroups = model.getConcreteModelObjects<model::ShadingSurfaceGroup>();
std::sort(shadingSurfaceGroups.begin(), shadingSurfaceGroups.end(), WorkspaceObjectNameLess());
if (m_progressBar){
m_progressBar->setWindowTitle(toString("Translating Site Shading"));
m_progressBar->setMinimum(0);
m_progressBar->setMaximum(shadingSurfaceGroups.size());
m_progressBar->setValue(0);
}
for (const model::ShadingSurfaceGroup& shadingSurfaceGroup : shadingSurfaceGroups){
if (istringEqual(shadingSurfaceGroup.shadingSurfaceType(), "Site")){
Transformation transformation = shadingSurfaceGroup.siteTransformation();
for (const model::ShadingSurface& shadingSurface : shadingSurfaceGroup.shadingSurfaces()){
boost::optional<QDomElement> shadingSurfaceElement = translateShadingSurface(shadingSurface, transformation, doc);
if (shadingSurfaceElement){
projectElement.appendChild(*shadingSurfaceElement);
}
}
}
if (m_progressBar){
m_progressBar->setValue(m_progressBar->value() + 1);
}
}
// translate the building
boost::optional<model::Building> building = model.getOptionalUniqueModelObject<model::Building>();
if (building){
boost::optional<QDomElement> buildingElement = translateBuilding(*building, doc);
if (buildingElement){
projectElement.appendChild(*buildingElement);
}
}
return doc;
}
boost::optional<QDomDocument> ForwardTranslator::translateModel(const openstudio::model::Model& model)
{
QDomDocument doc;
doc.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"utf-8\"");
QDomElement sddElement = doc.createElement("SDDXML");
sddElement.setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
sddElement.setAttribute("xmlns:xsd", "http://www.w3.org/2001/XMLSchema");
doc.appendChild(sddElement);
// set ruleset, where should this data come from?
QDomElement rulesetFilenameElement = doc.createElement("RulesetFilename");
sddElement.appendChild(rulesetFilenameElement);
rulesetFilenameElement.setAttribute("file", "CEC 2013 NonRes.bin"); // DLM: only allow one value for now
// set project, where should this data come from?
QDomElement projectElement = doc.createElement("Proj");
sddElement.appendChild(projectElement);
// DLM: what name to use here?
QDomElement projectNameElement = doc.createElement("Name");
projectElement.appendChild(projectNameElement);
projectNameElement.appendChild(doc.createTextNode("unknown"));
// site data
boost::optional<model::ClimateZones> climateZones = model.getOptionalUniqueModelObject<model::ClimateZones>();
if (climateZones){
// todo: check document year
std::vector<model::ClimateZone> zones = climateZones->getClimateZones("CEC");
if (zones.size() > 0 && !zones[0].value().empty()){
bool isNumber;
QString value = toQString(zones[0].value());
value.toInt(&isNumber);
if (isNumber){
value = QString("ClimateZone") + value;
}
QDomElement projectClimateZoneElement = doc.createElement("CliZn");
projectElement.appendChild(projectClimateZoneElement);
projectClimateZoneElement.appendChild(doc.createTextNode(value));
m_translatedObjects[climateZones->handle()] = projectClimateZoneElement;
}
}
// set lat, lon, elev
// DLM: do not translate forward, Issue 242: Forward Translator - Remove Proj:Lat/Lon/Elevation translation
/*
boost::optional<model::Site> site = model.getOptionalUniqueModelObject<model::Site>();
if (site){
double latitude = site->latitude();
QDomElement latElement = doc.createElement("Lat");
projectElement.appendChild(latElement);
latElement.appendChild( doc.createTextNode(QString::number(latitude)));
double longitude = site->longitude();
QDomElement longElement = doc.createElement("Long");
projectElement.appendChild(longElement);
longElement.appendChild( doc.createTextNode(QString::number(longitude)));
double elevationSI = site->elevation();
double elevationIP = elevationSI/0.3048;
QDomElement elevationElement = doc.createElement("Elevation");
projectElement.appendChild(elevationElement);
elevationElement.appendChild( doc.createTextNode(QString::number(elevationIP)));
m_translatedObjects[site.handle()] = latElement;
}
*/
// todo: write out epw file path
// todo: write out ddy file and set path
//<DDWeatherFile>C:/svn-CBECC-Com-130521/CBECC-Com13/Data/EPW/SACRAMENTO-EXECUTIVE_724830_CZ2010.ddy</DDWeatherFile>
//<AnnualWeatherFile>C:/svn-CBECC-Com-130521/CBECC-Com13/Data/EPW/SACRAMENTO-EXECUTIVE_724830_CZ2010.epw</AnnualWeatherFile>
//<HVACAutoSizing>1</HVACAutoSizing>
//<SimDsgnDays>1</SimDsgnDays>
//<RunPeriodBeginMonth>0</RunPeriodBeginMonth>
//<RunPeriodBeginDay>0</RunPeriodBeginDay>
//<RunPeriodEndMonth>0</RunPeriodEndMonth>
//<RunPeriodEndDay>0</RunPeriodEndDay>
//<RunPeriodYear>0</RunPeriodYear>
// do materials before constructions
std::vector<model::Material> materials = model.getModelObjects<model::Material>();
std::sort(materials.begin(), materials.end(), WorkspaceObjectNameLess());
if (m_progressBar){
m_progressBar->setWindowTitle(toString("Translating Materials"));
m_progressBar->setMinimum(0);
m_progressBar->setMaximum((int)materials.size());
m_progressBar->setValue(0);
}
for (const model::Material& material : materials){
boost::optional<QDomElement> materialElement = translateMaterial(material, doc);
if (materialElement){
projectElement.appendChild(*materialElement);
}
if (m_progressBar){
m_progressBar->setValue(m_progressBar->value() + 1);
}
}
// do constructions before geometry
std::vector<model::ConstructionBase> constructions = model.getModelObjects<model::ConstructionBase>();
std::sort(constructions.begin(), constructions.end(), WorkspaceObjectNameLess());
if (m_progressBar){
m_progressBar->setWindowTitle(toString("Translating Constructions"));
m_progressBar->setMinimum(0);
m_progressBar->setMaximum(3 * ((int)constructions.size())); // three loops below
m_progressBar->setValue(0);
}
std::set<Handle> surfaceConstructions;
for (const model::Surface& surface : model.getConcreteModelObjects<model::Surface>()){
boost::optional<model::ConstructionBase> construction = surface.construction();
if (construction){
surfaceConstructions.insert(construction->handle());
}
}
std::set<Handle> doorConstructions;
std::set<Handle> fenestrationConstructions;
for (const model::SubSurface& subSurface : model.getConcreteModelObjects<model::SubSurface>()){
boost::optional<model::ConstructionBase> construction = subSurface.construction();
if (construction){
std::string subSurfaceType = subSurface.subSurfaceType();
if (istringEqual("Door", subSurfaceType) || istringEqual("OverheadDoor", subSurfaceType)){
doorConstructions.insert(construction->handle());
}else{
fenestrationConstructions.insert(construction->handle());
}
}
}
// translate surface constructions
for (const model::ConstructionBase& constructionBase : constructions){
if (surfaceConstructions.find(constructionBase.handle()) == surfaceConstructions.end()){
continue;
}
boost::optional<QDomElement> constructionElement = translateConstructionBase(constructionBase, doc);
if (constructionElement){
projectElement.appendChild(*constructionElement);
}
if (m_progressBar){
m_progressBar->setValue(m_progressBar->value() + 1);
}
}
// translate door constructions
for (const model::ConstructionBase& constructionBase : constructions){
if (doorConstructions.find(constructionBase.handle()) == doorConstructions.end()){
continue;
}
boost::optional<QDomElement> constructionElement = translateDoorConstruction(constructionBase, doc);
if (constructionElement){
projectElement.appendChild(*constructionElement);
}
if (m_progressBar){
m_progressBar->setValue(m_progressBar->value() + 1);
}
}
// translate fenestration constructions
for (const model::ConstructionBase& constructionBase : constructions){
if (fenestrationConstructions.find(constructionBase.handle()) == fenestrationConstructions.end()){
continue;
}
boost::optional<QDomElement> constructionElement = translateFenestrationConstruction(constructionBase, doc);
if (constructionElement){
projectElement.appendChild(*constructionElement);
}
if (m_progressBar){
m_progressBar->setValue(m_progressBar->value() + 1);
}
}
// translate site shading
std::vector<model::ShadingSurfaceGroup> shadingSurfaceGroups = model.getConcreteModelObjects<model::ShadingSurfaceGroup>();
std::sort(shadingSurfaceGroups.begin(), shadingSurfaceGroups.end(), WorkspaceObjectNameLess());
if (m_progressBar){
m_progressBar->setWindowTitle(toString("Translating Site Shading"));
m_progressBar->setMinimum(0);
m_progressBar->setMaximum((int)shadingSurfaceGroups.size());
m_progressBar->setValue(0);
}
for (const model::ShadingSurfaceGroup& shadingSurfaceGroup : shadingSurfaceGroups){
if (istringEqual(shadingSurfaceGroup.shadingSurfaceType(), "Site")){
Transformation transformation = shadingSurfaceGroup.siteTransformation();
for (const model::ShadingSurface& shadingSurface : shadingSurfaceGroup.shadingSurfaces()){
boost::optional<QDomElement> shadingSurfaceElement = translateShadingSurface(shadingSurface, transformation, doc);
if (shadingSurfaceElement){
projectElement.appendChild(*shadingSurfaceElement);
}
}
}
if (m_progressBar){
m_progressBar->setValue(m_progressBar->value() + 1);
}
}
// translate the building
boost::optional<model::Building> building = model.getOptionalUniqueModelObject<model::Building>();
if (building){
boost::optional<QDomElement> buildingElement = translateBuilding(*building, doc);
if (buildingElement){
projectElement.appendChild(*buildingElement);
}
}
m_ignoreTypes.push_back(model::BoilerSteam::iddObjectType());
m_ignoreTypes.push_back(model::ClimateZones::iddObjectType()); // might not be translated but it is checked
m_ignoreTypes.push_back(model::CoilCoolingDXMultiSpeedStageData::iddObjectType());
m_ignoreTypes.push_back(model::CoilHeatingGasMultiStageStageData::iddObjectType());
m_ignoreTypes.push_back(model::ComponentCostAdjustments::iddObjectType());
m_ignoreTypes.push_back(model::ComponentData::iddObjectType());
m_ignoreTypes.push_back(model::Connection::iddObjectType());
m_ignoreTypes.push_back(model::ControllerWaterCoil::iddObjectType());
m_ignoreTypes.push_back(model::ConvergenceLimits::iddObjectType());
m_ignoreTypes.push_back(model::CoolingTowerPerformanceCoolTools::iddObjectType());
m_ignoreTypes.push_back(model::CoolingTowerPerformanceYorkCalc::iddObjectType());
m_ignoreTypes.push_back(model::CurrencyType::iddObjectType());
m_ignoreTypes.push_back(model::CurveBicubic::iddObjectType());
m_ignoreTypes.push_back(model::CurveBiquadratic::iddObjectType());
m_ignoreTypes.push_back(model::CurveCubic::iddObjectType());
m_ignoreTypes.push_back(model::CurveDoubleExponentialDecay::iddObjectType());
m_ignoreTypes.push_back(model::CurveExponent::iddObjectType());
m_ignoreTypes.push_back(model::CurveExponentialDecay::iddObjectType());
m_ignoreTypes.push_back(model::CurveExponentialSkewNormal::iddObjectType());
m_ignoreTypes.push_back(model::CurveFanPressureRise::iddObjectType());
m_ignoreTypes.push_back(model::CurveFunctionalPressureDrop::iddObjectType());
m_ignoreTypes.push_back(model::CurveLinear::iddObjectType());
m_ignoreTypes.push_back(model::CurveQuadratic::iddObjectType());
m_ignoreTypes.push_back(model::CurveQuadraticLinear::iddObjectType());
m_ignoreTypes.push_back(model::CurveQuartic::iddObjectType());
m_ignoreTypes.push_back(model::CurveRectangularHyperbola1::iddObjectType());
m_ignoreTypes.push_back(model::CurveRectangularHyperbola2::iddObjectType());
m_ignoreTypes.push_back(model::CurveSigmoid::iddObjectType());
m_ignoreTypes.push_back(model::CurveTriquadratic::iddObjectType());
m_ignoreTypes.push_back(model::DefaultConstructionSet::iddObjectType());
m_ignoreTypes.push_back(model::DesignDay::iddObjectType());
m_ignoreTypes.push_back(model::DefaultScheduleSet::iddObjectType());
m_ignoreTypes.push_back(model::DesignSpecificationZoneAirDistribution::iddObjectType());
m_ignoreTypes.push_back(model::DefaultSurfaceConstructions::iddObjectType());
m_ignoreTypes.push_back(model::DefaultSubSurfaceConstructions::iddObjectType());
m_ignoreTypes.push_back(model::Facility::iddObjectType());
m_ignoreTypes.push_back(model::HeatBalanceAlgorithm::iddObjectType());
m_ignoreTypes.push_back(model::IlluminanceMap::iddObjectType());
m_ignoreTypes.push_back(model::InsideSurfaceConvectionAlgorithm::iddObjectType());
m_ignoreTypes.push_back(model::InternalMass::iddObjectType());
m_ignoreTypes.push_back(model::LifeCycleCost::iddObjectType());
m_ignoreTypes.push_back(model::LifeCycleCostParameters::iddObjectType());
m_ignoreTypes.push_back(model::LightingDesignDay::iddObjectType());
m_ignoreTypes.push_back(model::LightingSimulationControl::iddObjectType());
m_ignoreTypes.push_back(model::Meter::iddObjectType());
m_ignoreTypes.push_back(model::ModelObjectList::iddObjectType());
m_ignoreTypes.push_back(model::Node::iddObjectType());
m_ignoreTypes.push_back(model::OutputControlReportingTolerances::iddObjectType());
m_ignoreTypes.push_back(model::OutputVariable::iddObjectType());
m_ignoreTypes.push_back(model::OutsideSurfaceConvectionAlgorithm::iddObjectType());
m_ignoreTypes.push_back(model::PortList::iddObjectType());
m_ignoreTypes.push_back(model::ProgramControl::iddObjectType());
m_ignoreTypes.push_back(model::RadianceParameters::iddObjectType());
m_ignoreTypes.push_back(model::RenderingColor::iddObjectType());
m_ignoreTypes.push_back(model::RunPeriod::iddObjectType());
m_ignoreTypes.push_back(model::ScheduleCompact::iddObjectType());
m_ignoreTypes.push_back(model::ScheduleConstant::iddObjectType());
m_ignoreTypes.push_back(model::ScheduleDay::iddObjectType());
m_ignoreTypes.push_back(model::ScheduleFixedInterval::iddObjectType());
m_ignoreTypes.push_back(model::ScheduleRule::iddObjectType());
m_ignoreTypes.push_back(model::ScheduleRuleset::iddObjectType());
m_ignoreTypes.push_back(model::ScheduleTypeLimits::iddObjectType());
m_ignoreTypes.push_back(model::ScheduleVariableInterval::iddObjectType());
m_ignoreTypes.push_back(model::ScheduleWeek::iddObjectType());
m_ignoreTypes.push_back(model::ScheduleYear::iddObjectType());
m_ignoreTypes.push_back(model::SetpointManagerMixedAir::iddObjectType());
m_ignoreTypes.push_back(model::ShadowCalculation::iddObjectType());
m_ignoreTypes.push_back(model::SimulationControl::iddObjectType());
m_ignoreTypes.push_back(model::Site::iddObjectType()); // might not be translated but it is checked
m_ignoreTypes.push_back(model::SiteGroundReflectance::iddObjectType());
m_ignoreTypes.push_back(model::SiteGroundTemperatureBuildingSurface::iddObjectType());
m_ignoreTypes.push_back(model::SiteWaterMainsTemperature::iddObjectType());
m_ignoreTypes.push_back(model::SizingParameters::iddObjectType());
m_ignoreTypes.push_back(model::SkyTemperature::iddObjectType());
m_ignoreTypes.push_back(model::StandardsInformationConstruction::iddObjectType());
m_ignoreTypes.push_back(model::StandardsInformationMaterial::iddObjectType());
m_ignoreTypes.push_back(model::TableMultiVariableLookup::iddObjectType());
m_ignoreTypes.push_back(model::Timestep::iddObjectType());
m_ignoreTypes.push_back(model::UtilityBill::iddObjectType());
m_ignoreTypes.push_back(model::UtilityCost_Charge_Block::iddObjectType());
m_ignoreTypes.push_back(model::UtilityCost_Charge_Simple::iddObjectType());
m_ignoreTypes.push_back(model::UtilityCost_Computation::iddObjectType());
m_ignoreTypes.push_back(model::UtilityCost_Qualify::iddObjectType());
m_ignoreTypes.push_back(model::UtilityCost_Ratchet::iddObjectType());
m_ignoreTypes.push_back(model::UtilityCost_Tariff::iddObjectType());
m_ignoreTypes.push_back(model::UtilityCost_Variable::iddObjectType());
m_ignoreTypes.push_back(model::Version::iddObjectType());
m_ignoreTypes.push_back(model::WeatherFile::iddObjectType());
m_ignoreTypes.push_back(model::WeatherFileConditionType::iddObjectType());
m_ignoreTypes.push_back(model::WeatherFileDays::iddObjectType());
m_ignoreTypes.push_back(model::YearDescription::iddObjectType());
m_ignoreTypes.push_back(model::ZoneAirContaminantBalance::iddObjectType());
m_ignoreTypes.push_back(model::ZoneAirHeatBalanceAlgorithm::iddObjectType());
m_ignoreTypes.push_back(model::ZoneCapacitanceMultiplierResearchSpecial::iddObjectType());
m_ignoreTypes.push_back(model::ZoneHVACEquipmentList::iddObjectType());
return doc;
}
void ZoneChooserView::layoutView()
{
this->setUpdatesEnabled(false);
QLayoutItem * child;
while((child = m_vLayout->takeAt(0)) != 0)
{
delete child->widget();
delete child;
}
m_zoneChooserItems.clear();
if( m_mixer )
{
QLabel * label = new QLabel();
label->setObjectName("IGHeader");
label->setText(toQString(m_mixer->iddObject().name()));
m_vLayout->addWidget(label);
}
else if( m_splitter )
{
QLabel * label = new QLabel();
label->setObjectName("IGHeader");
label->setText(toQString(m_splitter->iddObject().name()));
m_vLayout->addWidget(label);
}
if( m_mixer )
{
if( model::OptionalAirLoopHVAC airLoop = m_mixer->airLoopHVAC() )
{
m_splitter = airLoop->zoneSplitter();
}
else
{
return;
}
}
else if( ! m_splitter )
{
return;
}
std::vector<model::ThermalZone> zones;
zones = m_splitter->model().getModelObjects<model::ThermalZone>();
std::sort(zones.begin(),zones.end(),WorkspaceObjectNameLess());
for( std::vector<model::ThermalZone>::iterator it = zones.begin();
it < zones.end();
++it )
{
if( ! it->isPlenum() )
{
ZoneChooserItem * zoneChooserItem = new ZoneChooserItem(*it,this);
m_zoneChooserItems.push_back(zoneChooserItem);
m_vLayout->addWidget(zoneChooserItem);
zoneChooserItem->setChecked(false);
}
}
m_vLayout->addStretch();
std::vector<model::ThermalZone> thermalZones;
thermalZones = m_splitter->thermalZones();
for( std::vector<model::ThermalZone>::iterator it = thermalZones.begin();
it < thermalZones.end();
++it )
{
zoneChooserItemForZone(it->name().get())->setChecked(true);
}
for(int i = 0; i < m_vLayout->count(); i++)
{
if( QWidget * widget = m_vLayout->itemAt(i)->widget() )
{
widget->show();
}
}
this->setUpdatesEnabled(true);
}
boost::optional<IdfObject> ForwardTranslator::translateBuilding( Building & modelObject )
{
Model model = modelObject.model();
IdfObject idfObject(IddObjectType::Building);
m_idfObjects.push_back(idfObject);
for (LifeCycleCost lifeCycleCost : modelObject.lifeCycleCosts()){
translateAndMapModelObject(lifeCycleCost);
}
OptionalString optS = modelObject.name();
if( optS )
{
idfObject.setName(stripOS2(*optS));
}
if (!modelObject.isNorthAxisDefaulted()){
idfObject.setDouble(openstudio::BuildingFields::NorthAxis, modelObject.northAxis());
}
// terrain comes from Site
OptionalSite site = model.getOptionalUniqueModelObject<Site>();
if (site){
if (!site->isTerrainDefaulted()){
idfObject.setString(openstudio::BuildingFields::Terrain, site->terrain());
}
}
// these fields come from SimulationControl
OptionalSimulationControl simulationControl = model.getOptionalUniqueModelObject<SimulationControl>();
if (simulationControl){
if (!simulationControl->isLoadsConvergenceToleranceValueDefaulted()){
idfObject.setDouble(openstudio::BuildingFields::LoadsConvergenceToleranceValue, simulationControl->loadsConvergenceToleranceValue());
}
if (!simulationControl->isTemperatureConvergenceToleranceValueDefaulted()){
idfObject.setDouble(openstudio::BuildingFields::TemperatureConvergenceToleranceValue, simulationControl->temperatureConvergenceToleranceValue());
}
if (!simulationControl->isSolarDistributionDefaulted()){
idfObject.setString(openstudio::BuildingFields::SolarDistribution, simulationControl->solarDistribution());
}
if (!simulationControl->isMaximumNumberofWarmupDaysDefaulted()){
idfObject.setInt(openstudio::BuildingFields::MaximumNumberofWarmupDays, simulationControl->maximumNumberofWarmupDays());
}
if (!simulationControl->isMinimumNumberofWarmupDaysDefaulted()) {
idfObject.setInt(openstudio::BuildingFields::MinimumNumberofWarmupDays, simulationControl->minimumNumberofWarmupDays());
}
}
// translate shading groups
ShadingSurfaceGroupVector shadingSurfaceGroups = modelObject.shadingSurfaceGroups();
std::sort(shadingSurfaceGroups.begin(), shadingSurfaceGroups.end(), WorkspaceObjectNameLess());
for (ShadingSurfaceGroup& shadingSurfaceGroup : shadingSurfaceGroups){
translateAndMapModelObject(shadingSurfaceGroup);
}
return boost::optional<IdfObject>(idfObject);
}
boost::optional<IdfObject> ForwardTranslator::translateSpaceType( SpaceType & modelObject )
{
std::vector<Space> spaces = modelObject.spaces();
// check if this is a dummy space type meant to prevent inheriting building space type
std::vector<ModelObject> children = modelObject.children();
if (children.empty()){
LOG(Info, "SpaceType " << modelObject.name().get() << " has no children, it will not be translated");
return boost::none;
}
IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::ZoneList,
modelObject);
std::set<std::string> zoneNames;
for (const Space& space : spaces){
boost::optional<ThermalZone> thermalZone = space.thermalZone();
if (thermalZone){
zoneNames.insert(thermalZone->name().get());
}
}
idfObject.clearExtensibleGroups();
for (const std::string& zoneName : zoneNames){
idfObject.pushExtensibleGroup(std::vector<std::string>(1, zoneName));
}
// translate internal mass
InternalMassVector internalMasses = modelObject.internalMass();
std::sort(internalMasses.begin(), internalMasses.end(), WorkspaceObjectNameLess());
for (InternalMass& internalMass : internalMasses){
translateAndMapModelObject(internalMass);
}
// translate lights
LightsVector lights = modelObject.lights();
std::sort(lights.begin(), lights.end(), WorkspaceObjectNameLess());
for (Lights& light : lights){
translateAndMapModelObject(light);
}
// translate luminaires
LuminaireVector luminaires = modelObject.luminaires();
std::sort(luminaires.begin(), luminaires.end(), WorkspaceObjectNameLess());
for (Luminaire& luminaire : luminaires){
translateAndMapModelObject(luminaire);
}
// translate people
PeopleVector people = modelObject.people();
std::sort(people.begin(), people.end(), WorkspaceObjectNameLess());
for (People& person : people){
translateAndMapModelObject(person);
}
// translate electric equipment
ElectricEquipmentVector electricEquipment = modelObject.electricEquipment();
std::sort(electricEquipment.begin(), electricEquipment.end(), WorkspaceObjectNameLess());
for (ElectricEquipment& equipment : electricEquipment){
translateAndMapModelObject(equipment);
}
// translate gas equipment
GasEquipmentVector gasEquipment = modelObject.gasEquipment();
std::sort(gasEquipment.begin(), gasEquipment.end(), WorkspaceObjectNameLess());
for (GasEquipment& equipment : gasEquipment){
translateAndMapModelObject(equipment);
}
// translate hot water equipment
HotWaterEquipmentVector hotWaterEquipment = modelObject.hotWaterEquipment();
std::sort(hotWaterEquipment.begin(), hotWaterEquipment.end(), WorkspaceObjectNameLess());
for (HotWaterEquipment& equipment : hotWaterEquipment){
translateAndMapModelObject(equipment);
}
// translate steam equipment
SteamEquipmentVector steamEquipment = modelObject.steamEquipment();
std::sort(steamEquipment.begin(), steamEquipment.end(), WorkspaceObjectNameLess());
for (SteamEquipment& equipment : steamEquipment){
translateAndMapModelObject(equipment);
}
// translate other equipment
OtherEquipmentVector otherEquipment = modelObject.otherEquipment();
std::sort(otherEquipment.begin(), otherEquipment.end(), WorkspaceObjectNameLess());
for (OtherEquipment& equipment : otherEquipment){
translateAndMapModelObject(equipment);
}
// translate SpaceInfiltration_DesignFlowRate
SpaceInfiltrationDesignFlowRateVector spaceInfiltrationDesignFlowRates = modelObject.spaceInfiltrationDesignFlowRates();
std::sort(spaceInfiltrationDesignFlowRates.begin(), spaceInfiltrationDesignFlowRates.end(), WorkspaceObjectNameLess());
for (SpaceInfiltrationDesignFlowRate& spaceInfiltrationDesignFlowRate : spaceInfiltrationDesignFlowRates){
translateAndMapModelObject(spaceInfiltrationDesignFlowRate);
}
// translate SpaceInfiltration_EffectiveLeakageArea
SpaceInfiltrationEffectiveLeakageAreaVector spaceInfiltrationEffectiveLeakageAreas = modelObject.spaceInfiltrationEffectiveLeakageAreas();
std::sort(spaceInfiltrationEffectiveLeakageAreas.begin(), spaceInfiltrationEffectiveLeakageAreas.end(), WorkspaceObjectNameLess());
for (SpaceInfiltrationEffectiveLeakageArea& spaceInfiltrationEffectiveLeakageArea : spaceInfiltrationEffectiveLeakageAreas){
translateAndMapModelObject(spaceInfiltrationEffectiveLeakageArea);
}
return idfObject;
}
