Performance refactor for Schedule:File

src/EnergyPlus/ScheduleManager.hh

@@ -48,6 +48,9 @@
 #ifndef ScheduleManager_hh_INCLUDED
 #define ScheduleManager_hh_INCLUDED
 
+// C++ Headers
+#include <set>
+
 // ObjexxFCL Headers
 #include <ObjexxFCL/Array1D.hh>
 #include <ObjexxFCL/Array1S.hh>
@@ -328,6 +331,109 @@ namespace ScheduleManager {
 
     int GetNumberOfSchedules(EnergyPlusData &state);
 
+    struct CSVRow
+    {
+        std::string_view operator[](std::size_t index) const;
+        std::size_t rowEnd();
+        std::string delimiter{'*'}; // eg. comma in CSV
+        void readNextRow(std::istream &str);
+
+    private:
+        std::string m_line;
+        std::vector<int> m_data;
+    };
+
+    std::istream &operator>>(std::istream &str, CSVRow &data);
+
+    void PreProcessIDF(EnergyPlus::EnergyPlusData &state, int &SchNum, int NumCommaFileSchedules);
+
+    struct schedInputIdfPreprocessObject
+    {
+        std::string name;     // <- can inherit from parent sched class
+        std::string fileName; // <- can inherit from parent sched class
+        int ScheduleTypePtr{-1};
+        int columnOfInterest{-1};
+        int numHourlyValues{-1};
+        int MinutesPerItem{-1};
+        int rowsToSkip{-1};
+        bool FileIntervalInterpolated{false};
+        std::basic_string<char> columnSeperator{"*"};
+        int columnarDataIndex{-1}; // TODO : Figure out what to do here (size_t to int conversion)
+        int SchNum{-1};
+
+        schedInputIdfPreprocessObject(std::string name,     // <- can inherit from parent sched class
+                                      std::string fileName, // <- can inherit from parent sched class
+                                      int ScheduleTypePtr = -1,
+                                      int columnOfInterest = -1,
+                                      int numHourlyValues = -1,
+                                      int MinutesPerItem = -1,
+                                      int rowsToSkip = -1,
+                                      bool FileIntervalInterpolated = false,
+                                      std::basic_string<char> columnSeperator = "*",
+                                      int SchNum = -1)
+        {
+
+            this->name = name;
+            this->fileName = fileName;
+            this->ScheduleTypePtr = ScheduleTypePtr;
+            this->columnOfInterest = columnOfInterest - 1; // - 1 to get index to match with c++ containers (start at 0)
+            this->numHourlyValues = numHourlyValues;
+            this->MinutesPerItem = MinutesPerItem;
+            this->rowsToSkip = rowsToSkip;
+            this->FileIntervalInterpolated = FileIntervalInterpolated;
+            this->columnSeperator = columnSeperator;
+            this->SchNum = SchNum;
+        }
+        void setColumnarDataIndex(int incomingData)
+        {
+            this->columnarDataIndex = incomingData;
+        }
+    };
+
+    void PopulateSetOfFilenames(const std::vector<schedInputIdfPreprocessObject> &allIdfSchedData, std::set<std::string> &setOfFilenames);
+
+    struct PreProcessedColumn
+    {
+        std::string name;
+        int columnOfInterest = -1;
+        int numHourlyValues = -1;
+        int MinutesPerItem = -1;
+        int rowsToSkip = -1;
+        bool FileIntervalInterpolated = false;
+        int ScheduleTypePtr = -1;
+        int SchNum = -1;
+        int rowCnt = 0;
+        int numerrors = 0;
+        std::string fileName;
+        std::string delimiter;
+        std::vector<Real64> vals; // rows to skip + number of hours*items/hour
+
+        PreProcessedColumn(std::string name, // <- can inherit from parent sched class
+                           int columnOfInterest,
+                           int numHourlyValues,
+                           int MinutesPerItem,
+                           int rowsToSkip,
+                           bool FileIntervalInterpolated,
+                           std::string fileName,
+                           std::string delimiter,
+                           int ScheduleTypePtr,
+                           int SchNum,
+                           std::vector<Real64> vals)
+        {
+            this->name = name; // <- can inherit from parent sched class
+            this->columnOfInterest = columnOfInterest;
+            this->numHourlyValues = numHourlyValues;
+            this->MinutesPerItem = MinutesPerItem;
+            this->rowsToSkip = rowsToSkip;
+            this->FileIntervalInterpolated = FileIntervalInterpolated;
+            this->fileName = fileName;
+            this->delimiter = delimiter;
+            this->ScheduleTypePtr = ScheduleTypePtr;
+            this->SchNum = SchNum;
+            this->vals = vals;
+        }
+    };
+
 } // namespace ScheduleManager
 
 struct ScheduleManagerData : BaseGlobalStruct
