Esempio n. 1
0
  std::vector<double> ScheduleDay_Impl::values() const {
    if (!m_cachedValues){

      std::vector<double> result;

      for (const IdfExtensibleGroup& group : extensibleGroups()) {
        OptionalDouble value = group.getDouble(OS_Schedule_DayExtensibleFields::ValueUntilTime, true);

        if (value){
          result.push_back(*value);
        }else{
          LOG(Error, "Could not read value " << group.groupIndex() << " in " << briefDescription() << "." );
        }
      }

      m_cachedValues = result;
    }

    return m_cachedValues.get();
  }
Esempio n. 2
0
  std::vector<ScheduleWeek> ScheduleYear_Impl::scheduleWeeks() const
  {
    std::vector<ScheduleWeek> result;

    for (const ModelExtensibleGroup& group : castVector<ModelExtensibleGroup>(this->extensibleGroups()))
    {
      OptionalWorkspaceObject object = group.getTarget(2);
      if (object){
        boost::optional<ScheduleWeek> schedule = object->optionalCast<ScheduleWeek>();

        if (schedule){
          result.push_back(*schedule);
        }else{
          LOG(Error, "Could not read schedule " << group.groupIndex() << " in " << briefDescription() << "." );
        }
      }
    }

    return result;
  }
Esempio n. 3
0
void NamespaceDef::writeBriefDescription(OutputList &ol)
{
  if (hasBriefDescription())
  {
    DocRoot *rootNode = validatingParseDoc(briefFile(),briefLine(),this,0,
                        briefDescription(),TRUE,FALSE,0,TRUE,FALSE);
    if (rootNode && !rootNode->isEmpty())
    {
      ol.startParagraph();
      ol.pushGeneratorState();
      ol.disableAllBut(OutputGenerator::Man);
      ol.writeString(" - ");
      ol.popGeneratorState();
      ol.writeDoc(rootNode,this,0);
      ol.pushGeneratorState();
      ol.disable(OutputGenerator::RTF);
      ol.writeString(" \n");
      ol.enable(OutputGenerator::RTF);

      if (hasDetailedDescription())
      {
        ol.disableAllBut(OutputGenerator::Html);
        ol.startTextLink(0,"details");
        ol.parseText(theTranslator->trMore());
        ol.endTextLink();
      }
      ol.popGeneratorState();
      ol.endParagraph();
    }
    delete rootNode;

    // FIXME:PARA
    //ol.pushGeneratorState();
    //ol.disable(OutputGenerator::RTF);
    //ol.newParagraph();
    //ol.popGeneratorState();
  }
  ol.writeSynopsis();
}
Esempio n. 4
0
void DirDef::writeBriefDescription(OutputList &ol)
{
  if (hasBriefDescription())
  {
    DocRoot *rootNode = validatingParseDoc(
         briefFile(),briefLine(),this,0,briefDescription(),TRUE,FALSE);
    if (rootNode && !rootNode->isEmpty())
    {
      ol.startParagraph();
      ol.pushGeneratorState();
      ol.disableAllBut(OutputGenerator::Man);
      ol.writeString(" - ");
      ol.popGeneratorState();
      ol.writeDoc(rootNode,this,0);
      ol.pushGeneratorState();
      ol.disable(OutputGenerator::RTF);
      ol.writeString(" \n");
      ol.enable(OutputGenerator::RTF);

      if (Config_getBool(REPEAT_BRIEF) ||
          !documentation().isEmpty()
         )
      {
        ol.disableAllBut(OutputGenerator::Html);
        ol.startTextLink(0,"details");
        ol.parseText(theTranslator->trMore());
        ol.endTextLink();
      }
      ol.popGeneratorState();

      ol.endParagraph();
    }
    delete rootNode;
  }
  ol.writeSynopsis();
}
ZoneHVACLowTempRadiantVarFlow::ZoneHVACLowTempRadiantVarFlow(const Model& model,
                                                             Schedule& availabilitySchedule,
                                                             HVACComponent& heatingCoil,
                                                             HVACComponent& coolingCoil)
                                                             
  : ZoneHVACComponent(ZoneHVACLowTempRadiantVarFlow::iddObjectType(),model)
{
  OS_ASSERT(getImpl<detail::ZoneHVACLowTempRadiantVarFlow_Impl>());

  bool ok = setAvailabilitySchedule(availabilitySchedule);
  
  if (!ok) 
  {
    remove();
    LOG_AND_THROW("Unable to set " << briefDescription() << "'s availability schedule to "
                  << availabilitySchedule.briefDescription() << ".");
  }
  
  ok = setHeatingCoil(heatingCoil);
  OS_ASSERT(ok);

  ok = setCoolingCoil(coolingCoil);
  OS_ASSERT(ok);
} 
  bool LayeredConstruction_Impl::setLayer(unsigned layerIndex, 
                                          const Material& material)
  {
    OS_ASSERT(material.model() == model());
    layerIndex = mf_clearNullLayers(layerIndex);
    if (layerIndex >= numLayers()) {
      LOG(Info,"Asked to change the Material at layer " << layerIndex << " in "
          << briefDescription() << ", but there are only " << numLayers() << " layers.");
      return false;
    }

    MaterialVector layers = this->layers();
    layers[layerIndex] = material;
    if ((model().strictnessLevel() < StrictnessLevel::Final) || 
        LayeredConstruction::layersAreValid(layers)) {
      ModelExtensibleGroup group = getExtensibleGroup(layerIndex).cast<ModelExtensibleGroup>();
      OS_ASSERT(!group.empty());
      bool ok = group.setPointer(0,material.handle());
      OS_ASSERT(ok);
      return true;
    }

    return false;
  }
