diff --git a/src/EnergyPlus/OutputReportTabularAnnual.cc b/src/EnergyPlus/OutputReportTabularAnnual.cc index dcae14a61f5..373d4432a7e 100644 --- a/src/EnergyPlus/OutputReportTabularAnnual.cc +++ b/src/EnergyPlus/OutputReportTabularAnnual.cc @@ -58,7 +58,6 @@ #include // EnergyPlus Headers -#include #include #include #include @@ -75,6 +74,9 @@ namespace EnergyPlus::OutputReportTabularAnnual { +constexpr Real64 veryLarge = std::numeric_limits::max(); +constexpr Real64 verySmall = std::numeric_limits::min(); + void GetInputTabularAnnual(EnergyPlusData &state) { // Jason Glazer, August 2015 @@ -87,16 +89,13 @@ void GetInputTabularAnnual(EnergyPlusData &state) static std::string const currentModuleObject("Output:Table:Annual"); - int jAlpha; int numParams; // Number of elements combined int numAlphas; // Number of elements in the alpha array int numNums; // Number of elements in the numeric array Array1D_string alphArray; // character string data Array1D numArray; // numeric data int IOStat; // IO Status when calling get input subroutine - // static bool ErrorsFound( false ); int objCount(0); - int curNumDgts; AnnualFieldSet::AggregationKind curAgg(AnnualFieldSet::AggregationKind::sumOrAvg); auto &annualTables = state.dataOutputReportTabularAnnual->annualTables; @@ -124,7 +123,7 @@ void GetInputTabularAnnual(EnergyPlusData &state) if (numAlphas >= 5) { annualTables.emplace_back(state, alphArray(1), alphArray(2), alphArray(3)); // the remaining fields are repeating in groups of three and need to be added to the data structure - for (jAlpha = 4; jAlpha <= numAlphas; jAlpha += 2) { + for (int jAlpha = 4; jAlpha <= numAlphas; jAlpha += 2) { std::string curVarMtr = alphArray(jAlpha); if (curVarMtr.empty()) { ShowWarningError(state, @@ -133,12 +132,13 @@ void GetInputTabularAnnual(EnergyPlusData &state) alphArray(1))); } if (jAlpha <= numAlphas) { - std::string aggregationString = alphArray(jAlpha + 1); + const std::string &aggregationString = alphArray(jAlpha + 1); curAgg = stringToAggKind(state, aggregationString); } else { curAgg = AnnualFieldSet::AggregationKind::sumOrAvg; // if missing aggregation type use SumOrAverage } - int indexNums = 1 + (jAlpha - 3) / 2; // compute the corresponding field index in the numArray + const int indexNums = 1 + (jAlpha - 3) / 2; // compute the corresponding field index in the numArray + int curNumDgts; if (indexNums <= numNums) { curNumDgts = numArray(indexNums); } else { @@ -155,7 +155,7 @@ void GetInputTabularAnnual(EnergyPlusData &state) } } -void AnnualTable::addFieldSet(std::string varName, AnnualFieldSet::AggregationKind aggKind, int dgts) +void AnnualTable::addFieldSet(const std::string &varName, AnnualFieldSet::AggregationKind aggKind, int dgts) // Jason Glazer, August 2015 // This method is used along with the constructor to convert the GetInput for REPORT:TABLE:ANNUAL // into the class data. @@ -164,7 +164,7 @@ void AnnualTable::addFieldSet(std::string varName, AnnualFieldSet::AggregationKi m_annualFields.back().m_colHead = varName; // use the variable name for the column heading } -void AnnualTable::addFieldSet(std::string varName, std::string colName, AnnualFieldSet::AggregationKind aggKind, int dgts) +void AnnualTable::addFieldSet(const std::string &varName, const std::string &colName, AnnualFieldSet::AggregationKind aggKind, int dgts) // Jason Glazer, August 2015 // This overloaded method allows for a specific column name to be different than the output variable or meter name { @@ -173,89 +173,87 @@ void AnnualTable::addFieldSet(std::string varName, std::string colName, AnnualFi } void AnnualTable::setupGathering(EnergyPlusData &state) -// Jason Glazer, August 2015 -// This method is used after GetInput for REPORT:TABLE:ANNUAL to set up how output variables, meters, -// input fields, and ems variables are gathered. { + // Used after GetInput for REPORT:TABLE:ANNUAL to set up how output variables, meters, + // input fields, and ems variables are gathered. + OutputProcessor::VariableType typeVar = OutputProcessor::VariableType::Invalid; OutputProcessor::StoreType avgSumVar; OutputProcessor::TimeStepType stepTypeVar; Constant::Units unitsVar = Constant::Units::None; - Array1D_string namesOfKeys; // keyNames - Array1D_int indexesForKeyVar; // keyVarIndexes std::list allKeys; std::string filterFieldUpper = m_filter; std::transform(filterFieldUpper.begin(), filterFieldUpper.end(), filterFieldUpper.begin(), ::toupper); - bool useFilter = (!m_filter.empty()); + const bool useFilter = !m_filter.empty(); - std::vector::iterator fldStIt; - for (fldStIt = m_annualFields.begin(); fldStIt != m_annualFields.end(); ++fldStIt) { - int keyCount = fldStIt->getVariableKeyCountandTypeFromFldSt(state, typeVar, avgSumVar, stepTypeVar, unitsVar); - fldStIt->getVariableKeysFromFldSt(state, typeVar, keyCount, fldStIt->m_namesOfKeys, fldStIt->m_indexesForKeyVar); - for (std::string nm : fldStIt->m_namesOfKeys) { + // Gather key lists for each field set and build the union of all keys (optionally filtered) + for (auto &fldSt : m_annualFields) { + const int keyCount = fldSt.getVariableKeyCountandTypeFromFldSt(state, typeVar, avgSumVar, stepTypeVar, unitsVar); + fldSt.getVariableKeysFromFldSt(state, typeVar, keyCount, fldSt.m_namesOfKeys, fldSt.m_indexesForKeyVar); + for (const auto &nm : fldSt.m_namesOfKeys) { std::string nmUpper = nm; std::transform(nmUpper.begin(), nmUpper.end(), nmUpper.begin(), ::toupper); if (!useFilter || nmUpper.find(filterFieldUpper) != std::string::npos) { - allKeys.push_back(nm); // create list of all items + allKeys.push_back(nm); } } - fldStIt->m_typeOfVar = typeVar; - fldStIt->m_varAvgSum = avgSumVar; - fldStIt->m_varStepType = stepTypeVar; - fldStIt->m_varUnits = unitsVar; - fldStIt->m_keyCount = keyCount; + fldSt.m_typeOfVar = typeVar; + fldSt.m_varAvgSum = avgSumVar; + fldSt.m_varStepType = stepTypeVar; + fldSt.m_varUnits = unitsVar; + fldSt.m_keyCount = keyCount; } allKeys.sort(); - allKeys.unique(); // will now just have a list of the unique keys that is sorted - std::copy(allKeys.begin(), allKeys.end(), back_inserter(m_objectNames)); // copy list to the object names - // size all columns list of cells to be the size of the - for (fldStIt = m_annualFields.begin(); fldStIt != m_annualFields.end(); ++fldStIt) { - fldStIt->m_cell.resize(m_objectNames.size()); + allKeys.unique(); + m_objectNames.clear(); + std::copy(allKeys.begin(), allKeys.end(), std::back_inserter(m_objectNames)); + // Size each field set's cell array for the number of object names (rows) + for (auto &fldSt : m_annualFields) { + fldSt.m_cell.resize(m_objectNames.size()); } - // for each column (field set) set the rows cell to the output variable index (for variables) - int foundKeyIndex; + // Populate per-row/per-field cell metadata int tableRowIndex = 0; - for (std::vector::iterator objNmIt = m_objectNames.begin(); objNmIt != m_objectNames.end(); ++objNmIt) { - for (fldStIt = m_annualFields.begin(); fldStIt != m_annualFields.end(); ++fldStIt) { - foundKeyIndex = -1; - for (std::string::size_type i = 0; i < fldStIt->m_namesOfKeys.size(); i++) { - if (fldStIt->m_namesOfKeys[i] == *objNmIt) { - foundKeyIndex = i; + for (const auto &objName : m_objectNames) { + for (auto &fldSt : m_annualFields) { + int foundKeyIndex = -1; + for (std::size_t i = 0; i < fldSt.m_namesOfKeys.size(); ++i) { + if (fldSt.m_namesOfKeys[i] == objName) { + foundKeyIndex = static_cast(i); break; } } - if (foundKeyIndex > -1) { - fldStIt->m_cell[tableRowIndex].indexesForKeyVar = fldStIt->m_indexesForKeyVar[foundKeyIndex]; - } else { - fldStIt->m_cell[tableRowIndex].indexesForKeyVar = -1; // flag value that cell is not gathered + fldSt.m_cell[tableRowIndex].indexesForKeyVar = (foundKeyIndex >= 0) ? fldSt.m_indexesForKeyVar[foundKeyIndex] : -1; + // Initialize result based on aggregation kind + switch (fldSt.m_aggregate) { + case AnnualFieldSet::AggregationKind::maximum: + case AnnualFieldSet::AggregationKind::maximumDuringHoursShown: + fldSt.m_cell[tableRowIndex].result = -9.9e99; + break; + case AnnualFieldSet::AggregationKind::minimum: + case AnnualFieldSet::AggregationKind::minimumDuringHoursShown: + fldSt.m_cell[tableRowIndex].result = 9.9e99; + break; + default: + fldSt.m_cell[tableRowIndex].result = 0.0; + break; } - if (fldStIt->m_aggregate == AnnualFieldSet::AggregationKind::maximum || - fldStIt->m_aggregate == AnnualFieldSet::AggregationKind::maximumDuringHoursShown) { - fldStIt->m_cell[tableRowIndex].result = -9.9e99; - } else if (fldStIt->m_aggregate == AnnualFieldSet::AggregationKind::minimum || - fldStIt->m_aggregate == AnnualFieldSet::AggregationKind::minimumDuringHoursShown) { - fldStIt->m_cell[tableRowIndex].result = 9.9e99; - } else { - fldStIt->m_cell[tableRowIndex].result = 0.0; - } - fldStIt->m_cell[tableRowIndex].duration = 0.0; - fldStIt->m_cell[tableRowIndex].timeStamp = 0; + fldSt.m_cell[tableRowIndex].duration = 0.0; + fldSt.m_cell[tableRowIndex].timeStamp = 0; } - tableRowIndex++; + ++tableRowIndex; } } void checkAggregationOrderForAnnual(EnergyPlusData &state) { - std::vector::iterator annualTableIt; bool invalidAggregationOrderFound = false; auto &annualTables = state.dataOutputReportTabularAnnual->annualTables; if (!state.dataGlobal->DoWeathSim) { // if no weather simulation than no reading of MonthlyInput array return; } - for (annualTableIt = annualTables.begin(); annualTableIt != annualTables.end(); ++annualTableIt) { - if (annualTableIt->invalidAggregationOrder(state)) { + for (auto &annualTable : annualTables) { + if (annualTable.invalidAggregationOrder(state)) { invalidAggregationOrderFound = true; } } @@ -267,32 +265,38 @@ void checkAggregationOrderForAnnual(EnergyPlusData &state) // Generate an error message if an advanced aggregation kind columns don't follow the appropriate column - Glazer 2017 bool AnnualTable::invalidAggregationOrder(EnergyPlusData &state) { - std::vector::iterator fldStIt; bool foundMinOrMax = false; bool foundHourAgg = false; bool missingMaxOrMinError = false; bool missingHourAggError = false; - for (fldStIt = m_annualFields.begin(); fldStIt != m_annualFields.end(); ++fldStIt) { - if ((fldStIt->m_aggregate == AnnualFieldSet::AggregationKind::maximum) || - (fldStIt->m_aggregate == AnnualFieldSet::AggregationKind::minimum)) { + for (auto const &fldSt : m_annualFields) { + switch (fldSt.m_aggregate) { + case AnnualFieldSet::AggregationKind::maximum: + case AnnualFieldSet::AggregationKind::minimum: foundMinOrMax = true; - } else if ((fldStIt->m_aggregate == AnnualFieldSet::AggregationKind::hoursNonZero) || - (fldStIt->m_aggregate == AnnualFieldSet::AggregationKind::hoursZero) || - (fldStIt->m_aggregate == AnnualFieldSet::AggregationKind::hoursPositive) || - (fldStIt->m_aggregate == AnnualFieldSet::AggregationKind::hoursNonPositive) || - (fldStIt->m_aggregate == AnnualFieldSet::AggregationKind::hoursNegative) || - (fldStIt->m_aggregate == AnnualFieldSet::AggregationKind::hoursNonNegative)) { + break; + case AnnualFieldSet::AggregationKind::hoursNonZero: + case AnnualFieldSet::AggregationKind::hoursZero: + case AnnualFieldSet::AggregationKind::hoursPositive: + case AnnualFieldSet::AggregationKind::hoursNonPositive: + case AnnualFieldSet::AggregationKind::hoursNegative: + case AnnualFieldSet::AggregationKind::hoursNonNegative: foundHourAgg = true; - } else if (fldStIt->m_aggregate == AnnualFieldSet::AggregationKind::valueWhenMaxMin) { + break; + case AnnualFieldSet::AggregationKind::valueWhenMaxMin: if (!foundMinOrMax) { missingMaxOrMinError = true; } - } else if ((fldStIt->m_aggregate == AnnualFieldSet::AggregationKind::sumOrAverageHoursShown) || - (fldStIt->m_aggregate == AnnualFieldSet::AggregationKind::maximumDuringHoursShown) || - (fldStIt->m_aggregate == AnnualFieldSet::AggregationKind::minimumDuringHoursShown)) { + break; + case AnnualFieldSet::AggregationKind::sumOrAverageHoursShown: + case AnnualFieldSet::AggregationKind::maximumDuringHoursShown: + case AnnualFieldSet::AggregationKind::minimumDuringHoursShown: if (!foundHourAgg) { missingHourAggError = true; } + break; + default: + break; } } if (missingMaxOrMinError) { @@ -310,15 +314,14 @@ bool AnnualTable::invalidAggregationOrder(EnergyPlusData &state) return (missingHourAggError || missingMaxOrMinError); } -void GatherAnnualResultsForTimeStep(EnergyPlusData &state, OutputProcessor::TimeStepType kindOfTimeStep) +void GatherAnnualResultsForTimeStep(EnergyPlusData &state, const OutputProcessor::TimeStepType kindOfTimeStep) { // Jason Glazer, August 2015 // This function is not part of the class but acts as an interface between procedural code and the class by // gathering data for each of the AnnualTable objects - std::vector::iterator annualTableIt; auto &annualTables = state.dataOutputReportTabularAnnual->annualTables; - for (annualTableIt = annualTables.begin(); annualTableIt != annualTables.end(); ++annualTableIt) { - annualTableIt->gatherForTimestep(state, kindOfTimeStep); + for (auto &annualTable : annualTables) { + annualTable.gatherForTimestep(state, kindOfTimeStep); } } @@ -350,7 +353,6 @@ void AnnualTable::gatherForTimestep(EnergyPlusData &state, OutputProcessor::Time Real64 curValue = GetInternalVariableValue(state, curTypeOfVar, curVarNum); // Get the value from the result array Real64 oldResultValue = fldStIt->m_cell[row].result; - // int oldTimeStamp = fldStIt->m_cell[row].timeStamp; Real64 oldDuration = fldStIt->m_cell[row].duration; // Zero the revised values (as default if not set later) Real64 newResultValue = 0.0; @@ -469,7 +471,7 @@ void AnnualTable::gatherForTimestep(EnergyPlusData &state, OutputProcessor::Time fldStIt->m_cell[row].deferredResults.push_back(curValue); } fldStIt->m_cell[row].deferredElapsed.push_back(elapsedTime); // save the amount of time for this particular value - newDuration = oldDuration + elapsedTime; + // newDuration = oldDuration + elapsedTime; break; case AnnualFieldSet::AggregationKind::noAggregation: case AnnualFieldSet::AggregationKind::valueWhenMaxMin: @@ -523,7 +525,6 @@ void AnnualTable::gatherForTimestep(EnergyPlusData &state, OutputProcessor::Time if (activeHoursShown) { for (fldStRemainIt = fldStIt + 1; fldStRemainIt != m_annualFields.end(); ++fldStRemainIt) { OutputProcessor::VariableType scanTypeOfVar = fldStRemainIt->m_typeOfVar; - // int scanStepType = fldStRemainIt->m_varStepType; int scanVarNum = fldStRemainIt->m_cell[row].indexesForKeyVar; Real64 oldScanValue = fldStRemainIt->m_cell[row].result; if (scanVarNum > -1) { @@ -565,7 +566,7 @@ void AnnualTable::gatherForTimestep(EnergyPlusData &state, OutputProcessor::Time // do nothing } } - activeHoursShown = false; // fixed CR8317 + activeHoursShown = false; } } } @@ -574,42 +575,46 @@ void AnnualTable::gatherForTimestep(EnergyPlusData &state, OutputProcessor::Time } } -void ResetAnnualGathering(EnergyPlusData &state) +void ResetAnnualGathering(const EnergyPlusData &state) { // Jason Glazer, October 2015 // This function is not part of the class but acts as an interface between procedural code and the class by // resetting data for each of the AnnualTable objects - std::vector::iterator annualTableIt; auto &annualTables = state.dataOutputReportTabularAnnual->annualTables; - for (annualTableIt = annualTables.begin(); annualTableIt != annualTables.end(); ++annualTableIt) { - annualTableIt->resetGathering(); + for (auto &annualTable : annualTables) { + annualTable.resetGathering(); } } void AnnualTable::resetGathering() { - std::vector::iterator fldStIt; - for (unsigned int row = 0; row != m_objectNames.size(); row++) { // loop through by row. - for (fldStIt = m_annualFields.begin(); fldStIt != m_annualFields.end(); ++fldStIt) { - if (fldStIt->m_aggregate == AnnualFieldSet::AggregationKind::maximum || - fldStIt->m_aggregate == AnnualFieldSet::AggregationKind::maximumDuringHoursShown) { - fldStIt->m_cell[row].result = -9.9e99; - } else if (fldStIt->m_aggregate == AnnualFieldSet::AggregationKind::minimum || - fldStIt->m_aggregate == AnnualFieldSet::AggregationKind::minimumDuringHoursShown) { - fldStIt->m_cell[row].result = 9.9e99; - } else { - fldStIt->m_cell[row].result = 0.0; + for (std::size_t row = 0; row < m_objectNames.size(); ++row) { + for (auto &fldSt : m_annualFields) { + auto &cell = fldSt.m_cell[row]; + switch (fldSt.m_aggregate) { + case AnnualFieldSet::AggregationKind::maximum: + case AnnualFieldSet::AggregationKind::maximumDuringHoursShown: + cell.result = -9.9e99; + break; + case AnnualFieldSet::AggregationKind::minimum: + case AnnualFieldSet::AggregationKind::minimumDuringHoursShown: + cell.result = 9.9e99; + break; + default: + cell.result = 0.0; + break; } - fldStIt->m_cell[row].duration = 0.0; - fldStIt->m_cell[row].timeStamp = 0; - // if any deferred results - fldStIt->m_cell[row].deferredResults.clear(); - fldStIt->m_cell[row].deferredElapsed.clear(); + cell.duration = 0.0; + cell.timeStamp = 0; + + // Clear deferred results + cell.deferredResults.clear(); + cell.deferredElapsed.clear(); } } } -Real64 AnnualTable::getElapsedTime(EnergyPlusData &state, OutputProcessor::TimeStepType kindOfTimeStep) +Real64 AnnualTable::getElapsedTime(const EnergyPlusData &state, const OutputProcessor::TimeStepType kindOfTimeStep) { Real64 elapsedTime; if (kindOfTimeStep == OutputProcessor::TimeStepType::Zone) { @@ -620,7 +625,7 @@ Real64 AnnualTable::getElapsedTime(EnergyPlusData &state, OutputProcessor::TimeS return elapsedTime; } -Real64 AnnualTable::getSecondsInTimeStep(EnergyPlusData &state, OutputProcessor::TimeStepType kindOfTimeStep) +Real64 AnnualTable::getSecondsInTimeStep(const EnergyPlusData &state, const OutputProcessor::TimeStepType kindOfTimeStep) { Real64 secondsInTimeStep; if (kindOfTimeStep == OutputProcessor::TimeStepType::Zone) { @@ -634,14 +639,13 @@ Real64 AnnualTable::getSecondsInTimeStep(EnergyPlusData &state, OutputProcessor: void WriteAnnualTables(EnergyPlusData &state) { auto &annualTables = state.dataOutputReportTabularAnnual->annualTables; - for (auto ¤tStyle : state.dataOutRptTab->tabularReportPasses) { + for (auto const ¤tStyle : state.dataOutRptTab->tabularReportPasses) { // Jason Glazer, August 2015 // This function is not part of the class but acts as an interface between procedural code and the class by // invoking the writeTable member function for each of the AnnualTable objects - std::vector::iterator annualTableIt; - for (annualTableIt = annualTables.begin(); annualTableIt != annualTables.end(); ++annualTableIt) { - annualTableIt->writeTable(state, currentStyle); + for (auto &annualTable : annualTables) { + annualTable.writeTable(state, currentStyle); } } } @@ -652,8 +656,6 @@ void AnnualTable::writeTable(EnergyPlusData &state, OutputReportTabular::tabular Array1D_int columnWidth; Array1D_string rowHead; Array2D_string tableBody; - Real64 veryLarge = 1.0E280; - Real64 verySmall = -1.0E280; std::vector aggString; std::string energyUnitsString; std::string varNameWithUnits; @@ -668,9 +670,6 @@ void AnnualTable::writeTable(EnergyPlusData &state, OutputReportTabular::tabular Real64 sumDuration; bool createBinRangeTable = false; - static Real64 const storedMaxVal(std::numeric_limits::max()); - static Real64 const storedMinVal(std::numeric_limits::lowest()); - aggString = setupAggString(); Real64 energyUnitsConversionFactor = AnnualTable::setEnergyUnitStringAndFactor(style.unitsStyle, energyUnitsString); @@ -684,9 +683,8 @@ void AnnualTable::writeTable(EnergyPlusData &state, OutputReportTabular::tabular // since max and min actually define two columns (the value // and the timestamp). int columnCount = 0; - std::vector::iterator fldStIt; - for (fldStIt = m_annualFields.begin(); fldStIt != m_annualFields.end(); ++fldStIt) { - columnCount += columnCountForAggregation(fldStIt->m_aggregate); + for (auto &fldStIt : m_annualFields) { + columnCount += columnCountForAggregation(fldStIt.m_aggregate); } columnHead.allocate(columnCount); columnWidth.dimension(columnCount); @@ -707,54 +705,62 @@ void AnnualTable::writeTable(EnergyPlusData &state, OutputReportTabular::tabular tableBody.allocate(columnCount, rowCount); tableBody = ""; // set entire table to blank as default int columnRecount = 0; - for (fldStIt = m_annualFields.begin(); fldStIt != m_annualFields.end(); ++fldStIt) { - std::string curAggString = aggString[(int)fldStIt->m_aggregate]; + for (auto &fldSt : m_annualFields) { + std::string curAggString = aggString[static_cast(fldSt.m_aggregate)]; if (!curAggString.empty()) { curAggString = " {" + trim(curAggString) + '}'; } // do the unit conversions - if (style.unitsStyle == OutputReportTabular::UnitsStyle::InchPound || - style.unitsStyle == OutputReportTabular::UnitsStyle::InchPoundExceptElectricity) { - varNameWithUnits = format("{} [{}]", fldStIt->m_variMeter, Constant::unitNames[(int)fldStIt->m_varUnits]); + switch (style.unitsStyle) { + case OutputReportTabular::UnitsStyle::InchPound: + case OutputReportTabular::UnitsStyle::InchPoundExceptElectricity: { + varNameWithUnits = format("{} [{}]", fldSt.m_variMeter, Constant::unitNames[static_cast(fldSt.m_varUnits)]); OutputReportTabular::LookupSItoIP(state, varNameWithUnits, indexUnitConv, curUnits); OutputReportTabular::GetUnitConversion(state, indexUnitConv, curConversionFactor, curConversionOffset, curUnits); - } else { // just do the Joule conversion - // if units is in Joules, convert if specified - if (fldStIt->m_varUnits == Constant::Units::J) { + break; + } + default: { + // Just do the Joule conversion + switch (fldSt.m_varUnits) { + case Constant::Units::J: curUnits = energyUnitsString; curConversionFactor = energyUnitsConversionFactor; curConversionOffset = 0.0; - } else { // if not joules don't perform conversion - curUnits = Constant::unitNames[(int)fldStIt->m_varUnits]; + break; + default: + curUnits = Constant::unitNames[static_cast(fldSt.m_varUnits)]; curConversionFactor = 1.0; curConversionOffset = 0.0; + break; } + break; } - int curAgg = fldStIt->m_aggregate; - columnRecount += columnCountForAggregation(fldStIt->m_aggregate); - if ((curAgg == AnnualFieldSet::AggregationKind::sumOrAvg) || (curAgg == AnnualFieldSet::AggregationKind::sumOrAverageHoursShown)) { - // put in the name of the variable for the column - columnHead(columnRecount) = fldStIt->m_colHead + curAggString + " [" + curUnits + ']'; + } + int curAgg = fldSt.m_aggregate; + columnRecount += columnCountForAggregation(fldSt.m_aggregate); + switch (curAgg) { + case AnnualFieldSet::AggregationKind::sumOrAvg: + case AnnualFieldSet::AggregationKind::sumOrAverageHoursShown: { + columnHead(columnRecount) = fldSt.m_colHead + curAggString + " [" + curUnits + ']'; sumVal = 0.0; sumDuration = 0.0; - minVal = storedMaxVal; - maxVal = storedMinVal; - - for (unsigned int row = 0; row != m_objectNames.size(); row++) { // loop through by row. - if (fldStIt->m_cell[row].indexesForKeyVar >= 0) { - if (fldStIt->m_varAvgSum == OutputProcessor::StoreType::Average) { // if it is a average variable divide by duration - if (fldStIt->m_cell[row].duration != 0.0) { - curVal = ((fldStIt->m_cell[row].result / fldStIt->m_cell[row].duration) * curConversionFactor) + curConversionOffset; + minVal = veryLarge; + maxVal = verySmall; + for (unsigned int row = 0; row != m_objectNames.size(); ++row) { + if (fldSt.m_cell[row].indexesForKeyVar >= 0) { + if (fldSt.m_varAvgSum == OutputProcessor::StoreType::Average) { + if (fldSt.m_cell[row].duration != 0.0) { + curVal = ((fldSt.m_cell[row].result / fldSt.m_cell[row].duration) * curConversionFactor) + curConversionOffset; } else { curVal = 0.0; } - sumVal += (fldStIt->m_cell[row].result * curConversionFactor) + curConversionOffset; - sumDuration += fldStIt->m_cell[row].duration; + sumVal += (fldSt.m_cell[row].result * curConversionFactor) + curConversionOffset; + sumDuration += fldSt.m_cell[row].duration; } else { - curVal = (fldStIt->m_cell[row].result * curConversionFactor) + curConversionOffset; + curVal = (fldSt.m_cell[row].result * curConversionFactor) + curConversionOffset; sumVal += curVal; } - tableBody(columnRecount, row + 1) = OutputReportTabular::RealToStr(style.formatReals, curVal, fldStIt->m_showDigits); + tableBody(columnRecount, row + 1) = OutputReportTabular::RealToStr(style.formatReals, curVal, fldSt.m_showDigits); if (curVal > maxVal) { maxVal = curVal; } @@ -764,37 +770,38 @@ void AnnualTable::writeTable(EnergyPlusData &state, OutputReportTabular::tabular } else { tableBody(columnRecount, row + 1) = "-"; } - - } // row - // add the summary to bottom - if (fldStIt->m_varAvgSum == OutputProcessor::StoreType::Average) { // if it is a average variable divide by duration + } + if (fldSt.m_varAvgSum == OutputProcessor::StoreType::Average) { if (sumDuration > 0) { - tableBody(columnRecount, rowSumAvg) = - OutputReportTabular::RealToStr(style.formatReals, sumVal / sumDuration, fldStIt->m_showDigits); + tableBody(columnRecount, rowSumAvg) = OutputReportTabular::RealToStr(style.formatReals, sumVal / sumDuration, fldSt.m_showDigits); } else { tableBody(columnRecount, rowSumAvg) = ""; } } else { - tableBody(columnRecount, rowSumAvg) = OutputReportTabular::RealToStr(style.formatReals, sumVal, fldStIt->m_showDigits); + tableBody(columnRecount, rowSumAvg) = OutputReportTabular::RealToStr(style.formatReals, sumVal, fldSt.m_showDigits); } - if (minVal != storedMaxVal) { - tableBody(columnRecount, rowMax) = OutputReportTabular::RealToStr(style.formatReals, minVal, fldStIt->m_showDigits); + if (minVal != veryLarge) { + tableBody(columnRecount, rowMax) = OutputReportTabular::RealToStr(style.formatReals, minVal, fldSt.m_showDigits); } - if (maxVal != storedMinVal) { - tableBody(columnRecount, rowMin) = OutputReportTabular::RealToStr(style.formatReals, maxVal, fldStIt->m_showDigits); + if (maxVal != verySmall) { + tableBody(columnRecount, rowMin) = OutputReportTabular::RealToStr(style.formatReals, maxVal, fldSt.m_showDigits); } - } else if ((curAgg == AnnualFieldSet::AggregationKind::hoursZero) || (curAgg == AnnualFieldSet::AggregationKind::hoursNonZero) || - (curAgg == AnnualFieldSet::AggregationKind::hoursPositive) || (curAgg == AnnualFieldSet::AggregationKind::hoursNonPositive) || - (curAgg == AnnualFieldSet::AggregationKind::hoursNegative) || (curAgg == AnnualFieldSet::AggregationKind::hoursNonNegative)) { - // put in the name of the variable for the column - columnHead(columnRecount) = fldStIt->m_colHead + curAggString + " [HOURS]"; + break; + } + case AnnualFieldSet::AggregationKind::hoursZero: + case AnnualFieldSet::AggregationKind::hoursNonZero: + case AnnualFieldSet::AggregationKind::hoursPositive: + case AnnualFieldSet::AggregationKind::hoursNonPositive: + case AnnualFieldSet::AggregationKind::hoursNegative: + case AnnualFieldSet::AggregationKind::hoursNonNegative: { + columnHead(columnRecount) = fldSt.m_colHead + curAggString + " [HOURS]"; sumVal = 0.0; - minVal = storedMaxVal; - maxVal = storedMinVal; - for (unsigned int row = 0; row != m_objectNames.size(); row++) { // loop through by row. - curVal = fldStIt->m_cell[row].result; + minVal = veryLarge; + maxVal = verySmall; + for (unsigned int row = 0; row != m_objectNames.size(); ++row) { + curVal = fldSt.m_cell[row].result; curVal = curVal * curConversionFactor + curConversionOffset; - tableBody(columnRecount, row + 1) = OutputReportTabular::RealToStr(style.formatReals, curVal, fldStIt->m_showDigits); + tableBody(columnRecount, row + 1) = OutputReportTabular::RealToStr(style.formatReals, curVal, fldSt.m_showDigits); sumVal += curVal; if (curVal > maxVal) { maxVal = curVal; @@ -802,58 +809,57 @@ void AnnualTable::writeTable(EnergyPlusData &state, OutputReportTabular::tabular if (curVal < minVal) { minVal = curVal; } - } // row - // add the summary to bottom - tableBody(columnRecount, rowSumAvg) = OutputReportTabular::RealToStr(style.formatReals, sumVal, fldStIt->m_showDigits); - if (minVal != storedMaxVal) { - tableBody(columnRecount, rowMax) = OutputReportTabular::RealToStr(style.formatReals, minVal, fldStIt->m_showDigits); } - if (maxVal != storedMinVal) { - tableBody(columnRecount, rowMin) = OutputReportTabular::RealToStr(style.formatReals, maxVal, fldStIt->m_showDigits); + tableBody(columnRecount, rowSumAvg) = OutputReportTabular::RealToStr(style.formatReals, sumVal, fldSt.m_showDigits); + if (minVal != veryLarge) { + tableBody(columnRecount, rowMax) = OutputReportTabular::RealToStr(style.formatReals, minVal, fldSt.m_showDigits); + } + if (maxVal != verySmall) { + tableBody(columnRecount, rowMin) = OutputReportTabular::RealToStr(style.formatReals, maxVal, fldSt.m_showDigits); } - } else if (curAgg == AnnualFieldSet::AggregationKind::valueWhenMaxMin) { - if (fldStIt->m_varAvgSum == OutputProcessor::StoreType::Sum) { + break; + } + case AnnualFieldSet::AggregationKind::valueWhenMaxMin: { + if (fldSt.m_varAvgSum == OutputProcessor::StoreType::Sum) { curUnits += "/s"; } fixUnitsPerSecond(curUnits, curConversionFactor); - columnHead(columnRecount) = fldStIt->m_colHead + curAggString + " [" + curUnits + ']'; - minVal = storedMaxVal; - maxVal = storedMinVal; - for (unsigned int row = 0; row != m_objectNames.size(); row++) { // loop through by row. - curVal = fldStIt->m_cell[row].result; + columnHead(columnRecount) = fldSt.m_colHead + curAggString + " [" + curUnits + ']'; + minVal = veryLarge; + maxVal = verySmall; + for (unsigned int row = 0; row != m_objectNames.size(); ++row) { + curVal = fldSt.m_cell[row].result; curVal = curVal * curConversionFactor + curConversionOffset; - tableBody(columnRecount, row + 1) = OutputReportTabular::RealToStr(style.formatReals, curVal, fldStIt->m_showDigits); + tableBody(columnRecount, row + 1) = OutputReportTabular::RealToStr(style.formatReals, curVal, fldSt.m_showDigits); if (curVal > maxVal) { maxVal = curVal; } if (curVal < minVal) { minVal = curVal; } - } // row - // add the summary to bottom - if (minVal != storedMaxVal) { - tableBody(columnRecount, rowMin) = OutputReportTabular::RealToStr(style.formatReals, minVal, fldStIt->m_showDigits); } - if (maxVal != storedMinVal) { - tableBody(columnRecount, rowMax) = OutputReportTabular::RealToStr(style.formatReals, maxVal, fldStIt->m_showDigits); + if (minVal != veryLarge) { + tableBody(columnRecount, rowMin) = OutputReportTabular::RealToStr(style.formatReals, minVal, fldSt.m_showDigits); } - } else if ((curAgg == AnnualFieldSet::AggregationKind::maximum) || (curAgg == AnnualFieldSet::AggregationKind::minimum) || - (curAgg == AnnualFieldSet::AggregationKind::maximumDuringHoursShown) || - (curAgg == AnnualFieldSet::AggregationKind::minimumDuringHoursShown)) { - // put in the name of the variable for the column - if (fldStIt->m_varAvgSum == OutputProcessor::StoreType::Sum) { // if it is a summed variable + if (maxVal != verySmall) { + tableBody(columnRecount, rowMax) = OutputReportTabular::RealToStr(style.formatReals, maxVal, fldSt.m_showDigits); + } + break; + } + case AnnualFieldSet::AggregationKind::maximum: + case AnnualFieldSet::AggregationKind::minimum: + case AnnualFieldSet::AggregationKind::maximumDuringHoursShown: + case AnnualFieldSet::AggregationKind::minimumDuringHoursShown: { + if (fldSt.m_varAvgSum == OutputProcessor::StoreType::Sum) { curUnits += "/s"; } fixUnitsPerSecond(curUnits, curConversionFactor); - columnHead(columnRecount - 1) = fldStIt->m_colHead + curAggString + " [" + curUnits + ']'; - columnHead(columnRecount) = fldStIt->m_colHead + " {TIMESTAMP}"; - minVal = storedMaxVal; - maxVal = storedMinVal; - for (unsigned int row = 0; row != m_objectNames.size(); row++) { // loop through by row. - curVal = fldStIt->m_cell[row].result; - // CR7788 the conversion factors were causing an overflow for the InchPound case since the - // value was very small - // restructured the following lines to hide showing HUGE and -HUGE values in output table CR8154 Glazer + columnHead(columnRecount - 1) = fldSt.m_colHead + curAggString + " [" + curUnits + ']'; + columnHead(columnRecount) = fldSt.m_colHead + " {TIMESTAMP}"; + minVal = veryLarge; + maxVal = verySmall; + for (unsigned int row = 0; row != m_objectNames.size(); ++row) { + curVal = fldSt.m_cell[row].result; if ((curVal < veryLarge) && (curVal > verySmall)) { curVal = curVal * curConversionFactor + curConversionOffset; if (curVal > maxVal) { @@ -863,97 +869,105 @@ void AnnualTable::writeTable(EnergyPlusData &state, OutputReportTabular::tabular minVal = curVal; } if (curVal < veryLarge && curVal > verySmall) { - tableBody(columnRecount - 1, row + 1) = OutputReportTabular::RealToStr(style.formatReals, curVal, fldStIt->m_showDigits); + tableBody(columnRecount - 1, row + 1) = OutputReportTabular::RealToStr(style.formatReals, curVal, fldSt.m_showDigits); } else { tableBody(columnRecount - 1, row + 1) = "-"; } - tableBody(columnRecount, row + 1) = OutputReportTabular::DateToString(fldStIt->m_cell[row].timeStamp); + tableBody(columnRecount, row + 1) = OutputReportTabular::DateToString(fldSt.m_cell[row].timeStamp); } else { tableBody(columnRecount - 1, row + 1) = "-"; tableBody(columnRecount, row + 1) = "-"; } - } // row - // add the summary to bottom - // Don't include if the original min and max values are still present + } if (minVal < veryLarge) { - tableBody(columnRecount - 1, rowMin) = OutputReportTabular::RealToStr(style.formatReals, minVal, fldStIt->m_showDigits); + tableBody(columnRecount - 1, rowMin) = OutputReportTabular::RealToStr(style.formatReals, minVal, fldSt.m_showDigits); } else { tableBody(columnRecount - 1, rowMin) = "-"; } if (maxVal > verySmall) { - tableBody(columnRecount - 1, rowMax) = OutputReportTabular::RealToStr(style.formatReals, maxVal, fldStIt->m_showDigits); + tableBody(columnRecount - 1, rowMax) = OutputReportTabular::RealToStr(style.formatReals, maxVal, fldSt.m_showDigits); } else { tableBody(columnRecount - 1, rowMax) = "-"; } - } else if (curAgg == AnnualFieldSet::AggregationKind::hoursInTenBinsMinToMax) { - // put in the name of the variable for the column - if (fldStIt->m_varAvgSum == OutputProcessor::StoreType::Sum) { // if it is a summed variable + break; + } + case AnnualFieldSet::AggregationKind::hoursInTenBinsMinToMax: { + if (fldSt.m_varAvgSum == OutputProcessor::StoreType::Sum) { curUnits += "/s"; } fixUnitsPerSecond(curUnits, curConversionFactor); - for (int iBin = 0; iBin != 10; iBin++) { - char binIndicator = iBin + 65; - columnHead(columnRecount - 9 + iBin) = fldStIt->m_colHead + curAggString + " BIN " + binIndicator; - for (unsigned int row = 0; row != m_objectNames.size(); row++) { // loop through by row. + for (int iBin = 0; iBin != 10; ++iBin) { + char binIndicator = static_cast(iBin + 65); + columnHead(columnRecount - 9 + iBin) = fldSt.m_colHead + curAggString + " BIN " + binIndicator; + for (unsigned int row = 0; row != m_objectNames.size(); ++row) { tableBody(columnRecount - 9 + iBin, row + 1) = - OutputReportTabular::RealToStr(style.formatReals, fldStIt->m_cell[row].m_timeInBin[iBin], fldStIt->m_showDigits); + OutputReportTabular::RealToStr(style.formatReals, fldSt.m_cell[row].m_timeInBin[iBin], fldSt.m_showDigits); } + tableBody(columnRecount - 9 + iBin, rowSumAvg) = - OutputReportTabular::RealToStr(style.formatReals, fldStIt->m_timeInBinTotal[iBin], fldStIt->m_showDigits); + OutputReportTabular::RealToStr(style.formatReals, fldSt.m_timeInBinTotal[iBin], fldSt.m_showDigits); } createBinRangeTable = true; - } else if (curAgg == AnnualFieldSet::AggregationKind::hoursInTenBinsZeroToMax) { - // put in the name of the variable for the column - if (fldStIt->m_varAvgSum == OutputProcessor::StoreType::Sum) { // if it is a summed variable + break; + } + case AnnualFieldSet::AggregationKind::hoursInTenBinsZeroToMax: { + if (fldSt.m_varAvgSum == OutputProcessor::StoreType::Sum) { curUnits += "/s"; } fixUnitsPerSecond(curUnits, curConversionFactor); - for (int iBin = 0; iBin != 10; iBin++) { - char binIndicator = iBin + 65; - columnHead(columnRecount - 9 + iBin) = fldStIt->m_colHead + curAggString + " BIN " + binIndicator; - for (unsigned int row = 0; row != m_objectNames.size(); row++) { // loop through by row. + for (int iBin = 0; iBin != 10; ++iBin) { + char binIndicator = static_cast(iBin + 65); + columnHead(columnRecount - 9 + iBin) = fldSt.m_colHead + curAggString + " BIN " + binIndicator; + for (unsigned int row = 0; row != m_objectNames.size(); ++row) { tableBody(columnRecount - 9 + iBin, row + 1) = - OutputReportTabular::RealToStr(style.formatReals, fldStIt->m_cell[row].m_timeInBin[iBin], fldStIt->m_showDigits); + OutputReportTabular::RealToStr(style.formatReals, fldSt.m_cell[row].m_timeInBin[iBin], fldSt.m_showDigits); } tableBody(columnRecount - 9 + iBin, rowSumAvg) = - OutputReportTabular::RealToStr(style.formatReals, fldStIt->m_timeInBinTotal[iBin], fldStIt->m_showDigits); + OutputReportTabular::RealToStr(style.formatReals, fldSt.m_timeInBinTotal[iBin], fldSt.m_showDigits); } - columnHead(columnRecount - 10) = fldStIt->m_colHead + curAggString + " LESS THAN BIN A"; - for (unsigned int row = 0; row != m_objectNames.size(); row++) { // loop through by row. + columnHead(columnRecount - 10) = fldSt.m_colHead + curAggString + " LESS THAN BIN A"; + for (unsigned int row = 0; row != m_objectNames.size(); ++row) { tableBody(columnRecount - 10, row + 1) = - OutputReportTabular::RealToStr(style.formatReals, fldStIt->m_cell[row].m_timeBelowBottomBin, fldStIt->m_showDigits); + OutputReportTabular::RealToStr(style.formatReals, fldSt.m_cell[row].m_timeBelowBottomBin, fldSt.m_showDigits); } tableBody(columnRecount - 10, rowSumAvg) = - OutputReportTabular::RealToStr(style.formatReals, fldStIt->m_timeBelowBottomBinTotal, fldStIt->m_showDigits); + OutputReportTabular::RealToStr(style.formatReals, fldSt.m_timeBelowBottomBinTotal, fldSt.m_showDigits); createBinRangeTable = true; - } else if (curAgg == AnnualFieldSet::AggregationKind::hoursInTenBinsMinToZero) { - // put in the name of the variable for the column - if (fldStIt->m_varAvgSum == OutputProcessor::StoreType::Sum) { // if it is a summed variable + break; + } + case AnnualFieldSet::AggregationKind::hoursInTenBinsMinToZero: { + if (fldSt.m_varAvgSum == OutputProcessor::StoreType::Sum) { curUnits += "/s"; } fixUnitsPerSecond(curUnits, curConversionFactor); - for (int iBin = 0; iBin != 10; iBin++) { - char binIndicator = iBin + 65; - columnHead(columnRecount - 10 + iBin) = fldStIt->m_colHead + curAggString + " BIN " + binIndicator; - for (unsigned int row = 0; row != m_objectNames.size(); row++) { // loop through by row. + for (int iBin = 0; iBin != 10; ++iBin) { + char binIndicator = static_cast(iBin + 65); + columnHead(columnRecount - 10 + iBin) = fldSt.m_colHead + curAggString + " BIN " + binIndicator; + for (unsigned int row = 0; row != m_objectNames.size(); ++row) { tableBody(columnRecount - 10 + iBin, row + 1) = - OutputReportTabular::RealToStr(style.formatReals, fldStIt->m_cell[row].m_timeInBin[iBin], fldStIt->m_showDigits); + OutputReportTabular::RealToStr(style.formatReals, fldSt.m_cell[row].m_timeInBin[iBin], fldSt.m_showDigits); } tableBody(columnRecount - 10 + iBin, rowSumAvg) = - OutputReportTabular::RealToStr(style.formatReals, fldStIt->m_timeInBinTotal[iBin], fldStIt->m_showDigits); + OutputReportTabular::RealToStr(style.formatReals, fldSt.m_timeInBinTotal[iBin], fldSt.m_showDigits); } - columnHead(columnRecount) = fldStIt->m_colHead + curAggString + " MORE THAN BIN J"; - for (unsigned int row = 0; row != m_objectNames.size(); row++) { // loop through by row. + columnHead(columnRecount) = fldSt.m_colHead + curAggString + " MORE THAN BIN J"; + for (unsigned int row = 0; row != m_objectNames.size(); ++row) { tableBody(columnRecount, row + 1) = - OutputReportTabular::RealToStr(style.formatReals, fldStIt->m_cell[row].m_timeAboveTopBin, fldStIt->m_showDigits); + OutputReportTabular::RealToStr(style.formatReals, fldSt.m_cell[row].m_timeAboveTopBin, fldSt.m_showDigits); } - tableBody(columnRecount, rowSumAvg) = - OutputReportTabular::RealToStr(style.formatReals, fldStIt->m_timeAboveTopBinTotal, fldStIt->m_showDigits); + tableBody(columnRecount, rowSumAvg) = OutputReportTabular::RealToStr(style.formatReals, fldSt.m_timeAboveTopBinTotal, fldSt.m_showDigits); createBinRangeTable = true; - } else if (curAgg == AnnualFieldSet::AggregationKind::hoursInTenPercentBins || - curAgg == AnnualFieldSet::AggregationKind::hoursInTenBinsPlusMinusTwoStdDev || - curAgg == AnnualFieldSet::AggregationKind::hoursInTenBinsPlusMinusThreeStdDev) { + break; + } + case AnnualFieldSet::AggregationKind::hoursInTenPercentBins: + case AnnualFieldSet::AggregationKind::hoursInTenBinsPlusMinusTwoStdDev: + case AnnualFieldSet::AggregationKind::hoursInTenBinsPlusMinusThreeStdDev: + break; + + default: + break; } + } // fldStIt if (style.produceTabular) { OutputReportTabular::WriteReportHeaders(state, m_name, "Entire Facility", OutputProcessor::StoreType::Average); @@ -985,39 +999,35 @@ void AnnualTable::writeTable(EnergyPlusData &state, OutputReportTabular::tabular rowHeadRange(1) = ">="; rowHeadRange(2) = "<"; tableBodyRange.allocate(10, 2); - for (fldStIt = m_annualFields.begin(); fldStIt != m_annualFields.end(); ++fldStIt) { - int curAgg = fldStIt->m_aggregate; - if ((curAgg == AnnualFieldSet::AggregationKind::hoursInTenBinsMinToMax) || - (curAgg == AnnualFieldSet::AggregationKind::hoursInTenBinsZeroToMax) || - (curAgg == AnnualFieldSet::AggregationKind::hoursInTenBinsMinToZero)) { - tableBodyRange = ""; // set entire table to blank as default - Real64 binBottom = fldStIt->m_bottomBinValue; - Real64 binTop = fldStIt->m_topBinValue; - Real64 numBins = 10.; - Real64 intervalSize = (binTop - binBottom) / numBins; - - // could not get the following to work using - colHeadRange(1) = "BIN A"; - colHeadRange(2) = "BIN B"; - colHeadRange(3) = "BIN C"; - colHeadRange(4) = "BIN D"; - colHeadRange(5) = "BIN E"; - colHeadRange(6) = "BIN F"; - colHeadRange(7) = "BIN G"; - colHeadRange(8) = "BIN H"; - colHeadRange(9) = "BIN I"; - colHeadRange(10) = "BIN J"; - for (int iBin = 0; iBin != 10; iBin++) { - // colHeadRange( iBin + 1 ) = "BIN " + ( char )( iBin + 65 ); // not sure why this does not work - tableBodyRange(iBin + 1, 1) = - OutputReportTabular::RealToStr(style.formatReals, binBottom + float(iBin) * intervalSize, fldStIt->m_showDigits); - tableBodyRange(iBin + 1, 2) = - OutputReportTabular::RealToStr(style.formatReals, binBottom + float(iBin + 1) * intervalSize, fldStIt->m_showDigits); + for (auto &fldStIt : m_annualFields) { + switch (fldStIt.m_aggregate) { + case AnnualFieldSet::AggregationKind::hoursInTenBinsMinToMax: + case AnnualFieldSet::AggregationKind::hoursInTenBinsZeroToMax: + case AnnualFieldSet::AggregationKind::hoursInTenBinsMinToZero: { + const Real64 binBottom = fldStIt.m_bottomBinValue; + const Real64 binTop = fldStIt.m_topBinValue; + constexpr int numBins = 10; + const Real64 intervalSize = (binTop - binBottom) / static_cast(numBins); + // Column headers + for (int iBin = 0; iBin < numBins; ++iBin) { + const char binLetter = static_cast('A' + iBin); + colHeadRange(iBin + 1) = std::string("BIN ") + binLetter; + } + // Bin bounds + for (int iBin = 0; iBin < numBins; ++iBin) { + const Real64 lo = binBottom + static_cast(iBin) * intervalSize; + const Real64 hi = binBottom + static_cast(iBin + 1) * intervalSize; + tableBodyRange(iBin + 1, 1) = OutputReportTabular::RealToStr(style.formatReals, lo, fldStIt.m_showDigits); + tableBodyRange(iBin + 1, 2) = OutputReportTabular::RealToStr(style.formatReals, hi, fldStIt.m_showDigits); } if (style.produceTabular) { - OutputReportTabular::WriteSubtitle(state, "Bin Sizes for: " + fldStIt->m_colHead); - OutputReportTabular::WriteTable( - state, tableBodyRange, rowHeadRange, colHeadRange, colWidthRange, true); // transpose annual XML tables. + OutputReportTabular::WriteSubtitle(state, "Bin Sizes for: " + fldStIt.m_colHead); + OutputReportTabular::WriteTable(state, + tableBodyRange, + rowHeadRange, + colHeadRange, + colWidthRange, + true); // transpose annual XML tables } if (style.produceSQLite) { if (state.dataSQLiteProcedures->sqlite) { @@ -1031,6 +1041,10 @@ void AnnualTable::writeTable(EnergyPlusData &state, OutputReportTabular::tabular tableBodyRange, rowHeadRange, colHeadRange, m_name, "Entire Facility", "Bin Sizes"); } } + break; + } + default: + break; } } } @@ -1066,24 +1080,26 @@ std::vector AnnualTable::setupAggString() Real64 AnnualTable::setEnergyUnitStringAndFactor(OutputReportTabular::UnitsStyle const unitsStyle, std::string &unitString) { - Real64 convFactor; - // set the unit conversion - if (unitsStyle == OutputReportTabular::UnitsStyle::None) { - unitString = "J"; - convFactor = 1.0; - } else if (unitsStyle == OutputReportTabular::UnitsStyle::JtoKWH) { + Real64 convFactor = 1.0; + unitString = "J"; + switch (unitsStyle) { + case OutputReportTabular::UnitsStyle::JtoKWH: unitString = "kWh"; convFactor = 1.0 / 3600000.0; - } else if (unitsStyle == OutputReportTabular::UnitsStyle::JtoMJ) { + break; + case OutputReportTabular::UnitsStyle::JtoMJ: unitString = "MJ"; convFactor = 1.0 / 1000000.0; - } else if (unitsStyle == OutputReportTabular::UnitsStyle::JtoGJ) { + break; + case OutputReportTabular::UnitsStyle::JtoGJ: unitString = "GJ"; convFactor = 1.0 / 1000000000.0; - } else { // Should never happen but assures compilers of initialization - unitString = "J"; - convFactor = 1.0; + break; + case OutputReportTabular::UnitsStyle::None: + default: + break; } + return convFactor; } @@ -1166,35 +1182,42 @@ AnnualFieldSet::AggregationKind stringToAggKind(EnergyPlusData &state, std::stri return outAggType; } -int AnnualTable::columnCountForAggregation(AnnualFieldSet::AggregationKind curAgg) +int AnnualTable::columnCountForAggregation(const AnnualFieldSet::AggregationKind curAgg) { - int returnCount = 0; - if (curAgg == AnnualFieldSet::AggregationKind::sumOrAvg || curAgg == AnnualFieldSet::AggregationKind::valueWhenMaxMin || - curAgg == AnnualFieldSet::AggregationKind::hoursZero || curAgg == AnnualFieldSet::AggregationKind::hoursNonZero || - curAgg == AnnualFieldSet::AggregationKind::hoursPositive || curAgg == AnnualFieldSet::AggregationKind::hoursNonPositive || - curAgg == AnnualFieldSet::AggregationKind::hoursNegative || curAgg == AnnualFieldSet::AggregationKind::hoursNonNegative || - curAgg == AnnualFieldSet::AggregationKind::sumOrAverageHoursShown || curAgg == AnnualFieldSet::AggregationKind::noAggregation) { - returnCount = 1; - } else if (curAgg == AnnualFieldSet::AggregationKind::maximum || curAgg == AnnualFieldSet::AggregationKind::minimum || - curAgg == AnnualFieldSet::AggregationKind::maximumDuringHoursShown || - curAgg == AnnualFieldSet::AggregationKind::minimumDuringHoursShown) { - returnCount = 2; - } else if (curAgg == AnnualFieldSet::AggregationKind::hoursInTenBinsMinToMax) { - returnCount = 10; - } else if (curAgg == AnnualFieldSet::AggregationKind::hoursInTenBinsZeroToMax || - curAgg == AnnualFieldSet::AggregationKind::hoursInTenBinsMinToZero) { - returnCount = 11; - } else if (curAgg == AnnualFieldSet::AggregationKind::hoursInTenPercentBins || - curAgg == AnnualFieldSet::AggregationKind::hoursInTenBinsPlusMinusTwoStdDev || - curAgg == AnnualFieldSet::AggregationKind::hoursInTenBinsPlusMinusThreeStdDev) { - returnCount = 12; + switch (curAgg) { + case AnnualFieldSet::AggregationKind::sumOrAvg: + case AnnualFieldSet::AggregationKind::valueWhenMaxMin: + case AnnualFieldSet::AggregationKind::hoursZero: + case AnnualFieldSet::AggregationKind::hoursNonZero: + case AnnualFieldSet::AggregationKind::hoursPositive: + case AnnualFieldSet::AggregationKind::hoursNonPositive: + case AnnualFieldSet::AggregationKind::hoursNegative: + case AnnualFieldSet::AggregationKind::hoursNonNegative: + case AnnualFieldSet::AggregationKind::sumOrAverageHoursShown: + case AnnualFieldSet::AggregationKind::noAggregation: + return 1; + case AnnualFieldSet::AggregationKind::maximum: + case AnnualFieldSet::AggregationKind::minimum: + case AnnualFieldSet::AggregationKind::maximumDuringHoursShown: + case AnnualFieldSet::AggregationKind::minimumDuringHoursShown: + return 2; + case AnnualFieldSet::AggregationKind::hoursInTenBinsMinToMax: + return 10; + case AnnualFieldSet::AggregationKind::hoursInTenBinsZeroToMax: + case AnnualFieldSet::AggregationKind::hoursInTenBinsMinToZero: + return 11; + case AnnualFieldSet::AggregationKind::hoursInTenPercentBins: + case AnnualFieldSet::AggregationKind::hoursInTenBinsPlusMinusTwoStdDev: + case AnnualFieldSet::AggregationKind::hoursInTenBinsPlusMinusThreeStdDev: + return 12; + default: + return 0; } - return returnCount; } std::string AnnualTable::trim(const std::string &str) { - std::string whitespace = " \t"; + const std::string whitespace = " \t"; const size_t strBegin = str.find_first_not_of(whitespace); if (strBegin == std::string::npos) { return ""; // no content @@ -1206,19 +1229,18 @@ std::string AnnualTable::trim(const std::string &str) return str.substr(strBegin, strRange); } -void AddAnnualTableOfContents(EnergyPlusData &state, std::ostream &nameOfStream) +void AddAnnualTableOfContents(const EnergyPlusData &state, std::ostream &nameOfStream) { // Jason Glazer, August 2015 // This function is not part of the class but acts as an interface between procedural code and the class by // invoking the writeTable member function for each of the AnnualTable objects - std::vector::iterator annualTableIt; auto &annualTables = state.dataOutputReportTabularAnnual->annualTables; - for (annualTableIt = annualTables.begin(); annualTableIt != annualTables.end(); ++annualTableIt) { - annualTableIt->addTableOfContents(nameOfStream); + for (auto &annualTable : annualTables) { + annualTable.addTableOfContents(nameOfStream); } } -void AnnualTable::addTableOfContents(std::ostream &nameOfStream) +void AnnualTable::addTableOfContents(std::ostream &nameOfStream) const { nameOfStream << "

