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>());
}

//.........这里部分代码省略.........

  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);
 }

 double CoilHeatingGasMultiStageStageData_Impl::gasBurnerEfficiency() const {
   boost::optional<double> value = getDouble(OS_Coil_Heating_Gas_MultiStage_StageDataFields::GasBurnerEfficiency,true);
   OS_ASSERT(value);
   return value.get();
 }

//.........这里部分代码省略.........

  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

 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>());
}