FFactorGroundFloorConstruction_Impl::FFactorGroundFloorConstruction_Impl(
const openstudio::detail::WorkspaceObject_Impl& other,Model_Impl* model,bool keepHandle)
: ConstructionBase_Impl(other,model,keepHandle)
{
OS_ASSERT(other.iddObject().type() == FFactorGroundFloorConstruction::iddObjectType());
}
OptionalModelObject ReverseTranslator::translateElectricEquipment( const WorkspaceObject & workspaceObject )
{
if( workspaceObject.iddObject().type() != IddObjectType::ElectricEquipment ){
LOG(Error, "WorkspaceObject is not IddObjectType: ElectricEquipment");
return boost::none;
}
// create the definition
openstudio::model::ElectricEquipmentDefinition definition(m_model);
OptionalString s = workspaceObject.name();
if(s){
definition.setName(*s + " Definition");
}
s = workspaceObject.getString(openstudio::ElectricEquipmentFields::DesignLevelCalculationMethod, true);
OS_ASSERT(s);
OptionalDouble d;
if (istringEqual("EquipmentLevel", *s)){
d = workspaceObject.getDouble(openstudio::ElectricEquipmentFields::DesignLevel);
if (d){
definition.setDesignLevel(*d);
}else{
LOG(Error, "EquipmentLevel value not found for workspace object " << workspaceObject);
}
}else if(istringEqual("Watts/Area", *s)){
d = workspaceObject.getDouble(openstudio::ElectricEquipmentFields::WattsperZoneFloorArea);
if (d){
definition.setWattsperSpaceFloorArea(*d);
}else{
LOG(Error, "Watts/Area value not found for workspace object " << workspaceObject);
}
}else if(istringEqual("Watts/Person", *s)){
d = workspaceObject.getDouble(openstudio::ElectricEquipmentFields::WattsperPerson);
if (d){
definition.setWattsperPerson(*d);
}else{
LOG(Error, "Watts/Person value not found for workspace object " << workspaceObject);
}
}else{
LOG(Error, "Unknown DesignLevelCalculationMethod value for workspace object" << workspaceObject);
}
d = workspaceObject.getDouble(openstudio::ElectricEquipmentFields::FractionLatent);
if (d){
definition.setFractionLatent(*d);
}
d = workspaceObject.getDouble(openstudio::ElectricEquipmentFields::FractionRadiant);
if (d){
definition.setFractionRadiant(*d);
}
d = workspaceObject.getDouble(openstudio::ElectricEquipmentFields::FractionLost);
if (d){
definition.setFractionLost(*d);
}
// create the instance
ElectricEquipment electricEquipment(definition);
s = workspaceObject.name();
if(s){
electricEquipment.setName(*s);
}
OptionalWorkspaceObject target = workspaceObject.getTarget(openstudio::ElectricEquipmentFields::ZoneorZoneListName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (modelObject->optionalCast<Space>()){
electricEquipment.setSpace(modelObject->cast<Space>());
}else if (modelObject->optionalCast<SpaceType>()){
electricEquipment.setSpaceType(modelObject->cast<SpaceType>());
}
}
}
target = workspaceObject.getTarget(openstudio::ElectricEquipmentFields::ScheduleName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (OptionalSchedule intermediate = modelObject->optionalCast<Schedule>()){
Schedule schedule = *intermediate;
electricEquipment.setSchedule(schedule);
}
}
}
s = workspaceObject.getString(openstudio::ElectricEquipmentFields::EndUseSubcategory);
if(s){
electricEquipment.setEndUseSubcategory(*s);
}
return electricEquipment;
}
std::string GasEquipment_Impl::endUseSubcategory() const {
boost::optional<std::string> value = getString(OS_GasEquipmentFields::EndUseSubcategory,true);
OS_ASSERT(value);
return value.get();
}
OSGridView::OSGridView(OSGridController * gridController,
const QString & headerText,
const QString & dropZoneText,
bool useHeader,
QWidget * parent)
: QWidget(parent),
m_dropZone(nullptr),
m_contentLayout(nullptr),
m_CollapsibleView(nullptr),
m_gridController(gridController)
{
auto buttonGroup = new QButtonGroup();
connect(buttonGroup, static_cast<void (QButtonGroup::*)(int)>(&QButtonGroup::buttonClicked), this, &OSGridView::selectCategory);
auto buttonLayout = new QHBoxLayout();
buttonLayout->setSpacing(3);
buttonLayout->setContentsMargins(10,10,10,10);
buttonLayout->setAlignment(Qt::AlignCenter | Qt::AlignLeft);
auto vectorController = new GridViewDropZoneVectorController();
m_dropZone = new OSDropZone(vectorController, dropZoneText);
m_dropZone->setMaxItems(1);
connect(m_dropZone, &OSDropZone::itemDropped, m_gridController, &OSGridController::onItemDropped);
buttonLayout->addWidget(m_dropZone);
std::vector<QString> categories = m_gridController->categories();
for(unsigned i=0; i<categories.size(); i++){
auto button = new QPushButton(categories.at(i));
button->setSizePolicy(QSizePolicy::Minimum,QSizePolicy::MinimumExpanding);
button->setCheckable(true);
buttonLayout->addWidget(button);
buttonGroup->addButton(button,buttonGroup->buttons().size());
}
auto layout = new QVBoxLayout();
layout->setSpacing(0);
layout->setContentsMargins(0,0,0,0);
setLayout(layout);
auto widget = new QWidget;
if (useHeader) {
auto header = new DarkGradientHeader();
header->label->setText(headerText);
auto collabsibleView = new OSCollapsibleView(true);
collabsibleView->setHeader(header);
collabsibleView->setContent(widget);
collabsibleView->setExpanded(true);
layout->addWidget(collabsibleView);
} else {
layout->addWidget(widget);
}
m_contentLayout = new QVBoxLayout();
m_contentLayout->setAlignment(Qt::AlignTop | Qt::AlignLeft);
m_contentLayout->setSpacing(0);
m_contentLayout->setContentsMargins(0,0,0,0);
widget->setLayout(m_contentLayout);
m_contentLayout->addLayout(buttonLayout);
widget->setSizePolicy(QSizePolicy::Minimum,QSizePolicy::Fixed);
setGridController(m_gridController);
std::vector<QAbstractButton *> buttons = buttonGroup->buttons().toVector().toStdVector();
if(buttons.size() > 0){
QPushButton * button = qobject_cast<QPushButton *>(buttons.at(0));
OS_ASSERT(button);
button->setChecked(true);
selectCategory(0);
}
m_timer.setSingleShot(true);
connect(&m_timer, &QTimer::timeout, this, &OSGridView::doRefresh);
if (this->isVisible()) {
m_gridController->connectToModel();
refreshAll();
}
}
void AirGap_Impl::resetThermalResistance() {
bool result = setString(OS_Material_AirGapFields::ThermalResistance, "");
OS_ASSERT(result);
}
ScheduleTypeLimits::ScheduleTypeLimits(const Model& model)
: ResourceObject(ScheduleTypeLimits::iddObjectType(),model)
{
OS_ASSERT(getImpl<detail::ScheduleTypeLimits_Impl>());
}
DefaultSurfaceConstructions::DefaultSurfaceConstructions(const Model& model)
: ResourceObject(DefaultSurfaceConstructions::iddObjectType(),model)
{
OS_ASSERT(getImpl<detail::DefaultSurfaceConstructions_Impl>());
}
SurfaceInspectorView::SurfaceInspectorView(bool isIP, const openstudio::model::Model& model, QWidget * parent )
: ModelObjectInspectorView(model, true, parent)
{
m_isIP = isIP;
QWidget* hiddenWidget = new QWidget();
this->stackedWidget()->insertWidget(0, hiddenWidget);
QWidget* visibleWidget = new QWidget();
this->stackedWidget()->insertWidget(1, visibleWidget);
this->stackedWidget()->setCurrentIndex(0);
QGridLayout* mainGridLayout = new QGridLayout();
mainGridLayout->setContentsMargins(7,7,7,7);
mainGridLayout->setSpacing(14);
visibleWidget->setLayout(mainGridLayout);
// name
QVBoxLayout* vLayout = new QVBoxLayout();
QLabel* label = new QLabel();
label->setText("Name: ");
label->setStyleSheet("QLabel { font: bold; }");
vLayout->addWidget(label);
m_nameEdit = new OSLineEdit();
vLayout->addWidget(m_nameEdit);
mainGridLayout->addLayout(vLayout,0,0,1,2, Qt::AlignTop|Qt::AlignLeft);
// surface type
vLayout = new QVBoxLayout();
label = new QLabel();
label->setText("Surface Type: ");
label->setStyleSheet("QLabel { font: bold; }");
vLayout->addWidget(label);
m_surfaceType = new OSComboBox();
vLayout->addWidget(m_surfaceType);
vLayout->addStretch();
mainGridLayout->addLayout(vLayout,1,0);
// construction
vLayout = new QVBoxLayout();
label = new QLabel();
label->setText("Construction: ");
label->setStyleSheet("QLabel { font: bold; }");
vLayout->addWidget(label);
m_constructionVectorController = new SurfaceConstructionVectorController();
m_constructionDropZone = new OSDropZone(m_constructionVectorController);
m_constructionDropZone->setMinItems(0);
m_constructionDropZone->setMaxItems(1);
m_constructionDropZone->setItemsAcceptDrops(true);
vLayout->addWidget(m_constructionDropZone);
vLayout->addStretch();
mainGridLayout->addLayout(vLayout,1,1);
// outside boundary condition and object
vLayout = new QVBoxLayout();
label = new QLabel();
label->setText("Outside Boundary Condition: ");
label->setStyleSheet("QLabel { font: bold; }");
vLayout->addWidget(label);
m_outsideBoundaryCondition = new OSComboBox();
vLayout->addWidget(m_outsideBoundaryCondition);
vLayout->addStretch();
mainGridLayout->addLayout(vLayout,2,0);
vLayout = new QVBoxLayout();
label = new QLabel();
label->setText("Outside Boundary Condition Object: ");
label->setStyleSheet("QLabel { font: bold; }");
vLayout->addWidget(label);
m_surfaceOutsideBoundaryConditionObjectVectorController = new SurfaceOutsideBoundaryConditionObjectVectorController();
m_outsideBoundaryConditionObjectDropZone = new OSDropZone(m_surfaceOutsideBoundaryConditionObjectVectorController);
m_outsideBoundaryConditionObjectDropZone->setMinItems(0);
m_outsideBoundaryConditionObjectDropZone->setMaxItems(1);
m_outsideBoundaryConditionObjectDropZone->setItemsAcceptDrops(true);
vLayout->addWidget(m_outsideBoundaryConditionObjectDropZone);
vLayout->addStretch();
mainGridLayout->addLayout(vLayout,2,1);
// sun and wind exposure
vLayout = new QVBoxLayout();
label = new QLabel();
label->setText("Sun Exposure: ");
label->setStyleSheet("QLabel { font: bold; }");
vLayout->addWidget(label);
m_sunExposure = new OSComboBox();
vLayout->addWidget(m_sunExposure);
vLayout->addStretch();
mainGridLayout->addLayout(vLayout,3,0);
vLayout = new QVBoxLayout();
label = new QLabel();
label->setText("Wind Exposure: ");
label->setStyleSheet("QLabel { font: bold; }");
vLayout->addWidget(label);
m_windExposure = new OSComboBox();
vLayout->addWidget(m_windExposure);
vLayout->addStretch();
mainGridLayout->addLayout(vLayout,3,1);
// separator
vLayout = new QVBoxLayout();
vLayout->setContentsMargins(0,0,0,0);
QWidget * hLine = new QWidget();
hLine->setObjectName("HLine");
hLine->setStyleSheet("QWidget#HLine { background: #445051;}");
hLine->setFixedHeight(2);
vLayout->addWidget(hLine);
label = new QLabel();
label->setText("Vertices: ");
label->setStyleSheet("QLabel { font: bold; }");
vLayout->addWidget(label);
mainGridLayout->addLayout(vLayout,4,0,1,2);
// planar surface widget
m_planarSurfaceWidget = new PlanarSurfaceWidget(m_isIP);
bool isConnected = connect(this, SIGNAL(toggleUnitsClicked(bool)), m_planarSurfaceWidget, SLOT(toggleUnits(bool)));
OS_ASSERT(isConnected);
mainGridLayout->addWidget(m_planarSurfaceWidget,5,0,1,2);
mainGridLayout->setColumnMinimumWidth(0, 80);
mainGridLayout->setColumnMinimumWidth(1, 80);
mainGridLayout->setColumnStretch(2,1);
mainGridLayout->setRowMinimumHeight(0, 30);
mainGridLayout->setRowMinimumHeight(1, 30);
mainGridLayout->setRowMinimumHeight(2, 30);
mainGridLayout->setRowMinimumHeight(3, 30);
mainGridLayout->setRowMinimumHeight(4, 30);
mainGridLayout->setRowMinimumHeight(5, 30);
mainGridLayout->setRowStretch(6,1);
}
void CoilHeatingGasMultiStageStageData_Impl::autosizeNominalCapacity() {
bool result = setString(OS_Coil_Heating_Gas_MultiStage_StageDataFields::NominalCapacity, "autosize");
OS_ASSERT(result);
}
/// constructor
UtilityCost_Ratchet::UtilityCost_Ratchet(const Model& model)
: ParentObject(UtilityCost_Ratchet::iddObjectType(),model)
{
OS_ASSERT(getImpl<detail::UtilityCost_Ratchet_Impl>());
}
UtilityCost_Ratchet_Impl::UtilityCost_Ratchet_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle)
: ParentObject_Impl(idfObject, model, keepHandle)
{
OS_ASSERT(idfObject.iddObject().type() == UtilityCost_Ratchet::iddObjectType());
}
void WorkflowJSON_Impl::resetWorkflowSteps()
{
bool test = setWorkflowSteps(std::vector<WorkflowStep>()); // will hit onUpdate in setWorkflowSteps
OS_ASSERT(test);
}
PoissonDistribution::PoissonDistribution(std::shared_ptr<detail::UncertaintyDescription_Impl> impl)
: UncertaintyDescription(impl)
{
OS_ASSERT(type() == PoissonDistribution::type());
}
Quantity FFactorGroundFloorConstruction_Impl::getFFactor(bool returnIP) const {
OSOptionalQuantity value = getQuantity(OS_Construction_FfactorGroundFloorFields::FFactor,true,returnIP);
OS_ASSERT(value.isSet());
return value.get();
}
void ScheduleTypeLimits_Impl::resetUpperLimitValue() {
bool result = setString(OS_ScheduleTypeLimitsFields::UpperLimitValue, "");
OS_ASSERT(result);
}
void CoilHeatingGasMultiStageStageData_Impl::setParasiticElectricLoad(double ParasiticElectricLoad) {
bool result = setDouble(OS_Coil_Heating_Gas_MultiStage_StageDataFields::ParasiticElectricLoad, ParasiticElectricLoad);
OS_ASSERT(result);
}
void ScheduleTypeLimits_Impl::resetUnitType() {
bool result = setString(OS_ScheduleTypeLimitsFields::UnitType, "");
OS_ASSERT(result);
}
double CoilHeatingGasMultiStageStageData_Impl::gasBurnerEfficiency() const {
boost::optional<double> value = getDouble(OS_Coil_Heating_Gas_MultiStage_StageDataFields::GasBurnerEfficiency,true);
OS_ASSERT(value);
return value.get();
}
boost::optional<IdfObject> ForwardTranslator::translateAirConditionerVariableRefrigerantFlow( AirConditionerVariableRefrigerantFlow & modelObject )
{
boost::optional<std::string> s;
boost::optional<double> value;
IdfObject idfObject(IddObjectType::AirConditioner_VariableRefrigerantFlow);
m_idfObjects.push_back(idfObject);
// Name
s = modelObject.name();
if( s )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatPumpName,*s);
}
// AvailabilityScheduleName
if( boost::optional<model::Schedule> schedule = modelObject.availabilitySchedule() )
{
if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::AvailabilityScheduleName,_schedule->name().get());
}
}
// RatedTotalCoolingCapacity
if( modelObject.isRatedTotalCoolingCapacityAutosized() )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::RatedTotalCoolingCapacity,"Autosize");
}
else if( (value = modelObject.ratedTotalCoolingCapacity()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::RatedTotalCoolingCapacity,value.get());
}
// RatedCoolingCOP
if( (value = modelObject.ratedCoolingCOP()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::RatedCoolingCOP,value.get());
}
// MinimumOutdoorTemperatureinCoolingMode
if( (value = modelObject.minimumOutdoorTemperatureinCoolingMode()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::MinimumOutdoorTemperatureinCoolingMode,value.get());
}
// MaximumOutdoorTemperatureinCoolingMode
if( (value = modelObject.maximumOutdoorTemperatureinCoolingMode()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::MaximumOutdoorTemperatureinCoolingMode,value.get());
}
// CoolingCapacityRatioModifierFunctionofLowTemperatureCurveName
if( boost::optional<model::CurveBiquadratic> curve = modelObject.coolingCapacityRatioModifierFunctionofLowTemperatureCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CoolingCapacityRatioModifierFunctionofLowTemperatureCurveName,_curve->name().get());
}
}
// CoolingCapacityRatioBoundaryCurveName
if( boost::optional<model::CurveCubic> curve = modelObject.coolingCapacityRatioBoundaryCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CoolingCapacityRatioBoundaryCurveName,_curve->name().get());
}
}
// CoolingCapacityRatioModifierFunctionofHighTemperatureCurveName
if( boost::optional<model::CurveBiquadratic> curve = modelObject.coolingCapacityRatioModifierFunctionofHighTemperatureCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CoolingCapacityRatioModifierFunctionofHighTemperatureCurveName,_curve->name().get());
}
}
// CoolingEnergyInputRatioModifierFunctionofLowTemperatureCurveName
if( boost::optional<model::CurveBiquadratic> curve = modelObject.coolingEnergyInputRatioModifierFunctionofLowTemperatureCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CoolingEnergyInputRatioModifierFunctionofLowTemperatureCurveName,_curve->name().get());
}
}
// CoolingEnergyInputRatioBoundaryCurveName
if( boost::optional<model::CurveCubic> curve = modelObject.coolingEnergyInputRatioBoundaryCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CoolingEnergyInputRatioBoundaryCurveName,_curve->name().get());
}
}
// CoolingEnergyInputRatioModifierFunctionofHighTemperatureCurveName
if( boost::optional<model::CurveBiquadratic> curve = modelObject.coolingEnergyInputRatioModifierFunctionofHighTemperatureCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CoolingEnergyInputRatioModifierFunctionofHighTemperatureCurveName,_curve->name().get());
}
}
// CoolingEnergyInputRatioModifierFunctionofLowPartLoadRatioCurveName
if( boost::optional<model::CurveCubic> curve = modelObject.coolingEnergyInputRatioModifierFunctionofLowPartLoadRatioCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CoolingEnergyInputRatioModifierFunctionofLowPartLoadRatioCurveName,_curve->name().get());
}
}
// CoolingEnergyInputRatioModifierFunctionofHighPartLoadRatioCurveName
if( boost::optional<model::CurveCubic> curve = modelObject.coolingEnergyInputRatioModifierFunctionofHighPartLoadRatioCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CoolingEnergyInputRatioModifierFunctionofHighPartLoadRatioCurveName,_curve->name().get());
}
}
// CoolingCombinationRatioCorrectionFactorCurveName
if( boost::optional<model::CurveCubic> curve = modelObject.coolingCombinationRatioCorrectionFactorCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CoolingCombinationRatioCorrectionFactorCurveName,_curve->name().get());
}
}
// CoolingPartLoadFractionCorrelationCurveName
if( boost::optional<model::CurveCubic> curve = modelObject.coolingPartLoadFractionCorrelationCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CoolingPartLoadFractionCorrelationCurveName,_curve->name().get());
}
}
// RatedTotalHeatingCapacity
if( modelObject.isRatedTotalHeatingCapacityAutosized() )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::RatedTotalHeatingCapacity,"Autosize");
}
else if( (value = modelObject.ratedTotalHeatingCapacity()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::RatedTotalHeatingCapacity,value.get());
}
// RatedTotalHeatingCapacitySizingRatio
if( (value = modelObject.ratedTotalHeatingCapacitySizingRatio()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::RatedTotalHeatingCapacitySizingRatio,value.get());
}
// RatedHeatingCOP
if( (value = modelObject.ratedHeatingCOP()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::RatedHeatingCOP,value.get());
}
// MinimumOutdoorTemperatureinHeatingMode
if( (value = modelObject.minimumOutdoorTemperatureinHeatingMode()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::MinimumOutdoorTemperatureinHeatingMode,value.get());
}
// MaximumOutdoorTemperatureinHeatingMode
if( (value = modelObject.maximumOutdoorTemperatureinHeatingMode()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::MaximumOutdoorTemperatureinHeatingMode,value.get());
}
// HeatingCapacityRatioModifierFunctionofLowTemperatureCurveName
if( boost::optional<model::CurveBiquadratic> curve = modelObject.heatingCapacityRatioModifierFunctionofLowTemperatureCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatingCapacityRatioModifierFunctionofLowTemperatureCurveName,_curve->name().get());
}
}
// HeatingCapacityRatioBoundaryCurveName
if( boost::optional<model::CurveCubic> curve = modelObject.heatingCapacityRatioBoundaryCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatingCapacityRatioBoundaryCurveName,_curve->name().get());
}
}
// HeatingCapacityRatioModifierFunctionofHighTemperatureCurveName
if( boost::optional<model::CurveBiquadratic> curve = modelObject.heatingCapacityRatioModifierFunctionofHighTemperatureCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatingCapacityRatioModifierFunctionofHighTemperatureCurveName,_curve->name().get());
}
}
// HeatingEnergyInputRatioModifierFunctionofLowTemperatureCurveName
if( boost::optional<model::CurveBiquadratic> curve = modelObject.heatingEnergyInputRatioModifierFunctionofLowTemperatureCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatingEnergyInputRatioModifierFunctionofLowTemperatureCurveName,_curve->name().get());
}
}
// HeatingEnergyInputRatioBoundaryCurveName
if( boost::optional<model::CurveCubic> curve = modelObject.heatingEnergyInputRatioBoundaryCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatingEnergyInputRatioBoundaryCurveName,_curve->name().get());
}
}
// HeatingEnergyInputRatioModifierFunctionofHighTemperatureCurveName
if( boost::optional<model::CurveBiquadratic> curve = modelObject.heatingEnergyInputRatioModifierFunctionofHighTemperatureCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatingEnergyInputRatioModifierFunctionofHighTemperatureCurveName,_curve->name().get());
}
}
// HeatingPerformanceCurveOutdoorTemperatureType
if( (s = modelObject.heatingPerformanceCurveOutdoorTemperatureType()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatingPerformanceCurveOutdoorTemperatureType,s.get());
}
// HeatingEnergyInputRatioModifierFunctionofLowPartLoadRatioCurveName
if( boost::optional<model::CurveCubic> curve = modelObject.heatingEnergyInputRatioModifierFunctionofLowPartLoadRatioCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatingEnergyInputRatioModifierFunctionofLowPartLoadRatioCurveName,_curve->name().get());
}
}
// HeatingEnergyInputRatioModifierFunctionofHighPartLoadRatioCurveName
if( boost::optional<model::CurveCubic> curve = modelObject.heatingEnergyInputRatioModifierFunctionofHighPartLoadRatioCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatingEnergyInputRatioModifierFunctionofHighPartLoadRatioCurveName,_curve->name().get());
}
}
// HeatingCombinationRatioCorrectionFactorCurveName
if( boost::optional<model::CurveCubic> curve = modelObject.heatingCombinationRatioCorrectionFactorCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatingCombinationRatioCorrectionFactorCurveName,_curve->name().get());
}
}
// HeatingPartLoadFractionCorrelationCurveName
if( boost::optional<model::CurveCubic> curve = modelObject.heatingPartLoadFractionCorrelationCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatingPartLoadFractionCorrelationCurveName,_curve->name().get());
}
}
// MinimumHeatPumpPartLoadRatio
if( (value = modelObject.minimumHeatPumpPartLoadRatio()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::MinimumHeatPumpPartLoadRatio,value.get());
}
// ZoneNameforMasterThermostatLocation
if( boost::optional<model::ThermalZone> zone = modelObject.zoneforMasterThermostatLocation() )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::ZoneNameforMasterThermostatLocation,zone->name().get());
}
// MasterThermostatPriorityControlType
if( (s = modelObject.masterThermostatPriorityControlType()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::MasterThermostatPriorityControlType,s.get());
}
// ThermostatPriorityScheduleName
if( boost::optional<model::Schedule> schedule = modelObject.thermostatPrioritySchedule() )
{
if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::ThermostatPriorityScheduleName,_schedule->name().get());
}
}
// HeatPumpWasteHeatRecovery
if( modelObject.heatPumpWasteHeatRecovery() )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatPumpWasteHeatRecovery,"Yes");
}
else
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatPumpWasteHeatRecovery,"No");
}
// EquivalentPipingLengthusedforPipingCorrectionFactorinCoolingMode
if( (value = modelObject.equivalentPipingLengthusedforPipingCorrectionFactorinCoolingMode()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::EquivalentPipingLengthusedforPipingCorrectionFactorinCoolingMode,value.get());
}
// VerticalHeightusedforPipingCorrectionFactor
if( (value = modelObject.verticalHeightusedforPipingCorrectionFactor()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::VerticalHeightusedforPipingCorrectionFactor,value.get());
}
// PipingCorrectionFactorforLengthinCoolingModeCurveName
if( boost::optional<model::CurveBiquadratic> curve = modelObject.pipingCorrectionFactorforLengthinCoolingModeCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::PipingCorrectionFactorforLengthinCoolingModeCurveName,_curve->name().get());
}
}
// PipingCorrectionFactorforHeightinCoolingModeCoefficient
if( (value = modelObject.pipingCorrectionFactorforHeightinCoolingModeCoefficient()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::PipingCorrectionFactorforHeightinCoolingModeCoefficient,value.get());
}
// EquivalentPipingLengthusedforPipingCorrectionFactorinHeatingMode
if( (value = modelObject.equivalentPipingLengthusedforPipingCorrectionFactorinHeatingMode()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::EquivalentPipingLengthusedforPipingCorrectionFactorinHeatingMode,value.get());
}
// PipingCorrectionFactorforLengthinHeatingModeCurveName
if( boost::optional<model::CurveCubic> curve = modelObject.pipingCorrectionFactorforLengthinHeatingModeCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::PipingCorrectionFactorforLengthinHeatingModeCurveName,_curve->name().get());
}
}
// PipingCorrectionFactorforHeightinHeatingModeCoefficient
if( (value = modelObject.pipingCorrectionFactorforHeightinHeatingModeCoefficient()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::PipingCorrectionFactorforHeightinHeatingModeCoefficient,value.get());
}
// CrankcaseHeaterPowerperCompressor
if( (value = modelObject.crankcaseHeaterPowerperCompressor()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::CrankcaseHeaterPowerperCompressor,value.get());
}
// NumberofCompressors
{
int number = modelObject.numberofCompressors();
idfObject.setUnsigned(AirConditioner_VariableRefrigerantFlowFields::NumberofCompressors,(unsigned)number);
}
// RatioofCompressorSizetoTotalCompressorCapacity
if( (value = modelObject.ratioofCompressorSizetoTotalCompressorCapacity()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::RatioofCompressorSizetoTotalCompressorCapacity,value.get());
}
// MaximumOutdoorDrybulbTemperatureforCrankcaseHeater
if( (value = modelObject.maximumOutdoorDrybulbTemperatureforCrankcaseHeater()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::MaximumOutdoorDrybulbTemperatureforCrankcaseHeater,value.get());
}
// DefrostStrategy
if( (s = modelObject.defrostStrategy()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::DefrostStrategy,s.get());
}
// DefrostControl
if( (s = modelObject.defrostControl()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::DefrostControl,s.get());
}
// DefrostEnergyInputRatioModifierFunctionofTemperatureCurveName
if( boost::optional<model::CurveBiquadratic> curve = modelObject.defrostEnergyInputRatioModifierFunctionofTemperatureCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::DefrostEnergyInputRatioModifierFunctionofTemperatureCurveName,_curve->name().get());
}
}
// DefrostTimePeriodFraction
if( (value = modelObject.defrostTimePeriodFraction()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::DefrostTimePeriodFraction,value.get());
}
// ResistiveDefrostHeaterCapacity
if( modelObject.isResistiveDefrostHeaterCapacityAutosized() )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::ResistiveDefrostHeaterCapacity,"Autosize");
}
else if( (value = modelObject.resistiveDefrostHeaterCapacity()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::ResistiveDefrostHeaterCapacity,value.get());
}
// MaximumOutdoorDrybulbTemperatureforDefrostOperation
if( (value = modelObject.maximumOutdoorDrybulbTemperatureforDefrostOperation()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::MaximumOutdoorDrybulbTemperatureforDefrostOperation,value.get());
}
// CondenserInletNodeName
if( boost::optional<model::ModelObject> mo = modelObject.inletModelObject() )
{
if( boost::optional<IdfObject> _mo = translateAndMapModelObject(mo.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CondenserInletNodeName,_mo->name().get());
}
}
// CondenserOutletNodeName
if( boost::optional<model::ModelObject> mo = modelObject.outletModelObject() )
{
if( boost::optional<IdfObject> _mo = translateAndMapModelObject(mo.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CondenserOutletNodeName,_mo->name().get());
}
}
// WaterCondenserVolumeFlowRate
if( modelObject.isWaterCondenserVolumeFlowRateAutosized() )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::WaterCondenserVolumeFlowRate,"Autosize");
}
else if( (value = modelObject.waterCondenserVolumeFlowRate()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::WaterCondenserVolumeFlowRate,value.get());
}
// EvaporativeCondenserEffectiveness
if( (value = modelObject.evaporativeCondenserEffectiveness()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::EvaporativeCondenserEffectiveness,value.get());
}
// EvaporativeCondenserAirFlowRate
if( modelObject.isEvaporativeCondenserAirFlowRateAutosized() )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::EvaporativeCondenserAirFlowRate,"Autosize");
}
else if( (value = modelObject.evaporativeCondenserAirFlowRate()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::EvaporativeCondenserAirFlowRate,value.get());
}
// EvaporativeCondenserPumpRatedPowerConsumption
if( modelObject.isEvaporativeCondenserPumpRatedPowerConsumptionAutosized() )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::EvaporativeCondenserPumpRatedPowerConsumption,"Autosize");
}
else if( ( value = modelObject.evaporativeCondenserPumpRatedPowerConsumption()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::EvaporativeCondenserPumpRatedPowerConsumption,value.get());
}
// BasinHeaterCapacity
if( (value = modelObject.basinHeaterCapacity()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::BasinHeaterCapacity,value.get());
}
// BasinHeaterSetpointTemperature
if( (value = modelObject.basinHeaterSetpointTemperature()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::BasinHeaterSetpointTemperature,value.get());
}
// BasinHeaterOperatingScheduleName
if( boost::optional<model::Schedule> schedule = modelObject.basinHeaterOperatingSchedule() )
{
if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::BasinHeaterOperatingScheduleName,_schedule->name().get());
}
}
// FuelType
if( (s = modelObject.fuelType()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::FuelType,s.get());
}
// MinimumOutdoorTemperatureinHeatRecoveryMode
if( (value = modelObject.minimumOutdoorTemperatureinHeatRecoveryMode()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::MinimumOutdoorTemperatureinHeatRecoveryMode,value.get());
}
// MaximumOutdoorTemperatureinHeatRecoveryMode
if( (value = modelObject.maximumOutdoorTemperatureinHeatingMode()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::MaximumOutdoorTemperatureinHeatRecoveryMode,value.get());
}
// HeatRecoveryCoolingCapacityModifierCurveName
if( boost::optional<model::CurveBiquadratic> curve = modelObject.heatRecoveryCoolingCapacityModifierCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryCoolingCapacityModifierCurveName,_curve->name().get());
}
}
// InitialHeatRecoveryCoolingCapacityFraction
if( (value = modelObject.initialHeatRecoveryCoolingEnergyFraction()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::InitialHeatRecoveryCoolingCapacityFraction,value.get());
}
// HeatRecoveryCoolingCapacityTimeConstant
if( (value = modelObject.heatRecoveryCoolingCapacityTimeConstant()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryCoolingCapacityTimeConstant,value.get());
}
// HeatRecoveryCoolingEnergyModifierCurveName
if( boost::optional<model::CurveBiquadratic> curve = modelObject.heatRecoveryCoolingEnergyModifierCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryCoolingEnergyModifierCurveName,_curve->name().get());
}
}
// InitialHeatRecoveryCoolingEnergyFraction
if( (value = modelObject.initialHeatRecoveryCoolingEnergyFraction()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::InitialHeatRecoveryCoolingEnergyFraction,value.get());
}
// HeatRecoveryCoolingEnergyTimeConstant
if( (value = modelObject.heatRecoveryCoolingEnergyTimeConstant()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryCoolingEnergyTimeConstant,value.get());
}
// HeatRecoveryHeatingCapacityModifierCurveName
if( boost::optional<model::CurveBiquadratic> curve = modelObject.heatRecoveryHeatingCapacityModifierCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryHeatingCapacityModifierCurveName,_curve->name().get());
}
}
// InitialHeatRecoveryHeatingCapacityFraction
if( (value = modelObject.initialHeatRecoveryHeatingCapacityFraction()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::InitialHeatRecoveryHeatingCapacityFraction,value.get());
}
// HeatRecoveryHeatingCapacityTimeConstant
if( (value = modelObject.heatRecoveryHeatingCapacityTimeConstant()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryHeatingCapacityTimeConstant,value.get());
}
// HeatRecoveryHeatingEnergyModifierCurveName
if( boost::optional<model::CurveBiquadratic> curve = modelObject.heatRecoveryHeatingEnergyModifierCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryHeatingEnergyModifierCurveName,_curve->name().get());
}
}
// InitialHeatRecoveryHeatingEnergyFraction
if( (value = modelObject.initialHeatRecoveryHeatingEnergyFraction()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::InitialHeatRecoveryHeatingEnergyFraction,value.get());
}
// HeatRecoveryHeatingEnergyTimeConstant
if( (value = modelObject.heatRecoveryHeatingEnergyTimeConstant()) )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryHeatingEnergyTimeConstant,value.get());
}
// Terminal Unit List
IdfObject _zoneTerminalUnitList(IddObjectType::ZoneTerminalUnitList);
std::string terminalUnitListName = modelObject.name().get() + " Terminal List";
_zoneTerminalUnitList.setString(ZoneTerminalUnitListFields::ZoneTerminalUnitListName,terminalUnitListName);
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::ZoneTerminalUnitListName,terminalUnitListName);
m_idfObjects.push_back(_zoneTerminalUnitList);
std::vector<ZoneHVACTerminalUnitVariableRefrigerantFlow> terminals = modelObject.terminals();
for( std::vector<ZoneHVACTerminalUnitVariableRefrigerantFlow>::iterator it = terminals.begin();
it != terminals.end();
it++ )
{
boost::optional<IdfObject> _terminal = translateAndMapModelObject(*it);
OS_ASSERT(_terminal);
IdfExtensibleGroup eg = _zoneTerminalUnitList.pushExtensibleGroup();
eg.setString(ZoneTerminalUnitListExtensibleFields::ZoneTerminalUnitName,_terminal->name().get());
}
// CondenserType
if( modelObject.plantLoop() )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CondenserType,"WaterCooled");
}
else
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CondenserType,"AirCooled");
}
// CondenserInletNodeName
OptionalModelObject omo = modelObject.inletModelObject();
if( omo )
{
translateAndMapModelObject(*omo);
s = omo->name();
if(s)
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CondenserInletNodeName,*s );
}
}
// CondenserOutletNodeName
omo = modelObject.outletModelObject();
if( omo )
{
translateAndMapModelObject(*omo);
s = omo->name();
if(s)
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::CondenserOutletNodeName,*s );
}
}
// WaterCondenserVolumeFlowRate
if( modelObject.isWaterCondenserVolumeFlowRateAutosized() )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::WaterCondenserVolumeFlowRate,"Autosize");
}
else if( value = modelObject.waterCondenserVolumeFlowRate() )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::WaterCondenserVolumeFlowRate,value.get());
}
// EvaporativeCondenserEffectiveness
if( value = modelObject.evaporativeCondenserEffectiveness() )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::EvaporativeCondenserEffectiveness,value.get());
}
// EvaporativeCondenserAirFlowRate
if( modelObject.isEvaporativeCondenserAirFlowRateAutosized() )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::EvaporativeCondenserAirFlowRate,"Autosize");
}
else if( value = modelObject.evaporativeCondenserAirFlowRate() )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::EvaporativeCondenserAirFlowRate,value.get());
}
// EvaporativeCondenserPumpRatedPowerConsumption
if( modelObject.isEvaporativeCondenserPumpRatedPowerConsumptionAutosized() )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::EvaporativeCondenserPumpRatedPowerConsumption,"Autosize");
}
else if( value = modelObject.evaporativeCondenserPumpRatedPowerConsumption() )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::EvaporativeCondenserPumpRatedPowerConsumption,value.get());
}
// BasinHeaterCapacity
if( value = modelObject.basinHeaterCapacity() )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::BasinHeaterCapacity,value.get());
}
// BasinHeaterSetpointTemperature
if( value = modelObject.basinHeaterSetpointTemperature() )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::BasinHeaterSetpointTemperature,value.get());
}
// BasinHeaterOperatingScheduleName
if( boost::optional<model::Schedule> schedule = modelObject.basinHeaterOperatingSchedule() )
{
if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::BasinHeaterOperatingScheduleName,_schedule->name().get());
}
}
// FuelType
if( s = modelObject.fuelType() )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::FuelType,s.get());
}
// MinimumOutdoorTemperatureinHeatRecoveryMode
if( value = modelObject.minimumOutdoorTemperatureinHeatRecoveryMode() )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::MinimumOutdoorTemperatureinHeatRecoveryMode,value.get());
}
// MaximumOutdoorTemperatureinHeatRecoveryMode
if( value = modelObject.maximumOutdoorTemperatureinHeatRecoveryMode() )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::MaximumOutdoorTemperatureinHeatRecoveryMode,value.get());
}
// HeatRecoveryCoolingCapacityModifierCurveName
if( boost::optional<model::CurveBiquadratic> curve = modelObject.heatRecoveryCoolingCapacityModifierCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryCoolingCapacityModifierCurveName,_curve->name().get());
}
}
// InitialHeatRecoveryCoolingCapacityFraction
if( value = modelObject.initialHeatRecoveryCoolingCapacityFraction() )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::InitialHeatRecoveryCoolingCapacityFraction,value.get());
}
// HeatRecoveryCoolingCapacityTimeConstant
if( value = modelObject.heatRecoveryCoolingEnergyTimeConstant() )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryCoolingCapacityTimeConstant,value.get());
}
// HeatRecoveryCoolingEnergyModifierCurveName
if( boost::optional<model::CurveBiquadratic> curve = modelObject.heatRecoveryCoolingEnergyModifierCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryCoolingEnergyModifierCurveName,_curve->name().get());
}
}
// InitialHeatRecoveryCoolingEnergyFraction
if( value = modelObject.initialHeatRecoveryCoolingEnergyFraction() )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::InitialHeatRecoveryCoolingEnergyFraction,value.get());
}
// HeatRecoveryCoolingEnergyTimeConstant
if( value = modelObject.heatRecoveryCoolingEnergyTimeConstant() )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryCoolingEnergyTimeConstant,value.get());
}
// HeatRecoveryHeatingCapacityModifierCurveName
if( boost::optional<model::CurveBiquadratic> curve = modelObject.heatRecoveryHeatingCapacityModifierCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryHeatingCapacityModifierCurveName,_curve->name().get());
}
}
// InitialHeatRecoveryHeatingCapacityFraction
if( value = modelObject.initialHeatRecoveryHeatingCapacityFraction() )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::InitialHeatRecoveryHeatingCapacityFraction,value.get());
}
// HeatRecoveryHeatingCapacityTimeConstant
if( value = modelObject.heatRecoveryHeatingCapacityTimeConstant() )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryHeatingCapacityTimeConstant,value.get());
}
// HeatRecoveryHeatingEnergyModifierCurveName
if( boost::optional<model::CurveBiquadratic> curve = modelObject.heatRecoveryHeatingEnergyModifierCurve() )
{
if( boost::optional<IdfObject> _curve = translateAndMapModelObject(curve.get()) )
{
idfObject.setString(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryHeatingEnergyModifierCurveName,_curve->name().get());
}
}
// InitialHeatRecoveryHeatingEnergyFraction
if( value = modelObject.initialHeatRecoveryHeatingEnergyFraction() )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::InitialHeatRecoveryHeatingEnergyFraction,value.get());
}
// HeatRecoveryHeatingEnergyTimeConstant
if( value = modelObject.heatRecoveryHeatingEnergyTimeConstant() )
{
idfObject.setDouble(AirConditioner_VariableRefrigerantFlowFields::HeatRecoveryHeatingEnergyTimeConstant,value.get());
}
return idfObject;
}
double CoilHeatingGasMultiStageStageData_Impl::parasiticElectricLoad() const {
boost::optional<double> value = getDouble(OS_Coil_Heating_Gas_MultiStage_StageDataFields::ParasiticElectricLoad,true);
OS_ASSERT(value);
return value.get();
}
DefaultSurfaceConstructions_Impl::DefaultSurfaceConstructions_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle)
: ResourceObject_Impl(idfObject,model,keepHandle)
{
OS_ASSERT(idfObject.iddObject().type() == DefaultSurfaceConstructions::iddObjectType());
}
WorkspaceObjectDiff::WorkspaceObjectDiff(unsigned index, boost::optional<std::string> oldValue, boost::optional<std::string> newValue,
boost::optional<UUID> oldHandle, boost::optional<UUID> newHandle)
: IdfObjectDiff(std::shared_ptr<detail::WorkspaceObjectDiff_Impl>(new detail::WorkspaceObjectDiff_Impl(index, oldValue, newValue, oldHandle, newHandle)))
{
OS_ASSERT(getImpl<detail::WorkspaceObjectDiff_Impl>());
}
void LostCloudConnectionDialog::createCloudConnectionWidgets(QVBoxLayout * vLayout)
{
QHBoxLayout * hLayout = 0;
QSpacerItem * horizontalSpacer = 0;
QPushButton * button = 0;
bool isConnected = false;
QLabel * label = 0;
label = new QLabel;
label->setText("<b>" + tr("Options to correct the problem:") + "</b>");
vLayout->addWidget(label);
hLayout = new QHBoxLayout;
hLayout->setContentsMargins(QMargins(0,0,0,0));
hLayout->setSpacing(5);
vLayout->addLayout(hLayout);
horizontalSpacer = new QSpacerItem(INDENT, 0, QSizePolicy::Fixed, QSizePolicy::Fixed);
hLayout->addSpacerItem(horizontalSpacer);
label = new QLabel;
label->setWordWrap(true);
label->setText("<b>" + tr("Try Again Later. ") + "</b>" + tr("Verify your computer's internet connection then click \"Lost Cloud Connection\" to recover the lost cloud session."));
hLayout->addWidget(label);
label = new QLabel;
label->setText("<b>" + tr("Or") + "</b>");
vLayout->addWidget(label);
hLayout = new QHBoxLayout;
hLayout->setContentsMargins(QMargins(0,0,0,0));
hLayout->setSpacing(5);
vLayout->addLayout(hLayout);
horizontalSpacer = new QSpacerItem(INDENT, 0, QSizePolicy::Fixed, QSizePolicy::Fixed);
hLayout->addSpacerItem(horizontalSpacer);
label = new QLabel;
label->setWordWrap(true);
label->setText("<b>" + tr("Stop Cloud. ") + "</b>" + tr("Disconnect from cloud. This option will make the failed cloud session unavaible to Pat. Any data that has not been downloaded to Pat will be lost. Use the AWS Console to verify that the Amazon service have been completely shutdown."));
hLayout->addWidget(label);
label = new QLabel;
label->setText("<b>" + tr("Or") + "</b>");
vLayout->addWidget(label);
hLayout = new QHBoxLayout;
hLayout->setContentsMargins(QMargins(0,0,0,0));
hLayout->setSpacing(5);
vLayout->addLayout(hLayout);
horizontalSpacer = new QSpacerItem(INDENT, 0, QSizePolicy::Fixed, QSizePolicy::Fixed);
hLayout->addSpacerItem(horizontalSpacer);
label = new QLabel;
label->setWordWrap(true);
label->setText("<b>" + tr("Launch AWS Console. ") + "</b>" + tr("Use the AWS Console to diagnose Amazon services. You may still attempt to recover the lost cloud session."));
hLayout->addWidget(label,0);
vLayout->addStretch();
hLayout = new QHBoxLayout;
hLayout->setContentsMargins(QMargins(0,0,0,0));
hLayout->setSpacing(5);
vLayout->addLayout(hLayout);
//horizontalSpacer = new QSpacerItem(INDENT, 0, QSizePolicy::Fixed, QSizePolicy::Fixed);
//hLayout->addSpacerItem(horizontalSpacer);
button = new OrangeButton(this);
button->setText("Launch AWS Console");
button->setCheckable(false);
isConnected = connect(button, SIGNAL(clicked(bool)),
this, SLOT(on_launchAWSConsole(bool)));
OS_ASSERT(isConnected);
hLayout->addWidget(button);
hLayout->addStretch();
button = new OrangeButton(this);
button->setText("Stop Cloud");
button->setCheckable(false);
isConnected = connect(button, SIGNAL(clicked(bool)),
this, SLOT(on_clearCloudSession(bool)));
OS_ASSERT(isConnected);
hLayout->addWidget(button);
button = new OrangeButton(this);
button->setText("Try Again Later");
button->setCheckable(false);
isConnected = connect(button, SIGNAL(clicked(bool)),
this, SLOT(accept()));
OS_ASSERT(isConnected);
hLayout->addWidget(button);
}
WorkspaceObjectDiff::WorkspaceObjectDiff(const std::shared_ptr<detail::WorkspaceObjectDiff_Impl>& impl)
: IdfObjectDiff(impl)
{
OS_ASSERT(getImpl<detail::WorkspaceObjectDiff_Impl>());
}
double AirGap_Impl::thermalConductance() const {
OS_ASSERT(thermalResistance());
return 1.0/thermalResistance();
}
IddObjectTypeVector::const_iterator ObjectOrderBase::getIterator(const IddObjectType& type) const {
OS_ASSERT(m_iddOrder);
return std::find(m_iddOrder->begin(),m_iddOrder->end(),type);
}
double GasEquipment_Impl::multiplier() const {
boost::optional<double> value = getDouble(OS_GasEquipmentFields::Multiplier,true);
OS_ASSERT(value);
return value.get();
}
std::string ScheduleTypeLimits_Impl::unitType() const {
boost::optional<std::string> value = getString(OS_ScheduleTypeLimitsFields::UnitType,true);
OS_ASSERT(value);
return value.get();
}
void GasEquipment_Impl::resetMultiplier() {
bool result = setString(OS_GasEquipmentFields::Multiplier, "");
OS_ASSERT(result);
}
FFactorGroundFloorConstruction_Impl::FFactorGroundFloorConstruction_Impl(
const IdfObject& idfObject, Model_Impl* model, bool keepHandle)
: ConstructionBase_Impl(idfObject, model, keepHandle)
{
OS_ASSERT(idfObject.iddObject().type() == FFactorGroundFloorConstruction::iddObjectType());
}