boost::optional<IdfObject> ForwardTranslator::translateAvailabilityManagerHybridVentilation( 
    AvailabilityManagerHybridVentilation & modelObject)
{
  IdfObject idfObject(IddObjectType::AvailabilityManager_HybridVentilation);
  m_idfObjects.push_back(idfObject);

  boost::optional<AirLoopHVAC> airLoopHVAC;
  if( auto loop = modelObject.loop() ) {
    airLoopHVAC = loop->optionalCast<model::AirLoopHVAC>();
  }

  // Name
  if( auto s = modelObject.name() ) {
    idfObject.setName(*s);
  }

  // HVACAirLoopName
  if( auto loop = modelObject.loop() ) {
    idfObject.setString(AvailabilityManager_HybridVentilationFields::HVACAirLoopName,loop->name().get());
  }

  // ControlledZoneName
  if( auto zone = modelObject.controlledZone() ) {
    idfObject.setString(AvailabilityManager_HybridVentilationFields::ControlledZoneName,zone->name().get());
  } else {
    if( airLoopHVAC ) {
      auto zones = airLoopHVAC->thermalZones(); 
      if( ! zones.empty() ) {
        auto default_zone = zones.front();
        LOG(Info,modelObject.briefDescription() << " is missing Control Zone Name, defaulting to " << default_zone.briefDescription() << ".");
        idfObject.setString(AvailabilityManager_HybridVentilationFields::ControlledZoneName,default_zone.name().get());
      }
    }
  }

  // VentilationControlModeScheduleName
  {
    auto schedule = modelObject.ventilationControlModeSchedule();
    idfObject.setString(AvailabilityManager_HybridVentilationFields::VentilationControlModeScheduleName,schedule.name().get());    
  }

  // UseWeatherFileRainIndicators
  {
    if( modelObject.useWeatherFileRainIndicators() ) {
      idfObject.setString(AvailabilityManager_HybridVentilationFields::UseWeatherFileRainIndicators,"Yes");
    } else {
      idfObject.setString(AvailabilityManager_HybridVentilationFields::UseWeatherFileRainIndicators,"No");
    }
  }

  // MaximumWindSpeed
  {
    auto value = modelObject.maximumWindSpeed();
    idfObject.setDouble(AvailabilityManager_HybridVentilationFields::MaximumWindSpeed,value);
  }

  // MinimumOutdoorTemperature
  {
    auto value = modelObject.minimumOutdoorTemperature();
    idfObject.setDouble(AvailabilityManager_HybridVentilationFields::MinimumOutdoorTemperature,value);
  }

  // MaximumOutdoorTemperature
  {
    auto value = modelObject.maximumOutdoorTemperature();
    idfObject.setDouble(AvailabilityManager_HybridVentilationFields::MaximumOutdoorTemperature,value);
  }

  // MinimumOutdoorEnthalpy
  {
    auto value = modelObject.minimumOutdoorEnthalpy();
    idfObject.setDouble(AvailabilityManager_HybridVentilationFields::MinimumOutdoorEnthalpy,value);
  }

  // MaximumOutdoorEnthalpy
  {
    auto value = modelObject.maximumOutdoorEnthalpy();
    idfObject.setDouble(AvailabilityManager_HybridVentilationFields::MaximumOutdoorEnthalpy,value);
  }

  // MinimumOutdoorDewpoint
  {
    auto value = modelObject.minimumOutdoorDewpoint();
    idfObject.setDouble(AvailabilityManager_HybridVentilationFields::MinimumOutdoorDewpoint,value);
  }

  // MaximumOutdoorDewpoint
  {
    auto value = modelObject.maximumOutdoorDewpoint();
    idfObject.setDouble(AvailabilityManager_HybridVentilationFields::MaximumOutdoorDewpoint,value);
  }

  // MinimumOutdoorVentilationAirScheduleName
  { 
    auto schedule = modelObject.minimumOutdoorVentilationAirSchedule();
    idfObject.setString(AvailabilityManager_HybridVentilationFields::MinimumOutdoorVentilationAirScheduleName,schedule.name().get());
  }

  // OpeningFactorFunctionofWindSpeedCurveName
  if( auto curve = modelObject.openingFactorFunctionofWindSpeedCurve() ) {
    auto idf = translateAndMapModelObject(curve.get());
    OS_ASSERT(idf);
    idfObject.setString(AvailabilityManager_HybridVentilationFields::OpeningFactorFunctionofWindSpeedCurveName,idf->name().get());
  }

  return idfObject;
}
Esempio n. 8
0
bool DirDef::hasDetailedDescription() const
{
  static bool repeatBrief = Config_getBool(REPEAT_BRIEF);
  return (!briefDescription().isEmpty() && repeatBrief) || !documentation().isEmpty();
}
Esempio n. 9
0
bool NamespaceDef::hasDetailedDescription() const
{
    static bool repeatBrief = Config_getBool("REPEAT_BRIEF");
    return ((!briefDescription().isEmpty() && repeatBrief) ||
            !documentation().isEmpty());
}
  std::vector<SpectralDataField> MaterialPropertyGlazingSpectralData_Impl::spectralDataFields() const
  {
    std::vector<SpectralDataField> result;

    for (const ModelExtensibleGroup& group : castVector<ModelExtensibleGroup>(extensibleGroups()))
    {
      OptionalDouble wavelength = group.getDouble(OS_MaterialProperty_GlazingSpectralDataExtensibleFields::Wavelength);
      OptionalDouble transmittance = group.getDouble(OS_MaterialProperty_GlazingSpectralDataExtensibleFields::Transmittance);
      OptionalDouble frontReflectance = group.getDouble(OS_MaterialProperty_GlazingSpectralDataExtensibleFields::FrontReflectance);
      OptionalDouble backReflectance = group.getDouble(OS_MaterialProperty_GlazingSpectralDataExtensibleFields::BackReflectance);

      if (wavelength && transmittance && frontReflectance && backReflectance){
        result.push_back(SpectralDataField(*wavelength, *transmittance, *frontReflectance, *backReflectance));
      }else{
        LOG(Error, "Could not read SpectralDataField " << group.groupIndex() << " in " << briefDescription() << "." );
      }
    }

    return result;
  }
