TEST_F(EnergyPlusFixture,ReverseTranslatorTest_TranslateScheduleCompact) {
openstudio::Workspace workspace(openstudio::StrictnessLevel::None,openstudio::IddFileType::EnergyPlus);
openstudio::IdfObject idfObject( openstudio::IddObjectType::Schedule_Compact );
idfObject.setString(1,"Fraction");
idfObject.setString(2,"Through: 12/31");
idfObject.setString(3,"For: Weekdays SummerDesignDay");
idfObject.setString(4,"Until: 08:00");
idfObject.setString(5,"0.0");
idfObject.setString(6,"Until: 18:00");
idfObject.setString(7,"1.0");
idfObject.setString(8,"Until: 24:00");
idfObject.setString(9,"0.0");
idfObject.setString(10,"For: Weekends WinterDesignDay");
idfObject.setString(11,"Until: 10:00");
idfObject.setString(12,"0.0");
idfObject.setString(13,"Until: 16:00");
idfObject.setString(14,"1.0");
idfObject.setString(15,"Until: 24:00");
idfObject.setString(16,"0.0");
idfObject.setString(17,"For: Holidays AllOtherDays");
idfObject.setString(18,"Until: 24:00");
idfObject.setString(19,"0.0");
WorkspaceObject epScheduleCompact = workspace.addObject(idfObject).get();
ReverseTranslator trans;
ASSERT_NO_THROW(trans.translateWorkspace(workspace));
Model model = trans.translateWorkspace(workspace);
ASSERT_EQ(static_cast<unsigned>(1), model.getModelObjects<openstudio::model::ScheduleCompact>().size());
openstudio::model::ScheduleCompact scheduleCompact = model.getModelObjects<openstudio::model::ScheduleCompact>()[0];
EXPECT_EQ(unsigned(20),epScheduleCompact.numFields());
EXPECT_EQ(unsigned(21),scheduleCompact.numFields()); // has handle field
ASSERT_EQ(epScheduleCompact.numFields() + 1u,scheduleCompact.numFields());
ASSERT_TRUE(epScheduleCompact.name());
ASSERT_TRUE(scheduleCompact.name());
EXPECT_EQ(epScheduleCompact.name().get(),scheduleCompact.name().get());
for( unsigned i = 1; i < epScheduleCompact.numFields(); i++ )
{
boost::optional<std::string> s1 = epScheduleCompact.getString(i);
boost::optional<std::string> s2 = scheduleCompact.getString(i+1);
ASSERT_TRUE(s1);
ASSERT_TRUE(s2);
EXPECT_EQ(s1.get(),s2.get());
}
}
OptionalModelObject ReverseTranslator::translateInternalMass( const WorkspaceObject & workspaceObject )
{
if( workspaceObject.iddObject().type() != IddObjectType::InternalMass ){
LOG(Error, "WorkspaceObject is not IddObjectType: InternalMass");
return boost::none;
}
// create the definition
openstudio::model::InternalMassDefinition definition(m_model);
OptionalString s = workspaceObject.name();
if(s){
definition.setName(*s + " Definition");
}
OptionalWorkspaceObject target = workspaceObject.getTarget(openstudio::InternalMassFields::ConstructionName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (modelObject->optionalCast<ConstructionBase>()){
definition.setConstruction(modelObject->cast<ConstructionBase>());
}
}
}
OptionalDouble d = workspaceObject.getDouble(openstudio::InternalMassFields::SurfaceArea);
if(d){
definition.setSurfaceArea(*d);
}
// create the instance
InternalMass internalMass(definition);
s = workspaceObject.name();
if(s){
internalMass.setName(*s);
}
target = workspaceObject.getTarget(openstudio::InternalMassFields::ZoneName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (modelObject->optionalCast<Space>()){
internalMass.setSpace(modelObject->cast<Space>());
}else if (modelObject->optionalCast<SpaceType>()){
internalMass.setSpaceType(modelObject->cast<SpaceType>());
}
}
}
return internalMass;
}
bool WorkspaceObjectNameGreater::operator()(const WorkspaceObject& a, const WorkspaceObject& b) const
{
std::string aname;
boost::optional<std::string> oaname = a.name();
if (oaname){
aname = *oaname;
}
std::string bname;
boost::optional<std::string> obname = b.name();
if (obname){
bname = *obname;
}
return istringLess(bname, aname);
}
OptionalModelObject ReverseTranslator::translateSiteLocation( const WorkspaceObject & workspaceObject )
{
if( workspaceObject.iddObject().type() != IddObjectType::Site_Location ) {
LOG(Error, "WorkspaceObject is not IddObjectType: Site:Location");
return boost::none;
}
Site site = m_model.getUniqueModelObject<Site>();
OptionalString optS = workspaceObject.name();
if(optS) {
site.setName(*optS);
}
OptionalDouble od = workspaceObject.getDouble(Site_LocationFields::Latitude);
if(od) {
site.setLatitude(*od);
}
od = workspaceObject.getDouble(Site_LocationFields::Longitude);
if(od) {
site.setLongitude(*od);
}
od = workspaceObject.getDouble(Site_LocationFields::TimeZone);
if(od) {
site.setTimeZone(*od);
}
od = workspaceObject.getDouble(Site_LocationFields::Elevation);
if(od) {
site.setElevation(*od);
}
return site;
}
boost::optional<ModelObject> ReverseTranslator::translateCurveQuadraticLinear(
const WorkspaceObject& workspaceObject)
{
CurveQuadraticLinear curve(m_model);
OptionalString s;
OptionalDouble d;
if ((s = workspaceObject.name())) {
curve.setName(*s);
}
if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::Coefficient1Constant))) {
curve.setCoefficient1Constant(*d);
}
if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::Coefficient2x))) {
curve.setCoefficient2x(*d);
}
if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::Coefficient3x_POW_2))) {
curve.setCoefficient3xPOW2(*d);
}
if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::Coefficient4y))) {
curve.setCoefficient4y(*d);
}
if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::Coefficient5x_TIMES_y))) {
curve.setCoefficient5xTIMESY(*d);
}
if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::Coefficient6x_POW_2_TIMES_y))) {
curve.setCoefficient6xPOW2TIMESY(*d);
}
if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::MinimumValueofx))) {
curve.setMinimumValueofx(*d);
}
if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::MaximumValueofx))) {
curve.setMaximumValueofx(*d);
}
if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::MinimumValueofy))) {
curve.setMinimumValueofy(*d);
}
if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::MaximumValueofy))) {
curve.setMaximumValueofy(*d);
}
if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::MinimumCurveOutput))) {
curve.setMinimumCurveOutput(*d);
}
if ((d = workspaceObject.getDouble(Curve_QuadraticLinearFields::MaximumCurveOutput))) {
curve.setMaximumCurveOutput(*d);
}
if ((s = workspaceObject.getString(Curve_QuadraticLinearFields::InputUnitTypeforX,false,true))) {
curve.setInputUnitTypeforX(*s);
}
if ((s = workspaceObject.getString(Curve_QuadraticLinearFields::InputUnitTypeforY,false,true))) {
curve.setInputUnitTypeforY(*s);
}
if ((s = workspaceObject.getString(Curve_QuadraticLinearFields::OutputUnitType,false,true))) {
curve.setOutputUnitType(*s);
}
return curve;
}
OptionalModelObject ReverseTranslator::translateScheduleDayHourly(const WorkspaceObject & workspaceObject){
if (workspaceObject.iddObject().type() != IddObjectType::Schedule_Day_Hourly){
LOG(Error, "WorkspaceObject is not IddObjectType: Schedule:Day:Hourly");
return boost::none;
}
// create the schedule
ScheduleDay scheduleDay(m_model);
OptionalString s = workspaceObject.name();
if (s){
scheduleDay.setName(*s);
}
OptionalWorkspaceObject target = workspaceObject.getTarget(Schedule_Day_HourlyFields::ScheduleTypeLimitsName);
if (target){
OptionalModelObject scheduleTypeLimits = translateAndMapWorkspaceObject(*target);
if (scheduleTypeLimits){
scheduleDay.setPointer(OS_Schedule_DayFields::ScheduleTypeLimitsName, scheduleTypeLimits->handle());
}
}
for(unsigned i = 0; i < 24; ++i){
OptionalDouble d = workspaceObject.getDouble(Schedule_Day_HourlyFields::Hour1 + i, true);
if (d){
scheduleDay.addValue(openstudio::Time(0,i+1,0,0), *d);
}
}
return scheduleDay;
}
boost::optional<ModelObject> ReverseTranslator::translateCurveFunctionalPressureDrop(
const WorkspaceObject& workspaceObject )
{
CurveFunctionalPressureDrop curve(m_model);
OptionalString s;
OptionalDouble d;
if ((s = workspaceObject.name())) {
curve.setName(*s);
}
if ((d = workspaceObject.getDouble(Curve_Functional_PressureDropFields::Diameter))) {
curve.setDiameter(*d);
}
if ((d = workspaceObject.getDouble(Curve_Functional_PressureDropFields::MinorLossCoefficient))) {
curve.setMinorLossCoefficient(*d);
}
if ((d = workspaceObject.getDouble(Curve_Functional_PressureDropFields::Length))) {
curve.setLength(*d);
}
if ((d = workspaceObject.getDouble(Curve_Functional_PressureDropFields::Roughness))) {
curve.setRoughness(*d);
}
if ((d = workspaceObject.getDouble(Curve_Functional_PressureDropFields::FixedFrictionFactor))) {
curve.setFixedFrictionFactor(*d);
}
return curve;
}
OptionalModelObject ReverseTranslator::translateWindowMaterialSimpleGlazingSystem( const WorkspaceObject & workspaceObject )
{
OptionalModelObject result;
SimpleGlazing simpleGlazing( m_model );
OptionalString optS = workspaceObject.name();
if(optS)
{
simpleGlazing.setName(*optS);
}
OptionalDouble d = workspaceObject.getDouble(WindowMaterial_SimpleGlazingSystemFields::UFactor);
if(d) {
simpleGlazing.setUFactor(*d);
}
d = workspaceObject.getDouble(WindowMaterial_SimpleGlazingSystemFields::SolarHeatGainCoefficient);
if(d) {
simpleGlazing.setSolarHeatGainCoefficient(*d);
}
d = workspaceObject.getDouble(WindowMaterial_SimpleGlazingSystemFields::VisibleTransmittance);
if(d) {
simpleGlazing.setVisibleTransmittance(*d);
}
result = simpleGlazing;
return result;
}
OptionalModelObject ReverseTranslator::translateScheduleCompact( const WorkspaceObject & workspaceObject )
{
if( workspaceObject.iddObject().type() != IddObjectType::Schedule_Compact )
{
LOG(Error, "WorkspaceObject is not IddObjectType: Schedule:Compact");
return boost::none;
}
ScheduleCompact scheduleCompact(m_model);
OptionalWorkspaceObject target = workspaceObject.getTarget(Schedule_CompactFields::ScheduleTypeLimitsName);
if (target){
OptionalModelObject scheduleTypeLimits = translateAndMapWorkspaceObject(*target);
if (scheduleTypeLimits){
scheduleCompact.setPointer(OS_Schedule_CompactFields::ScheduleTypeLimitsName, scheduleTypeLimits->handle());
}
}
if (OptionalString os = workspaceObject.name()) {
scheduleCompact.setName(*os);
}
for (const IdfExtensibleGroup& eg : workspaceObject.extensibleGroups()) {
scheduleCompact.pushExtensibleGroup(eg.fields());
}
return scheduleCompact;
}
OptionalModelObject ReverseTranslator::translateZoneInfiltrationEffectiveLeakageArea( const WorkspaceObject & workspaceObject )
{
if( workspaceObject.iddObject().type() != IddObjectType::ZoneInfiltration_EffectiveLeakageArea ){
LOG(Error, "WorkspaceObject " << workspaceObject.briefDescription()
<< " is not IddObjectType: SpaceInfiltration_EffectiveLeakageArea");
return boost::none;
}
// create the instance
SpaceInfiltrationEffectiveLeakageArea spaceInfiltrationEffectiveLeakageArea(m_model);
OptionalString s = workspaceObject.name();
if(s){
spaceInfiltrationEffectiveLeakageArea.setName(*s);
}
OptionalWorkspaceObject target = workspaceObject.getTarget(ZoneInfiltration_EffectiveLeakageAreaFields::ZoneName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (modelObject->optionalCast<Space>()){
spaceInfiltrationEffectiveLeakageArea.setSpace(modelObject->cast<Space>());
}else if (modelObject->optionalCast<SpaceType>()){
spaceInfiltrationEffectiveLeakageArea.setSpaceType(modelObject->cast<SpaceType>());
}
}
}
target = workspaceObject.getTarget(ZoneInfiltration_EffectiveLeakageAreaFields::ScheduleName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (OptionalSchedule intermediate = modelObject->optionalCast<Schedule>()){
Schedule schedule(*intermediate);
spaceInfiltrationEffectiveLeakageArea.setSchedule(schedule);
}
}
}
boost::optional<double> value = workspaceObject.getDouble(ZoneInfiltration_EffectiveLeakageAreaFields::EffectiveAirLeakageArea);
if( value )
{
spaceInfiltrationEffectiveLeakageArea.setEffectiveAirLeakageArea(value.get());
}
value = workspaceObject.getDouble(ZoneInfiltration_EffectiveLeakageAreaFields::StackCoefficient);
if( value )
{
spaceInfiltrationEffectiveLeakageArea.setStackCoefficient(value.get());
}
value = workspaceObject.getDouble(ZoneInfiltration_EffectiveLeakageAreaFields::WindCoefficient);
if( value )
{
spaceInfiltrationEffectiveLeakageArea.setWindCoefficient(value.get());
}
return spaceInfiltrationEffectiveLeakageArea;
}
OptionalModelObject ReverseTranslator::translateMaterial( const WorkspaceObject & workspaceObject )
{
OptionalModelObject result;
if( workspaceObject.iddObject().type() != IddObjectType::Material )
{
LOG(Error, "WorkspaceObject is not IddObjectType: Material");
return result;
}
openstudio::model::StandardOpaqueMaterial mat( m_model );
OptionalString optS = workspaceObject.name();
if(optS) {
mat.setName(*optS);
}
optS = workspaceObject.getString(MaterialFields::Roughness);
if(optS) {
mat.setRoughness(*optS);
}
OptionalDouble od = workspaceObject.getDouble( MaterialFields::Thickness );
if(od) {
mat.setThickness(*od);
}
od = workspaceObject.getDouble( MaterialFields::Conductivity );
if(od) {
mat.setThermalConductivity(*od);
}
od = workspaceObject.getDouble( MaterialFields::Density );
if(od) {
mat.setDensity(*od);
}
od = workspaceObject.getDouble( MaterialFields::SpecificHeat );
if(od) {
mat.setSpecificHeat(*od);
}
od = workspaceObject.getDouble( MaterialFields::ThermalAbsorptance );
if(od) {
mat.setThermalAbsorptance(od);
}
od = workspaceObject.getDouble( MaterialFields::SolarAbsorptance );
if(od) {
mat.setSolarAbsorptance(od);
}
od = workspaceObject.getDouble( MaterialFields::VisibleAbsorptance );
if(od) {
mat.setVisibleAbsorptance(od);
}
result = mat;
return result;
}
OptionalModelObject ReverseTranslator::translateShadingBuildingDetailed( const WorkspaceObject & workspaceObject )
{
if( workspaceObject.iddObject().type() != IddObjectType::Shading_Building_Detailed ){
LOG(Error, "WorkspaceObject is not IddObjectType: Shading:Building:Detailed");
return boost::none;
}
openstudio::Point3dVector vertices = getVertices(Shading_Building_DetailedFields::NumberofVertices + 1, workspaceObject);
boost::optional<ShadingSurface> shadingSurface;
try{
shadingSurface = ShadingSurface(vertices, m_model);
}catch(const std::exception&){
LOG(Error, "Cannot create ShadingSurface for object: " << workspaceObject);
return boost::none;
}
OptionalString s = workspaceObject.name();
if(s) {
shadingSurface->setName(*s);
}
// look for first site level shading surface group
OptionalShadingSurfaceGroup shadingSurfaceGroup;
for (const ShadingSurfaceGroup& group : m_model.getConcreteModelObjects<ShadingSurfaceGroup>()){
if (istringEqual("Building", group.shadingSurfaceType())){
shadingSurfaceGroup = group;
break;
}
}
// if not found make one
if (!shadingSurfaceGroup){
shadingSurfaceGroup = ShadingSurfaceGroup(m_model);
shadingSurfaceGroup->setShadingSurfaceType("Building");
}
shadingSurface->setShadingSurfaceGroup(*shadingSurfaceGroup);
OptionalWorkspaceObject target = workspaceObject.getTarget(openstudio::Shading_Building_DetailedFields::TransmittanceScheduleName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (OptionalSchedule intermediate = modelObject->optionalCast<Schedule>()){
Schedule schedule(*intermediate);
shadingSurface->setTransmittanceSchedule(schedule);
}
}
}
return shadingSurface.get();
}
boost::optional<ModelObject> ReverseTranslator::translateCurveSigmoid(
const WorkspaceObject& workspaceObject )
{
CurveSigmoid curve(m_model);
OptionalString s;
OptionalDouble d;
if ((s = workspaceObject.name())) {
curve.setName(*s);
}
if ((d = workspaceObject.getDouble(Curve_SigmoidFields::Coefficient1C1))) {
curve.setCoefficient1C1(*d);
}
if ((d = workspaceObject.getDouble(Curve_SigmoidFields::Coefficient2C2))) {
curve.setCoefficient2C2(*d);
}
if ((d = workspaceObject.getDouble(Curve_SigmoidFields::Coefficient3C3))) {
curve.setCoefficient3C3(*d);
}
if ((d = workspaceObject.getDouble(Curve_SigmoidFields::Coefficient4C4))) {
curve.setCoefficient4C4(*d);
}
if ((d = workspaceObject.getDouble(Curve_SigmoidFields::Coefficient5C5))) {
curve.setCoefficient5C5(*d);
}
if ((d = workspaceObject.getDouble(Curve_SigmoidFields::MinimumValueofx))) {
curve.setMinimumValueofx(*d);
}
if ((d = workspaceObject.getDouble(Curve_SigmoidFields::MaximumValueofx))) {
curve.setMaximumValueofx(*d);
}
if ((d = workspaceObject.getDouble(Curve_SigmoidFields::MinimumCurveOutput))) {
curve.setMinimumCurveOutput(*d);
}
if ((d = workspaceObject.getDouble(Curve_SigmoidFields::MaximumCurveOutput))) {
curve.setMaximumCurveOutput(*d);
}
if ((s = workspaceObject.getString(Curve_SigmoidFields::InputUnitTypeforx,false,true))) {
curve.setInputUnitTypeforx(*s);
}
if ((s = workspaceObject.getString(Curve_SigmoidFields::OutputUnitType,false,true))) {
curve.setOutputUnitType(*s);
}
return curve;
}
boost::optional<ModelObject> ReverseTranslator::translateCurveCubic(
const WorkspaceObject& workspaceObject )
{
CurveCubic curve(m_model);
OptionalString s;
OptionalDouble d;
if ((s = workspaceObject.name())) {
curve.setName(*s);
}
if ((d = workspaceObject.getDouble(Curve_CubicFields::Coefficient1Constant))) {
curve.setCoefficient1Constant(*d);
}
if ((d = workspaceObject.getDouble(Curve_CubicFields::Coefficient2x))) {
curve.setCoefficient2x(*d);
}
if ((d = workspaceObject.getDouble(Curve_CubicFields::Coefficient3x_POW_2))) {
curve.setCoefficient3xPOW2(*d);
}
if ((d = workspaceObject.getDouble(Curve_CubicFields::Coefficient4x_POW_3))) {
curve.setCoefficient4xPOW3(*d);
}
if ((d = workspaceObject.getDouble(Curve_CubicFields::MinimumValueofx))) {
curve.setMinimumValueofx(*d);
}
if ((d = workspaceObject.getDouble(Curve_CubicFields::MaximumValueofx))) {
curve.setMaximumValueofx(*d);
}
if ((d = workspaceObject.getDouble(Curve_CubicFields::MinimumCurveOutput))) {
curve.setMinimumCurveOutput(*d);
}
if ((d = workspaceObject.getDouble(Curve_CubicFields::MaximumCurveOutput))) {
curve.setMaximumCurveOutput(*d);
}
if ((s = workspaceObject.getString(Curve_CubicFields::InputUnitTypeforX,false,true))) {
curve.setInputUnitTypeforX(*s);
}
if ((s = workspaceObject.getString(Curve_CubicFields::OutputUnitType,false,true))) {
curve.setOutputUnitType(*s);
}
return curve;
}
boost::optional<ModelObject> ReverseTranslator::translateCurveFanPressureRise(
const WorkspaceObject& workspaceObject )
{
CurveFanPressureRise curve(m_model);
OptionalString s;
OptionalDouble d;
if ((s = workspaceObject.name())) {
curve.setName(*s);
}
if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::Coefficient1C1))) {
curve.setCoefficient1C1(*d);
}
if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::Coefficient2C2))) {
curve.setCoefficient2C2(*d);
}
if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::Coefficient3C3))) {
curve.setCoefficient3C3(*d);
}
if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::Coefficient4C4))) {
curve.setCoefficient4C4(*d);
}
if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::MinimumValueofQfan))) {
curve.setMinimumValueofQfan(*d);
}
if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::MaximumValueofQfan))) {
curve.setMaximumValueofQfan(*d);
}
if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::MinimumValueofPsm))) {
curve.setMinimumValueofPsm(*d);
}
if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::MaximumValueofPsm))) {
curve.setMaximumValueofPsm(*d);
}
if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::MinimumCurveOutput))) {
curve.setMinimumCurveOutput(*d);
}
if ((d = workspaceObject.getDouble(Curve_FanPressureRiseFields::MaximumCurveOutput))) {
curve.setMaximumCurveOutput(*d);
}
return curve;
}
OptionalModelObject ReverseTranslator::translateMaterialNoMass( const WorkspaceObject & workspaceObject )
{
OptionalModelObject result;
if( workspaceObject.iddObject().type() != IddObjectType::Material_NoMass )
{
LOG(Error, "WorkspaceObject is not IddObjectType: Material:NoMass");
return result;
}
openstudio::model::MasslessOpaqueMaterial MOMat( m_model );
OptionalString optS = workspaceObject.name();
if(optS) {
MOMat.setName(*optS);
}
optS = workspaceObject.getString(Material_NoMassFields::Roughness);
if(optS) {
MOMat.setRoughness(*optS);
}
OptionalDouble d = workspaceObject.getDouble( Material_NoMassFields::ThermalResistance );
if(d) {
MOMat.setThermalResistance(*d);
}
d = workspaceObject.getDouble( Material_NoMassFields::ThermalAbsorptance );
if(d) {
MOMat.setThermalAbsorptance(*d);
}
d = workspaceObject.getDouble( Material_NoMassFields::SolarAbsorptance );
if(d) {
MOMat.setSolarAbsorptance(*d);
}
d = workspaceObject.getDouble( Material_NoMassFields::VisibleAbsorptance );
if(d) {
MOMat.setVisibleAbsorptance(*d);
}
result = MOMat;
return result;
}
OptionalModelObject ReverseTranslator::translateMaterialAirGap( const WorkspaceObject & workspaceObject )
{
if( workspaceObject.iddObject().type() != IddObjectType::Material_AirGap )
{
LOG(Error, "WorkspaceObject is not IddObjectType: Material_AirGap");
return boost::none;
}
openstudio::model::AirGap airGap(m_model);
OptionalString s = workspaceObject.name();
if (s) {
airGap.setName(*s);
}
OptionalDouble d = workspaceObject.getDouble(Material_AirGapFields::ThermalResistance);
if (d) {
airGap.setDouble(OS_Material_AirGapFields::ThermalResistance, *d);
}
return airGap;
}
TEST_F(ModelFixture, ComponentWatcher_BadComponentDataFromWorkspace) {
Workspace ws;
OptionalWorkspaceObject owo = ws.addObject(IdfObject(IddObjectType::OS_ComponentData));
ASSERT_TRUE(owo);
// make component data ok except points to non-existent object
WorkspaceObject cd = *owo;
OptionalString oName = cd.name(); // should have been set by constructor
ASSERT_TRUE(oName);
EXPECT_FALSE(oName->empty());
cd.setString(OS_ComponentDataFields::UUID,toString(createUUID()));
cd.setString(OS_ComponentDataFields::VersionUUID,toString(createUUID()));
StringVector values;
values.push_back("My Material");
IdfExtensibleGroup eg = cd.pushExtensibleGroup(values);
EXPECT_TRUE(eg.empty()); // Cannot register a bad pointer.
EXPECT_EQ(1u,ws.numObjects());
Model model(ws);
// expect ComponentWatcher creation to kick out ComponentData
EXPECT_EQ(0u,model.numObjects());
}
OptionalModelObject ReverseTranslator::translateZoneList( const WorkspaceObject & workspaceObject )
{
if( workspaceObject.iddObject().type() != IddObjectType::Zone ){
LOG(Error, "WorkspaceObject is not IddObjectType: Zone");
return boost::none;
}
openstudio::model::SpaceType spaceType( m_model );
OptionalString s = workspaceObject.name();
if(s){
spaceType.setName(*s);
}
for (const IdfExtensibleGroup& idfGroup : workspaceObject.extensibleGroups()){
WorkspaceExtensibleGroup workspaceGroup = idfGroup.cast<WorkspaceExtensibleGroup>();
OptionalWorkspaceObject target = workspaceGroup.getTarget(0);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (modelObject->optionalCast<Space>()){
Space space = modelObject->cast<Space>();
if (space.spaceType()){
LOG(Warn, "Overriding previously assigned SpaceType for Space '" << space.name().get() << "'");
}
space.setSpaceType(spaceType);
}
}
}
}
return spaceType;
}
OptionalModelObject ReverseTranslator::translateGeneratorMicroTurbine( const WorkspaceObject & workspaceObject )
{
OptionalModelObject result,temp;
OptionalDouble d;
boost::optional<WorkspaceObject> owo;
OptionalString optS;
// TODO: The availability schedule is in the ElectricLoadCenter:Generators (list) in E+, here it's carried by the generator itself
// Should also get the Rated Thermal To Electrical Power Ratio in the list
//Generator:MicroTurbine,
// Capstone C65, !- Name
openstudio::model::GeneratorMicroTurbine mchp( m_model );
// Name
optS = workspaceObject.name();
if(optS)
{
mchp.setName(*optS);
}
// 65000, !- Reference Electrical Power Output {W}
d = workspaceObject.getDouble(Generator_MicroTurbineFields::ReferenceElectricalPowerOutput);
if(d)
{
mchp.setReferenceElectricalPowerOutput(*d);
}
// 29900, !- Minimum Full Load Electrical Power Output {W}
d = workspaceObject.getDouble(Generator_MicroTurbineFields::MinimumFullLoadElectricalPowerOutput);
if(d)
{
mchp.setMinimumFullLoadElectricalPowerOutput(*d);
}
// 65000, !- Maximum Full Load Electrical Power Output {W} setMaximumFullLoadElectricalPowerOutput
d = workspaceObject.getDouble(Generator_MicroTurbineFields::MaximumFullLoadElectricalPowerOutput);
if(d)
{
mchp.setMaximumFullLoadElectricalPowerOutput(*d);
}
// 0.29, !- Reference Electrical Efficiency Using Lower Heating Value
d = workspaceObject.getDouble(Generator_MicroTurbineFields::ReferenceElectricalEfficiencyUsingLowerHeatingValue);
if(d)
{
mchp.setReferenceElectricalEfficiencyUsingLowerHeatingValue(*d);
}
// 15.0, !- Reference Combustion Air Inlet Temperature {C}
d = workspaceObject.getDouble(Generator_MicroTurbineFields::ReferenceCombustionAirInletTemperature);
if(d)
{
mchp.setReferenceCombustionAirInletTemperature(*d);
}
// 0.00638, !- Reference Combustion Air Inlet Humidity Ratio {kgWater/kgDryAir}
d = workspaceObject.getDouble(Generator_MicroTurbineFields::ReferenceCombustionAirInletHumidityRatio);
if(d)
{
mchp.setReferenceCombustionAirInletHumidityRatio(*d);
}
// 0.0, !- Reference Elevation {m}
d = workspaceObject.getDouble(Generator_MicroTurbineFields::MinimumFullLoadElectricalPowerOutput);
if(d)
{
mchp.setMinimumFullLoadElectricalPowerOutput(*d);
}
// Capstone C65 Power_vs_Temp_Elev, !- Electrical Power Function of Temperature and Elevation Curve Name
// BiquadraticCurves
if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::ElectricalPowerFunctionofTemperatureandElevationCurveName)) )
{
if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) )
{
if( boost::optional<CurveBiquadratic> curve = mo->optionalCast<CurveBiquadratic>() )
{
mchp.setElectricalPowerFunctionofTemperatureandElevationCurve(curve.get());
}
else
{
LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Electrical Power Function of Temperature and Elevation Curve Name");
}
}
}
// Capstone C65 Efficiency_vs_Temp, !- Electrical Efficiency Function of Temperature Curve Name
// QuadraticCubicCurves
if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::ElectricalEfficiencyFunctionofTemperatureCurveName)) )
{
if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) )
{
if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() )
{
mchp.setElectricalEfficiencyFunctionofTemperatureCurve(curve.get());
}
else if( boost::optional<CurveCubic> curve = mo->optionalCast<CurveCubic>() )
{
mchp.setElectricalEfficiencyFunctionofTemperatureCurve(curve.get());
}
else
{
LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Electrical Efficiency Function of Temperature Curve Name");
}
}
}
// Capstone C65 Efficiency_vs_PLR, !- Electrical Efficiency Function of Part Load Ratio Curve Name
// QuadraticCubicCurves
// setElectricalEfficiencyFunctionofPartLoadRatioCurve
if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::ElectricalEfficiencyFunctionofPartLoadRatioCurveName)) )
{
if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) )
{
if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() )
{
mchp.setElectricalEfficiencyFunctionofPartLoadRatioCurve(curve.get());
}
else if( boost::optional<CurveCubic> curve = mo->optionalCast<CurveCubic>() )
{
mchp.setElectricalEfficiencyFunctionofPartLoadRatioCurve(curve.get());
}
else
{
LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Electrical Efficiency Function of Part Load Ratio Curve Name");
}
}
}
// NaturalGas, !- Fuel Type
optS = workspaceObject.getString(Generator_MicroTurbineFields::FuelType);
if(optS)
{
mchp.setFuelType(*optS);
}
// 50000, !- Fuel Higher Heating Value {kJ/kg}
d = workspaceObject.getDouble(Generator_MicroTurbineFields::FuelHigherHeatingValue);
if(d)
{
mchp.setFuelHigherHeatingValue(*d);
}
// 45450, !- Fuel Lower Heating Value {kJ/kg}
d = workspaceObject.getDouble(Generator_MicroTurbineFields::FuelLowerHeatingValue);
if(d)
{
mchp.setFuelLowerHeatingValue(*d);
}
// 300, !- Standby Power {W}
d = workspaceObject.getDouble(Generator_MicroTurbineFields::StandbyPower);
if(d)
{
mchp.setStandbyPower(*d);
}
// 4500, !- Ancillary Power {W}
d = workspaceObject.getDouble(Generator_MicroTurbineFields::AncillaryPower);
if(d)
{
mchp.setAncillaryPower(*d);
}
// , !- Ancillary Power Function of Fuel Input Curve Name
// QuadraticCurves
// mchp.setAncillaryPowerFunctionofFuelInputCurve
if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::AncillaryPowerFunctionofFuelInputCurveName)) )
{
if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) )
{
if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() )
{
mchp.setAncillaryPowerFunctionofFuelInputCurve(curve.get());
}
else
{
LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Ancillary Power Function of Fuel Input Curve Name");
}
}
}
// Fields in between (in E+.idd) are moved at the end in the Heat Recovery section
// Capstone C65 Combustion Air Inlet Node, !- Combustion Air Inlet Node Name
// Capstone C65 Combustion Air Outlet Node, !- Combustion Air Outlet Node Name
// 0.489885, !- Reference Exhaust Air Mass Flow Rate {kg/s}
d = workspaceObject.getDouble(Generator_MicroTurbineFields::ReferenceExhaustAirMassFlowRate);
if(d)
{
mchp.setReferenceExhaustAirMassFlowRate(*d);
}
// Capstone C65 ExhAirFlowRate_vs_InletTemp, !- Exhaust Air Flow Rate Function of Temperature Curve Name
// QuadraticCubicCurves
// mchp.setExhaustAirFlowRateFunctionofTemperatureCurve
if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::ExhaustAirFlowRateFunctionofTemperatureCurveName)) )
{
if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) )
{
if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() )
{
mchp.setExhaustAirFlowRateFunctionofTemperatureCurve(curve.get());
}
else if( boost::optional<CurveCubic> curve = mo->optionalCast<CurveCubic>() )
{
mchp.setExhaustAirFlowRateFunctionofTemperatureCurve(curve.get());
}
else
{
LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Exhaust Air Flow Rate Function of Temperature Curve Name");
}
}
}
// Capstone C65 ExhAirFlowRate_vs_PLR, !- Exhaust Air Flow Rate Function of Part Load Ratio Curve Name
// QuadraticCubicCurves
// mchp.setExhaustAirFlowRateFunctionofPartLoadRatioCurve(curve)
if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::ExhaustAirFlowRateFunctionofPartLoadRatioCurveName)) )
{
if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) )
{
if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() )
{
mchp.setExhaustAirFlowRateFunctionofPartLoadRatioCurve(curve.get());
}
else if( boost::optional<CurveCubic> curve = mo->optionalCast<CurveCubic>() )
{
mchp.setExhaustAirFlowRateFunctionofPartLoadRatioCurve(curve.get());
}
else
{
LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Exhaust Air Flow Rate Function of Part Load Ratio Curve Name");
}
}
}
// 308.9, !- Nominal Exhaust Air Outlet Temperature
d = workspaceObject.getDouble(Generator_MicroTurbineFields::NominalExhaustAirOutletTemperature);
if(d)
{
mchp.setNominalExhaustAirOutletTemperature(*d);
}
// Capstone C65 ExhaustTemp_vs_InletTemp, !- Exhaust Air Temperature Function of Temperature Curve Name
// QuadraticCubicCurves
// mchp.setExhaustAirTemperatureFunctionofTemperatureCurve(curve)
if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::ExhaustAirTemperatureFunctionofTemperatureCurveName)) )
{
if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) )
{
if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() )
{
mchp.setExhaustAirTemperatureFunctionofTemperatureCurve(curve.get());
}
else if( boost::optional<CurveCubic> curve = mo->optionalCast<CurveCubic>() )
{
mchp.setExhaustAirTemperatureFunctionofTemperatureCurve(curve.get());
}
else
{
LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Exhaust Air Temperature Function of Temperature Curve Name");
}
}
}
// Capstone C65 ExhaustTemp_vs_PLR; !- Exhaust Air Temperature Function of Part Load Ratio Curve Name
// QuadraticCubicCurves
// mchp.setExhaustAirTemperatureFunctionofPartLoadRatioCurve(curve)
if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::ExhaustAirTemperatureFunctionofPartLoadRatioCurveName)) )
{
if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) )
{
if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() )
{
mchp.setExhaustAirTemperatureFunctionofPartLoadRatioCurve(curve.get());
}
else if( boost::optional<CurveCubic> curve = mo->optionalCast<CurveCubic>() )
{
mchp.setExhaustAirTemperatureFunctionofPartLoadRatioCurve(curve.get());
}
else
{
LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Exhaust Air Temperature Function of Part Load Ratio Curve Name");
}
}
}
/// HEAT RECOVERY PORTION
// Would need to add that to the plantLoop reverse translator
// Capstone C65 Heat Recovery Water Inlet Node, !- Heat Recovery Water Inlet Node Name
// Capstone C65 Heat Recovery Water Outlet Node, !- Heat Recovery Water Outlet Node Name
// TODO: For now, I trigger the creation is the 'Reference Thermal Efficiency Using Lower Heat Value' is filled.
// TODO: I should trigger it based on the `Rated Thermal To Electrical Power Ratio in the list` in the ElectricLoadCenter:Generators (list)
// TODO: But in order to do that, the ElectricLoadCenter:Distribution & ElectricLoadCenter:Generators need to have a reverse translator
// 0.4975, !- Reference Thermal Efficiency Using Lower Heat Value
d = workspaceObject.getDouble(Generator_MicroTurbineFields::ReferenceThermalEfficiencyUsingLowerHeatValue);
if(d)
{
// Create a GeneratorMicroTurbineHeatRecovery module, and assign it to the MicroTurbine
// I've Set the Name in the constructor
openstudio::model::GeneratorMicroTurbineHeatRecovery mchpHR (m_model, mchp);
// Assign the Reference Thermal Efficiency Using Lower Heat Value
mchpHR.setReferenceThermalEfficiencyUsingLowerHeatValue(*d);
// 60.0, !- Reference Inlet Water Temperature {C}
d = workspaceObject.getDouble(Generator_MicroTurbineFields::ReferenceInletWaterTemperature);
if(d)
{
mchpHR.setReferenceInletWaterTemperature(*d);
}
// PlantControl, !- Heat Recovery Water Flow Operating Mode
optS = workspaceObject.getString(Generator_MicroTurbineFields::HeatRecoveryWaterFlowOperatingMode);
if(optS)
{
mchpHR.setHeatRecoveryWaterFlowOperatingMode(*optS);
}
// 0.00252362, !- Reference Heat Recovery Water Flow Rate {m3/s}
d = workspaceObject.getDouble(Generator_MicroTurbineFields::ReferenceHeatRecoveryWaterFlowRate);
if(d)
{
mchpHR.setReferenceHeatRecoveryWaterFlowRate(*d);
}
// , !- Heat Recovery Water Flow Rate Function of Temperature and Power Curve Name
// BiquadraticCurves
// mchpHR.setHeatRecoveryWaterFlowRateFunctionofTemperatureandPowerCurve();
if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::HeatRecoveryWaterFlowRateFunctionofTemperatureandPowerCurveName)) )
{
if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) )
{
if( boost::optional<CurveBiquadratic> curve = mo->optionalCast<CurveBiquadratic>() )
{
mchpHR.setHeatRecoveryWaterFlowRateFunctionofTemperatureandPowerCurve(curve.get());
}
else
{
LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Heat Recovery Water Flow Rate Function of Temperature and Power Curve Name");
}
}
}
// Capstone C65 ThermalEff_vs_Temp_Elev, !- Thermal Efficiency Function of Temperature and Elevation Curve Name
// BicubicBiquadraticCurves
// mchpHR.setThermalEfficiencyFunctionofTemperatureandElevationCurve();
if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::ThermalEfficiencyFunctionofTemperatureandElevationCurveName)) )
{
if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) )
{
if( boost::optional<CurveBicubic> curve = mo->optionalCast<CurveBicubic>() )
{
mchpHR.setThermalEfficiencyFunctionofTemperatureandElevationCurve(curve.get());
}
else if( boost::optional<CurveBiquadratic> curve = mo->optionalCast<CurveBiquadratic>() )
{
mchpHR.setThermalEfficiencyFunctionofTemperatureandElevationCurve(curve.get());
}
else
{
LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Thermal Efficiency Function of Temperature and Elevation Curve Name");
}
}
}
// Capstone C65 HeatRecoveryRate_vs_PLR, !- Heat Recovery Rate Function of Part Load Ratio Curve Name
// QuadraticCubicCurves
// mchpHR.setHeatRecoveryRateFunctionofPartLoadRatioCurve();
if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::HeatRecoveryRateFunctionofPartLoadRatioCurveName)) )
{
if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) )
{
if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() )
{
mchpHR.setHeatRecoveryRateFunctionofPartLoadRatioCurve(curve.get());
}
else if( boost::optional<CurveCubic> curve = mo->optionalCast<CurveCubic>() )
{
mchpHR.setHeatRecoveryRateFunctionofPartLoadRatioCurve(curve.get());
}
else
{
LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Heat Recovery Rate Function of Part Load Ratio Curve Name");
}
}
}
// Capstone C65 HeatRecoveryRate_vs_InletTemp, !- Heat Recovery Rate Function of Inlet Water Temperature Curve Name
// QuadraticCurves
// mchpHR.setHeatRecoveryRateFunctionofInletWaterTemperatureCurve();
if ((owo = workspaceObject.getTarget(Generator_MicroTurbineFields::HeatRecoveryRateFunctionofInletWaterTemperatureCurveName)))
{
if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) )
{
if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() )
{
mchpHR.setHeatRecoveryRateFunctionofInletWaterTemperatureCurve(curve.get());
}
else
{
LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Heat Recovery Rate Function of Part Load Ratio Curve Name");
}
}
}
// Capstone C65 HeatRecoveryRate_vs_WaterFlow, !- Heat Recovery Rate Function of Water Flow Rate Curve Name
// QuadraticCurves
// mchpHR.setHeatRecoveryRateFunctionofInletWaterFlowRateCurve();
if( (owo = workspaceObject.getTarget(Generator_MicroTurbineFields::HeatRecoveryRateFunctionofWaterFlowRateCurveName)) )
{
if( boost::optional<ModelObject> mo = translateAndMapWorkspaceObject(owo.get()) )
{
if( boost::optional<CurveQuadratic> curve = mo->optionalCast<CurveQuadratic>() )
{
mchpHR.setHeatRecoveryRateFunctionofWaterFlowRateCurve(curve.get());
}
else
{
LOG(Warn, workspaceObject.briefDescription() << " has a wrong type curve for field Heat Recovery Rate Function of Water Flow Rate Curve Name");
}
}
}
// 0.001577263, !- Minimum Heat Recovery Water Flow Rate {m3/s}
d = workspaceObject.getDouble(Generator_MicroTurbineFields::MinimumHeatRecoveryWaterFlowRate);
if(d)
{
mchpHR.setMinimumHeatRecoveryWaterFlowRate(*d);
}
// 0.003785432, !- Maximum Heat Recovery Water Flow Rate {m3/s}
d = workspaceObject.getDouble(Generator_MicroTurbineFields::MaximumHeatRecoveryWaterFlowRate);
if(d)
{
mchpHR.setMaximumHeatRecoveryWaterFlowRate(*d);
}
// 82.2, !- Maximum Heat Recovery Water Temperature {C}
d = workspaceObject.getDouble(Generator_MicroTurbineFields::MaximumHeatRecoveryWaterTemperature);
if(d)
{
mchpHR.setMaximumHeatRecoveryWaterTemperature(*d);
}
}
result=mchp;
return result;
}
OptionalModelObject ReverseTranslator::translateDesignSpecificationOutdoorAir( const WorkspaceObject & workspaceObject )
{
if( workspaceObject.iddObject().type() != IddObjectType::DesignSpecification_OutdoorAir ){
LOG(Error, "WorkspaceObject is not IddObjectType: DesignSpecification:OutdoorAir");
return boost::none;
}
OptionalString outdoorAirMethod = workspaceObject.getString(DesignSpecification_OutdoorAirFields::OutdoorAirMethod, true);
if (!outdoorAirMethod){
LOG(Error, "No OutdoorAirMethod specified for DesignSpecification:OutdoorAir named '" << workspaceObject.name().get() << "'");
return boost::none;
}
DesignSpecificationOutdoorAir result(m_model);
OptionalString name = workspaceObject.name();
if(name){
result.setName(*name);
}
result.setOutdoorAirMethod(*outdoorAirMethod);
boost::optional<double> flowPerPerson = workspaceObject.getDouble(DesignSpecification_OutdoorAirFields::OutdoorAirFlowperPerson);
boost::optional<double> flowPerArea = workspaceObject.getDouble(DesignSpecification_OutdoorAirFields::OutdoorAirFlowperZoneFloorArea);
boost::optional<double> flowPerZone = workspaceObject.getDouble(DesignSpecification_OutdoorAirFields::OutdoorAirFlowperZone);
boost::optional<double> ach = workspaceObject.getDouble(DesignSpecification_OutdoorAirFields::OutdoorAirFlowAirChangesperHour);
if (istringEqual(*outdoorAirMethod, "Flow/Person")){
if (flowPerPerson){
result.setOutdoorAirFlowperPerson(*flowPerPerson);
}
}else if (istringEqual(*outdoorAirMethod, "Flow/Area")){
if (flowPerArea){
result.setOutdoorAirFlowperFloorArea(*flowPerArea);
}
}else if (istringEqual(*outdoorAirMethod, "Flow/Zone")){
if (flowPerZone){
result.setOutdoorAirFlowRate(*flowPerZone);
}
}else if (istringEqual(*outdoorAirMethod, "AirChanges/Hour")){
if (ach){
result.setOutdoorAirFlowRate(*ach);
}
}else if (istringEqual(*outdoorAirMethod, "Sum") || istringEqual(*outdoorAirMethod, "Maximum")){
if (flowPerPerson){
result.setOutdoorAirFlowperPerson(*flowPerPerson);
}
if (flowPerArea){
result.setOutdoorAirFlowperFloorArea(*flowPerArea);
}
if (flowPerZone){
result.setOutdoorAirFlowRate(*flowPerZone);
}
if (ach){
result.setOutdoorAirFlowRate(*ach);
}
}else{
LOG(Error, "Unknown OutdoorAirMethod '" << *outdoorAirMethod << "' specified for DesignSpecification:OutdoorAir named '" << workspaceObject.name().get() << "'");
}
OptionalWorkspaceObject target = workspaceObject.getTarget(DesignSpecification_OutdoorAirFields::OutdoorAirFlowRateFractionScheduleName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (OptionalSchedule intermediate = modelObject->optionalCast<Schedule>()){
Schedule schedule = *intermediate;
result.setOutdoorAirFlowRateFractionSchedule(schedule);
}
}
}
return result;
}
boost::optional<model::ModelObject> ReverseTranslator::translateExteriorLights(
const WorkspaceObject& workspaceObject)
{
if (workspaceObject.iddObject().type() != IddObjectType::Exterior_Lights) {
LOG(Error,"WorkspaceObject " << workspaceObject.briefDescription()
<< " is not of IddObjectType::Exterior_Lights.");
return boost::none;
}
model::ExteriorLightsDefinition definition(m_model);
OptionalString s;
OptionalDouble d;
if ((s = workspaceObject.name())) {
definition.setName(*s + " Definition");
}
if ((d = workspaceObject.getDouble(Exterior_LightsFields::DesignLevel))){
definition.setDesignLevel(*d);
}
model::OptionalExteriorLights exteriorLights;
model::OptionalSchedule schedule;
if (OptionalWorkspaceObject target = workspaceObject.getTarget(Exterior_LightsFields::ScheduleName))
{
if (model::OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target)) {
schedule = modelObject->optionalCast<model::Schedule>();
}
}
if (schedule) {
try {
exteriorLights = model::ExteriorLights(definition,*schedule);
}
catch (std::exception& e) {
LOG(Warn,"Could not reverse translate " << workspaceObject.briefDescription()
<< " in full, because " << e.what() << ".");
}
}
if (!exteriorLights) {
exteriorLights = model::ExteriorLights(definition);
}
OS_ASSERT(exteriorLights);
if ((s = workspaceObject.name())) {
exteriorLights->setName(*s);
}
if ((s = workspaceObject.getString(Exterior_LightsFields::ControlOption,false,true))) {
exteriorLights->setControlOption(*s);
}
if ((s = workspaceObject.getString(Exterior_LightsFields::EndUseSubcategory,false,true))) {
exteriorLights->setEndUseSubcategory(*s);
}
return *exteriorLights;
}
OptionalModelObject ReverseTranslator::translateCoilHeatingGas( const WorkspaceObject & workspaceObject )
{
OptionalModelObject result,temp;
OptionalSchedule schedule;
//get the Schedule
OptionalWorkspaceObject owo = workspaceObject.getTarget(Coil_Heating_GasFields::AvailabilityScheduleName);
if(!owo)
{
LOG(Error, "Error importing object: "
<< workspaceObject.briefDescription()
<< " Can't find Schedule.");
return result;
}
temp = translateAndMapWorkspaceObject(*owo);
if(temp)
{
schedule=temp->optionalCast<Schedule>();
}
if( !schedule )
{
LOG(Error, "Error importing object: "
<< workspaceObject.briefDescription()
<<"Failed to convert iddObject (schedule) into ModelObject. Maybe it does not exist in model yet");
return result;
}
try {
openstudio::model::CoilHeatingGas coil( m_model,
*schedule );
OptionalString optS = workspaceObject.name();
if(optS)
{
coil.setName(*optS);
}
OptionalDouble d;
d = workspaceObject.getDouble(openstudio::Coil_Heating_GasFields::GasBurnerEfficiency);
if(d)
{
coil.setGasBurnerEfficiency(*d);
}
d = workspaceObject.getDouble(openstudio::Coil_Heating_GasFields::NominalCapacity);
if(d)
{
coil.setNominalCapacity(*d);
}
//skip inlet and outlet node names. That should be done FOR us by the AirLoop Translator.
d = workspaceObject.getDouble(openstudio::Coil_Heating_GasFields::GasBurnerEfficiency);
if(d)
{
coil.setGasBurnerEfficiency(*d);
}
d = workspaceObject.getDouble(openstudio::Coil_Heating_GasFields::NominalCapacity);
if(d)
{
coil.setNominalCapacity(*d);
}
d = workspaceObject.getDouble(openstudio::Coil_Heating_GasFields::ParasiticElectricLoad);
if(d)
{
coil.setParasiticElectricLoad(*d);
}
d = workspaceObject.getDouble(openstudio::Coil_Heating_GasFields::ParasiticGasLoad);
if(d)
{
coil.setParasiticGasLoad(*d);
}
result = coil;
}
catch (std::exception& e) {
LOG(Error,"Unable to reverse translate " << workspaceObject.briefDescription() << ", because "
<< e.what() << ".");
return boost::none;
}
return result;
}
OptionalModelObject ReverseTranslator::translateScheduleWeekDaily(const WorkspaceObject & workspaceObject){
if (workspaceObject.iddObject().type() != IddObjectType::Schedule_Week_Daily){
LOG(Error, "WorkspaceObject is not IddObjectType: Schedule:Week");
return boost::none;
}
// create the schedule
ScheduleWeek scheduleWeek(m_model);
OptionalString s = workspaceObject.name();
if (s){
scheduleWeek.setName(*s);
}
OptionalWorkspaceObject target = workspaceObject.getTarget(Schedule_Week_DailyFields::SundaySchedule_DayName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (modelObject->optionalCast<ScheduleDay>()){
scheduleWeek.setSundaySchedule(modelObject->cast<ScheduleDay>());
}
}
}
target = workspaceObject.getTarget(Schedule_Week_DailyFields::MondaySchedule_DayName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (modelObject->optionalCast<ScheduleDay>()){
scheduleWeek.setMondaySchedule(modelObject->cast<ScheduleDay>());
}
}
}
target = workspaceObject.getTarget(Schedule_Week_DailyFields::TuesdaySchedule_DayName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (modelObject->optionalCast<ScheduleDay>()){
scheduleWeek.setTuesdaySchedule(modelObject->cast<ScheduleDay>());
}
}
}
target = workspaceObject.getTarget(Schedule_Week_DailyFields::WednesdaySchedule_DayName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (modelObject->optionalCast<ScheduleDay>()){
scheduleWeek.setWednesdaySchedule(modelObject->cast<ScheduleDay>());
}
}
}
target = workspaceObject.getTarget(Schedule_Week_DailyFields::ThursdaySchedule_DayName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (modelObject->optionalCast<ScheduleDay>()){
scheduleWeek.setThursdaySchedule(modelObject->cast<ScheduleDay>());
}
}
}
target = workspaceObject.getTarget(Schedule_Week_DailyFields::FridaySchedule_DayName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (modelObject->optionalCast<ScheduleDay>()){
scheduleWeek.setFridaySchedule(modelObject->cast<ScheduleDay>());
}
}
}
target = workspaceObject.getTarget(Schedule_Week_DailyFields::SaturdaySchedule_DayName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (modelObject->optionalCast<ScheduleDay>()){
scheduleWeek.setSaturdaySchedule(modelObject->cast<ScheduleDay>());
}
}
}
target = workspaceObject.getTarget(Schedule_Week_DailyFields::HolidaySchedule_DayName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (modelObject->optionalCast<ScheduleDay>()){
scheduleWeek.setHolidaySchedule(modelObject->cast<ScheduleDay>());
}
}
}
target = workspaceObject.getTarget(Schedule_Week_DailyFields::SummerDesignDaySchedule_DayName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (modelObject->optionalCast<ScheduleDay>()){
scheduleWeek.setSummerDesignDaySchedule(modelObject->cast<ScheduleDay>());
}
}
}
target = workspaceObject.getTarget(Schedule_Week_DailyFields::WinterDesignDaySchedule_DayName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (modelObject->optionalCast<ScheduleDay>()){
scheduleWeek.setWinterDesignDaySchedule(modelObject->cast<ScheduleDay>());
}
}
}
target = workspaceObject.getTarget(Schedule_Week_DailyFields::CustomDay1Schedule_DayName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (modelObject->optionalCast<ScheduleDay>()){
scheduleWeek.setCustomDay1Schedule(modelObject->cast<ScheduleDay>());
}
}
}
target = workspaceObject.getTarget(Schedule_Week_DailyFields::CustomDay2Schedule_DayName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (modelObject->optionalCast<ScheduleDay>()){
scheduleWeek.setCustomDay2Schedule(modelObject->cast<ScheduleDay>());
}
}
}
return scheduleWeek;
}
OptionalModelObject ReverseTranslator::translateZone( const WorkspaceObject & workspaceObject )
{
if( workspaceObject.iddObject().type() != IddObjectType::Zone ){
LOG(Error, "WorkspaceObject is not IddObjectType: Zone");
return boost::none;
}
// this function creates a space and a thermal zone, it returns the space. If you want the
// thermal zone you can reliably dereference the result of space.thermalZone().
openstudio::model::ThermalZone thermalZone( m_model );
openstudio::model::Space space( m_model );
space.setThermalZone(thermalZone);
boost::optional<std::string> idfZoneName;
OptionalString s = workspaceObject.name();
if(s){
space.setName(*s);
thermalZone.setName(*s + " Thermal Zone");
idfZoneName = *s;
}
OptionalDouble d = workspaceObject.getDouble(ZoneFields::DirectionofRelativeNorth);
if(d){
space.setDirectionofRelativeNorth(*d);
}
d=workspaceObject.getDouble(ZoneFields::XOrigin);
if(d){
space.setXOrigin(*d);
}
d=workspaceObject.getDouble(ZoneFields::YOrigin);
if(d){
space.setYOrigin(*d);
}
d=workspaceObject.getDouble(ZoneFields::ZOrigin);
if(d){
space.setZOrigin(*d);
}
OptionalInt i = workspaceObject.getInt(ZoneFields::Type);
if(i){
// no-op
}
i = workspaceObject.getInt(ZoneFields::Multiplier);
if(i){
thermalZone.setMultiplier(*i);
}
d = workspaceObject.getDouble(ZoneFields::CeilingHeight);
if(d){
thermalZone.setCeilingHeight(*d);
}
d=workspaceObject.getDouble(ZoneFields::Volume);
if(d){
thermalZone.setVolume(*d);
}
s = workspaceObject.getString(ZoneFields::ZoneInsideConvectionAlgorithm);
if(s){
thermalZone.setZoneInsideConvectionAlgorithm(*s);
}
s = workspaceObject.getString(ZoneFields::ZoneOutsideConvectionAlgorithm);
if(s){
thermalZone.setZoneOutsideConvectionAlgorithm(*s);
}
s = workspaceObject.getString(ZoneFields::PartofTotalFloorArea);
if(s){
if(istringEqual("Yes",*s))
{
space.setPartofTotalFloorArea(true);
}
else
{
space.setPartofTotalFloorArea(false);
}
}
// Thermostat
// If the zone in the idf file does not have a name, there is no use in even trying to find a thermostat
if( idfZoneName )
{
Workspace workspace = workspaceObject.workspace();
std::vector<WorkspaceObject> _zoneControlThermostats;
_zoneControlThermostats = workspace.getObjectsByType(IddObjectType::ZoneControl_Thermostat);
for( const auto & _zoneControlThermostat : _zoneControlThermostats )
{
if( boost::optional<std::string> zoneName = _zoneControlThermostat.getString( ZoneControl_ThermostatFields::ZoneorZoneListName ) )
{
bool zoneControlThermostatfound = false;
if( zoneName.get() == idfZoneName )
{
zoneControlThermostatfound = true;
}
else if( boost::optional<WorkspaceObject> _zoneList = workspace.getObjectByTypeAndName(IddObjectType::ZoneList,zoneName.get()) )
{
std::vector<IdfExtensibleGroup> zoneListGroup = _zoneList->extensibleGroups();
for( const auto & zoneListElem : zoneListGroup )
{
boost::optional<std::string> zoneListZoneName = zoneListElem.getString(ZoneListExtensibleFields::ZoneName);
if( zoneListZoneName )
{
if( zoneListZoneName.get() == idfZoneName ) { zoneControlThermostatfound = true; }
break;
}
}
}
if( zoneControlThermostatfound )
{
std::vector<IdfExtensibleGroup> extensibleGroups = _zoneControlThermostat.extensibleGroups();
for( const auto & extensibleGroup : extensibleGroups )
{
boost::optional<std::string> thermostatType = extensibleGroup.getString(ZoneControl_ThermostatExtensibleFields::ControlObjectType);
boost::optional<std::string> thermostatName = extensibleGroup.getString(ZoneControl_ThermostatExtensibleFields::ControlName);
if( thermostatName && thermostatType )
{
boost::optional<WorkspaceObject> _thermostat
= workspace.getObjectByTypeAndName(IddObjectType(thermostatType.get()),thermostatName.get());
if( _thermostat )
{
boost::optional<ModelObject> thermostat = translateAndMapWorkspaceObject(_thermostat.get());
if( thermostat )
{
if( boost::optional<ThermostatSetpointDualSetpoint> thermostatSetpointDualSetpoint
= thermostat->optionalCast<ThermostatSetpointDualSetpoint>() )
{
thermalZone.setThermostatSetpointDualSetpoint(thermostatSetpointDualSetpoint.get());
}
}
}
}
}
break;
}
}
}
}
// Zone Equipment
/*
if( idfZoneName )
{
std::vector<WorkspaceObject> zoneHVACEquipmentConnections;
zoneHVACEquipmentConnections = workspaceObject.workspace().getObjectsByType(IddObjectType::ZoneHVAC_EquipmentConnections);
for( std::vector<WorkspaceObject>::iterator it = zoneHVACEquipmentConnections.begin();
it != zoneHVACEquipmentConnections.end();
it++ )
{
s = it->getString(ZoneHVAC_EquipmentConnectionsFields::ZoneName);
if( s && istringEqual(s.get(),idfZoneName.get()) )
{
boost::optional<WorkspaceObject> _zoneEquipmentList = it->getTarget(ZoneHVAC_EquipmentConnectionsFields::ZoneConditioningEquipmentListName);
if( _zoneEquipmentList )
{
translateAndMapWorkspaceObject(_zoneEquipmentList.get());
}
break;
}
}
}
*/
return space;
}
boost::optional<ModelObject> ReverseTranslator::translateWindowMaterialGlazing(
const WorkspaceObject& workspaceObject)
{
OptionalModelObject result;
StandardGlazing standardGlazing(m_model);
OptionalString optS = workspaceObject.name();
if(optS) {
standardGlazing.setName(*optS);
}
optS = workspaceObject.getString(WindowMaterial_GlazingFields::OpticalDataType);
if (optS) {
standardGlazing.setOpticalDataType(*optS);
}
optS = workspaceObject.getString(WindowMaterial_GlazingFields::WindowGlassSpectralDataSetName);
if (optS) {
standardGlazing.setWindowGlassSpectralDataSetName(*optS);
}
OptionalDouble d = workspaceObject.getDouble(WindowMaterial_GlazingFields::Thickness);
if (d) {
standardGlazing.setThickness(*d);
}
d = workspaceObject.getDouble(WindowMaterial_GlazingFields::SolarTransmittanceatNormalIncidence);
if (d) {
standardGlazing.setSolarTransmittance(*d);
}
d = workspaceObject.getDouble(WindowMaterial_GlazingFields::FrontSideSolarReflectanceatNormalIncidence);
if (d) {
standardGlazing.setFrontSideSolarReflectanceatNormalIncidence(*d);
}
d = workspaceObject.getDouble(WindowMaterial_GlazingFields::BackSideSolarReflectanceatNormalIncidence);
if (d) {
standardGlazing.setBackSideSolarReflectanceatNormalIncidence(*d);
}
d = workspaceObject.getDouble(WindowMaterial_GlazingFields::VisibleTransmittanceatNormalIncidence);
if (d) {
standardGlazing.setVisibleTransmittance(*d);
}
d = workspaceObject.getDouble(WindowMaterial_GlazingFields::FrontSideVisibleReflectanceatNormalIncidence);
if (d) {
standardGlazing.setFrontSideVisibleReflectanceatNormalIncidence(*d);
}
d = workspaceObject.getDouble(WindowMaterial_GlazingFields::BackSideVisibleReflectanceatNormalIncidence);
if (d) {
standardGlazing.setBackSideVisibleReflectanceatNormalIncidence(*d);
}
d = workspaceObject.getDouble(WindowMaterial_GlazingFields::InfraredTransmittanceatNormalIncidence);
if (d) {
standardGlazing.setInfraredTransmittance(*d);
}
d = workspaceObject.getDouble(WindowMaterial_GlazingFields::FrontSideInfraredHemisphericalEmissivity);
if (d) {
standardGlazing.setFrontSideInfraredHemisphericalEmissivity(*d);
}
d = workspaceObject.getDouble(WindowMaterial_GlazingFields::BackSideInfraredHemisphericalEmissivity);
if (d) {
standardGlazing.setBackSideInfraredHemisphericalEmissivity(*d);
}
d = workspaceObject.getDouble(WindowMaterial_GlazingFields::Conductivity);
if (d) {
standardGlazing.setThermalConductivity(*d);
}
d = workspaceObject.getDouble(WindowMaterial_GlazingFields::DirtCorrectionFactorforSolarandVisibleTransmittance);
if (d) {
standardGlazing.setDirtCorrectionFactorforSolarandVisibleTransmittance(*d);
}
optS = workspaceObject.getString(WindowMaterial_GlazingFields::SolarDiffusing);
if (optS) {
std::string temp=*optS;
boost::to_lower(temp);
if( temp == "no") {
standardGlazing.setSolarDiffusing(false);
}
else {
standardGlazing.setSolarDiffusing(true);
}
}
result = standardGlazing;
return result;
}
bool operator()(const WorkspaceObject& left, const WorkspaceObject& right) const {
OS_ASSERT(left.name());
OS_ASSERT(right.name());
return (istringLess(left.name().get(), right.name().get()));
}
OptionalModelObject ReverseTranslator::translateFanConstantVolume( const WorkspaceObject & workspaceObject )
{
OptionalModelObject result,temp;
OptionalSchedule schedule;
OptionalWorkspaceObject owo = workspaceObject.getTarget(Fan_ConstantVolumeFields::AvailabilityScheduleName);
if(!owo)
{
LOG(Error, "Error importing object: "
<< workspaceObject.briefDescription()
<< " Can't find Schedule: ");
return result;
}
temp = translateAndMapWorkspaceObject( *owo);
if(temp)
{
schedule = temp->optionalCast<Schedule>();
}
if( !schedule )
{
LOG(Error, "Error importing object: "
<< workspaceObject.name().get()
<<"Failed to convert iddObjects into model Objects. Maybe they do not exist in model yet");
return result;
}
openstudio::model::FanConstantVolume fan( m_model, *schedule );
OptionalString optS = workspaceObject.name();
if(optS)
{
fan.setName(*optS);
}
//inlet and outlet nodes are set my the HVACAirLoop
OptionalDouble d;
d = workspaceObject.getDouble(openstudio::Fan_ConstantVolumeFields::FanTotalEfficiency);
if(d)
{
fan.setFanEfficiency(*d);
}
d = workspaceObject.getDouble(openstudio::Fan_ConstantVolumeFields::PressureRise);
if(d)
{
fan.setPressureRise(*d);
}
d = workspaceObject.getDouble(openstudio::Fan_ConstantVolumeFields::MaximumFlowRate);
if(d)
{
fan.setMaximumFlowRate(*d);
}
d = workspaceObject.getDouble(openstudio::Fan_ConstantVolumeFields::MotorEfficiency);
if(d)
{
fan.setMotorEfficiency(*d);
}
d = workspaceObject.getDouble(openstudio::Fan_ConstantVolumeFields::MotorInAirstreamFraction);
if(d)
{
fan.setMotorInAirstreamFraction(*d);
}
optS=workspaceObject.getString(openstudio::Fan_ConstantVolumeFields::EndUseSubcategory);
if(optS)
{
fan.setEndUseSubcategory(*optS);
}
result=fan;
return result;
}
OptionalModelObject ReverseTranslator::translateGasEquipment( const WorkspaceObject & workspaceObject )
{
if( workspaceObject.iddObject().type() != IddObjectType::GasEquipment ){
LOG(Error, "WorkspaceObject is not IddObjectType: GasEquipment");
return boost::none;
}
// create the definition
openstudio::model::GasEquipmentDefinition definition(m_model);
OptionalString s = workspaceObject.name();
if(s){
definition.setName(*s + " Definition");
}
s = workspaceObject.getString(openstudio::GasEquipmentFields::DesignLevelCalculationMethod, true);
OS_ASSERT(s);
OptionalDouble d;
if (istringEqual("EquipmentLevel", *s)){
d = workspaceObject.getDouble(openstudio::GasEquipmentFields::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::GasEquipmentFields::PowerperZoneFloorArea);
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::GasEquipmentFields::PowerperPerson);
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::GasEquipmentFields::FractionLatent);
if (d){
definition.setFractionLatent(*d);
}
d = workspaceObject.getDouble(openstudio::GasEquipmentFields::FractionRadiant);
if (d){
definition.setFractionRadiant(*d);
}
d = workspaceObject.getDouble(openstudio::GasEquipmentFields::FractionLost);
if (d){
definition.setFractionLost(*d);
}
d = workspaceObject.getDouble(openstudio::GasEquipmentFields::CarbonDioxideGenerationRate);
if (d){
definition.setCarbonDioxideGenerationRate(*d);
}
// create the instance
GasEquipment gasEquipment(definition);
s = workspaceObject.name();
if(s){
gasEquipment.setName(*s);
}
OptionalWorkspaceObject target = workspaceObject.getTarget(openstudio::GasEquipmentFields::ZoneorZoneListName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (modelObject->optionalCast<Space>()){
gasEquipment.setSpace(modelObject->cast<Space>());
}else if (modelObject->optionalCast<SpaceType>()){
gasEquipment.setSpaceType(modelObject->cast<SpaceType>());
}
}
}
target = workspaceObject.getTarget(openstudio::GasEquipmentFields::ScheduleName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (OptionalSchedule intermediate = modelObject->optionalCast<Schedule>()){
Schedule schedule(*intermediate);
gasEquipment.setSchedule(schedule);
}
}
}
s = workspaceObject.getString(openstudio::GasEquipmentFields::EndUseSubcategory);
if(s){
gasEquipment.setEndUseSubcategory(*s);
}
return gasEquipment;
}
OptionalModelObject ReverseTranslator::translateOutputIlluminanceMap( const WorkspaceObject & workspaceObject )
{
if( workspaceObject.iddObject().type() != IddObjectType::Output_IlluminanceMap ){
LOG(Error, "WorkspaceObject is not IddObjectType: Output:IlluminanceMap");
return boost::none;
}
IlluminanceMap illuminanceMap( m_model );
OptionalString s = workspaceObject.name();
if (s){
illuminanceMap.setName(*s);
}
OptionalWorkspaceObject target = workspaceObject.getTarget(Output_IlluminanceMapFields::ZoneName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (modelObject->optionalCast<Space>()){
illuminanceMap.setSpace(modelObject->cast<Space>());
}
}
}
OptionalDouble d = workspaceObject.getDouble(Output_IlluminanceMapFields::Zheight);
if (d){
illuminanceMap.setOriginZCoordinate(*d);
}
d = workspaceObject.getDouble(Output_IlluminanceMapFields::XMinimumCoordinate);
if (d){
illuminanceMap.setOriginXCoordinate(*d);
OptionalDouble maxX = workspaceObject.getDouble(Output_IlluminanceMapFields::XMaximumCoordinate);
if (maxX){
illuminanceMap.setXLength(*maxX - *d);
}
}
OptionalInt i = workspaceObject.getInt(Output_IlluminanceMapFields::NumberofXGridPoints);
if (i){
illuminanceMap.setNumberofXGridPoints(*i);
}
d = workspaceObject.getDouble(Output_IlluminanceMapFields::YMinimumCoordinate);
if (d){
illuminanceMap.setOriginYCoordinate(*d);
OptionalDouble maxY = workspaceObject.getDouble(Output_IlluminanceMapFields::YMaximumCoordinate);
if (maxY){
illuminanceMap.setYLength(*maxY - *d);
}
}
i = workspaceObject.getInt(Output_IlluminanceMapFields::NumberofYGridPoints);
if (i){
illuminanceMap.setNumberofYGridPoints(*i);
}
return illuminanceMap;
}