some optimization

Author: pcarruscag

Common/include/option_structure.inl

@@ -96,8 +96,6 @@ public:
     typeName(type_name) {
   }
 
-  ~COptionScalar() = default;
-
   string SetValue(vector<string> option_value) override {
     COptionBase::SetValue(option_value);
 
@@ -155,14 +153,6 @@ public:
   }
 };
 
-class COptionString final : public COptionScalar<string> {
-public:
-  template<class... Ts>
-  COptionString(Ts&&... args) :
-    COptionScalar<string>("string", args...) {
-  }
-};
-
 class COptionBool final : public COptionScalar<bool> {
 public:
   template<class... Ts>
@@ -191,6 +181,38 @@ public:
   }
 };
 
+class COptionString final : public COptionBase {
+protected:
+  string& field; // Reference to the fieldname
+  const string def; // Default value
+  const string name; // identifier for the option
+
+public:
+  COptionString() = delete;
+
+  COptionString(const string& option_field_name,
+                string& option_field,
+                string default_value) :
+    field(option_field),
+    def(default_value),
+    name(option_field_name) {
+  }
+
+  string SetValue(vector<string> option_value) override {
+    COptionBase::SetValue(option_value);
+
+    string out = optionCheckMultipleValues(option_value, "string", name);
+    if (!out.empty()) return out;
+
+    field = option_value.front();
+    return "";
+  }
+
+  void SetDefault() override {
+    field = def;
+  }
+};
+
 template <class Tenum, class TField>
 class COptionEnumList final : public COptionBase {
 

Common/src/CConfig.cpp

@@ -7315,6 +7315,13 @@ bool CConfig::TokenizeString(string & str, string & option_name,
   // now fill the option value vector
   option_value.clear();
   last_pos = value_part.find_first_not_of(delimiters, 0);
+
+  // detect a raw string
+  if (value_part[last_pos] == '\'' && value_part.back() == '\'') {
+    option_value.push_back(value_part.substr(last_pos+1, value_part.size()-last_pos-2));
+    return true;
+  }
+
   pos = value_part.find_first_of(delimiters, last_pos);
   while (string::npos != pos || string::npos != last_pos) {
     // add token to the vector<string>

SU2_CFD/include/output/COutput.hpp

@@ -39,6 +39,14 @@
 #include "tools/CWindowingTools.hpp"
 #include "../../../Common/include/option_structure.hpp"
 
+/*--- AD workaround for a cmath function not defined in CoDi. ---*/
+namespace mel::internal {
+inline su2double hypot(const su2double& a, const su2double& b) {
+  return sqrt(a*a + b*b);
+}
+}
+#include "mel.hpp"
+
 class CGeometry;
 class CSolver;
 class CFileWriter;
@@ -159,6 +167,20 @@ class COutput {
   //! Structure to store the value initial residuals for relative residual computation
   std::map<string, su2double> initialResiduals;
 
+  /** \brief Struct to hold a parsed user-defined expression. */
+  struct CustomHistoryOutput {
+    mel::ExpressionTree<passivedouble> expression;
+    /*--- Pointers to values in the history output maps, to avoid key lookup every time. ---*/
+    std::vector<const su2double*> symbolValues;
+    bool ready = false;
+
+    su2double eval() const {
+      return mel::Eval<su2double>(expression, [&](int i) {return *symbolValues[i];});
+    }
+  };
+
+  CustomHistoryOutput customObjFunc;  /*!< \brief User-defined expression for a custom objective. */
+
    /*----------------------------- Volume output ----------------------------*/
 
    CParallelDataSorter* volumeDataSorter;    //!< Volume data sorter
@@ -379,13 +401,6 @@ class COutput {
     return historyOutputPerSurface_Map.at(field)[iMarker].value;
   }
 
-  /*!
-   * \brief Evaluate a custom expression of the history values.
-   * \param[in] expression - Some user-defined math with the history field names as variables.
-   * \return Result of the expression
-   */
-  su2double ComputeCustomHistoryValue(const string& expression) const;
-
   /*!
    * \brief Get a vector with all output fields in a particular group
    * \param groupname - Name of the history group
@@ -587,6 +602,13 @@ class COutput {
     }
   }
 
+  /*!
+   * \brief Setup a custom history output object for a given expression.
+   * \param[in] expression - Some user-defined math with the history field names as variables.
+   * \param[out] output - Custom output ready to evaluate.
+   */
+  void SetupCustomHistoryOutput(const string& expression, CustomHistoryOutput& output) const;
+
   /*!
    * \brief Add a new field to the volume output.
    * \param[in] name - Name for referencing it (in the config file and in the code).

SU2_CFD/src/output/COutput.cpp

@@ -28,8 +28,6 @@
 #include "../../../Common/include/geometry/CGeometry.hpp"
 #include "../../include/solvers/CSolver.hpp"
 
-#include "mel.hpp"
-
 #include "../../include/output/COutput.hpp"
 #include "../../include/output/filewriter/CFVMDataSorter.hpp"
 #include "../../include/output/filewriter/CFEMDataSorter.hpp"
@@ -264,30 +262,50 @@ void COutput::OutputScreenAndHistory(CConfig *config) {
   }
 }
 
-su2double COutput::ComputeCustomHistoryValue(const string& expression) const {
+void COutput::SetupCustomHistoryOutput(const std::string& expression, CustomHistoryOutput& output) const {
 
   std::vector<std::string> symbols;
-  const auto tree = mel::Parse<passivedouble>(expression, symbols);
+  output.expression = mel::Parse<passivedouble>(expression, symbols);
 
-  auto valueOfSymbol = [&](const std::string& symbol) {
+  auto ptrToSymbolValue = [&](const std::string& symbol) {
     /*--- Decide if it should be per surface. ---*/
     const auto pos = symbol.find('[');
+    const su2double* ptr = nullptr;
     if (pos == std::string::npos) {
-      return GetHistoryFieldValue(symbol);
+      const auto it = historyOutput_Map.find(symbol);
+      if (it != historyOutput_Map.end()) {
+        ptr = &(it->second.value);
+      }
     } else {
       const auto name = std::string(symbol, 0, pos);
       const auto idx = std::stoi(std::string(symbol.begin()+pos+1, symbol.end()-1));
-      return GetHistoryFieldValuePerSurface(name, idx);
+      const auto it = historyOutputPerSurface_Map.find(name);
+      if (it != historyOutputPerSurface_Map.end()) {
+        ptr = &(it->second[idx].value);
+      }
     }
+    return ptr;
   };
 
-  return mel::Eval<su2double>(tree, symbols, valueOfSymbol);
+  output.symbolValues.reserve(symbols.size());
+  for (const auto& symbol : symbols) {
+    const auto* ptr = ptrToSymbolValue(symbol);
+    if (ptr == nullptr) {
+      SU2_MPI::Error(std::string("Invalid history output (") + symbol + std::string(") used in expression:\n") +
+                     expression, CURRENT_FUNCTION);
+    }
+    output.symbolValues.push_back(ptr);
+  }
+  output.ready = true;
 }
 
 void COutput::SetCustomAndComboObjectives(int idxSol, const CConfig *config, CSolver **solver) {
 
   if (config->GetKind_ObjFunc() == CUSTOM_OBJFUNC && !config->GetCustomObjFunc().empty()) {
-    solver[idxSol]->SetTotal_Custom_ObjFunc(ComputeCustomHistoryValue(config->GetCustomObjFunc()));
+    if (!customObjFunc.ready) {
+      SetupCustomHistoryOutput(config->GetCustomObjFunc(), customObjFunc);
+    }
+    solver[idxSol]->SetTotal_Custom_ObjFunc(customObjFunc.eval());
   }
   solver[idxSol]->Evaluate_ObjFunc(config, solver);
   SetHistoryOutputValue("COMBO", solver[idxSol]->GetTotal_ComboObj());