@@ -355,6 +461,10 @@ struct ScheduleManagerData : BaseGlobalStruct
     Array1D<ScheduleManager::WeekScheduleData> WeekSchedule; // Week Schedule Storage
     Array1D<ScheduleManager::ScheduleData> Schedule;         // Schedule Storage
 
+    // Schedule:File variables
+    std::vector<ScheduleManager::schedInputIdfPreprocessObject> allIdfSchedData;
+    std::vector<ScheduleManager::PreProcessedColumn> columnarData;
+
     void clear_state() override
     {
         CheckScheduleValueMinMaxRunOnceOnly = true;
@@ -376,6 +486,9 @@ struct ScheduleManagerData : BaseGlobalStruct
         DaySchedule.clear();  // Day Schedule Storage
         WeekSchedule.clear(); // Week Schedule Storage
         Schedule.clear();     // Schedule Storage
+
+        allIdfSchedData.clear();
+        columnarData.clear();
     }
 };
 

src/EnergyPlus/StringUtilities.hh

@@ -59,6 +59,14 @@ inline std::stringstream stringReader(std::string str)
     return result;
 }
 
+inline std::stringstream stringReader(std::string_view str)
+{
+    std::stringstream ss;
+    ss << str;
+    ss.imbue(std::locale("C")); // the forced locale is to avoid issues with parsing floating point numbers that use non-decimal formats
+    return ss;
+}
+
 template <typename Param> bool readListItem(std::istream &stream, Param &&param)
 {
     if (stream.good()) {
@@ -80,6 +88,21 @@ template <typename Param> bool readItem(std::string input, Param &&param)
 {
     auto stream = stringReader(std::move(input));
     stream >> param;
+
+    return !stream.fail() && stream.eof();
+}
+
+template <typename Param> bool readItem(std::string_view input, Param &&param)
+{
+    std::string temp_string = static_cast<std::string>(input);
+    // make FORTRAN floating point number (containing 'd' or 'D')
+    // standardized by replacing 'd' or 'D' with 'e'
+    std::replace_if(
+        std::begin(temp_string), std::end(temp_string), [](const char c) { return c == 'D' || c == 'd'; }, 'e');
+    auto stream = stringReader(temp_string);
+
+    stream >> param;
+
     return !stream.fail() && stream.eof();
 }
 

src/EnergyPlus/UtilityRoutines.cc

@@ -122,7 +122,7 @@ namespace UtilityRoutines {
         // List directed Fortran input/output.
 
         // SUBROUTINE PARAMETER DEFINITIONS:
-        static std::string const ValidNumerics("0123456789.+-EeDd");
+        static constexpr std::string_view ValidNumerics("0123456789.+-EeDd");
 
         Real64 rProcessNumber = 0.0;
         //  Make sure the string has all what we think numerics should have
@@ -151,6 +151,62 @@ namespace UtilityRoutines {
         return rProcessNumber;
     }
 
+    Real64 ProcessNumber(std::basic_string_view<char> const &String_view, bool &ErrorFlag)
+    {
+
+        // FUNCTION INFORMATION:
+        //       AUTHOR         Linda K. Lawrie
+        //       DATE WRITTEN   September 1997
+        //       MODIFIED       na
+        //       RE-ENGINEERED  na
+
+        // PURPOSE OF THIS FUNCTION:
+        // This function processes a string that should be numeric and
+        // returns the real value of the string.
+
+        // METHODOLOGY EMPLOYED:
+        // FUNCTION ProcessNumber translates the argument (a string)
+        // into a real number.  The string should consist of all
+        // numeric characters (except a decimal point).  Numerics
+        // with exponentiation (i.e. 1.2345E+03) are allowed but if
+        // it is not a valid number an error message along with the
+        // string causing the error is printed out and 0.0 is returned
+        // as the value.
+
+        // REFERENCES:
+        // List directed Fortran input/output.
+
+        // SUBROUTINE PARAMETER DEFINITIONS:
+        static constexpr std::string_view ValidNumerics("0123456789.+-EeDd");
+
+        Real64 rProcessNumber = 0.0;
+        //  Make sure the string has all what we think numerics should have
+        std::string_view PString(stripped(String_view));
+        std::string::size_type const StringLen(PString.length());
+        ErrorFlag = false;
+        if (StringLen == 0) return rProcessNumber;
+        bool parseFailed = false;
+        if (PString.find_first_not_of(ValidNumerics) == std::string::npos) {
+
+            // std::replace_if - > moved to readItem
+            // is this not working because string_view is acting like a const variable? // Do we need to convert/cast it here? -> move this to the
+            // 'deepest' function so that the copying can be minimized
+
+            // then parse as a normal floating point value
+            parseFailed = !readItem(PString, rProcessNumber);
+            ErrorFlag = false;
+        } else {
+            rProcessNumber = 0.0;
+            ErrorFlag = true;
+        }
+        if (parseFailed) {
+            rProcessNumber = 0.0;
+            ErrorFlag = true;
+        }
+
+        return rProcessNumber;
+    }
+
     int FindItemInList(std::string const &String, Array1_string const &ListOfItems, int const NumItems)
     {
 

src/EnergyPlus/UtilityRoutines.hh

@@ -224,6 +224,7 @@ namespace UtilityRoutines {
     };
 
     Real64 ProcessNumber(std::string const &String, bool &ErrorFlag);
+    Real64 ProcessNumber(std::basic_string_view<char> const &String_view, bool &ErrorFlag);
 
     int FindItemInList(std::string const &String, Array1_string const &ListOfItems, int NumItems);
 

third_party/ObjexxFCL/src/ObjexxFCL/string.functions.cc

@@ -469,6 +469,22 @@ stripped( std::string const & s )
 	}
 }
 
+std::string_view
+stripped( std::string_view const & s )
+{
+  if ( s.empty() ) {
+    return s;
+  } else {
+    std::string::size_type const ib( s.find_first_not_of( ' ' ) );
+    std::string::size_type const ie( s.find_last_not_of( ' ' ) );
+    if ( ( ib == std::string::npos ) || ( ie == std::string::npos ) ) { // All of string is ' '
+      return std::string(); // Return empty string
+    } else {
+      return s.substr( ib, ie - ib + 1 );
+    }
+  }
+}
+
 // Space Stripped from a string's Left Tail Copy of a string
 std::string
 lstripped( std::string const & s )

third_party/ObjexxFCL/src/ObjexxFCL/string.functions.hh

@@ -1557,6 +1557,9 @@ rstripped( std::string const & s, std::string const & chars );
 std::string
 stripped( std::string const & s );
 
+std::string_view
+stripped( std::string_view const & s );
+
 // Space Stripped from a string's Left Tail Copy of a string
 std::string
 lstripped( std::string const & s );

tst/EnergyPlus/unit/StringUtilities.unit.cc

@@ -58,16 +58,29 @@ TEST_F(EnergyPlusFixture, readItem)
     int i = 0;
 
     // should read just 12
-    EXPECT_TRUE(EnergyPlus::readItem("12", i));
+    EXPECT_TRUE(EnergyPlus::readItem(static_cast<std::string>("12"), i));
     EXPECT_EQ(i, 12);
 
     // should fail if unable to process entire input string
-    EXPECT_FALSE(EnergyPlus::readItem("1234fgq", i));
+    EXPECT_FALSE(EnergyPlus::readItem(static_cast<std::string>("1234fgq"), i));
     // value is in an unknown state if read failed
     // EXPECT_EQ(i, 12);
 
     // should read nothing
-    EXPECT_FALSE(EnergyPlus::readItem("abc123", i));
+    EXPECT_FALSE(EnergyPlus::readItem(static_cast<std::string>("abc123"), i));
+    EXPECT_EQ(i, 0);
+
+    // should read just 12
+    EXPECT_TRUE(EnergyPlus::readItem(static_cast<std::string_view>("12"), i));
+    EXPECT_EQ(i, 12);
+
+    // should fail if unable to process entire input string
+    EXPECT_FALSE(EnergyPlus::readItem(static_cast<std::string_view>("1234fgq"), i));
+    // value is in an unknown state if read failed
+    // EXPECT_EQ(i, 12);
+
+    // should read nothing
+    EXPECT_FALSE(EnergyPlus::readItem(static_cast<std::string_view>("abc123"), i));
     EXPECT_EQ(i, 0);
 }