boost::optional<IdfObject> ForwardTranslator::translateWaterHeaterHeatPump( 
    WaterHeaterHeatPump & modelObject)
{
  IdfObject idfObject(IddObjectType::WaterHeater_HeatPump_PumpedCondenser);
  m_idfObjects.push_back(idfObject);

  // Name
  if( auto s = modelObject.name() ) {
    idfObject.setName(*s);
  }

  if( auto mo = modelObject.availabilitySchedule() ) {
    idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::AvailabilityScheduleName,mo->name().get());
  }

  {
    auto mo = modelObject.compressorSetpointTemperatureSchedule();
    idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::CompressorSetpointTemperatureScheduleName,mo.name().get());
  }

  {
    auto value = modelObject.deadBandTemperatureDifference();
    idfObject.setDouble(WaterHeater_HeatPump_PumpedCondenserFields::DeadBandTemperatureDifference,value);
  }

  if( modelObject.isCondenserWaterFlowRateAutosized() ) {
    idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::CondenserWaterFlowRate,"Autosize");
  } else if( auto value = modelObject.condenserWaterFlowRate() ) {
    idfObject.setDouble(WaterHeater_HeatPump_PumpedCondenserFields::CondenserWaterFlowRate,value.get());
  }

  if( modelObject.isEvaporatorAirFlowRateAutosized() ) {
    idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::EvaporatorAirFlowRate,"Autosize");
  } else if( auto value = modelObject.evaporatorAirFlowRate() ) {
    idfObject.setDouble(WaterHeater_HeatPump_PumpedCondenserFields::EvaporatorAirFlowRate,value.get());
  }

  {
    auto value = modelObject.inletAirConfiguration();
    idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::InletAirConfiguration,value);
  }

  if( auto mo = modelObject.inletAirTemperatureSchedule() ) {
    idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::InletAirTemperatureScheduleName,mo->name().get());
  }

  if( auto mo = modelObject.inletAirHumiditySchedule() ) {
    idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::InletAirHumidityScheduleName,mo->name().get());
  }

  {
    auto value = modelObject.minimumInletAirTemperatureforCompressorOperation();
    idfObject.setDouble(WaterHeater_HeatPump_PumpedCondenserFields::MinimumInletAirTemperatureforCompressorOperation,value);
  }

  {
    auto value = modelObject.compressorLocation();
    idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::CompressorLocation,value);
  }

  if( auto mo = modelObject.compressorAmbientTemperatureSchedule() ) {
    idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::CompressorAmbientTemperatureScheduleName,mo->name().get());
  }

  {
    auto value = modelObject.fanPlacement();
    idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::FanPlacement,value);
  }

  {
    auto value = modelObject.onCycleParasiticElectricLoad();
    idfObject.setDouble(WaterHeater_HeatPump_PumpedCondenserFields::OnCycleParasiticElectricLoad,value);
  }

  {
    auto value = modelObject.offCycleParasiticElectricLoad();
    idfObject.setDouble(WaterHeater_HeatPump_PumpedCondenserFields::OffCycleParasiticElectricLoad,value);
  }

  {
    auto value = modelObject.parasiticHeatRejectionLocation();
    idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::ParasiticHeatRejectionLocation,value);
  }

  {
    auto mo = modelObject.inletAirMixerSchedule();
    idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::InletAirMixerScheduleName,mo.name().get());
  }

  {
    auto tank = modelObject.tank();
    if( auto stratifiedTank = tank.optionalCast<model::WaterHeaterStratified>() ) {
      auto value = modelObject.controlSensorLocationInStratifiedTank();
      if( istringEqual(value,"Heater1") ) {
        auto height = stratifiedTank->heater1Height();
        idfObject.setDouble(WaterHeater_HeatPump_PumpedCondenserFields::ControlSensor1HeightInStratifiedTank,height);
      } else if( istringEqual(value,"Heater2") ) {
        auto height = stratifiedTank->heater2Height();
        idfObject.setDouble(WaterHeater_HeatPump_PumpedCondenserFields::ControlSensor1HeightInStratifiedTank,height);
      } else if( istringEqual(value,"SourceInlet") ) {
        if( auto height = stratifiedTank->sourceSideInletHeight() ) {
          idfObject.setDouble(WaterHeater_HeatPump_PumpedCondenserFields::ControlSensor1HeightInStratifiedTank,height.get());
        }
      } else if( istringEqual(value,"SourceOutlet") ) {
        auto height = stratifiedTank->sourceSideOutletHeight();
        idfObject.setDouble(WaterHeater_HeatPump_PumpedCondenserFields::ControlSensor1HeightInStratifiedTank,height);
      } else if( istringEqual(value,"UseInlet") ) {
        auto height = stratifiedTank->useSideInletHeight();
        idfObject.setDouble(WaterHeater_HeatPump_PumpedCondenserFields::ControlSensor1HeightInStratifiedTank,height);
      } else if( istringEqual(value,"UseOutlet") ) {
        if( auto height = stratifiedTank->useSideOutletHeight() ) {
          idfObject.setDouble(WaterHeater_HeatPump_PumpedCondenserFields::ControlSensor1HeightInStratifiedTank,height.get());
        }
      }
    }
  }

  std::string condOutletTankInletNodeName =
    modelObject.name().get() + " Condenser Outlet - Tank Inlet";

  std::string tankOutletCondInletNodeName = 
    modelObject.name().get() + " Tank Outlet - Condenser Inlet";

  idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::CondenserWaterInletNodeName,tankOutletCondInletNodeName);
  idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::CondenserWaterOutletNodeName,condOutletTankInletNodeName);

  std::string airInletNodeName;
  std::string airOutletNodeName;
  std::string outdoorAirNodeName;
  std::string exhaustAirNodeName;
  std::string inletAirZoneName;
  std::string inletAirMixerNodeName;
  std::string outletAirSplitterNodeName;
  std::string fanInletNodeName;
  std::string fanOutletNodeName;
  std::string evapInletNodeName;
  std::string evapOutletNodeName;

  auto inletAirConfiguration = modelObject.inletAirConfiguration();
  if( istringEqual(modelObject.fanPlacement(),"DrawThrough") ) {

    if( istringEqual(inletAirConfiguration,"ZoneAirOnly") ) {
      if( auto thermalZone = modelObject.thermalZone() ) {
        auto inletNode = modelObject.inletNode();
        OS_ASSERT(inletNode);
        airInletNodeName = inletNode->name().get();

        auto outletNode = modelObject.outletNode();
        OS_ASSERT(outletNode);
        airOutletNodeName = outletNode->name().get();
        
        inletAirZoneName = thermalZone->name().get();
        fanInletNodeName = modelObject.name().get() + " Evap Outlet - Fan Inlet";
        fanOutletNodeName = airOutletNodeName;
        evapInletNodeName = airInletNodeName;
        evapOutletNodeName = fanInletNodeName;
      }
    } else if( istringEqual(inletAirConfiguration,"ZoneAndOutdoorAir") ) {
      if( auto thermalZone = modelObject.thermalZone() ) {
        auto inletNode = modelObject.inletNode();
        OS_ASSERT(inletNode);
        airInletNodeName = inletNode->name().get();

        auto outletNode = modelObject.outletNode();
        OS_ASSERT(outletNode);
        airOutletNodeName = outletNode->name().get();

        outdoorAirNodeName = modelObject.name().get() + " Outdoor Air";
        exhaustAirNodeName = modelObject.name().get() + " Exhaust Air";
        inletAirZoneName = thermalZone->name().get();
        inletAirMixerNodeName = modelObject.name().get() + " Mixer Outlet - Evap Inlet";
        outletAirSplitterNodeName = modelObject.name().get() + " Fan Outlet - Splitter Inlet";
        fanInletNodeName = modelObject.name().get() + " Evap Outlet - Fan Inlet";
        fanOutletNodeName = outletAirSplitterNodeName;
        evapInletNodeName = inletAirMixerNodeName;
        evapOutletNodeName = fanInletNodeName;
      }
    } else if( istringEqual(inletAirConfiguration,"OutdoorAirOnly") ) {
      outdoorAirNodeName = modelObject.name().get() + " Outdoor Air";
      exhaustAirNodeName = modelObject.name().get() + " Exhaust Air";
      fanInletNodeName = modelObject.name().get() + " Evap Outlet - Fan Inlet";
      fanOutletNodeName = exhaustAirNodeName;
      evapInletNodeName = outdoorAirNodeName;
      evapOutletNodeName = fanInletNodeName;
    } else if( istringEqual(inletAirConfiguration,"Schedule") ) {
      airInletNodeName = modelObject.name().get() + " Inlet";
      airOutletNodeName = modelObject.name().get() + " Outlet";
      fanInletNodeName = modelObject.name().get() + " Evap Outlet - Fan Inlet";
      fanOutletNodeName = airOutletNodeName;
      evapInletNodeName = airInletNodeName;
      evapOutletNodeName = fanInletNodeName;
    }

  } else { // BlowThrough

    if( istringEqual(inletAirConfiguration,"ZoneAirOnly") ) {
      if( auto thermalZone = modelObject.thermalZone() ) {
        auto inletNode = modelObject.inletNode();
        OS_ASSERT(inletNode);
        airInletNodeName = inletNode->name().get();

        auto outletNode = modelObject.outletNode();
        OS_ASSERT(outletNode);
        airOutletNodeName = outletNode->name().get();
        
        inletAirZoneName = thermalZone->name().get();
        fanInletNodeName = airInletNodeName;
        fanOutletNodeName = modelObject.name().get() + " Fan Outlet - Evap Inlet";
        evapInletNodeName = fanOutletNodeName;
        evapOutletNodeName = airOutletNodeName;
      }
    } else if( istringEqual(inletAirConfiguration,"ZoneAndOutdoorAir") ) {
      if( auto thermalZone = modelObject.thermalZone() ) {
        auto inletNode = modelObject.inletNode();
        OS_ASSERT(inletNode);
        airInletNodeName = inletNode->name().get();

        auto outletNode = modelObject.outletNode();
        OS_ASSERT(outletNode);
        airOutletNodeName = outletNode->name().get();

        outdoorAirNodeName = modelObject.name().get() + " Outdoor Air";
        exhaustAirNodeName = modelObject.name().get() + " Exhaust Air";
        inletAirZoneName = thermalZone->name().get();
        inletAirMixerNodeName = modelObject.name().get() + " Mixer Outlet - Fan Inlet";
        outletAirSplitterNodeName = modelObject.name().get() + " Evap Outlet - Splitter Inlet";
        fanInletNodeName = inletAirMixerNodeName;
        fanOutletNodeName = modelObject.name().get() + " Fan Outlet - Evap Inlet";
        evapInletNodeName = fanOutletNodeName;
        evapOutletNodeName = outletAirSplitterNodeName;
      }
    } else if( istringEqual(inletAirConfiguration,"OutdoorAirOnly") ) {
      outdoorAirNodeName = modelObject.name().get() + " Outdoor Air";
      exhaustAirNodeName = modelObject.name().get() + " Exhaust Air";
      fanInletNodeName = outdoorAirNodeName;
      fanOutletNodeName = modelObject.name().get() + " Fan Outlet - Evap Inlet";
      evapInletNodeName = fanOutletNodeName;
      evapOutletNodeName = exhaustAirNodeName;
    } else if( istringEqual(inletAirConfiguration,"Schedule") ) {
      airInletNodeName = modelObject.name().get() + " Inlet";
      airOutletNodeName = modelObject.name().get() + " Outlet";
      fanInletNodeName = airInletNodeName;
      fanOutletNodeName = modelObject.name().get() + " Fan Outlet - Evap Inlet";
      evapInletNodeName = fanOutletNodeName;
      evapOutletNodeName = airOutletNodeName;
    }

  }

  {
    auto mo = modelObject.tank();
    if( auto idf = translateAndMapModelObject(mo) ) {
      idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::TankName,idf->name().get());
      idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::TankObjectType,idf->iddObject().name());
      if( mo.iddObjectType() == model::WaterHeaterMixed::iddObjectType() ) {
        idf->setString(WaterHeater_MixedFields::SourceSideOutletNodeName,tankOutletCondInletNodeName);
        idf->setString(WaterHeater_MixedFields::SourceSideInletNodeName,condOutletTankInletNodeName);
        auto waterHeaterMixed = mo.cast<model::WaterHeaterMixed>();
        if( auto node = waterHeaterMixed.supplyInletModelObject() ) {
          idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::TankUseSideInletNodeName,node->name().get());
        }
        if( auto node = waterHeaterMixed.supplyOutletModelObject() ) {
          idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::TankUseSideOutletNodeName,node->name().get());
        }
      } else if( mo.iddObjectType() == model::WaterHeaterStratified::iddObjectType() ) {
        idf->setString(WaterHeater_StratifiedFields::SourceSideOutletNodeName,tankOutletCondInletNodeName);
        idf->setString(WaterHeater_StratifiedFields::SourceSideInletNodeName,condOutletTankInletNodeName);
        auto waterHeaterStratified = mo.cast<model::WaterHeaterStratified>();
        if( auto node = waterHeaterStratified.supplyInletModelObject() ) {
          idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::TankUseSideInletNodeName,node->name().get());
        }
        if( auto node = waterHeaterStratified.supplyOutletModelObject() ) {
          idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::TankUseSideOutletNodeName,node->name().get());
        }
      } else {
        LOG(Error, modelObject.briefDescription() << " is attached to an unsupported type of tank: " << mo.briefDescription() );
      }
    }
  }

  {
    auto mo = modelObject.dXCoil();
    if( auto idf = translateAndMapModelObject(mo) ) {
      idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::DXCoilName,idf->name().get());
      idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::DXCoilObjectType,idf->iddObject().name());
      if( mo.iddObjectType() == model::CoilWaterHeatingAirToWaterHeatPump::iddObjectType() ) {
        idf->setString(Coil_WaterHeating_AirToWaterHeatPump_PumpedFields::CondenserWaterInletNodeName,tankOutletCondInletNodeName);
        idf->setString(Coil_WaterHeating_AirToWaterHeatPump_PumpedFields::CondenserWaterOutletNodeName,condOutletTankInletNodeName);
        idf->setString(Coil_WaterHeating_AirToWaterHeatPump_PumpedFields::EvaporatorAirInletNodeName,evapInletNodeName);
        idf->setString(Coil_WaterHeating_AirToWaterHeatPump_PumpedFields::EvaporatorAirOutletNodeName,evapOutletNodeName);
      } else {
        LOG(Error, modelObject.briefDescription() << " is attached to an unsupported type of coil: " << mo.briefDescription() );
      }
    }
  }

  {
    auto mo = modelObject.fan();
    if( auto idf = translateAndMapModelObject(mo) ) {
      idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::FanName,idf->name().get());
      idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::FanObjectType,idf->iddObject().name());
      if( mo.iddObjectType() == model::FanOnOff::iddObjectType() ) {
        idf->setString(Fan_OnOffFields::AirInletNodeName,fanInletNodeName);
        idf->setString(Fan_OnOffFields::AirOutletNodeName,fanOutletNodeName);
      } else {
        LOG(Error, modelObject.briefDescription() << " is attached to an unsupported type of fan: " << mo.briefDescription() );
      }
    }
  }

  idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::AirInletNodeName,airInletNodeName);
  idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::AirOutletNodeName,airOutletNodeName);
  idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::OutdoorAirNodeName,outdoorAirNodeName);
  idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::ExhaustAirNodeName,exhaustAirNodeName);
  idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::InletAirZoneName,inletAirZoneName);
  idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::InletAirMixerNodeName,inletAirMixerNodeName);
  idfObject.setString(WaterHeater_HeatPump_PumpedCondenserFields::OutletAirSplitterNodeName,outletAirSplitterNodeName);

  return idfObject;
}
void NamespaceDef::writeDocumentation(OutputList &ol)
{
  QCString pageTitle;
  if (Config_getBool("OPTIMIZE_OUTPUT_JAVA"))
  {
    pageTitle = theTranslator->trPackage(displayName());
  }
  else
  {
    pageTitle = theTranslator->trNamespaceReference(displayName());
  }
  startFile(ol,getOutputFileBase(),name(),pageTitle,HLI_NamespaceVisible);
  if (getOuterScope()!=Doxygen::globalScope)
  {
    writeNavigationPath(ol);
  }
  startTitle(ol,getOutputFileBase());
  ol.parseText(pageTitle);
  addGroupListToTitle(ol,this);
  endTitle(ol,getOutputFileBase(),displayName());
  
  if (Config_getBool("SEARCHENGINE"))
  {
    Doxygen::searchIndex->setCurrentDoc(pageTitle,getOutputFileBase());
    Doxygen::searchIndex->addWord(localName(),TRUE);
  }

  if (!Config_getString("GENERATE_TAGFILE").isEmpty())
  {
    Doxygen::tagFile << "  <compound kind=\"namespace\">" << endl;
    Doxygen::tagFile << "    <name>" << convertToXML(name()) << "</name>" << endl;
    Doxygen::tagFile << "    <filename>" << convertToXML(getOutputFileBase()) << Doxygen::htmlFileExtension << "</filename>" << endl;
  }
  
  ol.startTextBlock();
    
  if (Config_getBool("DETAILS_AT_TOP"))
  {
    writeDetailedDocumentation(ol);
    ol.newParagraph();
  }
  else if (!briefDescription().isEmpty()) 
  {
    ol.parseDoc(briefFile(),briefLine(),this,0,briefDescription(),TRUE,FALSE);
    ol.writeString(" \n");
    ol.pushGeneratorState();
    ol.disableAllBut(OutputGenerator::Html);
    ol.startTextLink(0,"_details");
    ol.parseText(theTranslator->trMore());
    ol.endTextLink();
    ol.enableAll();
    ol.disableAllBut(OutputGenerator::Man);
    ol.newParagraph();
    ol.popGeneratorState();
  }
  ol.disable(OutputGenerator::Man);
  ol.newParagraph();
  ol.enable(OutputGenerator::Man);
  ol.writeSynopsis();

  ol.endTextBlock();
  
  ol.startMemberSections();
  classSDict->writeDeclaration(ol,0,0,TRUE);

  namespaceSDict->writeDeclaration(ol,TRUE);

  /* write user defined member groups */
  MemberGroupSDict::Iterator mgli(*memberGroupSDict);
  MemberGroup *mg;
  for (;(mg=mgli.current());++mgli)
  {
    mg->writeDeclarations(ol,0,this,0,0);
  }

  //allMemberList.writeDeclarations(ol,0,this,0,0,0,0);
  decDefineMembers.writeDeclarations(ol,0,this,0,0,theTranslator->trDefines(),0);
  decProtoMembers.writeDeclarations(ol,0,this,0,0,theTranslator->trFuncProtos(),0);
  decTypedefMembers.writeDeclarations(ol,0,this,0,0,theTranslator->trTypedefs(),0);
  decEnumMembers.writeDeclarations(ol,0,this,0,0,theTranslator->trEnumerations(),0);
  decFuncMembers.writeDeclarations(ol,0,this,0,0,theTranslator->trFunctions(),0);
  decVarMembers.writeDeclarations(ol,0,this,0,0,theTranslator->trVariables(),0);
  ol.endMemberSections();
  
  if (!Config_getBool("DETAILS_AT_TOP"))
  {
    writeDetailedDocumentation(ol);
  }

  writeMemberDocumentation(ol);

  // write Author section (Man only)
  ol.pushGeneratorState();
  ol.disableAllBut(OutputGenerator::Man);
  ol.startGroupHeader();
  ol.parseText(theTranslator->trAuthor(TRUE,TRUE));
  ol.endGroupHeader();
  ol.parseText(theTranslator->trGeneratedAutomatically(Config_getString("PROJECT_NAME")));

  if (!Config_getString("GENERATE_TAGFILE").isEmpty()) 
  {
    writeDocAnchorsToTagFile();
    Doxygen::tagFile << "  </compound>" << endl;
  }

  ol.popGeneratorState();
  endFile(ol);

  if (Config_getBool("SEPARATE_MEMBER_PAGES"))
  {
    allMemberList.sort();
    writeMemberPages(ol);
  }
}
 bool AirTerminalSingleDuctConstantVolumeFourPipeBeam_Impl::setHeatingCoil(const HVACComponent& coilHeatingFourPipeBeam) {
   bool result = setPointer(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeBeamFields::HeatingCoilName, coilHeatingFourPipeBeam.handle());
   if (!result) {
     if ( !coilHeatingFourPipeBeam.optionalCast<CoilHeatingFourPipeBeam>() ) {
       LOG(Error, "Cannot set the heating coil to something else than CoilHeatingFourPipeBeam for " << briefDescription());
     }
   }
   return result;
 }
