From 93b9daca2c0896b7f604ed2246e4e76896f8471c Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Wed, 26 Aug 2020 10:23:33 -0700 Subject: [PATCH 01/12] Add output control files to idd. --- resources/model/OpenStudio.idd | 163 +++++++++++++++++++++++++++++++++ 1 file changed, 163 insertions(+) diff --git a/resources/model/OpenStudio.idd b/resources/model/OpenStudio.idd index 9346140abaf..9bfa6b2672d 100644 --- a/resources/model/OpenStudio.idd +++ b/resources/model/OpenStudio.idd @@ -30885,6 +30885,169 @@ OS:UtilityBill, \group OpenStudio Output Requests +OutputControl:Files, + \memo Conditionally turn on/off output from EnergyPlus. + \unique-object + A1, \field Handle + \type handle + \required-field + A2, \field Output CSV + \type choice + \key Yes + \key No + \default No + A3, \field Output MTR + \type choice + \key Yes + \key No + \default No + A4, \field Output ESO + \type choice + \key Yes + \key No + \default Yes + A5, \field Output EIO + \type choice + \key Yes + \key No + \default Yes + A6, \field Output Tabular + \type choice + \key Yes + \key No + \default Yes + A7, \field Output SQLite + \type choice + \key Yes + \key No + \default Yes + A8, \field Output JSON + \type choice + \key Yes + \key No + \default Yes + A9, \field Output AUDIT + \type choice + \key Yes + \key No + \default Yes + A10, \field Output Zone Sizing + \type choice + \key Yes + \key No + \default Yes + A11, \field Output System Sizing + \type choice + \key Yes + \key No + \default Yes + A12, \field Output DXF + \type choice + \key Yes + \key No + \default Yes + A13, \field Output BND + \type choice + \key Yes + \key No + \default Yes + A14, \field Output RDD + \type choice + \key Yes + \key No + \default Yes + A15, \field Output MDD + \type choice + \key Yes + \key No + \default Yes + A16, \field Output MTD + \type choice + \key Yes + \key No + \default Yes + A17, \field Output END + \type choice + \key Yes + \key No + \default Yes + A18, \field Output SHD + \type choice + \key Yes + \key No + \default Yes + A19, \field Output DFS + \type choice + \key Yes + \key No + \default Yes + A20, \field Output GLHE + \type choice + \key Yes + \key No + \default Yes + A21, \field Output DelightIn + \type choice + \key Yes + \key No + \default Yes + A22, \field Output DelightELdmp + \type choice + \key Yes + \key No + \default Yes + A23, \field Output DelightDFdmp + \type choice + \key Yes + \key No + \default Yes + A24, \field Output EDD + \type choice + \key Yes + \key No + \default Yes + A25, \field Output DBG + \type choice + \key Yes + \key No + \default Yes + A26, \field Output PerfLog + \type choice + \key Yes + \key No + \default Yes + A27, \field Output SLN + \type choice + \key Yes + \key No + \default Yes + A28, \field Output SCI + \type choice + \key Yes + \key No + \default Yes + A29, \field Output WRL + \type choice + \key Yes + \key No + \default Yes + A30, \field Output Screen + \type choice + \key Yes + \key No + \default Yes + A31, \field Output ExtShd + \type choice + \key Yes + \key No + \default Yes + A32; \field Output Tarcog + \note Not Implemented Yet + \type choice + \key Yes + \key No + \default Yes + OS:OutputControl:ReportingTolerances, \memo Calculations of the time that setpoints are not met use a tolerance of 0.2C. \memo This object allows changing the tolerance used to determine when setpoints are being met. From 09fc4da36dee386b9d64fe8cad6efe93cc5db923 Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Wed, 26 Aug 2020 10:43:19 -0700 Subject: [PATCH 02/12] Add and stub model files. --- src/model/CMakeLists.txt | 4 + src/model/ConcreteModelObjects.hpp | 2 + src/model/Model.cpp | 2 + src/model/ModelSimulation.i | 2 + src/model/OutputControlFiles.cpp | 98 +++++++++++++++++++ src/model/OutputControlFiles.hpp | 101 ++++++++++++++++++++ src/model/OutputControlFiles_Impl.hpp | 100 +++++++++++++++++++ src/model/test/OutputControlFiles_GTest.cpp | 44 +++++++++ src/model/test/UniqueModelObject_GTest.cpp | 10 ++ 9 files changed, 363 insertions(+) create mode 100644 src/model/OutputControlFiles.cpp create mode 100644 src/model/OutputControlFiles.hpp create mode 100644 src/model/OutputControlFiles_Impl.hpp create mode 100644 src/model/test/OutputControlFiles_GTest.cpp diff --git a/src/model/CMakeLists.txt b/src/model/CMakeLists.txt index bf94e52cf7b..bdba322b525 100644 --- a/src/model/CMakeLists.txt +++ b/src/model/CMakeLists.txt @@ -968,6 +968,9 @@ set(${target_name}_src OpaqueMaterial.hpp OpaqueMaterial_Impl.hpp OpaqueMaterial.cpp + OutputControlFiles.hpp + OutputControlFiles_Impl.hpp + OutputControlFiles.cpp OutputControlReportingTolerances.hpp OutputControlReportingTolerances_Impl.hpp OutputControlReportingTolerances.cpp @@ -1955,6 +1958,7 @@ set(${target_name}_test_src test/PortList_GTest.cpp test/OpaqueMaterial_GTest.cpp test/OtherEquipment_GTest.cpp + test/OutputControlFiles_GTest.cpp test/OutputControlReportingTolerances_GTest.cpp test/OutputDebuggingData_GTest.cpp test/OutputJSON_GTest.cpp diff --git a/src/model/ConcreteModelObjects.hpp b/src/model/ConcreteModelObjects.hpp index 67482bdb2e6..24454b27cd0 100644 --- a/src/model/ConcreteModelObjects.hpp +++ b/src/model/ConcreteModelObjects.hpp @@ -319,6 +319,7 @@ #include "PortList.hpp" #include "OtherEquipment.hpp" #include "OtherEquipmentDefinition.hpp" +#include "OutputControlFiles.hpp" #include "OutputControlReportingTolerances.hpp" #include "OutputDebuggingData.hpp" #include "OutputDiagnostics.hpp" @@ -810,6 +811,7 @@ #include "PortList_Impl.hpp" #include "OtherEquipment_Impl.hpp" #include "OtherEquipmentDefinition_Impl.hpp" +#include "OutputControlFiles_Impl.hpp" #include "OutputControlReportingTolerances_Impl.hpp" #include "OutputDebuggingData_Impl.hpp" #include "OutputDiagnostics_Impl.hpp" diff --git a/src/model/Model.cpp b/src/model/Model.cpp index 3956499eb55..7cd05f39d68 100644 --- a/src/model/Model.cpp +++ b/src/model/Model.cpp @@ -3007,6 +3007,7 @@ detail::Model_Impl::ModelObjectCreator::ModelObjectCreator() { REGISTER_CONSTRUCTOR(Node); REGISTER_CONSTRUCTOR(OtherEquipment); REGISTER_CONSTRUCTOR(OtherEquipmentDefinition); + REGISTER_CONSTRUCTOR(OutputControlFiles); REGISTER_CONSTRUCTOR(OutputControlReportingTolerances); REGISTER_CONSTRUCTOR(OutputDebuggingData); REGISTER_CONSTRUCTOR(OutputDiagnostics); @@ -3506,6 +3507,7 @@ detail::Model_Impl::ModelObjectCreator::ModelObjectCreator() { REGISTER_COPYCONSTRUCTORS(Node); REGISTER_COPYCONSTRUCTORS(OtherEquipment); REGISTER_COPYCONSTRUCTORS(OtherEquipmentDefinition); + REGISTER_COPYCONSTRUCTORS(OutputControlFiles); REGISTER_COPYCONSTRUCTORS(OutputControlReportingTolerances); REGISTER_COPYCONSTRUCTORS(OutputDebuggingData); REGISTER_COPYCONSTRUCTORS(OutputDiagnostics); diff --git a/src/model/ModelSimulation.i b/src/model/ModelSimulation.i index 21448e1b634..c6de559f106 100644 --- a/src/model/ModelSimulation.i +++ b/src/model/ModelSimulation.i @@ -66,6 +66,7 @@ UNIQUEMODELOBJECT_TEMPLATES(ConvergenceLimits); UNIQUEMODELOBJECT_TEMPLATES(RunPeriodControlDaylightSavingTime); UNIQUEMODELOBJECT_TEMPLATES(HeatBalanceAlgorithm); UNIQUEMODELOBJECT_TEMPLATES(InsideSurfaceConvectionAlgorithm); +UNIQUEMODELOBJECT_TEMPLATES(OutputControlFiles); UNIQUEMODELOBJECT_TEMPLATES(OutputControlReportingTolerances); UNIQUEMODELOBJECT_TEMPLATES(OutputDebuggingData); UNIQUEMODELOBJECT_TEMPLATES(OutputDiagnostics); @@ -110,6 +111,7 @@ SWIG_UNIQUEMODELOBJECT(ConvergenceLimits); SWIG_UNIQUEMODELOBJECT(RunPeriodControlDaylightSavingTime); SWIG_UNIQUEMODELOBJECT(HeatBalanceAlgorithm); SWIG_UNIQUEMODELOBJECT(InsideSurfaceConvectionAlgorithm); +SWIG_UNIQUEMODELOBJECT(OutputControlFiles); SWIG_UNIQUEMODELOBJECT(OutputControlReportingTolerances); SWIG_UNIQUEMODELOBJECT(OutputDebuggingData); SWIG_UNIQUEMODELOBJECT(OutputDiagnostics); diff --git a/src/model/OutputControlFiles.cpp b/src/model/OutputControlFiles.cpp new file mode 100644 index 00000000000..f2622f46ff4 --- /dev/null +++ b/src/model/OutputControlFiles.cpp @@ -0,0 +1,98 @@ +/*********************************************************************************************************************** +* OpenStudio(R), Copyright (c) 2008-2020, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved. +* +* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the +* following conditions are met: +* +* (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following +* disclaimer. +* +* (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the distribution. +* +* (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote products +* derived from this software without specific prior written permission from the respective party. +* +* (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works +* may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior +* written permission from Alliance for Sustainable Energy, LLC. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, +* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED +* STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF +* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +***********************************************************************************************************************/ + +#include "OutputControlFiles.hpp" +#include "OutputControlFiles_Impl.hpp" + +#include +#include + +#include "../utilities/units/Unit.hpp" + +#include "../utilities/core/Assert.hpp" + +namespace openstudio { +namespace model { + +namespace detail { + + OutputControlFiles_Impl::OutputControlFiles_Impl(const IdfObject& idfObject, + Model_Impl* model, + bool keepHandle) + : ModelObject_Impl(idfObject,model,keepHandle) + { + OS_ASSERT(idfObject.iddObject().type() == OutputControlFiles::iddObjectType()); + } + + OutputControlFiles_Impl::OutputControlFiles_Impl(const openstudio::detail::WorkspaceObject_Impl& other, + Model_Impl* model, + bool keepHandle) + : ModelObject_Impl(other,model,keepHandle) + { + OS_ASSERT(other.iddObject().type() == OutputControlFiles::iddObjectType()); + } + + OutputControlFiles_Impl::OutputControlFiles_Impl(const OutputControlFiles_Impl& other, + Model_Impl* model, + bool keepHandle) + : ModelObject_Impl(other,model,keepHandle) + {} + + const std::vector& OutputControlFiles_Impl::outputVariableNames() const + { + static const std::vector result; + return result; + } + + IddObjectType OutputControlFiles_Impl::iddObjectType() const { + return OutputControlFiles::iddObjectType(); + } + + + +} // detail + +IddObjectType OutputControlFiles::iddObjectType() { + return IddObjectType(IddObjectType::OS_OutputControl_Files); +} + + + +/// @cond +OutputControlFiles::OutputControlFiles(std::shared_ptr impl) + : ModelObject(std::move(impl)) +{} +OutputControlFiles::OutputControlFiles(Model& model) + : ModelObject(OutputControlFiles::iddObjectType(),model) +{} + +/// @endcond + +} // model +} // openstudio diff --git a/src/model/OutputControlFiles.hpp b/src/model/OutputControlFiles.hpp new file mode 100644 index 00000000000..fedcef4ff19 --- /dev/null +++ b/src/model/OutputControlFiles.hpp @@ -0,0 +1,101 @@ +/*********************************************************************************************************************** +* OpenStudio(R), Copyright (c) 2008-2020, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved. +* +* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the +* following conditions are met: +* +* (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following +* disclaimer. +* +* (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the distribution. +* +* (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote products +* derived from this software without specific prior written permission from the respective party. +* +* (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works +* may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior +* written permission from Alliance for Sustainable Energy, LLC. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, +* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED +* STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF +* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +***********************************************************************************************************************/ + +#ifndef MODEL_OUTPUTCONTROLFILES_HPP +#define MODEL_OUTPUTCONTROLFILES_HPP + +#include "ModelAPI.hpp" +#include "ModelObject.hpp" + +namespace openstudio { + + +namespace model { + +namespace detail { + + class OutputControlFiles_Impl; + +} // detail + +/** OutputControlFiles is a ModelObject that wraps the OpenStudio IDD object 'OS:OutputControl:Files'. */ +class MODEL_API OutputControlFiles : public ModelObject { + public: + /** @name Constructors and Destructors */ + //@{ + + virtual ~OutputControlFiles() {} + + //@} + + static IddObjectType iddObjectType(); + + /** @name Getters */ + //@{ + + + + //@} + /** @name Setters */ + //@{ + + + + //@} + /** @name Other */ + //@{ + + //@} + protected: + /// @cond + typedef detail::OutputControlFiles_Impl ImplType; + + explicit OutputControlFiles(std::shared_ptr impl); + + friend class detail::OutputControlFiles_Impl; + friend class Model; + friend class IdfObject; + friend class openstudio::detail::IdfObject_Impl; + explicit OutputControlFiles(Model& model); + + /// @endcond + private: + REGISTER_LOGGER("openstudio.model.OutputControlFiles"); +}; + +/** \relates OutputControlFiles*/ +typedef boost::optional OptionalOutputControlFiles; + +/** \relates OutputControlFiles*/ +typedef std::vector OutputControlFilesVector; + +} // model +} // openstudio + +#endif // MODEL_OUTPUTCONTROLFILES_HPP diff --git a/src/model/OutputControlFiles_Impl.hpp b/src/model/OutputControlFiles_Impl.hpp new file mode 100644 index 00000000000..ceaee3c57a8 --- /dev/null +++ b/src/model/OutputControlFiles_Impl.hpp @@ -0,0 +1,100 @@ +/*********************************************************************************************************************** +* OpenStudio(R), Copyright (c) 2008-2020, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved. +* +* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the +* following conditions are met: +* +* (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following +* disclaimer. +* +* (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the distribution. +* +* (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote products +* derived from this software without specific prior written permission from the respective party. +* +* (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works +* may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior +* written permission from Alliance for Sustainable Energy, LLC. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, +* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED +* STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF +* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +***********************************************************************************************************************/ + +#ifndef MODEL_OUTPUTCONTROLFILES_IMPL_HPP +#define MODEL_OUTPUTCONTROLFILES_IMPL_HPP + +#include "ModelAPI.hpp" +#include "ModelObject_Impl.hpp" + + +namespace openstudio { +namespace model { + +namespace detail { + + /** OutputControlFiles_Impl is a ModelObject_Impl that is the implementation class for OutputControlFiles.*/ + class MODEL_API OutputControlFiles_Impl : public ModelObject_Impl { + + public: + /** @name Constructors and Destructors */ + //@{ + + OutputControlFiles_Impl(const IdfObject& idfObject, + Model_Impl* model, + bool keepHandle); + + OutputControlFiles_Impl(const openstudio::detail::WorkspaceObject_Impl& other, + Model_Impl* model, + bool keepHandle); + + OutputControlFiles_Impl(const OutputControlFiles_Impl& other, + Model_Impl* model, + bool keepHandle); + + virtual ~OutputControlFiles_Impl() {} + + //@} + + /** @name Virtual Methods */ + //@{ + + virtual const std::vector& outputVariableNames() const override; + + virtual IddObjectType iddObjectType() const override; + + //@} + /** @name Getters */ + //@{ + + + + //@} + /** @name Setters */ + //@{ + + + + //@} + /** @name Other */ + //@{ + + //@} + protected: + private: + REGISTER_LOGGER("openstudio.model.OutputControlFiles"); + + }; + +} // detail + +} // model +} // openstudio + +#endif // MODEL_OUTPUTCONTROLFILES_IMPL_HPP diff --git a/src/model/test/OutputControlFiles_GTest.cpp b/src/model/test/OutputControlFiles_GTest.cpp new file mode 100644 index 00000000000..cf3db63e76a --- /dev/null +++ b/src/model/test/OutputControlFiles_GTest.cpp @@ -0,0 +1,44 @@ +/*********************************************************************************************************************** +* OpenStudio(R), Copyright (c) 2008-2020, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved. +* +* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the +* following conditions are met: +* +* (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following +* disclaimer. +* +* (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the distribution. +* +* (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote products +* derived from this software without specific prior written permission from the respective party. +* +* (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works +* may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior +* written permission from Alliance for Sustainable Energy, LLC. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, +* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED +* STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF +* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +***********************************************************************************************************************/ + +#include + +#include "ModelFixture.hpp" +#include "../OutputControlFiles.hpp" +#include "../OutputControlFiles_Impl.hpp" + +using namespace openstudio; +using namespace openstudio::model; + +TEST_F(ModelFixture,OutputControlFiles_GettersSetters) { + Model model; + OutputControlFiles outputControlFiles = model.getUniqueModelObject(); + + +} diff --git a/src/model/test/UniqueModelObject_GTest.cpp b/src/model/test/UniqueModelObject_GTest.cpp index ae9f94bf8d2..47d0ac2f668 100644 --- a/src/model/test/UniqueModelObject_GTest.cpp +++ b/src/model/test/UniqueModelObject_GTest.cpp @@ -54,6 +54,8 @@ #include "../LifeCycleCostParameters_Impl.hpp" #include "../LightingSimulationControl.hpp" #include "../LightingSimulationControl_Impl.hpp" +#include "../OutputControlFiles.hpp" +#include "../OutputControlFiles_Impl.hpp" #include "../OutputControlReportingTolerances.hpp" #include "../OutputControlReportingTolerances_Impl.hpp" #include "../OutputDebuggingData.hpp" @@ -347,6 +349,14 @@ TEST_F(ModelFixture, LightingSimulationControl_UniqueModelObject_Clone) EXPECT_EQ("! Custom Object", lightingSimulationControlClone2.comment()); } +TEST_F(ModelFixture, OutputControlFiles_UniqueModelObject_Clone) +{ + // create a model to use + Model model; + + +} + TEST_F(ModelFixture, OutputControlReportingTolerances_UniqueModelObject_Clone) { // create a model to use From b79e187b280c7d873db88df0fe09cde67550f771 Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Wed, 26 Aug 2020 10:43:33 -0700 Subject: [PATCH 03/12] Add and stub energyplus files. --- src/energyplus/CMakeLists.txt | 1 + src/energyplus/ForwardTranslator.cpp | 11 +++- src/energyplus/ForwardTranslator.hpp | 3 + .../ForwardTranslateOutputControlFiles.cpp | 65 +++++++++++++++++++ 4 files changed, 78 insertions(+), 2 deletions(-) create mode 100644 src/energyplus/ForwardTranslator/ForwardTranslateOutputControlFiles.cpp diff --git a/src/energyplus/CMakeLists.txt b/src/energyplus/CMakeLists.txt index b0fa8a8e4d3..0be6f3c1fd2 100644 --- a/src/energyplus/CMakeLists.txt +++ b/src/energyplus/CMakeLists.txt @@ -229,6 +229,7 @@ set(${target_name}_src ForwardTranslator/ForwardTranslateNode.cpp ForwardTranslator/ForwardTranslateOtherEquipment.cpp ForwardTranslator/ForwardTranslateOutsideSurfaceConvectionAlgorithm.cpp + ForwardTranslator/ForwardTranslateOutputControlFiles.cpp ForwardTranslator/ForwardTranslateOutputControlReportingTolerances.cpp ForwardTranslator/ForwardTranslateOutputMeter.cpp ForwardTranslator/ForwardTranslateOutputVariable.cpp diff --git a/src/energyplus/ForwardTranslator.cpp b/src/energyplus/ForwardTranslator.cpp index 33b4ebaeca5..f2b5f288236 100644 --- a/src/energyplus/ForwardTranslator.cpp +++ b/src/energyplus/ForwardTranslator.cpp @@ -2438,10 +2438,16 @@ boost::optional ForwardTranslator::translateAndMapModelObject(ModelOb retVal = translatePumpVariableSpeed(pump); break; } + case openstudio::IddObjectType::OS_OutputControl_Files : + { + model::OutputControlFiles outputControlFiles = modelObject.cast(); + retVal = translateOutputControlFiles(outputControlFiles); + break; + } case openstudio::IddObjectType::OS_OutputControl_ReportingTolerances : { - model::OutputControlReportingTolerances outputControl = modelObject.cast(); - retVal = translateOutputControlReportingTolerances(outputControl); + model::OutputControlReportingTolerances outputControlReportingTolerances = modelObject.cast(); + retVal = translateOutputControlReportingTolerances(outputControlReportingTolerances); break; } case openstudio::IddObjectType::OS_Output_DebuggingData : @@ -3530,6 +3536,7 @@ std::vector ForwardTranslator::iddObjectsToTranslateInitializer() result.push_back(IddObjectType::OS_ZoneAirHeatBalanceAlgorithm); result.push_back(IddObjectType::OS_ZoneAirMassFlowConservation); result.push_back(IddObjectType::OS_ZoneCapacitanceMultiplier_ResearchSpecial); + result.push_back(IddObjectType::OS_OutputControl_Files); result.push_back(IddObjectType::OS_OutputControl_ReportingTolerances); result.push_back(IddObjectType::OS_Output_DebuggingData); result.push_back(IddObjectType::OS_Output_Diagnostics); diff --git a/src/energyplus/ForwardTranslator.hpp b/src/energyplus/ForwardTranslator.hpp index 5e30a33b542..4730498e457 100644 --- a/src/energyplus/ForwardTranslator.hpp +++ b/src/energyplus/ForwardTranslator.hpp @@ -283,6 +283,7 @@ class MeterCustomDecrement; class Node; class OtherEquipment; class OutsideSurfaceConvectionAlgorithm; +class OutputControlFiles; class OutputControlReportingTolerances; class OutputDebuggingData; class OutputDiagnostics; @@ -1016,6 +1017,8 @@ class ENERGYPLUS_API ForwardTranslator { boost::optional translateOutsideSurfaceConvectionAlgorithm( model::OutsideSurfaceConvectionAlgorithm & modelObject ); + boost::optional translateOutputControlFiles( model::OutputControlFiles & modelObject ); + boost::optional translateOutputControlReportingTolerances( model::OutputControlReportingTolerances & modelObject ); boost::optional translateOutputDebuggingData( model::OutputDebuggingData & modelObject ); diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateOutputControlFiles.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateOutputControlFiles.cpp new file mode 100644 index 00000000000..2e59e61a41b --- /dev/null +++ b/src/energyplus/ForwardTranslator/ForwardTranslateOutputControlFiles.cpp @@ -0,0 +1,65 @@ +/*********************************************************************************************************************** +* OpenStudio(R), Copyright (c) 2008-2020, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved. +* +* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the +* following conditions are met: +* +* (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following +* disclaimer. +* +* (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the distribution. +* +* (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote products +* derived from this software without specific prior written permission from the respective party. +* +* (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works +* may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior +* written permission from Alliance for Sustainable Energy, LLC. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, +* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED +* STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF +* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +***********************************************************************************************************************/ + +#include "../ForwardTranslator.hpp" +#include "../../model/Model.hpp" +#include "../../model/OutputControlFiles.hpp" +#include +#include "../../utilities/idd/IddEnums.hpp" +#include +#include + +using namespace openstudio::model; + +using namespace std; + +namespace openstudio { + +namespace energyplus { + +boost::optional ForwardTranslator::translateOutputControlFiles( OutputControlFiles& modelObject ) +{ + IdfObject idfObject( openstudio::IddObjectType::OutputControl_Files ); + + m_idfObjects.push_back(idfObject); + + OptionalString s = modelObject.name(); + if( s ) + { + idfObject.setName(*s); + } + + + return boost::optional(idfObject); +} + +} // energyplus + +} // openstudio + From 79aa90e9669c609f4c9ffc9343b607c60dadab90 Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Wed, 26 Aug 2020 13:07:36 -0700 Subject: [PATCH 04/12] Update idd. --- resources/model/OpenStudio.idd | 62 +++++++++++++++++----------------- 1 file changed, 31 insertions(+), 31 deletions(-) diff --git a/resources/model/OpenStudio.idd b/resources/model/OpenStudio.idd index 9bfa6b2672d..b4625ea2dc3 100644 --- a/resources/model/OpenStudio.idd +++ b/resources/model/OpenStudio.idd @@ -30895,158 +30895,158 @@ OutputControl:Files, \type choice \key Yes \key No - \default No + \required-field A3, \field Output MTR \type choice \key Yes \key No - \default No + \required-field A4, \field Output ESO \type choice \key Yes \key No - \default Yes + \required-field A5, \field Output EIO \type choice \key Yes \key No - \default Yes + \required-field A6, \field Output Tabular \type choice \key Yes \key No - \default Yes + \required-field A7, \field Output SQLite \type choice \key Yes \key No - \default Yes + \required-field A8, \field Output JSON \type choice \key Yes \key No - \default Yes + \required-field A9, \field Output AUDIT \type choice \key Yes \key No - \default Yes + \required-field A10, \field Output Zone Sizing \type choice \key Yes \key No - \default Yes + \required-field A11, \field Output System Sizing \type choice \key Yes \key No - \default Yes + \required-field A12, \field Output DXF \type choice \key Yes \key No - \default Yes + \required-field A13, \field Output BND \type choice \key Yes \key No - \default Yes + \required-field A14, \field Output RDD \type choice \key Yes \key No - \default Yes + \required-field A15, \field Output MDD \type choice \key Yes \key No - \default Yes + \required-field A16, \field Output MTD \type choice \key Yes \key No - \default Yes + \required-field A17, \field Output END \type choice \key Yes \key No - \default Yes + \required-field A18, \field Output SHD \type choice \key Yes \key No - \default Yes + \required-field A19, \field Output DFS \type choice \key Yes \key No - \default Yes + \required-field A20, \field Output GLHE \type choice \key Yes \key No - \default Yes + \required-field A21, \field Output DelightIn \type choice \key Yes \key No - \default Yes + \required-field A22, \field Output DelightELdmp \type choice \key Yes \key No - \default Yes + \required-field A23, \field Output DelightDFdmp \type choice \key Yes \key No - \default Yes + \required-field A24, \field Output EDD \type choice \key Yes \key No - \default Yes + \required-field A25, \field Output DBG \type choice \key Yes \key No - \default Yes + \required-field A26, \field Output PerfLog \type choice \key Yes \key No - \default Yes + \required-field A27, \field Output SLN \type choice \key Yes \key No - \default Yes + \required-field A28, \field Output SCI \type choice \key Yes \key No - \default Yes + \required-field A29, \field Output WRL \type choice \key Yes \key No - \default Yes + \required-field A30, \field Output Screen \type choice \key Yes \key No - \default Yes + \required-field A31, \field Output ExtShd \type choice \key Yes \key No - \default Yes + \required-field A32; \field Output Tarcog \note Not Implemented Yet \type choice \key Yes \key No - \default Yes + \required-field OS:OutputControl:ReportingTolerances, \memo Calculations of the time that setpoints are not met use a tolerance of 0.2C. From 98213dcb7a6ab5f8fa0c6e79b6e932e5f078e366 Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Wed, 26 Aug 2020 13:07:46 -0700 Subject: [PATCH 05/12] Fill out moel files. --- src/model/OutputControlFiles.cpp | 549 +++++++++++++++++++++++++- src/model/OutputControlFiles.hpp | 124 +++++- src/model/OutputControlFiles_Impl.hpp | 135 ++++++- 3 files changed, 787 insertions(+), 21 deletions(-) diff --git a/src/model/OutputControlFiles.cpp b/src/model/OutputControlFiles.cpp index f2622f46ff4..45f55163530 100644 --- a/src/model/OutputControlFiles.cpp +++ b/src/model/OutputControlFiles.cpp @@ -30,10 +30,12 @@ #include "OutputControlFiles.hpp" #include "OutputControlFiles_Impl.hpp" -#include -#include +#include "Model.hpp" +#include "Model_Impl.hpp" -#include "../utilities/units/Unit.hpp" +#include +#include +#include #include "../utilities/core/Assert.hpp" @@ -43,30 +45,32 @@ namespace model { namespace detail { OutputControlFiles_Impl::OutputControlFiles_Impl(const IdfObject& idfObject, - Model_Impl* model, - bool keepHandle) + Model_Impl* model, + bool keepHandle) : ModelObject_Impl(idfObject,model,keepHandle) { OS_ASSERT(idfObject.iddObject().type() == OutputControlFiles::iddObjectType()); } OutputControlFiles_Impl::OutputControlFiles_Impl(const openstudio::detail::WorkspaceObject_Impl& other, - Model_Impl* model, - bool keepHandle) + Model_Impl* model, + bool keepHandle) : ModelObject_Impl(other,model,keepHandle) { OS_ASSERT(other.iddObject().type() == OutputControlFiles::iddObjectType()); } OutputControlFiles_Impl::OutputControlFiles_Impl(const OutputControlFiles_Impl& other, - Model_Impl* model, - bool keepHandle) + Model_Impl* model, + bool keepHandle) : ModelObject_Impl(other,model,keepHandle) {} const std::vector& OutputControlFiles_Impl::outputVariableNames() const { static const std::vector result; + if (result.empty()){ + } return result; } @@ -74,7 +78,253 @@ namespace detail { return OutputControlFiles::iddObjectType(); } + bool OutputControlFiles_Impl::outputCSV() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputCSV); + } + + bool OutputControlFiles_Impl::outputMTR() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputMTR); + } + + bool OutputControlFiles_Impl::outputESO() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputESO); + } + + bool OutputControlFiles_Impl::outputEIO() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputEIO); + } + + bool OutputControlFiles_Impl::outputTabular() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputTabular); + } + + bool OutputControlFiles_Impl::outputSQLite() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputSQLite); + } + + bool OutputControlFiles_Impl::outputJSON() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputJSON); + } + + bool OutputControlFiles_Impl::outputAUDIT() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputAUDIT); + } + + bool OutputControlFiles_Impl::outputZoneSizing() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputZoneSizing); + } + + bool OutputControlFiles_Impl::outputSystemSizing() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputSystemSizing); + } + + bool OutputControlFiles_Impl::outputDXF() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputDXF); + } + + bool OutputControlFiles_Impl::outputBND() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputBND); + } + + bool OutputControlFiles_Impl::outputRDD() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputRDD); + } + + bool OutputControlFiles_Impl::outputMDD() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputMDD); + } + + bool OutputControlFiles_Impl::outputMTD() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputMTD); + } + + bool OutputControlFiles_Impl::outputEND() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputEND); + } + + bool OutputControlFiles_Impl::outputSHD() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputSHD); + } + + bool OutputControlFiles_Impl::outputDFS() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputDFS); + } + + bool OutputControlFiles_Impl::outputGLHE() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputGLHE); + } + + bool OutputControlFiles_Impl::outputDelightIn() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputDelightIn); + } + + bool OutputControlFiles_Impl::outputDelightELdmp() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputDelightELdmp); + } + + bool OutputControlFiles_Impl::outputDelightDFdmp() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputDelightDFdmp); + } + + bool OutputControlFiles_Impl::outputEDD() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputEDD); + } + + bool OutputControlFiles_Impl::outputDBG() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputDBG); + } + + bool OutputControlFiles_Impl::outputPerfLog() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputPerfLog); + } + + bool OutputControlFiles_Impl::outputSLN() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputSLN); + } + + bool OutputControlFiles_Impl::outputSCI() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputSCI); + } + + bool OutputControlFiles_Impl::outputWRL() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputWRL); + } + + bool OutputControlFiles_Impl::outputScreen() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputScreen); + } + + bool OutputControlFiles_Impl::outputExtShd() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputExtShd); + } + + bool OutputControlFiles_Impl::outputTarcog() const { + return getBooleanFieldValue(OS_OutputControl_FilesFields::OutputTarcog); + } + + bool OutputControlFiles_Impl::setOutputCSV(bool outputCSV) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::Output, output); + } + + bool OutputControlFiles_Impl::setOutputMTR(bool outputMTR) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::Output, output); + } + + bool OutputControlFiles_Impl::setOutputESO(bool outputESO) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::Output, output); + } + + bool OutputControlFiles_Impl::setOutputEIO(bool outputEIO) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::Output, output); + } + + bool OutputControlFiles_Impl::setOutputTabular(bool outputTabular) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::Output, output); + } + + bool OutputControlFiles_Impl::setOutputSQLite(bool outputSQLite) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::Output, output); + } + + bool OutputControlFiles_Impl::setOutputJSON(bool outputJSON) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::Output, output); + } + + bool OutputControlFiles_Impl::setOutputAUDIT(bool outputAUDIT) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::Output, output); + } + + bool OutputControlFiles_Impl::setOutputZoneSizing(bool outputZoneSizing) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::Output, output); + } + + bool OutputControlFiles_Impl::setOutputSystemSizing(bool outputSystemSizing) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::Output, output); + } + + bool OutputControlFiles_Impl::setOutputDXF(bool outputDXF) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputDXF, outputDXF); + } + + bool OutputControlFiles_Impl::setOutputBND(bool outputBND) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputBND, outputBND); + } + + bool OutputControlFiles_Impl::setOutputRDD(bool outputRDD) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputRDD, outputRDD); + } + + bool OutputControlFiles_Impl::setOutputMDD(bool outputMDD) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputMDD, outputMDD); + } + + bool OutputControlFiles_Impl::setOutputMTD(bool outputMTD) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputMTD, outputMTD); + } + + bool OutputControlFiles_Impl::setOutputEND(bool outputEND) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputEND, outputEND); + } + + bool OutputControlFiles_Impl::setOutputSHD(bool outputSHD) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputSHD, outputSHD); + } + + bool OutputControlFiles_Impl::setOutputDFS(bool outputDFS) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputDFS, outputDFS); + } + + bool OutputControlFiles_Impl::setOutputGLHE(bool outputGLHE) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputGLHE, outputGLHE); + } + + bool OutputControlFiles_Impl::setOutputDelightIn(bool outputDelightIn) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputDelightIn, outputDelightIn); + } + + bool OutputControlFiles_Impl::setOutputDelightELdmp(bool outputDelightELdmp) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputDelightELdmp, outputDelightELdmp); + } + + bool OutputControlFiles_Impl::setOutputDelightDFdmp(bool outputDelightDFdmp) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputDelightDFdmp, outputDelightDFdmp); + } + + bool OutputControlFiles_Impl::setOutputEDD(bool outputEDD) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputEDD, outputEDD); + } + + bool OutputControlFiles_Impl::setOutputDBG(bool outputDBG) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputDBG, outputDBG); + } + + bool OutputControlFiles_Impl::setOutputPerfLog(bool outputPerfLog) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputPerfLog, outputPerfLog); + } + + bool OutputControlFiles_Impl::setOutputSLN(bool outputSLN) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputSLN, outputSLN); + } + + bool OutputControlFiles_Impl::setOutputSCI(bool outputSCI) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputSCI, outputSCI); + } + + bool OutputControlFiles_Impl::setOutputWRL(bool outputWRL) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputWRL, outputWRL); + } + + bool OutputControlFiles_Impl::setOutputScreen(bool outputScreen) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputScreen, outputScreen); + } + + bool OutputControlFiles_Impl::setOutputExtShd(bool outputExtShd) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputExtShd, outputExtShd); + } + bool OutputControlFiles_Impl::setOutputTarcog(bool outputTarcog) { + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputTarcog, outputTarcog); + } } // detail @@ -82,7 +332,253 @@ IddObjectType OutputControlFiles::iddObjectType() { return IddObjectType(IddObjectType::OS_OutputControl_Files); } +bool OutputControlFiles::outputCSV() const { + return getImpl()->outputCSV(); +} + +bool OutputControlFiles::outputMTR() const { + return getImpl()->outputMTR(); +} + +bool OutputControlFiles::outputESO() const { + return getImpl()->outputESO(); +} + +bool OutputControlFiles::outputEIO() const { + return getImpl()->outputEIO(); +} + +bool OutputControlFiles::outputTabular() const { + return getImpl()->outputTabular(); +} + +bool OutputControlFiles::outputSQLite() const { + return getImpl()->outputSQLite(); +} + +bool OutputControlFiles::outputJSON() const { + return getImpl()->outputJSON(); +} + +bool OutputControlFiles::outputAUDIT() const { + return getImpl()->outputAUDIT(); +} + +bool OutputControlFiles::outputZoneSizing() const { + return getImpl()->outputZoneSizing(); +} + +bool OutputControlFiles::outputSystemSizing() const { + return getImpl()->outputSystemSizing(); +} + +bool OutputControlFiles::outputDXF() const { + return getImpl()->outputDXF(); +} + +bool OutputControlFiles::outputBND() const { + return getImpl()->outputBND(); +} + +bool OutputControlFiles::outputRDD() const { + return getImpl()->outputRDD(); +} + +bool OutputControlFiles::outputMDD() const { + return getImpl()->outputMDD(); +} + +bool OutputControlFiles::outputMTD() const { + return getImpl()->outputMTD(); +} + +bool OutputControlFiles::outputEND() const { + return getImpl()->outputEND(); +} +bool OutputControlFiles::outputSHD() const { + return getImpl()->outputSHD(); +} + +bool OutputControlFiles::outputDFS() const { + return getImpl()->outputDFS(); +} + +bool OutputControlFiles::outputGLHE() const { + return getImpl()->outputGLHE(); +} + +bool OutputControlFiles::outputDelightIn() const { + return getImpl()->outputDelightIn(); +} + +bool OutputControlFiles::outputDelightELdmp() const { + return getImpl()->outputDelightELdmp(); +} + +bool OutputControlFiles::outputDelightDFdmp() const { + return getImpl()->outputDelightDFdmp(); +} + +bool OutputControlFiles::outputEDD() const { + return getImpl()->outputEDD(); +} + +bool OutputControlFiles::outputDBG() const { + return getImpl()->outputDBG(); +} + +bool OutputControlFiles::outputPerfLog() const { + return getImpl()->outputPerfLog(); +} + +bool OutputControlFiles::outputSLN() const { + return getImpl()->outputSLN(); +} + +bool OutputControlFiles::outputSCI() const { + return getImpl()->outputSCI(); +} + +bool OutputControlFiles::outputWRL() const { + return getImpl()->outputWRL(); +} + +bool OutputControlFiles::outputScreen() const { + return getImpl()->outputScreen(); +} + +bool OutputControlFiles::outputExtShd() const { + return getImpl()->outputExtShd(); +} + +bool OutputControlFiles::outputTarcog() const { + return getImpl()->outputTarcog(); +} + +bool OutputControlFiles::setOutputCSV(bool outputCSV) { + return getImpl()->setOutputCSV(outputCSV); +} + +bool OutputControlFiles::setOutputMTR(bool outputMTR) { + return getImpl()->setOutputMTR(outputMTR); +} + +bool OutputControlFiles::setOutputESO(bool outputESO) { + return getImpl()->setOutputESO(outputESO); +} + +bool OutputControlFiles::setOutputEIO(bool outputEIO) { + return getImpl()->setOutputEIO(outputEIO); +} + +bool OutputControlFiles::setOutputTabular(bool outputTabular) { + return getImpl()->setOutputTabular(outputTabular); +} + +bool OutputControlFiles::setOutputSQLite(bool outputSQLite) { + return getImpl()->setOutputSQLite(outputSQLite); +} + +bool OutputControlFiles::setOutputJSON(bool outputJSON) { + return getImpl()->setOutputJSON(outputJSON); +} + +bool OutputControlFiles::setOutputAUDIT(bool outputAUDIT) { + return getImpl()->setOutputAUDIT(outputAUDIT); +} + +bool OutputControlFiles::setOutputZoneSizing(bool outputZoneSizing) { + return getImpl()->setOutputZoneSizing(outputZoneSizing); +} + +bool OutputControlFiles::setOutputSystemSizing(bool outputSystemSizing) { + return getImpl()->setOutputSystemSizing(outputSystemSizing); +} + +bool OutputControlFiles::setOutputDXF(bool outputDXF) { + return getImpl()->setOutputDXF(outputDXF); +} + +bool OutputControlFiles::setOutputBND(bool outputBND) { + return getImpl()->setOutputBND(outputBND); +} + +bool OutputControlFiles::setOutputRDD(bool outputRDD) { + return getImpl()->setOutputRDD(outputRDD); +} + +bool OutputControlFiles::setOutputMDD(bool outputMDD) { + return getImpl()->setOutputMDD(outputMDD); +} + +bool OutputControlFiles::setOutputMTD(bool outputMTD) { + return getImpl()->setOutputMTD(outputMTD); +} + +bool OutputControlFiles::setOutputEND(bool outputEND) { + return getImpl()->setOutputEND(outputEND); +} + +bool OutputControlFiles::setOutputSHD(bool outputSHD) { + return getImpl()->setOutputSHD(outputSHD); +} + +bool OutputControlFiles::setOutputDFS(bool outputDFS) { + return getImpl()->setOutputDFS(outputDFS); +} + +bool OutputControlFiles::setOutputGLHE(bool outputGLHE) { + return getImpl()->setOutputGLHE(outputGLHE); +} + +bool OutputControlFiles::setOutputDelightIn(bool outputDelightIn) { + return getImpl()->setOutputDelightIn(outputDelightIn); +} + +bool OutputControlFiles::setOutputDelightELdmp(bool outputDelightELdmp) { + return getImpl()->setOutputDelightELdmp(outputDelightELdmp); +} + +bool OutputControlFiles::setOutputDelightDFdmp(bool outputDelightDFdmp) { + return getImpl()->setOutputDelightDFdmp(outputDelightDFdmp); +} + +bool OutputControlFiles::setOutputEDD(bool outputEDD) { + return getImpl()->setOutputEDD(outputEDD); +} + +bool OutputControlFiles::setOutputDBG(bool outputDBG) { + return getImpl()->setOutputDBG(outputDBG); +} + +bool OutputControlFiles::setOutputPerfLog(bool outputPerfLog) { + return getImpl()->setOutputPerfLog(outputPerfLog); +} + +bool OutputControlFiles::setOutputSLN(bool outputSLN) { + return getImpl()->setOutputSLN(outputSLN); +} + +bool OutputControlFiles::setOutputSCI(bool outputSCI) { + return getImpl()->setOutputSCI(outputSCI); +} + +bool OutputControlFiles::setOutputWRL(bool outputWRL) { + return getImpl()->setOutputWRL(outputWRL); +} + +bool OutputControlFiles::setOutputScreen(bool outputScreen) { + return getImpl()->setOutputScreen(outputScreen); +} + +bool OutputControlFiles::setOutputExtShd(bool outputExtShd) { + return getImpl()->setOutputExtShd(outputExtShd); +} + +bool OutputControlFiles::setOutputTarcog(bool outputTarcog) { + return getImpl()->setOutputTarcog(outputTarcog); +} /// @cond OutputControlFiles::OutputControlFiles(std::shared_ptr impl) @@ -90,7 +586,40 @@ OutputControlFiles::OutputControlFiles(std::shared_ptr" #include "ModelObject.hpp" namespace openstudio { - - namespace model { namespace detail { @@ -59,13 +57,133 @@ class MODEL_API OutputControlFiles : public ModelObject { /** @name Getters */ //@{ + bool outputCSV() const; + + bool outputMTR() const; + + bool outputESO() const; + + bool outputEIO() const; + + bool outputTabular() const; + + bool outputSQLite() const; + + bool outputJSON() const; + + bool outputAUDIT() const; + + bool outputZoneSizing() const; + + bool outputSystemSizing() const; + + bool outputDXF() const; + + bool outputBND() const; + + bool outputRDD() const; + + bool outputMDD() const; + + bool outputMTD() const; + + bool outputEND() const; + + bool outputSHD() const; + + bool outputDFS() const; + + bool outputGLHE() const; + + bool outputDelightIn() const; + + bool outputDelightELdmp() const; + + bool outputDelightDFdmp() const; + + bool outputEDD() const; + + bool outputDBG() const; + + bool outputPerfLog() const; + + bool outputSLN() const; + + bool outputSCI() const; + + bool outputWRL() const; + + bool outputScreen() const; + bool outputExtShd() const; + + bool outputTarcog() const; //@} /** @name Setters */ //@{ + bool setOutputCSV(bool outputCSV); + + bool setOutputMTR(bool outputMTR); + + bool setOutputESO(bool outputESO); + + bool setOutputEIO(bool outputEIO); + + bool setOutputTabular(bool outputTabular); + + bool setOutputSQLite(bool outputSQLite); + + bool setOutputJSON(bool outputJSON); + + bool setOutputAUDIT(bool outputAUDIT); + + bool setOutputZoneSizing(bool outputZoneSizing); + + bool setOutputSystemSizing(bool outputSystemSizing); + + bool setOutputDXF(bool outputDXF); + + bool setOutputBND(bool outputBND); + + bool setOutputRDD(bool outputRDD); + + bool setOutputMDD(bool outputMDD); + + bool setOutputMTD(bool outputMTD); + + bool setOutputEND(bool outputEND); + + bool setOutputSHD(bool outputSHD); + + bool setOutputDFS(bool outputDFS); + + bool setOutputGLHE(bool outputGLHE); + + bool setOutputDelightIn(bool outputDelightIn); + + bool setOutputDelightELdmp(bool outputDelightELdmp); + + bool setOutputDelightDFdmp(bool outputDelightDFdmp); + + bool setOutputEDD(bool outputEDD); + + bool setOutputDBG(bool outputDBG); + + bool setOutputPerfLog(bool outputPerfLog); + + bool setOutputSLN(bool outputSLN); + + bool setOutputSCI(bool outputSCI); + + bool setOutputWRL(bool outputWRL); + + bool setOutputScreen(bool outputScreen); + + bool setOutputExtShd(bool outputExtShd); + bool setOutputTarcog(bool outputTarcog); //@} /** @name Other */ diff --git a/src/model/OutputControlFiles_Impl.hpp b/src/model/OutputControlFiles_Impl.hpp index ceaee3c57a8..fe31dcdb46e 100644 --- a/src/model/OutputControlFiles_Impl.hpp +++ b/src/model/OutputControlFiles_Impl.hpp @@ -30,10 +30,9 @@ #ifndef MODEL_OUTPUTCONTROLFILES_IMPL_HPP #define MODEL_OUTPUTCONTROLFILES_IMPL_HPP -#include "ModelAPI.hpp" +#include "" #include "ModelObject_Impl.hpp" - namespace openstudio { namespace model { @@ -47,16 +46,16 @@ namespace detail { //@{ OutputControlFiles_Impl(const IdfObject& idfObject, - Model_Impl* model, - bool keepHandle); + Model_Impl* model, + bool keepHandle); OutputControlFiles_Impl(const openstudio::detail::WorkspaceObject_Impl& other, - Model_Impl* model, - bool keepHandle); + Model_Impl* model, + bool keepHandle); OutputControlFiles_Impl(const OutputControlFiles_Impl& other, - Model_Impl* model, - bool keepHandle); + Model_Impl* model, + bool keepHandle); virtual ~OutputControlFiles_Impl() {} @@ -73,13 +72,133 @@ namespace detail { /** @name Getters */ //@{ + bool outputCSV() const; + + bool outputMTR() const; + + bool outputESO() const; + + bool outputEIO() const; + + bool outputTabular() const; + + bool outputSQLite() const; + + bool outputJSON() const; + + bool outputAUDIT() const; + + bool outputZoneSizing() const; + + bool outputSystemSizing() const; + + bool outputDXF() const; + + bool outputBND() const; + + bool outputRDD() const; + + bool outputMDD() const; + + bool outputMTD() const; + + bool outputEND() const; + + bool outputSHD() const; + + bool outputDFS() const; + + bool outputGLHE() const; + + bool outputDelightIn() const; + + bool outputDelightELdmp() const; + + bool outputDelightDFdmp() const; + + bool outputEDD() const; + + bool outputDBG() const; + + bool outputPerfLog() const; + + bool outputSLN() const; + + bool outputSCI() const; + + bool outputWRL() const; + + bool outputScreen() const; + + bool outputExtShd() const; + bool outputTarcog() const; //@} /** @name Setters */ //@{ + bool setOutputCSV(bool outputCSV); + + bool setOutputMTR(bool outputMTR); + + bool setOutputESO(bool outputESO); + + bool setOutputEIO(bool outputEIO); + + bool setOutputTabular(bool outputTabular); + + bool setOutputSQLite(bool outputSQLite); + + bool setOutputJSON(bool outputJSON); + + bool setOutputAUDIT(bool outputAUDIT); + + bool setOutputZoneSizing(bool outputZoneSizing); + + bool setOutputSystemSizing(bool outputSystemSizing); + + bool setOutputDXF(bool outputDXF); + + bool setOutputBND(bool outputBND); + + bool setOutputRDD(bool outputRDD); + + bool setOutputMDD(bool outputMDD); + + bool setOutputMTD(bool outputMTD); + + bool setOutputEND(bool outputEND); + + bool setOutputSHD(bool outputSHD); + + bool setOutputDFS(bool outputDFS); + + bool setOutputGLHE(bool outputGLHE); + + bool setOutputDelightIn(bool outputDelightIn); + + bool setOutputDelightELdmp(bool outputDelightELdmp); + + bool setOutputDelightDFdmp(bool outputDelightDFdmp); + + bool setOutputEDD(bool outputEDD); + + bool setOutputDBG(bool outputDBG); + + bool setOutputPerfLog(bool outputPerfLog); + + bool setOutputSLN(bool outputSLN); + + bool setOutputSCI(bool outputSCI); + + bool setOutputWRL(bool outputWRL); + + bool setOutputScreen(bool outputScreen); + + bool setOutputExtShd(bool outputExtShd); + bool setOutputTarcog(bool outputTarcog); //@} /** @name Other */ From aba92a204f587cee8086a8c4dda8a6d2786f1ab3 Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Wed, 26 Aug 2020 13:07:56 -0700 Subject: [PATCH 06/12] Update ft and rt. --- src/energyplus/CMakeLists.txt | 2 + .../ForwardTranslateOutputControlFiles.cpp | 197 +++++++++++++++++- src/energyplus/ReverseTranslator.cpp | 5 + src/energyplus/ReverseTranslator.hpp | 2 + .../ReverseTranslateOutputControlFiles.cpp | 59 ++++++ .../Test/OutputControlFiles_GTest.cpp | 79 +++++++ 6 files changed, 334 insertions(+), 10 deletions(-) create mode 100644 src/energyplus/ReverseTranslator/ReverseTranslateOutputControlFiles.cpp create mode 100644 src/energyplus/Test/OutputControlFiles_GTest.cpp diff --git a/src/energyplus/CMakeLists.txt b/src/energyplus/CMakeLists.txt index 0be6f3c1fd2..b6d696531d4 100644 --- a/src/energyplus/CMakeLists.txt +++ b/src/energyplus/CMakeLists.txt @@ -486,6 +486,7 @@ set(${target_name}_src ReverseTranslator/ReverseTranslateMeterCustom.cpp ReverseTranslator/ReverseTranslateMeterCustomDecrement.cpp ReverseTranslator/ReverseTranslateOtherEquipment.cpp + ReverseTranslator/ReverseTranslateOutputControlFiles.cpp ReverseTranslator/ReverseTranslateOutputDebuggingData.cpp ReverseTranslator/ReverseTranslateOutputDiagnostics.cpp ReverseTranslator/ReverseTranslateOutputEnergyManagementSystem.cpp @@ -634,6 +635,7 @@ set(${target_name}_test_src Test/Lights_GTest.cpp Test/Luminaire_GTest.cpp Test/Meter_GTest.cpp + Test/OutputControlFiles_GTest.cpp Test/OutputDebuggingData_GTest.cpp Test/OutputDiagnostics_GTest.cpp Test/OutputJSON_GTest.cpp diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateOutputControlFiles.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateOutputControlFiles.cpp index 2e59e61a41b..4f33866f222 100644 --- a/src/energyplus/ForwardTranslator/ForwardTranslateOutputControlFiles.cpp +++ b/src/energyplus/ForwardTranslator/ForwardTranslateOutputControlFiles.cpp @@ -29,16 +29,15 @@ #include "../ForwardTranslator.hpp" #include "../../model/Model.hpp" + #include "../../model/OutputControlFiles.hpp" + #include -#include "../../utilities/idd/IddEnums.hpp" +// #include "../../utilities/idd/IddEnums.hpp" #include -#include using namespace openstudio::model; -using namespace std; - namespace openstudio { namespace energyplus { @@ -46,17 +45,195 @@ namespace energyplus { boost::optional ForwardTranslator::translateOutputControlFiles( OutputControlFiles& modelObject ) { IdfObject idfObject( openstudio::IddObjectType::OutputControl_Files ); - m_idfObjects.push_back(idfObject); - OptionalString s = modelObject.name(); - if( s ) - { - idfObject.setName(*s); + if (modelObject.outputCSV()) { + idfObject.setString(OutputControl_FilesFields::OutputCSV, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputCSV, "No"); + } + + if (modelObject.outputMTR()) { + idfObject.setString(OutputControl_FilesFields::OutputMTR, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputMTR, "No"); + } + + if (modelObject.outputESO()) { + idfObject.setString(OutputControl_FilesFields::OutputESO, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputESO, "No"); + } + + if (modelObject.outputEIO()) { + idfObject.setString(OutputControl_FilesFields::OutputEIO, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputEIO, "No"); + } + + if (modelObject.outputTabular()) { + idfObject.setString(OutputControl_FilesFields::OutputTabular, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputTabular, "No"); + } + + if (modelObject.outputSQLite()) { + idfObject.setString(OutputControl_FilesFields::OutputSQLite, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputSQLite, "No"); + } + + if (modelObject.outputJSON()) { + idfObject.setString(OutputControl_FilesFields::OutputJSON, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputJSON, "No"); + } + + if (modelObject.outputAUDIT()) { + idfObject.setString(OutputControl_FilesFields::OutputAUDIT, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputAUDIT, "No"); + } + + if (modelObject.outputZoneSizing()) { + idfObject.setString(OutputControl_FilesFields::OutputZoneSizing, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputZoneSizing, "No"); + } + + if (modelObject.outputSystemSizing()) { + idfObject.setString(OutputControl_FilesFields::OutputSystemSizing, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputSystemSizing, "No"); + } + + if (modelObject.outputDXF()) { + idfObject.setString(OutputControl_FilesFields::OutputDXF, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputDXF, "No"); + } + + if (modelObject.outputBND()) { + idfObject.setString(OutputControl_FilesFields::OutputBND, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputBND, "No"); + } + + if (modelObject.outputRDD()) { + idfObject.setString(OutputControl_FilesFields::OutputRDD, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputRDD, "No"); + } + + if (modelObject.outputMDD()) { + idfObject.setString(OutputControl_FilesFields::OutputMDD, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputMDD, "No"); + } + + if (modelObject.outputMTD()) { + idfObject.setString(OutputControl_FilesFields::OutputMTD, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputMTD, "No"); } + if (modelObject.outputEND()) { + idfObject.setString(OutputControl_FilesFields::OutputEND, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputEND, "No"); + } + + if (modelObject.outputSHD()) { + idfObject.setString(OutputControl_FilesFields::OutputSHD, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputSHD, "No"); + } + + if (modelObject.outputDFS()) { + idfObject.setString(OutputControl_FilesFields::OutputDFS, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputDFS, "No"); + } + + if (modelObject.outputGLHE()) { + idfObject.setString(OutputControl_FilesFields::OutputGLHE, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputGLHE, "No"); + } + + if (modelObject.outputDelightIn()) { + idfObject.setString(OutputControl_FilesFields::OutputDelightIn, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputDelightIn, "No"); + } + + if (modelObject.outputDelightELdmp()) { + idfObject.setString(OutputControl_FilesFields::OutputDelightELdmp, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputDelightELdmp, "No"); + } + + if (modelObject.outputDelightInDFdmp()) { + idfObject.setString(OutputControl_FilesFields::OutputDelightDFdmp, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputDelightDFdmp, "No"); + } + + if (modelObject.outputEDD()) { + idfObject.setString(OutputControl_FilesFields::OutputEDD, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputEDD, "No"); + } + + if (modelObject.outputDBG()) { + idfObject.setString(OutputControl_FilesFields::OutputDBG, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputDBG, "No"); + } + + if (modelObject.outputPerfLog()) { + idfObject.setString(OutputControl_FilesFields::OutputPerfLog, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputPerfLog, "No"); + } + + if (modelObject.outputSLN()) { + idfObject.setString(OutputControl_FilesFields::OutputSLN, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputSLN, "No"); + } + + if (modelObject.outputSCI()) { + idfObject.setString(OutputControl_FilesFields::OutputSCI, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputSCI, "No"); + } + + if (modelObject.outputWRL()) { + idfObject.setString(OutputControl_FilesFields::OutputWRL, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputWRL, "No"); + } + + if (modelObject.outputScreen()) { + idfObject.setString(OutputControl_FilesFields::OutputScreen, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputScreen, "No"); + } + + if (modelObject.outputExtShd()) { + idfObject.setString(OutputControl_FilesFields::OutputExtShd, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputExtShd, "No"); + } + + if (modelObject.outputTarcog()) { + idfObject.setString(OutputControl_FilesFields::OutputTarcog, "Yes"); + } else { + idfObject.setString(OutputControl_FilesFields::OutputTarcog, "No"); + } - return boost::optional(idfObject); + return idfObject; } } // energyplus diff --git a/src/energyplus/ReverseTranslator.cpp b/src/energyplus/ReverseTranslator.cpp index c55cafa8197..cfe35c1321f 100644 --- a/src/energyplus/ReverseTranslator.cpp +++ b/src/energyplus/ReverseTranslator.cpp @@ -809,6 +809,11 @@ boost::optional ReverseTranslator::translateAndMapWorkspaceObject(c modelObject = translateOutputVariable(workspaceObject); break; } + case openstudio::IddObjectType::OutputControl_Files: + { + modelObject = translateOutputControlFiles(workspaceObject); + break; + } case openstudio::IddObjectType::OutputControl_Table_Style : { break; // no-op diff --git a/src/energyplus/ReverseTranslator.hpp b/src/energyplus/ReverseTranslator.hpp index 13bfa045a85..f957118c524 100644 --- a/src/energyplus/ReverseTranslator.hpp +++ b/src/energyplus/ReverseTranslator.hpp @@ -233,6 +233,8 @@ class ENERGYPLUS_API ReverseTranslator { boost::optional translateMeterCustomDecrement(const WorkspaceObject & workspaceObject); + boost::optional translateOutputControlFiles(const WorkspaceObject & workspaceObject); + boost::optional translateOutputDebuggingData(const WorkspaceObject & workspaceObject); boost::optional translateOutputDiagnostics(const WorkspaceObject & workspaceObject); diff --git a/src/energyplus/ReverseTranslator/ReverseTranslateOutputControlFiles.cpp b/src/energyplus/ReverseTranslator/ReverseTranslateOutputControlFiles.cpp new file mode 100644 index 00000000000..a9745fac718 --- /dev/null +++ b/src/energyplus/ReverseTranslator/ReverseTranslateOutputControlFiles.cpp @@ -0,0 +1,59 @@ +/*********************************************************************************************************************** +* OpenStudio(R), Copyright (c) 2008-2020, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved. +* +* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the +* following conditions are met: +* +* (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following +* disclaimer. +* +* (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the distribution. +* +* (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote products +* derived from this software without specific prior written permission from the respective party. +* +* (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works +* may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior +* written permission from Alliance for Sustainable Energy, LLC. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, +* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED +* STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF +* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +***********************************************************************************************************************/ + +#include "../ReverseTranslator.hpp" + +#include "../../model/OutputControlFiles.hpp" +#include "../../model/OutputControlFiles_Impl.hpp" + +#include +#include + +using namespace openstudio::model; + +namespace openstudio { + +namespace energyplus { + +boost::optional ReverseTranslator::translateOutputControlFiles( const WorkspaceObject & workspaceObject ) +{ + boost::optional result; + + // This is a Unique ModelObject + openstudio::model::OutputControlFiles modelObject = m_model.getUniqueModelObject(); + + + + result = modelObject; + return result; + +} // End of translate function + +} // end namespace energyplus +} // end namespace openstudio diff --git a/src/energyplus/Test/OutputControlFiles_GTest.cpp b/src/energyplus/Test/OutputControlFiles_GTest.cpp new file mode 100644 index 00000000000..426621caf0e --- /dev/null +++ b/src/energyplus/Test/OutputControlFiles_GTest.cpp @@ -0,0 +1,79 @@ +/*********************************************************************************************************************** +* OpenStudio(R), Copyright (c) 2008-2020, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved. +* +* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the +* following conditions are met: +* +* (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following +* disclaimer. +* +* (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following +* disclaimer in the documentation and/or other materials provided with the distribution. +* +* (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote products +* derived from this software without specific prior written permission from the respective party. +* +* (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works +* may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior +* written permission from Alliance for Sustainable Energy, LLC. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, +* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED +* STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF +* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +***********************************************************************************************************************/ + +#include +#include "EnergyPlusFixture.hpp" + +#include "../ForwardTranslator.hpp" +#include "../ReverseTranslator.hpp" + +#include "../../model/Model.hpp" +#include "../../model/OutputControlFiles.hpp" +#include "../../model/OutputControlFiles_Impl.hpp" + +#include "../../utilities/idf/IdfFile.hpp" +#include "../../utilities/idf/Workspace.hpp" +#include "../../utilities/idf/IdfObject.hpp" +#include "../../utilities/idf/WorkspaceObject.hpp" + +#include +#include + +using namespace openstudio::energyplus; +using namespace openstudio::model; +using namespace openstudio; + +TEST_F(EnergyPlusFixture, ForwardTranslator_OutputControlFiles) { + + ForwardTranslator ft; + + // Create a model + Model m; + + // Get the unique object + OutputControlFiles outputControlFiles = m.getUniqueModelObject(); + + +} + +TEST_F(EnergyPlusFixture, ReverseTranslator_OutputControlFiles) { + + ReverseTranslator rt; + + Workspace w(StrictnessLevel::None, IddFileType::EnergyPlus); + + // Not there, Model shouldn't have it either + Model m = rt.translateWorkspace(w); + EXPECT_FALSE(m.getOptionalUniqueModelObject()); + + OptionalWorkspaceObject _i_outputControlFiles = w.addObject(IdfObject(IddObjectType::OutputControl_Files)); + ASSERT_TRUE(_i_outputControlFiles); + + +} From 7135baa9f78220be4a52f871d09325c6e6c4473c Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Wed, 26 Aug 2020 14:58:00 -0700 Subject: [PATCH 07/12] Small typo in idd. --- resources/model/OpenStudio.idd | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/resources/model/OpenStudio.idd b/resources/model/OpenStudio.idd index b4625ea2dc3..d86c67251a3 100644 --- a/resources/model/OpenStudio.idd +++ b/resources/model/OpenStudio.idd @@ -30885,7 +30885,7 @@ OS:UtilityBill, \group OpenStudio Output Requests -OutputControl:Files, +OS:OutputControl:Files, \memo Conditionally turn on/off output from EnergyPlus. \unique-object A1, \field Handle From 7d481abc32c9338a832c2312c2661fe49f1ff984 Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Wed, 26 Aug 2020 14:58:29 -0700 Subject: [PATCH 08/12] Fill out model tests. --- src/model/OutputControlFiles.cpp | 21 +-- src/model/OutputControlFiles.hpp | 2 +- src/model/OutputControlFiles_Impl.hpp | 2 +- src/model/test/OutputControlFiles_GTest.cpp | 184 ++++++++++++++++++++ src/model/test/UniqueModelObject_GTest.cpp | 18 ++ 5 files changed, 215 insertions(+), 12 deletions(-) diff --git a/src/model/OutputControlFiles.cpp b/src/model/OutputControlFiles.cpp index 45f55163530..68c2e05bedd 100644 --- a/src/model/OutputControlFiles.cpp +++ b/src/model/OutputControlFiles.cpp @@ -203,43 +203,43 @@ namespace detail { } bool OutputControlFiles_Impl::setOutputCSV(bool outputCSV) { - return setBooleanFieldValue(OS_OutputControl_FilesFields::Output, output); + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputCSV, outputCSV); } bool OutputControlFiles_Impl::setOutputMTR(bool outputMTR) { - return setBooleanFieldValue(OS_OutputControl_FilesFields::Output, output); + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputMTR, outputMTR); } bool OutputControlFiles_Impl::setOutputESO(bool outputESO) { - return setBooleanFieldValue(OS_OutputControl_FilesFields::Output, output); + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputESO, outputESO); } bool OutputControlFiles_Impl::setOutputEIO(bool outputEIO) { - return setBooleanFieldValue(OS_OutputControl_FilesFields::Output, output); + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputEIO, outputEIO); } bool OutputControlFiles_Impl::setOutputTabular(bool outputTabular) { - return setBooleanFieldValue(OS_OutputControl_FilesFields::Output, output); + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputTabular, outputTabular); } bool OutputControlFiles_Impl::setOutputSQLite(bool outputSQLite) { - return setBooleanFieldValue(OS_OutputControl_FilesFields::Output, output); + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputSQLite, outputSQLite); } bool OutputControlFiles_Impl::setOutputJSON(bool outputJSON) { - return setBooleanFieldValue(OS_OutputControl_FilesFields::Output, output); + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputJSON, outputJSON); } bool OutputControlFiles_Impl::setOutputAUDIT(bool outputAUDIT) { - return setBooleanFieldValue(OS_OutputControl_FilesFields::Output, output); + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputAUDIT, outputAUDIT); } bool OutputControlFiles_Impl::setOutputZoneSizing(bool outputZoneSizing) { - return setBooleanFieldValue(OS_OutputControl_FilesFields::Output, output); + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputZoneSizing, outputZoneSizing); } bool OutputControlFiles_Impl::setOutputSystemSizing(bool outputSystemSizing) { - return setBooleanFieldValue(OS_OutputControl_FilesFields::Output, output); + return setBooleanFieldValue(OS_OutputControl_FilesFields::OutputSystemSizing, outputSystemSizing); } bool OutputControlFiles_Impl::setOutputDXF(bool outputDXF) { @@ -609,6 +609,7 @@ OutputControlFiles::OutputControlFiles(Model& model) setOutputDFS(true); setOutputGLHE(true); setOutputDelightIn(true); + setOutputDelightELdmp(true); setOutputDelightDFdmp(true); setOutputEDD(true); setOutputDBG(true); diff --git a/src/model/OutputControlFiles.hpp b/src/model/OutputControlFiles.hpp index 28c1560c344..4a220c801c9 100644 --- a/src/model/OutputControlFiles.hpp +++ b/src/model/OutputControlFiles.hpp @@ -30,7 +30,7 @@ #ifndef MODEL_OUTPUTCONTROLFILES_HPP #define MODEL_OUTPUTCONTROLFILES_HPP -#include "" +#include "ModelAPI.hpp" #include "ModelObject.hpp" namespace openstudio { diff --git a/src/model/OutputControlFiles_Impl.hpp b/src/model/OutputControlFiles_Impl.hpp index fe31dcdb46e..f8ab61e0113 100644 --- a/src/model/OutputControlFiles_Impl.hpp +++ b/src/model/OutputControlFiles_Impl.hpp @@ -30,7 +30,7 @@ #ifndef MODEL_OUTPUTCONTROLFILES_IMPL_HPP #define MODEL_OUTPUTCONTROLFILES_IMPL_HPP -#include "" +#include "ModelAPI.hpp" #include "ModelObject_Impl.hpp" namespace openstudio { diff --git a/src/model/test/OutputControlFiles_GTest.cpp b/src/model/test/OutputControlFiles_GTest.cpp index cf3db63e76a..b82d9cde997 100644 --- a/src/model/test/OutputControlFiles_GTest.cpp +++ b/src/model/test/OutputControlFiles_GTest.cpp @@ -40,5 +40,189 @@ TEST_F(ModelFixture,OutputControlFiles_GettersSetters) { Model model; OutputControlFiles outputControlFiles = model.getUniqueModelObject(); + EXPECT_FALSE(outputControlFiles.outputCSV()); + EXPECT_TRUE(outputControlFiles.setOutputCSV(false)); + EXPECT_FALSE(outputControlFiles.outputCSV()); + EXPECT_TRUE(outputControlFiles.setOutputCSV(true)); + EXPECT_TRUE(outputControlFiles.outputCSV()); + EXPECT_FALSE(outputControlFiles.outputMTR()); + EXPECT_TRUE(outputControlFiles.setOutputMTR(false)); + EXPECT_FALSE(outputControlFiles.outputMTR()); + EXPECT_TRUE(outputControlFiles.setOutputMTR(true)); + EXPECT_TRUE(outputControlFiles.outputMTR()); + + EXPECT_TRUE(outputControlFiles.outputESO()); + EXPECT_TRUE(outputControlFiles.setOutputESO(false)); + EXPECT_FALSE(outputControlFiles.outputESO()); + EXPECT_TRUE(outputControlFiles.setOutputESO(true)); + EXPECT_TRUE(outputControlFiles.outputESO()); + + EXPECT_TRUE(outputControlFiles.outputEIO()); + EXPECT_TRUE(outputControlFiles.setOutputEIO(false)); + EXPECT_FALSE(outputControlFiles.outputEIO()); + EXPECT_TRUE(outputControlFiles.setOutputEIO(true)); + EXPECT_TRUE(outputControlFiles.outputEIO()); + + EXPECT_TRUE(outputControlFiles.outputTabular()); + EXPECT_TRUE(outputControlFiles.setOutputTabular(false)); + EXPECT_FALSE(outputControlFiles.outputTabular()); + EXPECT_TRUE(outputControlFiles.setOutputTabular(true)); + EXPECT_TRUE(outputControlFiles.outputTabular()); + + EXPECT_TRUE(outputControlFiles.outputSQLite()); + EXPECT_TRUE(outputControlFiles.setOutputSQLite(false)); + EXPECT_FALSE(outputControlFiles.outputSQLite()); + EXPECT_TRUE(outputControlFiles.setOutputSQLite(true)); + EXPECT_TRUE(outputControlFiles.outputSQLite()); + + EXPECT_TRUE(outputControlFiles.outputJSON()); + EXPECT_TRUE(outputControlFiles.setOutputJSON(false)); + EXPECT_FALSE(outputControlFiles.outputJSON()); + EXPECT_TRUE(outputControlFiles.setOutputJSON(true)); + EXPECT_TRUE(outputControlFiles.outputJSON()); + + EXPECT_TRUE(outputControlFiles.outputAUDIT()); + EXPECT_TRUE(outputControlFiles.setOutputAUDIT(false)); + EXPECT_FALSE(outputControlFiles.outputAUDIT()); + EXPECT_TRUE(outputControlFiles.setOutputAUDIT(true)); + EXPECT_TRUE(outputControlFiles.outputAUDIT()); + + EXPECT_TRUE(outputControlFiles.outputZoneSizing()); + EXPECT_TRUE(outputControlFiles.setOutputZoneSizing(false)); + EXPECT_FALSE(outputControlFiles.outputZoneSizing()); + EXPECT_TRUE(outputControlFiles.setOutputZoneSizing(true)); + EXPECT_TRUE(outputControlFiles.outputZoneSizing()); + + EXPECT_TRUE(outputControlFiles.outputSystemSizing()); + EXPECT_TRUE(outputControlFiles.setOutputSystemSizing(false)); + EXPECT_FALSE(outputControlFiles.outputSystemSizing()); + EXPECT_TRUE(outputControlFiles.setOutputSystemSizing(true)); + EXPECT_TRUE(outputControlFiles.outputSystemSizing()); + + EXPECT_TRUE(outputControlFiles.outputDXF()); + EXPECT_TRUE(outputControlFiles.setOutputDXF(false)); + EXPECT_FALSE(outputControlFiles.outputDXF()); + EXPECT_TRUE(outputControlFiles.setOutputDXF(true)); + EXPECT_TRUE(outputControlFiles.outputDXF()); + + EXPECT_TRUE(outputControlFiles.outputBND()); + EXPECT_TRUE(outputControlFiles.setOutputBND(false)); + EXPECT_FALSE(outputControlFiles.outputBND()); + EXPECT_TRUE(outputControlFiles.setOutputBND(true)); + EXPECT_TRUE(outputControlFiles.outputBND()); + + EXPECT_TRUE(outputControlFiles.outputRDD()); + EXPECT_TRUE(outputControlFiles.setOutputRDD(false)); + EXPECT_FALSE(outputControlFiles.outputRDD()); + EXPECT_TRUE(outputControlFiles.setOutputRDD(true)); + EXPECT_TRUE(outputControlFiles.outputRDD()); + + EXPECT_TRUE(outputControlFiles.outputMDD()); + EXPECT_TRUE(outputControlFiles.setOutputMDD(false)); + EXPECT_FALSE(outputControlFiles.outputMDD()); + EXPECT_TRUE(outputControlFiles.setOutputMDD(true)); + EXPECT_TRUE(outputControlFiles.outputMDD()); + + EXPECT_TRUE(outputControlFiles.outputMTD()); + EXPECT_TRUE(outputControlFiles.setOutputMTD(false)); + EXPECT_FALSE(outputControlFiles.outputMTD()); + EXPECT_TRUE(outputControlFiles.setOutputMTD(true)); + EXPECT_TRUE(outputControlFiles.outputMTD()); + + EXPECT_TRUE(outputControlFiles.outputEND()); + EXPECT_TRUE(outputControlFiles.setOutputEND(false)); + EXPECT_FALSE(outputControlFiles.outputEND()); + EXPECT_TRUE(outputControlFiles.setOutputEND(true)); + EXPECT_TRUE(outputControlFiles.outputEND()); + + EXPECT_TRUE(outputControlFiles.outputSHD()); + EXPECT_TRUE(outputControlFiles.setOutputSHD(false)); + EXPECT_FALSE(outputControlFiles.outputSHD()); + EXPECT_TRUE(outputControlFiles.setOutputSHD(true)); + EXPECT_TRUE(outputControlFiles.outputSHD()); + + EXPECT_TRUE(outputControlFiles.outputDFS()); + EXPECT_TRUE(outputControlFiles.setOutputDFS(false)); + EXPECT_FALSE(outputControlFiles.outputDFS()); + EXPECT_TRUE(outputControlFiles.setOutputDFS(true)); + EXPECT_TRUE(outputControlFiles.outputDFS()); + + EXPECT_TRUE(outputControlFiles.outputGLHE()); + EXPECT_TRUE(outputControlFiles.setOutputGLHE(false)); + EXPECT_FALSE(outputControlFiles.outputGLHE()); + EXPECT_TRUE(outputControlFiles.setOutputGLHE(true)); + EXPECT_TRUE(outputControlFiles.outputGLHE()); + + EXPECT_TRUE(outputControlFiles.outputDelightIn()); + EXPECT_TRUE(outputControlFiles.setOutputDelightIn(false)); + EXPECT_FALSE(outputControlFiles.outputDelightIn()); + EXPECT_TRUE(outputControlFiles.setOutputDelightIn(true)); + EXPECT_TRUE(outputControlFiles.outputDelightIn()); + + EXPECT_TRUE(outputControlFiles.outputDelightELdmp()); + EXPECT_TRUE(outputControlFiles.setOutputDelightELdmp(false)); + EXPECT_FALSE(outputControlFiles.outputDelightELdmp()); + EXPECT_TRUE(outputControlFiles.setOutputDelightELdmp(true)); + EXPECT_TRUE(outputControlFiles.outputDelightELdmp()); + + EXPECT_TRUE(outputControlFiles.outputDelightDFdmp()); + EXPECT_TRUE(outputControlFiles.setOutputDelightDFdmp(false)); + EXPECT_FALSE(outputControlFiles.outputDelightDFdmp()); + EXPECT_TRUE(outputControlFiles.setOutputDelightDFdmp(true)); + EXPECT_TRUE(outputControlFiles.outputDelightDFdmp()); + + EXPECT_TRUE(outputControlFiles.outputEDD()); + EXPECT_TRUE(outputControlFiles.setOutputEDD(false)); + EXPECT_FALSE(outputControlFiles.outputEDD()); + EXPECT_TRUE(outputControlFiles.setOutputEDD(true)); + EXPECT_TRUE(outputControlFiles.outputEDD()); + + EXPECT_TRUE(outputControlFiles.outputDBG()); + EXPECT_TRUE(outputControlFiles.setOutputDBG(false)); + EXPECT_FALSE(outputControlFiles.outputDBG()); + EXPECT_TRUE(outputControlFiles.setOutputDBG(true)); + EXPECT_TRUE(outputControlFiles.outputDBG()); + + EXPECT_TRUE(outputControlFiles.outputPerfLog()); + EXPECT_TRUE(outputControlFiles.setOutputPerfLog(false)); + EXPECT_FALSE(outputControlFiles.outputPerfLog()); + EXPECT_TRUE(outputControlFiles.setOutputPerfLog(true)); + EXPECT_TRUE(outputControlFiles.outputPerfLog()); + + EXPECT_TRUE(outputControlFiles.outputSLN()); + EXPECT_TRUE(outputControlFiles.setOutputSLN(false)); + EXPECT_FALSE(outputControlFiles.outputSLN()); + EXPECT_TRUE(outputControlFiles.setOutputSLN(true)); + EXPECT_TRUE(outputControlFiles.outputSLN()); + + EXPECT_TRUE(outputControlFiles.outputSCI()); + EXPECT_TRUE(outputControlFiles.setOutputSCI(false)); + EXPECT_FALSE(outputControlFiles.outputSCI()); + EXPECT_TRUE(outputControlFiles.setOutputSCI(true)); + EXPECT_TRUE(outputControlFiles.outputSCI()); + + EXPECT_TRUE(outputControlFiles.outputWRL()); + EXPECT_TRUE(outputControlFiles.setOutputWRL(false)); + EXPECT_FALSE(outputControlFiles.outputWRL()); + EXPECT_TRUE(outputControlFiles.setOutputWRL(true)); + EXPECT_TRUE(outputControlFiles.outputWRL()); + + EXPECT_TRUE(outputControlFiles.outputScreen()); + EXPECT_TRUE(outputControlFiles.setOutputScreen(false)); + EXPECT_FALSE(outputControlFiles.outputScreen()); + EXPECT_TRUE(outputControlFiles.setOutputScreen(true)); + EXPECT_TRUE(outputControlFiles.outputScreen()); + + EXPECT_TRUE(outputControlFiles.outputExtShd()); + EXPECT_TRUE(outputControlFiles.setOutputExtShd(false)); + EXPECT_FALSE(outputControlFiles.outputExtShd()); + EXPECT_TRUE(outputControlFiles.setOutputExtShd(true)); + EXPECT_TRUE(outputControlFiles.outputExtShd()); + + EXPECT_TRUE(outputControlFiles.outputTarcog()); + EXPECT_TRUE(outputControlFiles.setOutputTarcog(false)); + EXPECT_FALSE(outputControlFiles.outputTarcog()); + EXPECT_TRUE(outputControlFiles.setOutputTarcog(true)); + EXPECT_TRUE(outputControlFiles.outputTarcog()); } diff --git a/src/model/test/UniqueModelObject_GTest.cpp b/src/model/test/UniqueModelObject_GTest.cpp index 47d0ac2f668..9b8d8eb54dc 100644 --- a/src/model/test/UniqueModelObject_GTest.cpp +++ b/src/model/test/UniqueModelObject_GTest.cpp @@ -354,7 +354,25 @@ TEST_F(ModelFixture, OutputControlFiles_UniqueModelObject_Clone) // create a model to use Model model; + // Get the Unique ModelObject + EXPECT_FALSE(model.getOptionalUniqueModelObject()); + OutputControlFiles outputControlFiles = model.getUniqueModelObject(); + EXPECT_TRUE(model.getOptionalUniqueModelObject()); + // We use a comment to see if cloning to another model works + outputControlFiles.setComment("Custom Object"); + + // clone it into same model + OutputControlFiles outputControlFilesClone = outputControlFiles.clone(model).cast(); + // UniqueModelObject: should be the same as the original + EXPECT_EQ(outputControlFiles, outputControlFilesClone); + EXPECT_EQ("! Custom Object", outputControlFilesClone.comment()); + // clone it into a different model + Model model2; + EXPECT_FALSE(model2.getOptionalUniqueModelObject()); + OutputControlFiles outputControlFilesClone2 = outputControlFiles.clone(model2).cast(); + EXPECT_TRUE(model2.getOptionalUniqueModelObject()); + EXPECT_EQ("! Custom Object", outputControlFilesClone2.comment()); } TEST_F(ModelFixture, OutputControlReportingTolerances_UniqueModelObject_Clone) From dcbd8016f8451b50681cd0a12db1f84abb3c269a Mon Sep 17 00:00:00 2001 From: Joe Robertson Date: Wed, 26 Aug 2020 14:58:40 -0700 Subject: [PATCH 09/12] Fill out ft and rt tests. --- .../ForwardTranslateOutputControlFiles.cpp | 2 +- .../ReverseTranslateOutputControlFiles.cpp | 246 ++++++++++++++++++ .../Test/OutputControlFiles_GTest.cpp | 74 +++++- 3 files changed, 320 insertions(+), 2 deletions(-) diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateOutputControlFiles.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateOutputControlFiles.cpp index 4f33866f222..df02450c068 100644 --- a/src/energyplus/ForwardTranslator/ForwardTranslateOutputControlFiles.cpp +++ b/src/energyplus/ForwardTranslator/ForwardTranslateOutputControlFiles.cpp @@ -173,7 +173,7 @@ boost::optional ForwardTranslator::translateOutputControlFiles( Outpu idfObject.setString(OutputControl_FilesFields::OutputDelightELdmp, "No"); } - if (modelObject.outputDelightInDFdmp()) { + if (modelObject.outputDelightDFdmp()) { idfObject.setString(OutputControl_FilesFields::OutputDelightDFdmp, "Yes"); } else { idfObject.setString(OutputControl_FilesFields::OutputDelightDFdmp, "No"); diff --git a/src/energyplus/ReverseTranslator/ReverseTranslateOutputControlFiles.cpp b/src/energyplus/ReverseTranslator/ReverseTranslateOutputControlFiles.cpp index a9745fac718..28696e4ecf6 100644 --- a/src/energyplus/ReverseTranslator/ReverseTranslateOutputControlFiles.cpp +++ b/src/energyplus/ReverseTranslator/ReverseTranslateOutputControlFiles.cpp @@ -48,7 +48,253 @@ boost::optional ReverseTranslator::translateOutputControlFiles( con // This is a Unique ModelObject openstudio::model::OutputControlFiles modelObject = m_model.getUniqueModelObject(); + if (boost::optional _outputCSV = workspaceObject.getString(OutputControl_FilesFields::OutputCSV, true)) { + if(istringEqual("Yes", _outputCSV.get())) { + modelObject.setOutputCSV(true); + } else { + modelObject.setOutputCSV(false); + } + } + if (boost::optional _outputMTR = workspaceObject.getString(OutputControl_FilesFields::OutputMTR, true)) { + if(istringEqual("Yes", _outputMTR.get())) { + modelObject.setOutputMTR(true); + } else { + modelObject.setOutputMTR(false); + } + } + + if (boost::optional _outputESO = workspaceObject.getString(OutputControl_FilesFields::OutputESO, true)) { + if(istringEqual("Yes", _outputESO.get())) { + modelObject.setOutputESO(true); + } else { + modelObject.setOutputESO(false); + } + } + + if (boost::optional _outputEIO = workspaceObject.getString(OutputControl_FilesFields::OutputEIO, true)) { + if(istringEqual("Yes", _outputEIO.get())) { + modelObject.setOutputEIO(true); + } else { + modelObject.setOutputEIO(false); + } + } + + if (boost::optional _outputTabular = workspaceObject.getString(OutputControl_FilesFields::OutputTabular, true)) { + if(istringEqual("Yes", _outputTabular.get())) { + modelObject.setOutputTabular(true); + } else { + modelObject.setOutputTabular(false); + } + } + + if (boost::optional _outputSQLite = workspaceObject.getString(OutputControl_FilesFields::OutputSQLite, true)) { + if(istringEqual("Yes", _outputSQLite.get())) { + modelObject.setOutputSQLite(true); + } else { + modelObject.setOutputSQLite(false); + } + } + + if (boost::optional _outputJSON = workspaceObject.getString(OutputControl_FilesFields::OutputJSON, true)) { + if(istringEqual("Yes", _outputJSON.get())) { + modelObject.setOutputJSON(true); + } else { + modelObject.setOutputJSON(false); + } + } + + if (boost::optional _outputAUDIT = workspaceObject.getString(OutputControl_FilesFields::OutputAUDIT, true)) { + if(istringEqual("Yes", _outputAUDIT.get())) { + modelObject.setOutputAUDIT(true); + } else { + modelObject.setOutputAUDIT(false); + } + } + + if (boost::optional _outputZoneSizing = workspaceObject.getString(OutputControl_FilesFields::OutputZoneSizing, true)) { + if(istringEqual("Yes", _outputZoneSizing.get())) { + modelObject.setOutputZoneSizing(true); + } else { + modelObject.setOutputZoneSizing(false); + } + } + + if (boost::optional _outputSystemSizing = workspaceObject.getString(OutputControl_FilesFields::OutputSystemSizing, true)) { + if(istringEqual("Yes", _outputSystemSizing.get())) { + modelObject.setOutputSystemSizing(true); + } else { + modelObject.setOutputSystemSizing(false); + } + } + + if (boost::optional _outputDXF = workspaceObject.getString(OutputControl_FilesFields::OutputDXF, true)) { + if(istringEqual("Yes", _outputDXF.get())) { + modelObject.setOutputDXF(true); + } else { + modelObject.setOutputDXF(false); + } + } + + if (boost::optional _outputBND = workspaceObject.getString(OutputControl_FilesFields::OutputBND, true)) { + if(istringEqual("Yes", _outputBND.get())) { + modelObject.setOutputBND(true); + } else { + modelObject.setOutputBND(false); + } + } + + if (boost::optional _outputRDD = workspaceObject.getString(OutputControl_FilesFields::OutputRDD, true)) { + if(istringEqual("Yes", _outputRDD.get())) { + modelObject.setOutputRDD(true); + } else { + modelObject.setOutputRDD(false); + } + } + + if (boost::optional _outputMDD = workspaceObject.getString(OutputControl_FilesFields::OutputMDD, true)) { + if(istringEqual("Yes", _outputMDD.get())) { + modelObject.setOutputMDD(true); + } else { + modelObject.setOutputMDD(false); + } + } + + if (boost::optional _outputMTD = workspaceObject.getString(OutputControl_FilesFields::OutputMTD, true)) { + if(istringEqual("Yes", _outputMTD.get())) { + modelObject.setOutputMTD(true); + } else { + modelObject.setOutputMTD(false); + } + } + + if (boost::optional _outputEND = workspaceObject.getString(OutputControl_FilesFields::OutputEND, true)) { + if(istringEqual("Yes", _outputEND.get())) { + modelObject.setOutputEND(true); + } else { + modelObject.setOutputEND(false); + } + } + + if (boost::optional _outputSHD = workspaceObject.getString(OutputControl_FilesFields::OutputSHD, true)) { + if(istringEqual("Yes", _outputSHD.get())) { + modelObject.setOutputSHD(true); + } else { + modelObject.setOutputSHD(false); + } + } + + if (boost::optional _outputDFS = workspaceObject.getString(OutputControl_FilesFields::OutputDFS, true)) { + if(istringEqual("Yes", _outputDFS.get())) { + modelObject.setOutputDFS(true); + } else { + modelObject.setOutputDFS(false); + } + } + + if (boost::optional _outputGLHE = workspaceObject.getString(OutputControl_FilesFields::OutputGLHE, true)) { + if(istringEqual("Yes", _outputGLHE.get())) { + modelObject.setOutputGLHE(true); + } else { + modelObject.setOutputGLHE(false); + } + } + + if (boost::optional _outputDelightIn = workspaceObject.getString(OutputControl_FilesFields::OutputDelightIn, true)) { + if(istringEqual("Yes", _outputDelightIn.get())) { + modelObject.setOutputDelightIn(true); + } else { + modelObject.setOutputDelightIn(false); + } + } + + if (boost::optional _outputDelightELdmp = workspaceObject.getString(OutputControl_FilesFields::OutputDelightELdmp, true)) { + if(istringEqual("Yes", _outputDelightELdmp.get())) { + modelObject.setOutputDelightELdmp(true); + } else { + modelObject.setOutputDelightELdmp(false); + } + } + + if (boost::optional _outputDelightDFdmp = workspaceObject.getString(OutputControl_FilesFields::OutputDelightDFdmp, true)) { + if(istringEqual("Yes", _outputDelightDFdmp.get())) { + modelObject.setOutputDelightDFdmp(true); + } else { + modelObject.setOutputDelightDFdmp(false); + } + } + + if (boost::optional _outputEDD = workspaceObject.getString(OutputControl_FilesFields::OutputEDD, true)) { + if(istringEqual("Yes", _outputEDD.get())) { + modelObject.setOutputEDD(true); + } else { + modelObject.setOutputEDD(false); + } + } + + if (boost::optional _outputDBG = workspaceObject.getString(OutputControl_FilesFields::OutputDBG, true)) { + if(istringEqual("Yes", _outputDBG.get())) { + modelObject.setOutputDBG(true); + } else { + modelObject.setOutputDBG(false); + } + } + + if (boost::optional _outputPerfLog = workspaceObject.getString(OutputControl_FilesFields::OutputPerfLog, true)) { + if(istringEqual("Yes", _outputPerfLog.get())) { + modelObject.setOutputPerfLog(true); + } else { + modelObject.setOutputPerfLog(false); + } + } + + if (boost::optional _outputSLN = workspaceObject.getString(OutputControl_FilesFields::OutputSLN, true)) { + if(istringEqual("Yes", _outputSLN.get())) { + modelObject.setOutputSLN(true); + } else { + modelObject.setOutputSLN(false); + } + } + + if (boost::optional _outputSCI = workspaceObject.getString(OutputControl_FilesFields::OutputSCI, true)) { + if(istringEqual("Yes", _outputSCI.get())) { + modelObject.setOutputSCI(true); + } else { + modelObject.setOutputSCI(false); + } + } + + if (boost::optional _outputWRL = workspaceObject.getString(OutputControl_FilesFields::OutputWRL, true)) { + if(istringEqual("Yes", _outputWRL.get())) { + modelObject.setOutputWRL(true); + } else { + modelObject.setOutputWRL(false); + } + } + + if (boost::optional _outputScreen = workspaceObject.getString(OutputControl_FilesFields::OutputScreen, true)) { + if(istringEqual("Yes", _outputScreen.get())) { + modelObject.setOutputScreen(true); + } else { + modelObject.setOutputScreen(false); + } + } + + if (boost::optional _outputExtShd = workspaceObject.getString(OutputControl_FilesFields::OutputExtShd, true)) { + if(istringEqual("Yes", _outputExtShd.get())) { + modelObject.setOutputExtShd(true); + } else { + modelObject.setOutputExtShd(false); + } + } + + if (boost::optional _outputTarcog = workspaceObject.getString(OutputControl_FilesFields::OutputTarcog, true)) { + if(istringEqual("Yes", _outputTarcog.get())) { + modelObject.setOutputTarcog(true); + } else { + modelObject.setOutputTarcog(false); + } + } result = modelObject; return result; diff --git a/src/energyplus/Test/OutputControlFiles_GTest.cpp b/src/energyplus/Test/OutputControlFiles_GTest.cpp index 426621caf0e..92b81adbd6f 100644 --- a/src/energyplus/Test/OutputControlFiles_GTest.cpp +++ b/src/energyplus/Test/OutputControlFiles_GTest.cpp @@ -59,7 +59,44 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_OutputControlFiles) { // Get the unique object OutputControlFiles outputControlFiles = m.getUniqueModelObject(); - + Workspace w = ft.translateModel(m); + + WorkspaceObjectVector idfObjs = w.getObjectsByType(IddObjectType::OutputControl_Files); + ASSERT_EQ(1u, idfObjs.size()); + + WorkspaceObject idf_outputControlFiles(idfObjs[0]); + + EXPECT_EQ("No", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputCSV).get()); + EXPECT_EQ("No", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputMTR).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputESO).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputEIO).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputTabular).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputSQLite).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputJSON).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputAUDIT).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputZoneSizing).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputSystemSizing).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputDXF).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputBND).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputRDD).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputMDD).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputMTD).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputEND).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputSHD).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputDFS).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputGLHE).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputDelightIn).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputDelightELdmp).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputDelightDFdmp).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputEDD).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputDBG).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputPerfLog).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputSLN).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputSCI).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputWRL).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputScreen).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputExtShd).get()); + EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputTarcog).get()); } TEST_F(EnergyPlusFixture, ReverseTranslator_OutputControlFiles) { @@ -75,5 +112,40 @@ TEST_F(EnergyPlusFixture, ReverseTranslator_OutputControlFiles) { OptionalWorkspaceObject _i_outputControlFiles = w.addObject(IdfObject(IddObjectType::OutputControl_Files)); ASSERT_TRUE(_i_outputControlFiles); + Model m2 = rt.translateWorkspace(w); + // Get the unique object + OutputControlFiles outputControlFiles = m2.getUniqueModelObject(); + + EXPECT_FALSE(outputControlFiles.outputCSV()); + EXPECT_FALSE(outputControlFiles.outputMTR()); + EXPECT_TRUE(outputControlFiles.outputESO()); + EXPECT_TRUE(outputControlFiles.outputEIO()); + EXPECT_TRUE(outputControlFiles.outputTabular()); + EXPECT_TRUE(outputControlFiles.outputSQLite()); + EXPECT_TRUE(outputControlFiles.outputJSON()); + EXPECT_TRUE(outputControlFiles.outputAUDIT()); + EXPECT_TRUE(outputControlFiles.outputZoneSizing()); + EXPECT_TRUE(outputControlFiles.outputSystemSizing()); + EXPECT_TRUE(outputControlFiles.outputDXF()); + EXPECT_TRUE(outputControlFiles.outputBND()); + EXPECT_TRUE(outputControlFiles.outputRDD()); + EXPECT_TRUE(outputControlFiles.outputMDD()); + EXPECT_TRUE(outputControlFiles.outputMTD()); + EXPECT_TRUE(outputControlFiles.outputEND()); + EXPECT_TRUE(outputControlFiles.outputSHD()); + EXPECT_TRUE(outputControlFiles.outputDFS()); + EXPECT_TRUE(outputControlFiles.outputGLHE()); + EXPECT_TRUE(outputControlFiles.outputDelightIn()); + EXPECT_TRUE(outputControlFiles.outputDelightELdmp()); + EXPECT_TRUE(outputControlFiles.outputDelightDFdmp()); + EXPECT_TRUE(outputControlFiles.outputEDD()); + EXPECT_TRUE(outputControlFiles.outputDBG()); + EXPECT_TRUE(outputControlFiles.outputPerfLog()); + EXPECT_TRUE(outputControlFiles.outputSLN()); + EXPECT_TRUE(outputControlFiles.outputSCI()); + EXPECT_TRUE(outputControlFiles.outputWRL()); + EXPECT_TRUE(outputControlFiles.outputScreen()); + EXPECT_TRUE(outputControlFiles.outputExtShd()); + EXPECT_TRUE(outputControlFiles.outputTarcog()); } From 88b4843f9bd485de7aa778dc8974d975efec439a Mon Sep 17 00:00:00 2001 From: Julien Marrec Date: Fri, 28 Aug 2020 12:43:55 +0200 Subject: [PATCH 10/12] Update FT and RT tests to really test the fields. --- .../Test/OutputControlFiles_GTest.cpp | 224 ++++++++++++------ 1 file changed, 150 insertions(+), 74 deletions(-) diff --git a/src/energyplus/Test/OutputControlFiles_GTest.cpp b/src/energyplus/Test/OutputControlFiles_GTest.cpp index 92b81adbd6f..86afb178964 100644 --- a/src/energyplus/Test/OutputControlFiles_GTest.cpp +++ b/src/energyplus/Test/OutputControlFiles_GTest.cpp @@ -59,44 +59,82 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_OutputControlFiles) { // Get the unique object OutputControlFiles outputControlFiles = m.getUniqueModelObject(); - Workspace w = ft.translateModel(m); - - WorkspaceObjectVector idfObjs = w.getObjectsByType(IddObjectType::OutputControl_Files); - ASSERT_EQ(1u, idfObjs.size()); - - WorkspaceObject idf_outputControlFiles(idfObjs[0]); - - EXPECT_EQ("No", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputCSV).get()); - EXPECT_EQ("No", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputMTR).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputESO).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputEIO).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputTabular).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputSQLite).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputJSON).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputAUDIT).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputZoneSizing).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputSystemSizing).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputDXF).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputBND).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputRDD).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputMDD).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputMTD).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputEND).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputSHD).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputDFS).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputGLHE).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputDelightIn).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputDelightELdmp).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputDelightDFdmp).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputEDD).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputDBG).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputPerfLog).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputSLN).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputSCI).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputWRL).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputScreen).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputExtShd).get()); - EXPECT_EQ("Yes", idf_outputControlFiles.getString(OutputControl_FilesFields::OutputTarcog).get()); + // Check all cases where a single output request is True so we know we assigned the fields correctly + auto boolToString = [](bool b) { return b ? "Yes" : "No"; }; + + for (size_t i = 0; i < 31; ++i) { + bool status[31] = {false}; + status[i] = true; + EXPECT_TRUE(outputControlFiles.setOutputCSV(status[0])); + EXPECT_TRUE(outputControlFiles.setOutputMTR(status[1])); + EXPECT_TRUE(outputControlFiles.setOutputESO(status[2])); + EXPECT_TRUE(outputControlFiles.setOutputEIO(status[3])); + EXPECT_TRUE(outputControlFiles.setOutputTabular(status[4])); + EXPECT_TRUE(outputControlFiles.setOutputSQLite(status[5])); + EXPECT_TRUE(outputControlFiles.setOutputJSON(status[6])); + EXPECT_TRUE(outputControlFiles.setOutputAUDIT(status[7])); + EXPECT_TRUE(outputControlFiles.setOutputZoneSizing(status[8])); + EXPECT_TRUE(outputControlFiles.setOutputSystemSizing(status[9])); + EXPECT_TRUE(outputControlFiles.setOutputDXF(status[10])); + EXPECT_TRUE(outputControlFiles.setOutputBND(status[11])); + EXPECT_TRUE(outputControlFiles.setOutputRDD(status[12])); + EXPECT_TRUE(outputControlFiles.setOutputMDD(status[13])); + EXPECT_TRUE(outputControlFiles.setOutputMTD(status[14])); + EXPECT_TRUE(outputControlFiles.setOutputEND(status[15])); + EXPECT_TRUE(outputControlFiles.setOutputSHD(status[16])); + EXPECT_TRUE(outputControlFiles.setOutputDFS(status[17])); + EXPECT_TRUE(outputControlFiles.setOutputGLHE(status[18])); + EXPECT_TRUE(outputControlFiles.setOutputDelightIn(status[19])); + EXPECT_TRUE(outputControlFiles.setOutputDelightELdmp(status[20])); + EXPECT_TRUE(outputControlFiles.setOutputDelightDFdmp(status[21])); + EXPECT_TRUE(outputControlFiles.setOutputEDD(status[22])); + EXPECT_TRUE(outputControlFiles.setOutputDBG(status[23])); + EXPECT_TRUE(outputControlFiles.setOutputPerfLog(status[24])); + EXPECT_TRUE(outputControlFiles.setOutputSLN(status[25])); + EXPECT_TRUE(outputControlFiles.setOutputSCI(status[26])); + EXPECT_TRUE(outputControlFiles.setOutputWRL(status[27])); + EXPECT_TRUE(outputControlFiles.setOutputScreen(status[28])); + EXPECT_TRUE(outputControlFiles.setOutputExtShd(status[29])); + EXPECT_TRUE(outputControlFiles.setOutputTarcog(status[30])); + + Workspace w = ft.translateModel(m); + WorkspaceObjectVector idfObjs = w.getObjectsByType(IddObjectType::OutputControl_Files); + ASSERT_EQ(1u, idfObjs.size()); + + WorkspaceObject idf_outputControlFiles(idfObjs[0]); + + EXPECT_EQ(boolToString(status[0]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputCSV).get()); + EXPECT_EQ(boolToString(status[1]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputMTR).get()); + EXPECT_EQ(boolToString(status[2]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputESO).get()); + EXPECT_EQ(boolToString(status[3]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputEIO).get()); + EXPECT_EQ(boolToString(status[4]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputTabular).get()); + EXPECT_EQ(boolToString(status[5]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputSQLite).get()); + EXPECT_EQ(boolToString(status[6]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputJSON).get()); + EXPECT_EQ(boolToString(status[7]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputAUDIT).get()); + EXPECT_EQ(boolToString(status[8]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputZoneSizing).get()); + EXPECT_EQ(boolToString(status[9]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputSystemSizing).get()); + EXPECT_EQ(boolToString(status[10]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputDXF).get()); + EXPECT_EQ(boolToString(status[11]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputBND).get()); + EXPECT_EQ(boolToString(status[12]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputRDD).get()); + EXPECT_EQ(boolToString(status[13]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputMDD).get()); + EXPECT_EQ(boolToString(status[14]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputMTD).get()); + EXPECT_EQ(boolToString(status[15]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputEND).get()); + EXPECT_EQ(boolToString(status[16]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputSHD).get()); + EXPECT_EQ(boolToString(status[17]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputDFS).get()); + EXPECT_EQ(boolToString(status[18]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputGLHE).get()); + EXPECT_EQ(boolToString(status[19]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputDelightIn).get()); + EXPECT_EQ(boolToString(status[20]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputDelightELdmp).get()); + EXPECT_EQ(boolToString(status[21]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputDelightDFdmp).get()); + EXPECT_EQ(boolToString(status[22]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputEDD).get()); + EXPECT_EQ(boolToString(status[23]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputDBG).get()); + EXPECT_EQ(boolToString(status[24]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputPerfLog).get()); + EXPECT_EQ(boolToString(status[25]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputSLN).get()); + EXPECT_EQ(boolToString(status[26]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputSCI).get()); + EXPECT_EQ(boolToString(status[27]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputWRL).get()); + EXPECT_EQ(boolToString(status[28]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputScreen).get()); + EXPECT_EQ(boolToString(status[29]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputExtShd).get()); + EXPECT_EQ(boolToString(status[30]), idf_outputControlFiles.getString(OutputControl_FilesFields::OutputTarcog).get()); + } } TEST_F(EnergyPlusFixture, ReverseTranslator_OutputControlFiles) { @@ -112,40 +150,78 @@ TEST_F(EnergyPlusFixture, ReverseTranslator_OutputControlFiles) { OptionalWorkspaceObject _i_outputControlFiles = w.addObject(IdfObject(IddObjectType::OutputControl_Files)); ASSERT_TRUE(_i_outputControlFiles); - Model m2 = rt.translateWorkspace(w); - - // Get the unique object - OutputControlFiles outputControlFiles = m2.getUniqueModelObject(); - - EXPECT_FALSE(outputControlFiles.outputCSV()); - EXPECT_FALSE(outputControlFiles.outputMTR()); - EXPECT_TRUE(outputControlFiles.outputESO()); - EXPECT_TRUE(outputControlFiles.outputEIO()); - EXPECT_TRUE(outputControlFiles.outputTabular()); - EXPECT_TRUE(outputControlFiles.outputSQLite()); - EXPECT_TRUE(outputControlFiles.outputJSON()); - EXPECT_TRUE(outputControlFiles.outputAUDIT()); - EXPECT_TRUE(outputControlFiles.outputZoneSizing()); - EXPECT_TRUE(outputControlFiles.outputSystemSizing()); - EXPECT_TRUE(outputControlFiles.outputDXF()); - EXPECT_TRUE(outputControlFiles.outputBND()); - EXPECT_TRUE(outputControlFiles.outputRDD()); - EXPECT_TRUE(outputControlFiles.outputMDD()); - EXPECT_TRUE(outputControlFiles.outputMTD()); - EXPECT_TRUE(outputControlFiles.outputEND()); - EXPECT_TRUE(outputControlFiles.outputSHD()); - EXPECT_TRUE(outputControlFiles.outputDFS()); - EXPECT_TRUE(outputControlFiles.outputGLHE()); - EXPECT_TRUE(outputControlFiles.outputDelightIn()); - EXPECT_TRUE(outputControlFiles.outputDelightELdmp()); - EXPECT_TRUE(outputControlFiles.outputDelightDFdmp()); - EXPECT_TRUE(outputControlFiles.outputEDD()); - EXPECT_TRUE(outputControlFiles.outputDBG()); - EXPECT_TRUE(outputControlFiles.outputPerfLog()); - EXPECT_TRUE(outputControlFiles.outputSLN()); - EXPECT_TRUE(outputControlFiles.outputSCI()); - EXPECT_TRUE(outputControlFiles.outputWRL()); - EXPECT_TRUE(outputControlFiles.outputScreen()); - EXPECT_TRUE(outputControlFiles.outputExtShd()); - EXPECT_TRUE(outputControlFiles.outputTarcog()); + auto boolToString = [](bool b) { return b ? "Yes" : "No";}; + + for (size_t i = 0; i < 31; ++i) { + bool status[31] = {false}; + status[i] = true; + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputCSV, boolToString(status[0]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputMTR, boolToString(status[1]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputESO, boolToString(status[2]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputEIO, boolToString(status[3]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputTabular, boolToString(status[4]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputSQLite, boolToString(status[5]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputJSON, boolToString(status[6]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputAUDIT, boolToString(status[7]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputZoneSizing, boolToString(status[8]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputSystemSizing, boolToString(status[9]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputDXF, boolToString(status[10]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputBND, boolToString(status[11]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputRDD, boolToString(status[12]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputMDD, boolToString(status[13]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputMTD, boolToString(status[14]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputEND, boolToString(status[15]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputSHD, boolToString(status[16]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputDFS, boolToString(status[17]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputGLHE, boolToString(status[18]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputDelightIn, boolToString(status[19]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputDelightELdmp, boolToString(status[20]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputDelightDFdmp, boolToString(status[21]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputEDD, boolToString(status[22]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputDBG, boolToString(status[23]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputPerfLog, boolToString(status[24]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputSLN, boolToString(status[25]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputSCI, boolToString(status[26]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputWRL, boolToString(status[27]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputScreen, boolToString(status[28]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputExtShd, boolToString(status[29]))); + EXPECT_TRUE(_i_outputControlFiles->setString(OutputControl_FilesFields::OutputTarcog, boolToString(status[30]))); + + Model m = rt.translateWorkspace(w); + + // // Get the unique object + OutputControlFiles outputControlFiles = m.getUniqueModelObject(); + + EXPECT_EQ(status[0], outputControlFiles.outputCSV()); + EXPECT_EQ(status[1], outputControlFiles.outputMTR()); + EXPECT_EQ(status[2], outputControlFiles.outputESO()); + EXPECT_EQ(status[3], outputControlFiles.outputEIO()); + EXPECT_EQ(status[4], outputControlFiles.outputTabular()); + EXPECT_EQ(status[5], outputControlFiles.outputSQLite()); + EXPECT_EQ(status[6], outputControlFiles.outputJSON()); + EXPECT_EQ(status[7], outputControlFiles.outputAUDIT()); + EXPECT_EQ(status[8], outputControlFiles.outputZoneSizing()); + EXPECT_EQ(status[9], outputControlFiles.outputSystemSizing()); + EXPECT_EQ(status[10], outputControlFiles.outputDXF()); + EXPECT_EQ(status[11], outputControlFiles.outputBND()); + EXPECT_EQ(status[12], outputControlFiles.outputRDD()); + EXPECT_EQ(status[13], outputControlFiles.outputMDD()); + EXPECT_EQ(status[14], outputControlFiles.outputMTD()); + EXPECT_EQ(status[15], outputControlFiles.outputEND()); + EXPECT_EQ(status[16], outputControlFiles.outputSHD()); + EXPECT_EQ(status[17], outputControlFiles.outputDFS()); + EXPECT_EQ(status[18], outputControlFiles.outputGLHE()); + EXPECT_EQ(status[19], outputControlFiles.outputDelightIn()); + EXPECT_EQ(status[20], outputControlFiles.outputDelightELdmp()); + EXPECT_EQ(status[21], outputControlFiles.outputDelightDFdmp()); + EXPECT_EQ(status[22], outputControlFiles.outputEDD()); + EXPECT_EQ(status[23], outputControlFiles.outputDBG()); + EXPECT_EQ(status[24], outputControlFiles.outputPerfLog()); + EXPECT_EQ(status[25], outputControlFiles.outputSLN()); + EXPECT_EQ(status[26], outputControlFiles.outputSCI()); + EXPECT_EQ(status[27], outputControlFiles.outputWRL()); + EXPECT_EQ(status[28], outputControlFiles.outputScreen()); + EXPECT_EQ(status[29], outputControlFiles.outputExtShd()); + EXPECT_EQ(status[30], outputControlFiles.outputTarcog()); + } } From a60a3ec19d41c07fb7a75b804d9fc2273553a55d Mon Sep 17 00:00:00 2001 From: Julien Marrec Date: Fri, 28 Aug 2020 12:44:40 +0200 Subject: [PATCH 11/12] Minor. --- src/model/OutputControlFiles.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/model/OutputControlFiles.cpp b/src/model/OutputControlFiles.cpp index 68c2e05bedd..c8a3a5a293c 100644 --- a/src/model/OutputControlFiles.cpp +++ b/src/model/OutputControlFiles.cpp @@ -69,8 +69,6 @@ namespace detail { const std::vector& OutputControlFiles_Impl::outputVariableNames() const { static const std::vector result; - if (result.empty()){ - } return result; } From 2574c9855642bf29cb156906f01349febfc91857 Mon Sep 17 00:00:00 2001 From: Julien Marrec Date: Fri, 28 Aug 2020 12:54:03 +0200 Subject: [PATCH 12/12] Implement a cache-enabled getter in Model for OutputControlFiles. --- src/model/Model.cpp | 35 +++++++++++++++++++++++++++++++++++ src/model/Model.hpp | 8 ++++++++ src/model/Model_Impl.hpp | 7 +++++++ 3 files changed, 50 insertions(+) diff --git a/src/model/Model.cpp b/src/model/Model.cpp index 7cd05f39d68..54a6d79ea88 100644 --- a/src/model/Model.cpp +++ b/src/model/Model.cpp @@ -275,6 +275,21 @@ namespace detail { return m_cachedFoundationKivaSettings; } + boost::optional Model_Impl::outputControlFiles() const + { + if (m_cachedOutputControlFiles){ + return m_cachedOutputControlFiles; + } + + boost::optional result = this->model().getOptionalUniqueModelObject(); + if (result){ + m_cachedOutputControlFiles = result; + result->getImpl().get()->OutputControlFiles_Impl::onRemoveFromWorkspace.connect(const_cast(this)); + } + + return m_cachedOutputControlFiles; + } + boost::optional Model_Impl::outputTableSummaryReports() const { if (m_cachedOutputTableSummaryReports){ @@ -1005,6 +1020,7 @@ namespace detail { Handle dummy; clearCachedBuilding(dummy); clearCachedFoundationKivaSettings(dummy); + clearCachedOutputControlFiles(dummy); clearCachedOutputTableSummaryReports(dummy); clearCachedLifeCycleCostParameters(dummy); clearCachedRunPeriod(dummy); @@ -1023,6 +1039,11 @@ namespace detail { m_cachedFoundationKivaSettings.reset(); } + void Model_Impl::clearCachedOutputControlFiles(const Handle &) + { + m_cachedOutputControlFiles.reset(); + } + void Model_Impl::clearCachedOutputTableSummaryReports(const Handle &) { m_cachedOutputTableSummaryReports.reset(); @@ -1218,6 +1239,11 @@ boost::optional Model::foundationKivaSettings() const return getImpl()->foundationKivaSettings(); } +boost::optional Model::outputControlFiles() const +{ + return getImpl()->outputControlFiles(); +} + boost::optional Model::outputTableSummaryReports() const { return getImpl()->outputTableSummaryReports(); @@ -2631,6 +2657,15 @@ FoundationKivaSettings Model::getUniqueModelObject() { } } +template <> +OutputControlFiles Model::getUniqueModelObject() { + if (boost::optional _b = outputControlFiles()) { + return _b.get(); + } else { + return OutputControlFiles(*this); + } +} + template <> OutputTableSummaryReports Model::getUniqueModelObject() { if (boost::optional _b = outputTableSummaryReports()) { diff --git a/src/model/Model.hpp b/src/model/Model.hpp index 1c45d6b7bf1..3efc1de61a4 100644 --- a/src/model/Model.hpp +++ b/src/model/Model.hpp @@ -60,6 +60,7 @@ class Schedule; class Node; class SpaceType; class FoundationKivaSettings; +class OutputControlFiles; class OutputTableSummaryReports; class PerformancePrecisionTradeoffs; @@ -120,6 +121,10 @@ class MODEL_API Model : public openstudio::Workspace { * object which can be significantly faster than calling getOptionalUniqueModelObject(). */ boost::optional foundationKivaSettings() const; + /** Get the OutputControlFiles object if there is one, this implementation uses a cached reference to the OutputControlFiles + * object which can be significantly faster than calling getOptionalUniqueModelObject(). */ + boost::optional outputControlFiles() const; + /** Get the OutputTableSummaryReports object if there is one, this implementation uses a cached reference to the OutputTableSummaryReports * object which can be significantly faster than calling getOptionalUniqueModelObject(). */ boost::optional outputTableSummaryReports() const; @@ -528,6 +533,9 @@ MODEL_API Building Model::getUniqueModelObject(); template <> MODEL_API FoundationKivaSettings Model::getUniqueModelObject(); +template <> +MODEL_API OutputControlFiles Model::getUniqueModelObject(); + template <> MODEL_API OutputTableSummaryReports Model::getUniqueModelObject(); diff --git a/src/model/Model_Impl.hpp b/src/model/Model_Impl.hpp index 5d92bb123a4..46637fce1f1 100644 --- a/src/model/Model_Impl.hpp +++ b/src/model/Model_Impl.hpp @@ -33,6 +33,7 @@ #include "ComponentWatcher.hpp" #include "Building.hpp" #include "FoundationKivaSettings.hpp" +#include "OutputControlFiles.hpp" #include "OutputTableSummaryReports.hpp" #include "LifeCycleCostParameters.hpp" #include "RunPeriod.hpp" @@ -147,6 +148,10 @@ namespace detail { * object which can be significantly faster than calling getOptionalUniqueModelObject(). */ boost::optional foundationKivaSettings() const; + /** Get the OutputControlFiles object if there is one, this implementation uses a cached reference to the OutputControlFiles + * object which can be significantly faster than calling getOptionalUniqueModelObject(). */ + boost::optional outputControlFiles() const; + /** Get the OutputTableSummaryReports object if there is one, this implementation uses a cached reference to the OutputTableSummaryReports * object which can be significantly faster than calling getOptionalUniqueModelObject(). */ boost::optional outputTableSummaryReports() const; @@ -308,6 +313,7 @@ namespace detail { mutable boost::optional m_cachedBuilding; mutable boost::optional m_cachedFoundationKivaSettings; + mutable boost::optional m_cachedOutputControlFiles; mutable boost::optional m_cachedOutputTableSummaryReports; mutable boost::optional m_cachedLifeCycleCostParameters; mutable boost::optional m_cachedPerformancePrecisionTradeoffs; @@ -319,6 +325,7 @@ namespace detail { void clearCachedData(); void clearCachedBuilding(const Handle& handle); void clearCachedFoundationKivaSettings(const Handle& handle); + void clearCachedOutputControlFiles(const Handle& handle); void clearCachedOutputTableSummaryReports(const Handle& handle); void clearCachedLifeCycleCostParameters(const Handle& handle); void clearCachedPerformancePrecisionTradeoffs(const Handle& handle);