" << m_name << "

|\n"; nameOfStream << "" << "Entire Facility" << " | \n"; @@ -1226,85 +1248,103 @@ void AnnualTable::addTableOfContents(std::ostream &nameOfStream) void AnnualTable::computeBinColumns(EnergyPlusData &state, OutputReportTabular::UnitsStyle const unitsStyle_para) { - std::vector::iterator fldStIt; - Real64 constexpr veryLarge = 1.0E280; - Real64 constexpr verySmall = -1.0E280; - for (fldStIt = m_annualFields.begin(); fldStIt != m_annualFields.end(); ++fldStIt) { - int curAgg = fldStIt->m_aggregate; + for (auto &fldStIt : m_annualFields) { // for columns with binning aggregation types compute the statistics - if (curAgg == AnnualFieldSet::AggregationKind::hoursInTenBinsMinToMax || curAgg == AnnualFieldSet::AggregationKind::hoursInTenBinsZeroToMax || - curAgg == AnnualFieldSet::AggregationKind::hoursInTenBinsMinToZero || curAgg == AnnualFieldSet::AggregationKind::hoursInTenPercentBins || - curAgg == AnnualFieldSet::AggregationKind::hoursInTenBinsPlusMinusTwoStdDev || - curAgg == AnnualFieldSet::AggregationKind::hoursInTenBinsPlusMinusThreeStdDev) { + switch (fldStIt.m_aggregate) { + case AnnualFieldSet::AggregationKind::hoursInTenBinsMinToMax: + case AnnualFieldSet::AggregationKind::hoursInTenBinsZeroToMax: + case AnnualFieldSet::AggregationKind::hoursInTenBinsMinToZero: + case AnnualFieldSet::AggregationKind::hoursInTenPercentBins: + case AnnualFieldSet::AggregationKind::hoursInTenBinsPlusMinusTwoStdDev: + case AnnualFieldSet::AggregationKind::hoursInTenBinsPlusMinusThreeStdDev: { // the size the deferred vectors should be same for all rows - if (allRowsSameSizeDefferedVectors(fldStIt)) { - convertUnitForDeferredResults(state, fldStIt, unitsStyle_para); - std::vector deferredTotalForColumn; - Real64 minVal = veryLarge; - Real64 maxVal = verySmall; - Real64 sum = 0; - Real64 curVal = 0.0; - for (unsigned int jDefRes = 0; jDefRes != fldStIt->m_cell[0].deferredResults.size(); jDefRes++) { - sum = 0; - for (unsigned int row = 0; row != m_objectNames.size(); row++) { // loop through by row. - curVal = fldStIt->m_cell[row].deferredResults[jDefRes]; - sum += curVal; - if (curVal > maxVal) { - maxVal = curVal; - } - if (curVal < minVal) { - minVal = curVal; - } - } - deferredTotalForColumn.push_back(sum / float(m_objectNames.size())); // put average value into the total row - } - if (curAgg == AnnualFieldSet::AggregationKind::hoursInTenBinsMinToMax) { - fldStIt->m_topBinValue = maxVal; - fldStIt->m_bottomBinValue = minVal; - } else if (curAgg == AnnualFieldSet::AggregationKind::hoursInTenBinsZeroToMax) { - fldStIt->m_topBinValue = maxVal; - fldStIt->m_bottomBinValue = 0.0; - } else if (curAgg == AnnualFieldSet::AggregationKind::hoursInTenBinsMinToZero) { - fldStIt->m_topBinValue = 0.0; - fldStIt->m_bottomBinValue = minVal; - } else if (curAgg == AnnualFieldSet::AggregationKind::hoursInTenPercentBins) { - fldStIt->m_topBinValue = 1.0; - fldStIt->m_bottomBinValue = 0.0; - } else if (curAgg == AnnualFieldSet::AggregationKind::hoursInTenBinsPlusMinusTwoStdDev) { - } else if (curAgg == AnnualFieldSet::AggregationKind::hoursInTenBinsPlusMinusThreeStdDev) { - } - // compute the actual amount of time spent in each bin and above and below + if (!allRowsSameSizeDeferredVectors(fldStIt)) { + break; + } + + convertUnitForDeferredResults(state, fldStIt, unitsStyle_para); + + std::vector deferredTotalForColumn; + Real64 minVal = veryLarge; + Real64 maxVal = verySmall; + Real64 sum = 0; + Real64 curVal = 0.0; + + for (unsigned int jDefRes = 0; jDefRes != fldStIt.m_cell[0].deferredResults.size(); jDefRes++) { + sum = 0; for (unsigned int row = 0; row != m_objectNames.size(); row++) { // loop through by row. - fldStIt->m_cell[row].m_timeInBin = calculateBins(10, - fldStIt->m_cell[row].deferredResults, - fldStIt->m_cell[row].deferredElapsed, - fldStIt->m_topBinValue, - fldStIt->m_bottomBinValue, - fldStIt->m_cell[row].m_timeAboveTopBin, - fldStIt->m_cell[row].m_timeBelowBottomBin); + curVal = fldStIt.m_cell[row].deferredResults[jDefRes]; + sum += curVal; + if (curVal > maxVal) { + maxVal = curVal; + } + if (curVal < minVal) { + minVal = curVal; + } } - // do the total row binning - fldStIt->m_timeInBinTotal = calculateBins(10, - deferredTotalForColumn, - fldStIt->m_cell[0].deferredElapsed, - fldStIt->m_topBinValue, - fldStIt->m_bottomBinValue, - fldStIt->m_timeAboveTopBinTotal, - fldStIt->m_timeBelowBottomBinTotal); + deferredTotalForColumn.push_back(sum / static_cast(m_objectNames.size())); // put average value into the total row } + + // Decide bin range endpoints based on aggregation kind + switch (fldStIt.m_aggregate) { + case AnnualFieldSet::AggregationKind::hoursInTenBinsMinToMax: + fldStIt.m_topBinValue = maxVal; + fldStIt.m_bottomBinValue = minVal; + break; + case AnnualFieldSet::AggregationKind::hoursInTenBinsZeroToMax: + fldStIt.m_topBinValue = maxVal; + fldStIt.m_bottomBinValue = 0.0; + break; + case AnnualFieldSet::AggregationKind::hoursInTenBinsMinToZero: + fldStIt.m_topBinValue = 0.0; + fldStIt.m_bottomBinValue = minVal; + break; + case AnnualFieldSet::AggregationKind::hoursInTenPercentBins: + fldStIt.m_topBinValue = 1.0; + fldStIt.m_bottomBinValue = 0.0; + break; + case AnnualFieldSet::AggregationKind::hoursInTenBinsPlusMinusTwoStdDev: + case AnnualFieldSet::AggregationKind::hoursInTenBinsPlusMinusThreeStdDev: + break; + default: + break; + } + + // compute the actual amount of time spent in each bin and above and below + for (unsigned int row = 0; row != m_objectNames.size(); row++) { // loop through by row. + fldStIt.m_cell[row].m_timeInBin = calculateBins(10, + fldStIt.m_cell[row].deferredResults, + fldStIt.m_cell[row].deferredElapsed, + fldStIt.m_topBinValue, + fldStIt.m_bottomBinValue, + fldStIt.m_cell[row].m_timeAboveTopBin, + fldStIt.m_cell[row].m_timeBelowBottomBin); + } + // do the total row binning + fldStIt.m_timeInBinTotal = calculateBins(10, + deferredTotalForColumn, + fldStIt.m_cell[0].deferredElapsed, + fldStIt.m_topBinValue, + fldStIt.m_bottomBinValue, + fldStIt.m_timeAboveTopBinTotal, + fldStIt.m_timeBelowBottomBinTotal); + break; + } + default: + break; } } } -bool AnnualTable::allRowsSameSizeDefferedVectors(std::vector::iterator fldStIt) +bool AnnualTable::allRowsSameSizeDeferredVectors(const AnnualFieldSet &fldSt) const { bool returnFlag = true; unsigned int sizeOfDeferred = 0; for (unsigned int row = 0; row != m_objectNames.size(); row++) { // loop through by row. if (sizeOfDeferred == 0) { - sizeOfDeferred = fldStIt->m_cell[row].deferredResults.size(); + sizeOfDeferred = fldSt.m_cell[row].deferredResults.size(); } else { - if (fldStIt->m_cell[row].deferredResults.size() != sizeOfDeferred) { + if (fldSt.m_cell[row].deferredResults.size() != sizeOfDeferred) { returnFlag = false; return returnFlag; } @@ -1313,52 +1353,59 @@ bool AnnualTable::allRowsSameSizeDefferedVectors(std::vector::it return returnFlag; } -void AnnualTable::convertUnitForDeferredResults(EnergyPlusData &state, - std::vector::iterator fldStIt, - OutputReportTabular::UnitsStyle const unitsStyle) +void AnnualTable::convertUnitForDeferredResults(EnergyPlusData &state, AnnualFieldSet &fldSt, OutputReportTabular::UnitsStyle const unitsStyle) const { Real64 curConversionFactor; Real64 curConversionOffset; std::string curUnits; std::string energyUnitsString; - Real64 curSI; - Real64 curIP; - Real64 energyUnitsConversionFactor = AnnualTable::setEnergyUnitStringAndFactor(unitsStyle, energyUnitsString); + const Real64 energyUnitsConversionFactor = AnnualTable::setEnergyUnitStringAndFactor(unitsStyle, energyUnitsString); + // do the unit conversions - if (unitsStyle == OutputReportTabular::UnitsStyle::InchPound || unitsStyle == OutputReportTabular::UnitsStyle::InchPoundExceptElectricity) { + switch (unitsStyle) { + case OutputReportTabular::UnitsStyle::InchPound: + case OutputReportTabular::UnitsStyle::InchPoundExceptElectricity: { int indexUnitConv; - std::string varNameWithUnits = format("{} [{}]", fldStIt->m_variMeter, Constant::unitNames[(int)fldStIt->m_varUnits]); + const std::string varNameWithUnits = format("{} [{}]", fldSt.m_variMeter, Constant::unitNames[static_cast(fldSt.m_varUnits)]); OutputReportTabular::LookupSItoIP(state, varNameWithUnits, indexUnitConv, curUnits); OutputReportTabular::GetUnitConversion(state, indexUnitConv, curConversionFactor, curConversionOffset, curUnits); - } else { // just do the Joule conversion - // if units is in Joules, convert if specified - if (fldStIt->m_varUnits == Constant::Units::J) { + break; + } + default: { // SI (and "Jto*" styles): just do the Joule conversion if needed + switch (fldSt.m_varUnits) { + case Constant::Units::J: curUnits = energyUnitsString; curConversionFactor = energyUnitsConversionFactor; curConversionOffset = 0.0; - } else { // if not joules don't perform conversion - curUnits = Constant::unitNames[(int)fldStIt->m_varUnits]; + break; + default: + curUnits = Constant::unitNames[static_cast(fldSt.m_varUnits)]; curConversionFactor = 1.0; curConversionOffset = 0.0; + break; } + break; } - if (fldStIt->m_varAvgSum == OutputProcessor::StoreType::Sum) { + } + + if (fldSt.m_varAvgSum == OutputProcessor::StoreType::Sum) { curUnits += "/s"; } fixUnitsPerSecond(curUnits, curConversionFactor); + if (curConversionFactor != 1.0 || curConversionOffset != 0.0) { for (unsigned int row = 0; row != m_objectNames.size(); row++) { // loop through by row. - for (unsigned int jDefRes = 0; jDefRes != fldStIt->m_cell[0].deferredResults.size(); jDefRes++) { - curSI = fldStIt->m_cell[row].deferredResults[jDefRes]; - curIP = curSI * curConversionFactor + curConversionOffset; - fldStIt->m_cell[row].deferredResults[jDefRes] = curIP; + for (unsigned int jDefRes = 0; jDefRes != fldSt.m_cell[0].deferredResults.size(); jDefRes++) { + const Real64 curSI = fldSt.m_cell[row].deferredResults[jDefRes]; + const Real64 curIP = curSI * curConversionFactor + curConversionOffset; + fldSt.m_cell[row].deferredResults[jDefRes] = curIP; } } } } std::vector AnnualTable::calculateBins(int const numberOfBins, - std::vector valuesToBin, + const std::vector &valuesToBin, std::vector corrElapsedTime, Real64 const topOfBins, Real64 const bottomOfBins, @@ -1367,20 +1414,18 @@ std::vector AnnualTable::calculateBins(int const numberOfBins, { std::vector returnBins(0.0); returnBins.resize(numberOfBins); - Real64 intervalSize = (topOfBins - bottomOfBins) / float(numberOfBins); + const Real64 intervalSize = (topOfBins - bottomOfBins) / static_cast(numberOfBins); timeAboveTopBin = 0.0; timeBelowBottomBin = 0.0; - std::vector::iterator elapsedTimeIt; - elapsedTimeIt = corrElapsedTime.begin(); - std::vector::iterator valueIt; - for (valueIt = valuesToBin.begin(); valueIt != valuesToBin.end(); ++valueIt) { - if (*valueIt < bottomOfBins) { + std::vector::iterator elapsedTimeIt = corrElapsedTime.begin(); + for (auto const &valueIt : valuesToBin) { + if (valueIt < bottomOfBins) { timeBelowBottomBin += *elapsedTimeIt; - } else if (*valueIt >= topOfBins) { + } else if (valueIt >= topOfBins) { timeAboveTopBin += *elapsedTimeIt; } else { // determine which bin the results are in - int binNum = int((*valueIt - bottomOfBins) / intervalSize); + const int binNum = static_cast((valueIt - bottomOfBins) / intervalSize); if (binNum < numberOfBins && binNum >= 0) { returnBins[binNum] += *elapsedTimeIt; } @@ -1390,17 +1435,16 @@ std::vector AnnualTable::calculateBins(int const numberOfBins, return returnBins; } -void AnnualTable::columnHeadersToTitleCase(EnergyPlusData &state) +void AnnualTable::columnHeadersToTitleCase(EnergyPlusData const &state) { - std::vector::iterator fldStIt; - for (fldStIt = m_annualFields.begin(); fldStIt != m_annualFields.end(); ++fldStIt) { - if (fldStIt->m_variMeter == fldStIt->m_colHead) { - if (!fldStIt->m_indexesForKeyVar.empty()) { - int varNum = fldStIt->m_indexesForKeyVar[0]; - if (fldStIt->m_typeOfVar == OutputProcessor::VariableType::Real) { - fldStIt->m_colHead = state.dataOutputProcessor->outVars[varNum]->name; - } else if (fldStIt->m_typeOfVar == OutputProcessor::VariableType::Meter) { - fldStIt->m_colHead = state.dataOutputProcessor->meters[varNum]->Name; + for (auto &fldSt : m_annualFields) { + if (fldSt.m_variMeter == fldSt.m_colHead) { + if (!fldSt.m_indexesForKeyVar.empty()) { + const int varNum = fldSt.m_indexesForKeyVar[0]; + if (fldSt.m_typeOfVar == OutputProcessor::VariableType::Real) { + fldSt.m_colHead = state.dataOutputProcessor->outVars[varNum]->name; + } else if (fldSt.m_typeOfVar == OutputProcessor::VariableType::Meter) { + fldSt.m_colHead = state.dataOutputProcessor->meters[varNum]->Name; } } } @@ -1416,7 +1460,7 @@ void AnnualTable::clearTable() m_annualFields.clear(); } -std::vector AnnualTable::inspectTable() +std::vector AnnualTable::inspectTable() const { // added function just to inspect the main private AnnualTable members because no other // interface to the AnnualTable class is output oriented except writeTable and that is very complex. @@ -1427,7 +1471,7 @@ std::vector AnnualTable::inspectTable() return ret; } -std::vector AnnualTable::inspectTableFieldSets(int fldIndex) +std::vector AnnualTable::inspectTableFieldSets(int const fldIndex) const { // added function just to inspect the private field set members of AnnualTable because no other // interface to the AnnualTable class is output oriented except writeTable and that is very complex. @@ -1437,17 +1481,17 @@ std::vector AnnualTable::inspectTableFieldSets(int fldIndex) ret.reserve(hasCell ? 14 : 13); ret.push_back(fldSt.m_colHead); ret.push_back(fldSt.m_variMeter); - ret.emplace_back(Constant::unitNames[(int)fldSt.m_varUnits]); + ret.emplace_back(Constant::unitNames[static_cast(fldSt.m_varUnits)]); std::string outStr = std::to_string(fldSt.m_showDigits); // ints ret.push_back(outStr); - outStr = std::to_string((int)fldSt.m_typeOfVar); + outStr = std::to_string(static_cast(fldSt.m_typeOfVar)); ret.push_back(outStr); outStr = std::to_string(fldSt.m_keyCount); ret.push_back(outStr); - outStr = std::to_string((int)fldSt.m_varAvgSum); + outStr = std::to_string(static_cast(fldSt.m_varAvgSum)); ret.push_back(outStr); - outStr = std::to_string((int)fldSt.m_varStepType); + outStr = std::to_string(static_cast(fldSt.m_varStepType)); ret.push_back(outStr); outStr = std::to_string(fldSt.m_aggregate); ret.push_back(outStr); diff --git a/src/EnergyPlus/OutputReportTabularAnnual.hh b/src/EnergyPlus/OutputReportTabularAnnual.hh index e2266537794..901d003ba36 100644 --- a/src/EnergyPlus/OutputReportTabularAnnual.hh +++ b/src/EnergyPlus/OutputReportTabularAnnual.hh @@ -53,11 +53,6 @@ #include #include -// ObjexxFCL Headers -#include -#include -#include - // EnergyPlus Headers #include #include @@ -77,13 +72,13 @@ namespace OutputReportTabularAnnual { void checkAggregationOrderForAnnual(EnergyPlusData &state); - void GatherAnnualResultsForTimeStep(EnergyPlusData &state, OutputProcessor::TimeStepType kindOfTypeStep); + void GatherAnnualResultsForTimeStep(EnergyPlusData &state, OutputProcessor::TimeStepType kindOfTimeStep); - void ResetAnnualGathering(EnergyPlusData &state); + void ResetAnnualGathering(const EnergyPlusData &state); void WriteAnnualTables(EnergyPlusData &state); - void AddAnnualTableOfContents(EnergyPlusData &state, std::ostream &); + void AddAnnualTableOfContents(const EnergyPlusData &state, std::ostream &); AnnualFieldSet::AggregationKind stringToAggKind(EnergyPlusData &state, std::string inString); @@ -94,7 +89,8 @@ namespace OutputReportTabularAnnual { AnnualTable() = default; // Member Constructor - AnnualTable(EnergyPlusData &state, std::string name, std::string filter, std::string schedName) : m_name(name), m_filter(filter) + AnnualTable(EnergyPlusData &state, const std::string &name, const std::string &filter, const std::string &schedName) + : m_name(name), m_filter(filter) { if (!schedName.empty()) { m_sched = Sched::GetSchedule(state, schedName); // index to the period schedule @@ -103,30 +99,30 @@ namespace OutputReportTabularAnnual { } }; - void addFieldSet(std::string, AnnualFieldSet::AggregationKind, int); + void addFieldSet(const std::string &, AnnualFieldSet::AggregationKind, int); - void addFieldSet(std::string, std::string, AnnualFieldSet::AggregationKind, int); + void addFieldSet(const std::string &, const std::string &, AnnualFieldSet::AggregationKind, int); void setupGathering(EnergyPlusData &state); bool invalidAggregationOrder(EnergyPlusData &state); - void gatherForTimestep(EnergyPlusData &state, OutputProcessor::TimeStepType kindOfTypeStep); + void gatherForTimestep(EnergyPlusData &state, OutputProcessor::TimeStepType kindOfTimeStep); void resetGathering(); void writeTable(EnergyPlusData &state, OutputReportTabular::tabularReportStyle const style); - void addTableOfContents(std::ostream &); + void addTableOfContents(std::ostream &) const; - std::vector inspectTable(); + std::vector inspectTable() const; - std::vector inspectTableFieldSets(int); + std::vector inspectTableFieldSets(int) const; void clearTable(); // this could be private but was made public for unit testing only - void columnHeadersToTitleCase(EnergyPlusData &state); + void columnHeadersToTitleCase(EnergyPlusData const &state); private: // Members @@ -137,35 +133,33 @@ namespace OutputReportTabularAnnual { std::vector m_objectNames; // for each row of annual table std::vector m_annualFields; // for each column - Real64 getElapsedTime(EnergyPlusData &state, OutputProcessor::TimeStepType kindOfTimeStep); + static Real64 getElapsedTime(const EnergyPlusData &state, OutputProcessor::TimeStepType kindOfTimeStep); - Real64 getSecondsInTimeStep(EnergyPlusData &state, OutputProcessor::TimeStepType kindOfTimeStep); + static Real64 getSecondsInTimeStep(const EnergyPlusData &state, OutputProcessor::TimeStepType kindOfTimeStep); void computeBinColumns(EnergyPlusData &state, OutputReportTabular::UnitsStyle unitsStyle_para); - std::vector setupAggString(); + static std::vector setupAggString(); - Real64 setEnergyUnitStringAndFactor(OutputReportTabular::UnitsStyle const unitsStyle, std::string &unitString); + static Real64 setEnergyUnitStringAndFactor(OutputReportTabular::UnitsStyle unitsStyle, std::string &unitString); - int columnCountForAggregation(AnnualFieldSet::AggregationKind curAgg); + static int columnCountForAggregation(AnnualFieldSet::AggregationKind curAgg); - std::string trim(const std::string &str); + static std::string trim(const std::string &str); - void fixUnitsPerSecond(std::string &unitString, Real64 &conversionFactor); + static void fixUnitsPerSecond(std::string &unitString, Real64 &conversionFactor); - bool allRowsSameSizeDefferedVectors(std::vector::iterator fldStIt); + bool allRowsSameSizeDeferredVectors(const AnnualFieldSet &fldSt) const; - void convertUnitForDeferredResults(EnergyPlusData &state, - std::vector::iterator fldStIt, - OutputReportTabular::UnitsStyle const unitsStyle); + void convertUnitForDeferredResults(EnergyPlusData &state, AnnualFieldSet &fldSt, OutputReportTabular::UnitsStyle unitsStyle) const; - std::vector calculateBins(int const numberOfBins, - std::vector const valuesToBin, - std::vector const corrElapsedTime, - Real64 const topOfBins, - Real64 const bottomOfBins, - Real64 &timeAboveTopBin, - Real64 &timeBelowBottomBin); + static std::vector calculateBins(int numberOfBins, + std::vector const &valuesToBin, + std::vector const corrElapsedTime, + Real64 const topOfBins, + Real64 const bottomOfBins, + Real64 &timeAboveTopBin, + Real64 &timeBelowBottomBin); }; // class AnnualTable