Esempio n. 14
0
bool Definition::hasBriefDescription() const
{
  static bool briefMemberDesc = Config_getBool("BRIEF_MEMBER_DESC");
  return !briefDescription().isEmpty() && briefMemberDesc;
}
 unsigned AirTerminalDualDuctVAVOutdoorAir_Impl::newInletPortAfterBranch(unsigned branchIndex) {
   LOG(Warn, "newInletPortAfterBranch is not supported for " << briefDescription() << " .");
   LOG(Warn, "Ports cannot be added or removed for " << briefDescription() << " .");
   return std::numeric_limits<unsigned>::max();
 }
 unsigned AirTerminalDualDuctVAVOutdoorAir_Impl::nextInletPort() const {
   LOG(Warn, "nextInletPort is not supported for " << briefDescription() << " .");
   LOG(Warn, "Ports cannot be added or removed for " << briefDescription() << " .");
   return std::numeric_limits<unsigned>::max();
 }
 double MasslessOpaqueMaterial_Impl::thermalResistivity() const {
   LOG_AND_THROW("Unable to convert thermal resistance to thermal resistivity for "
     << "MasslessOpaqueMaterial " << briefDescription() << ".");
   return 0.0;
 }
boost::optional<IdfObject> ForwardTranslator::translateZoneHVACEnergyRecoveryVentilator( ZoneHVACEnergyRecoveryVentilator & modelObject )
{
    boost::optional<std::string> s;
    boost::optional<double> value;
    boost::optional<ModelObject> temp;

    // Model Name
    std::string const baseName = modelObject.name().get();
    // Node Names
    std::string const oaNodeName = baseName + " OA Node";
    std::string const supplyFanInletNodeName = baseName + " Supply Fan Inlet Node";
    std::string const exhaustFanInletNodeName = baseName + " Exhaust Fan Inlet Node";
    std::string const exhaustFanOutletNodeName = baseName + " Exhaust Fan Outlet Node";

    auto const zoneExhaustNode = modelObject.inletNode();
    auto const zoneInletNode = modelObject.outletNode();

    // Name
    IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::ZoneHVAC_EnergyRecoveryVentilator, modelObject);

    // AvailabilityScheduleName
    {
        auto schedule = modelObject.availabilitySchedule();
        if( auto _schedule = translateAndMapModelObject(schedule) ) {
            idfObject.setString(ZoneHVAC_EnergyRecoveryVentilatorFields::AvailabilityScheduleName,_schedule->name().get());
        }
    }

    // Heat Exchanger
    {
        auto heatExchanger = modelObject.heatExchanger().cast<HeatExchangerAirToAirSensibleAndLatent>();

        if ( heatExchanger.supplyAirOutletTemperatureControl() ) {
            LOG(Warn,"Overriding supplyAirOutletTemperatureControl to \"No\" for " << heatExchanger.briefDescription() << " because the HX needs to control itself, not through Setpoint Manager.");
            heatExchanger.setSupplyAirOutletTemperatureControl( false );
        }

        if( auto _heatExchanger = translateAndMapModelObject(heatExchanger) )
        {
            // HeatExchangerName
            idfObject.setString(ZoneHVAC_EnergyRecoveryVentilatorFields::HeatExchangerName,_heatExchanger->name().get() );
            // Heat Exchanger Nodes
            if( _heatExchanger->iddObject().type() == IddObjectType::HeatExchanger_AirToAir_SensibleAndLatent )
            {
                _heatExchanger->setString(HeatExchanger_AirToAir_SensibleAndLatentFields::SupplyAirInletNodeName,oaNodeName );
                _heatExchanger->setString(HeatExchanger_AirToAir_SensibleAndLatentFields::SupplyAirOutletNodeName,supplyFanInletNodeName );
                _heatExchanger->setString(HeatExchanger_AirToAir_SensibleAndLatentFields::ExhaustAirInletNodeName,zoneExhaustNode->name().get() );
                _heatExchanger->setString(HeatExchanger_AirToAir_SensibleAndLatentFields::ExhaustAirOutletNodeName,exhaustFanInletNodeName );

                IdfObject _oaNodeList(openstudio::IddObjectType::OutdoorAir_NodeList);
                _oaNodeList.setString(0,oaNodeName);
                m_idfObjects.push_back(_oaNodeList);
            }
        }
    }

    // SupplyAirFlowRate
    if( modelObject.isSupplyAirFlowRateAutosized() ) {
        idfObject.setString(ZoneHVAC_EnergyRecoveryVentilatorFields::SupplyAirFlowRate,"AutoSize");
    } else if( (value = modelObject.supplyAirFlowRate()) ) {
        idfObject.setDouble(ZoneHVAC_EnergyRecoveryVentilatorFields::SupplyAirFlowRate,value.get());
    }

    // ExhaustAirFlowRate
    if( modelObject.isExhaustAirFlowRateAutosized() ) {
        idfObject.setString(ZoneHVAC_EnergyRecoveryVentilatorFields::ExhaustAirFlowRate,"AutoSize");
    } else if( (value = modelObject.exhaustAirFlowRate()) ) {
        idfObject.setDouble(ZoneHVAC_EnergyRecoveryVentilatorFields::ExhaustAirFlowRate,value.get());
    }

    // Supply Air Fan
    {
        auto supplyAirFan = modelObject.supplyAirFan();
        if( auto _supplyAirFan = translateAndMapModelObject(supplyAirFan) )
        {
            // SupplyAirFanName
            idfObject.setString(ZoneHVAC_EnergyRecoveryVentilatorFields::SupplyAirFanName,_supplyAirFan->name().get() );
            // Supply Air Fan Inlet and Outlet Nodes
            if( _supplyAirFan->iddObject().type() == IddObjectType::Fan_OnOff )
            {

                _supplyAirFan->setString(Fan_OnOffFields::AirInletNodeName,supplyFanInletNodeName );
                _supplyAirFan->setString(Fan_OnOffFields::AirOutletNodeName,zoneInletNode->name().get() );
            }
        }
    }

    // Exhaust Air Fan
    {
        auto exhaustAirFan = modelObject.exhaustAirFan();
        if( auto _exhaustAirFan = translateAndMapModelObject(exhaustAirFan) )
        {
            // ExhaustAirFanName
            idfObject.setString(ZoneHVAC_EnergyRecoveryVentilatorFields::ExhaustAirFanName,_exhaustAirFan->name().get() );
            // Exhaust Air Fan Inlet and Outlet Nodes
            if( _exhaustAirFan->iddObject().type() == IddObjectType::Fan_OnOff )
            {

                _exhaustAirFan->setString(Fan_OnOffFields::AirInletNodeName,exhaustFanInletNodeName );
                _exhaustAirFan->setString(Fan_OnOffFields::AirOutletNodeName,exhaustFanOutletNodeName );
            }
        }
    }

    // ControllerName
    if( auto controller = modelObject.controller() ) {
        if( auto _controller = translateAndMapModelObject(controller.get()) ) {
            idfObject.setString(ZoneHVAC_EnergyRecoveryVentilatorFields::ControllerName,_controller->name().get());

            // Need to set Humidistat Control Thermal Zone in Controller
            if( controller->highHumidityControlFlag() ) {
                if( auto thermalZone = modelObject.thermalZone() ) {
                    if( auto _thermalZone = translateAndMapModelObject(thermalZone.get()) ) {
                        _controller->setString(ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::HumidistatControlZoneName,_thermalZone->name().get());
                    }
                }
            }
        }
    }

    // VentilationRateperUnitFloorArea
    if( (value = modelObject.ventilationRateperUnitFloorArea()) ) {
        idfObject.setDouble(ZoneHVAC_EnergyRecoveryVentilatorFields::VentilationRateperUnitFloorArea,value.get());
    }

    // VentilationRateperOccupant
    if( (value = modelObject.ventilationRateperOccupant()) ) {
        idfObject.setDouble(ZoneHVAC_EnergyRecoveryVentilatorFields::VentilationRateperOccupant,value.get());
    }

    // AvailabilityManagerListName

    return idfObject;
}
Esempio n. 19
0
 double AirGap_Impl::thermalResistivity() const {
   LOG_AND_THROW("Unable to convert thermal resistance to thermal resistivity for AirGap "
     << briefDescription() << ".");
   return 0.0;
 }
 void AirTerminalDualDuctVAVOutdoorAir_Impl::removePortForBranch(unsigned branchIndex) {
   LOG(Warn, "removePortForBranch is not supported for " << briefDescription() << " .");
   LOG(Warn, "Ports cannot be added or removed for " << briefDescription() << " .");
 }
Esempio n. 21
0
void GroupDef::writeDocumentation(OutputList &ol)
{
    ol.pushGeneratorState();
    startFile(ol,getOutputFileBase(),name(),title);
    startTitle(ol,getOutputFileBase());
    ol.parseText(title);
    addGroupListToTitle(ol,this);
    endTitle(ol,getOutputFileBase(),title);

    if (Config_getBool("SEARCHENGINE"))
    {
        Doxygen::searchIndex->setCurrentDoc(title,getOutputFileBase());
        static QRegExp we("[a-zA-Z_][a-zA-Z_0-9]*");
        int i=0,p=0,l=0;
        while ((i=we.match(title,p,&l))!=-1) // foreach word in the title
        {
            Doxygen::searchIndex->addWord(title.mid(i,l),TRUE);
            p=i+l;
        }
    }

    if (Config_getBool("HAVE_DOT") && Config_getBool("GROUP_GRAPHS") )
    {
        DotGroupCollaboration graph(this);
        if (!graph.isTrivial())
        {
            msg("Generating dependency graph for group %s\n",qualifiedName().data());
            ol.pushGeneratorState();
            ol.disable(OutputGenerator::Man);
            ol.newParagraph();
            ol.startGroupCollaboration();
            ol.parseText(theTranslator->trCollaborationDiagram(title));
            ol.endGroupCollaboration(graph);
            ol.popGeneratorState();
        }
    }


    if (Config_getBool("DETAILS_AT_TOP"))
    {
        writeDetailedDocumentation(ol);
        ol.newParagraph();
    }
    else if (!briefDescription().isEmpty())
    {
        ol.parseDoc(briefFile(),briefLine(),this,0,briefDescription(),TRUE,FALSE);
        ol.writeString(" \n");
        ol.pushGeneratorState();
        ol.disable(OutputGenerator::Latex);
        ol.disable(OutputGenerator::RTF);
        ol.disable(OutputGenerator::Man);
        ol.startTextLink(0,"_details");
        ol.parseText(theTranslator->trMore());
        ol.endTextLink();
        ol.enableAll();
        ol.disableAllBut(OutputGenerator::Man);
        ol.newParagraph();
        ol.popGeneratorState();
    }

    if (!Config_getString("GENERATE_TAGFILE").isEmpty())
    {
        Doxygen::tagFile << "  <compound kind=\"group\">" << endl;
        Doxygen::tagFile << "    <name>" << convertToXML(name()) << "</name>" << endl;
        Doxygen::tagFile << "    <title>" << convertToXML(title) << "</title>" << endl;
        Doxygen::tagFile << "    <filename>" << convertToXML(getOutputFileBase()) << Doxygen::htmlFileExtension << "</filename>" << endl;
    }

    ol.startMemberSections();

    // write list of files
    if (fileList->count()>0)
    {
        ol.startMemberHeader();
        ol.parseText(theTranslator->trFile(TRUE,FALSE));
        ol.endMemberHeader();
        ol.startMemberList();
        FileDef *fd=fileList->first();
        while (fd)
        {
            ol.startMemberItem(0);
            ol.docify(theTranslator->trFile(FALSE,TRUE)+" ");
            ol.insertMemberAlign();
            ol.writeObjectLink(fd->getReference(),fd->getOutputFileBase(),0,fd->name());
            if (!Config_getString("GENERATE_TAGFILE").isEmpty())
            {
                Doxygen::tagFile << "    <file>" << convertToXML(fd->name()) << "</file>" << endl;
            }
            ol.endMemberItem();
            if (!fd->briefDescription().isEmpty() && Config_getBool("BRIEF_MEMBER_DESC"))
            {
                ol.startMemberDescription();
                ol.parseDoc(briefFile(),briefLine(),fd,0,fd->briefDescription(),FALSE,FALSE);
                ol.endMemberDescription();
                ol.newParagraph();
            }
            fd=fileList->next();
        }
        ol.endMemberList();
    }

    // write list of namespaces
    namespaceSDict->writeDeclaration(ol);

    // write list of groups
    if (groupList->count()>0)
    {
        ol.startMemberHeader();
        ol.parseText(theTranslator->trModules());
        ol.endMemberHeader();
        ol.startMemberList();
        GroupDef *gd=groupList->first();
        while (gd)
        {
            ol.startMemberItem(0);
            //ol.docify(theTranslator->trGroup(FALSE,TRUE));
            //ol.docify(" ");
            ol.insertMemberAlign();
            ol.writeObjectLink(gd->getReference(),gd->getOutputFileBase(),0,gd->groupTitle());
            if (!Config_getString("GENERATE_TAGFILE").isEmpty())
            {
                Doxygen::tagFile << "    <subgroup>" << convertToXML(gd->name()) << "</subgroup>" << endl;
            }
            ol.endMemberItem();
            if (!gd->briefDescription().isEmpty() && Config_getBool("BRIEF_MEMBER_DESC"))
            {
                ol.startMemberDescription();
                ol.parseDoc(briefFile(),briefLine(),gd,0,gd->briefDescription(),FALSE,FALSE);
                ol.endMemberDescription();
                ol.newParagraph();
            }
            gd=groupList->next();
        }
        ol.endMemberList();
    }

    // write list of directories
    if (dirList->count()>0)
    {
        ol.startMemberHeader();
        ol.parseText(theTranslator->trDirectories());
        ol.endMemberHeader();
        ol.startMemberList();
        DirDef *dd=dirList->first();
        while (dd)
        {
            ol.startMemberItem(0);
            ol.parseText(theTranslator->trDir(FALSE,TRUE));
            ol.insertMemberAlign();
            ol.writeObjectLink(dd->getReference(),dd->getOutputFileBase(),0,dd->shortName());
            ol.endMemberItem();
            if (!Config_getString("GENERATE_TAGFILE").isEmpty())
            {
                Doxygen::tagFile << "    <dir>" << convertToXML(dd->displayName()) << "</dir>" << endl;
            }
            if (!dd->briefDescription().isEmpty() && Config_getBool("BRIEF_MEMBER_DESC"))
            {
                ol.startMemberDescription();
                ol.parseDoc(briefFile(),briefLine(),dd,0,dd->briefDescription(),FALSE,FALSE);
                ol.endMemberDescription();
                ol.newParagraph();
            }
            dd=dirList->next();
        }

        ol.endMemberList();
    }

    // write list of classes
    classSDict->writeDeclaration(ol);

    // write list of members
    if (allMemberList->count()>0)
    {
        /* write user defined member groups */
        MemberGroupSDict::Iterator mgli(*memberGroupSDict);
        MemberGroup *mg;
        for (; (mg=mgli.current()); ++mgli)
        {
            mg->writeDeclarations(ol,0,0,0,this);
        }

        //allMemberList->writeDeclarations(ol,0,0,0,this,0,0);
        decDefineMembers.writeDeclarations(ol,0,0,0,this,theTranslator->trDefines(),0);
        decProtoMembers.writeDeclarations(ol,0,0,0,this,theTranslator->trFuncProtos(),0);
        decTypedefMembers.writeDeclarations(ol,0,0,0,this,theTranslator->trTypedefs(),0);
        decEnumMembers.writeDeclarations(ol,0,0,0,this,theTranslator->trEnumerations(),0);
        decFuncMembers.writeDeclarations(ol,0,0,0,this,theTranslator->trFunctions(),0);
        decVarMembers.writeDeclarations(ol,0,0,0,this,theTranslator->trVariables(),0);
    }
    ol.endMemberSections();

    if (!Config_getBool("DETAILS_AT_TOP"))
    {
        writeDetailedDocumentation(ol);
    }

    PageDef *pd=0;
    PageSDict::Iterator pdi(*pageDict);
    for (pdi.toFirst(); (pd=pdi.current()); ++pdi)
    {
        if (!pd->isReference())
        {
            QCString pageName = pd->getOutputFileBase();

            if (!Config_getString("GENERATE_TAGFILE").isEmpty())
            {
                Doxygen::tagFile << "    <page>" << convertToXML(pageName) << "</page>" << endl;
            }

            SectionInfo *si=0;
            if (!pd->title().isEmpty() && !pd->name().isEmpty() &&
                    (si=Doxygen::sectionDict[pd->name()])!=0)
            {
                ol.startSection(si->label,si->title,SectionInfo::Subsection);
                ol.docify(si->title);
                ol.endSection(si->label,SectionInfo::Subsection);
            }
            ol.startTextBlock();
            ol.parseDoc(pd->docFile(),pd->docLine(),pd,0,pd->documentation(),TRUE,FALSE);
            ol.endTextBlock();
        }
    }

    writeMemberDocumentation(ol);

    if (!Config_getString("GENERATE_TAGFILE").isEmpty())
    {
        writeDocAnchorsToTagFile();
        Doxygen::tagFile << "  </compound>" << endl;
    }

    endFile(ol);
    ol.popGeneratorState();

    if (Config_getBool("SEPARATE_MEMBER_PAGES"))
    {
        allMemberList->sort();
        writeMemberPages(ol);
    }

}