Remove defined_ flag, just check if arrays are allocated, add new exception classes

aabrown100-git · aabrown100-git · commit ee439960732e · 2025-09-25T16:06:12.000-07:00
diff --git a/Code/Source/solver/BoundaryCondition.cpp b/Code/Source/solver/BoundaryCondition.cpp
@@ -48,7 +48,6 @@ BoundaryCondition::BoundaryCondition(const std::string& vtp_file_path, const std
     , spatially_variable(true)
     , vtp_file_path_(vtp_file_path)
     , flags_(flags)
-    , defined_(false)  // Start as undefined, set to true only if successful
 {
     try {
         global_data_ = read_data_from_vtp_file(vtp_file_path, array_names);
@@ -68,11 +67,8 @@ BoundaryCondition::BoundaryCondition(const std::string& vtp_file_path, const std
         for (int i = 0; i < global_num_nodes_; i++) {
             global_node_map_[face_->gN(i)] = i;
         }
-        
-        defined_ = true;  // Mark as successfully defined
     } catch (const std::exception& e) {
-        // Constructor failed - object remains in undefined state
-        // defined_ remains false, resources are automatically cleaned up
+        // Constructor failed - resources are automatically cleaned up
         throw;  // Re-throw the exception
     }
 }
@@ -84,7 +80,6 @@ BoundaryCondition::BoundaryCondition(const StringDoubleMap& uniform_values, cons
     , spatially_variable(false)
     , vtp_file_path_("")
     , flags_(flags)
-    , defined_(false)  // Start as undefined, set to true only if successful
 {
     try {
         // Store array names, validate and store values
@@ -95,11 +90,8 @@ BoundaryCondition::BoundaryCondition(const StringDoubleMap& uniform_values, cons
             local_data_[name] = Array<double>(1, 1);
             local_data_[name](0, 0) = value;
         }
-        
-        defined_ = true;  // Mark as successfully defined
     } catch (const std::exception& e) {
-        // Constructor failed - object remains in undefined state
-        // defined_ remains false, resources are automatically cleaned up
+        // Constructor failed - resources are automatically cleaned up
         throw;  // Re-throw the exception
     }
 }
@@ -115,7 +107,6 @@ BoundaryCondition::BoundaryCondition(const BoundaryCondition& other)
     , vtp_file_path_(other.vtp_file_path_)
     , flags_(other.flags_)
     , global_node_map_(other.global_node_map_)
-    , defined_(other.defined_)
 {
     if (other.vtp_data_) {
         vtp_data_ = std::make_unique<VtkVtpData>(*other.vtp_data_);
@@ -135,7 +126,6 @@ void swap(BoundaryCondition& lhs, BoundaryCondition& rhs) noexcept {
     swap(lhs.flags_, rhs.flags_);
     swap(lhs.global_node_map_, rhs.global_node_map_);
     swap(lhs.vtp_data_, rhs.vtp_data_);
-    swap(lhs.defined_, rhs.defined_);
 }
 
 BoundaryCondition& BoundaryCondition::operator=(BoundaryCondition other) {
@@ -155,13 +145,11 @@ BoundaryCondition::BoundaryCondition(BoundaryCondition&& other) noexcept
     , flags_(std::move(other.flags_))
     , global_node_map_(std::move(other.global_node_map_))
     , vtp_data_(std::move(other.vtp_data_))
-    , defined_(other.defined_)
 {
     other.face_ = nullptr;
     other.global_num_nodes_ = 0;
     other.local_num_nodes_ = 0;
     other.spatially_variable = false;
-    other.defined_ = false;
 }
 
 
@@ -195,16 +183,15 @@ BoundaryCondition::StringArrayMap BoundaryCondition::read_data_from_vtp_file(con
     StringArrayMap result;
     for (const auto& array_name : array_names) {
         if (!vtp_data_->has_point_data(array_name)) {
-            throw std::runtime_error("VTP file '" + vtp_file_path + "' does not contain '" + array_name + "' point array.");
+            throw BoundaryConditionVtpArrayException(vtp_file_path, array_name);
         }
 
         auto array_data = vtp_data_->get_point_data(array_name);
 
         if (array_data.nrows() != global_num_nodes_ || array_data.ncols() != 1) {
-            throw std::runtime_error("'" + array_name + "' array in VTP file '" + vtp_file_path +
-                                       "' has incorrect dimensions. Expected " + std::to_string(global_num_nodes_) +
-                                       " x 1, got " + std::to_string(array_data.nrows()) + " x " +
-                                       std::to_string(array_data.ncols()) + ".");
+            throw BoundaryConditionVtpArrayDimensionException(vtp_file_path, array_name, 
+                                                           global_num_nodes_, 1, 
+                                                           array_data.nrows(), array_data.ncols());
         }
 
         // Store array in result map
@@ -223,12 +210,11 @@ double BoundaryCondition::get_value(const std::string& array_name, int node_id)
 {
     auto it = local_data_.find(array_name);
     if (it == local_data_.end()) {
-        throw std::runtime_error("Array '" + array_name + "' not found.");
+        throw BoundaryConditionArrayException(array_name);
     }
 
     if (node_id < 0 || node_id >= global_num_nodes_) {
-        throw std::runtime_error("Node ID " + std::to_string(node_id) +
-                                       " is out of range [0, " + std::to_string(global_num_nodes_ - 1) + "].");
+        throw BoundaryConditionNodeIdException(node_id, global_num_nodes_);
     }
 
     // Return value
@@ -257,8 +243,7 @@ int BoundaryCondition::get_local_index(int global_node_id) const
     if (spatially_variable) {
         auto it = global_node_map_.find(global_node_id);
         if (it == global_node_map_.end()) {
-            throw std::runtime_error("Global node ID " + std::to_string(global_node_id) +
-                                       " not found in global-to-local map.");
+            throw BoundaryConditionGlobalNodeIdException(global_node_id);
         }
         return it->second;
     } else {
@@ -292,7 +277,6 @@ void BoundaryCondition::distribute(const ComMod& com_mod, const CmMod& cm_mod, c
         distribute_uniform(cm_mod, cm, is_slave);
     }
     distribute_flags(cm_mod, cm, is_slave);
-    defined_ = true;
 
     #ifdef debug_distribute
     dmsg << "Finished distributing BC data" << std::endl;
@@ -338,7 +322,7 @@ void BoundaryCondition::distribute_spatially_variable(const ComMod& com_mod, con
     #endif
 
     if (face_ == nullptr) {
-        throw std::runtime_error("face_ is nullptr during distribute");
+        throw BoundaryConditionNullFaceException();
     }
     // Each processor collects the global node IDs and nodal positions of its 
     // associated face portion
@@ -513,9 +497,7 @@ int BoundaryCondition::find_vtp_point_index(double x, double y, double z,
         }
     }
 
-    throw std::runtime_error("Could not find matching point in VTP file for node at position (" +
-                                       std::to_string(x) + ", " + std::to_string(y) + ", " +
-                                       std::to_string(z) + ")");
+    throw BoundaryConditionPointNotFoundException(x, y, z);
 }
 
 std::string BoundaryCondition::flags_to_string() const {
diff --git a/Code/Source/solver/BoundaryCondition.h b/Code/Source/solver/BoundaryCondition.h
@@ -90,7 +90,6 @@ class BoundaryCondition {
     std::string vtp_file_path_;              ///< Path to VTP file (empty if uniform)
     std::map<int, int> global_node_map_;     ///< Maps global node IDs to local array indices
     std::unique_ptr<VtkVtpData> vtp_data_;   ///< VTP data object
-    bool defined_ = false;                           ///< Whether this BC has been properly initialized
 
 public:
     /// @brief Tolerance for point matching in VTP files
@@ -174,10 +173,10 @@ class BoundaryCondition {
         return vtp_file_path_;
     }
 
-    /// @brief Check if this BC is properly defined
-    /// @return true if BC has been initialized with either VTP data or uniform values
-    bool is_defined() const noexcept {
-        return defined_;
+    /// @brief Check if this BC has been properly initialized with data
+    /// @return true if BC has data (either global or local arrays are populated)
+    bool is_initialized() const noexcept {
+        return !global_data_.empty() || !local_data_.empty();
     }
 
     /// @brief Distribute BC data from the master process to the slave processes
@@ -275,4 +274,67 @@ class BoundaryConditionFlagException : public BoundaryConditionBaseException {
         : BoundaryConditionBaseException("BoundaryCondition flag not found: '" + flag_name + "'") {}
 };
 
+/// @brief Exception thrown when a requested array is not found
+class BoundaryConditionArrayException : public BoundaryConditionBaseException {
+public:
+    explicit BoundaryConditionArrayException(const std::string& array_name)
+        : BoundaryConditionBaseException("BoundaryCondition array not found: '" + array_name + "'") {}
+};
+
+/// @brief Exception thrown when BoundaryCondition is not properly initialized
+class BoundaryConditionNotInitializedException : public BoundaryConditionBaseException {
+public:
+    explicit BoundaryConditionNotInitializedException()
+        : BoundaryConditionBaseException("BoundaryCondition not properly initialized - no data available") {}
+};
+
+/// @brief Exception thrown when a node ID is out of range
+class BoundaryConditionNodeIdException : public BoundaryConditionBaseException {
+public:
+    explicit BoundaryConditionNodeIdException(int node_id, int max_node_id)
+        : BoundaryConditionBaseException("Node ID " + std::to_string(node_id) + 
+                                       " is out of range [0, " + std::to_string(max_node_id - 1) + "]") {}
+};
+
+/// @brief Exception thrown when a global node ID is not found in the global-to-local map
+class BoundaryConditionGlobalNodeIdException : public BoundaryConditionBaseException {
+public:
+    explicit BoundaryConditionGlobalNodeIdException(int global_node_id)
+        : BoundaryConditionBaseException("Global node ID " + std::to_string(global_node_id) + 
+                                       " not found in global-to-local map") {}
+};
+
+/// @brief Exception thrown when a VTP file doesn't contain a required array
+class BoundaryConditionVtpArrayException : public BoundaryConditionBaseException {
+public:
+    explicit BoundaryConditionVtpArrayException(const std::string& vtp_file, const std::string& array_name)
+        : BoundaryConditionBaseException("VTP file '" + vtp_file + "' does not contain '" + array_name + "' point array") {}
+};
+
+/// @brief Exception thrown when a VTP array has incorrect dimensions
+class BoundaryConditionVtpArrayDimensionException : public BoundaryConditionBaseException {
+public:
+    explicit BoundaryConditionVtpArrayDimensionException(const std::string& vtp_file, const std::string& array_name, 
+                                                       int expected_rows, int expected_cols, int actual_rows, int actual_cols)
+        : BoundaryConditionBaseException("'" + array_name + "' array in VTP file '" + vtp_file +
+                                       "' has incorrect dimensions. Expected " + std::to_string(expected_rows) +
+                                       " x " + std::to_string(expected_cols) + ", got " + std::to_string(actual_rows) +
+                                       " x " + std::to_string(actual_cols)) {}
+};
+
+/// @brief Exception thrown when face_ is nullptr during distribute
+class BoundaryConditionNullFaceException : public BoundaryConditionBaseException {
+public:
+    explicit BoundaryConditionNullFaceException()
+        : BoundaryConditionBaseException("face_ is nullptr during distribute") {}
+};
+
+/// @brief Exception thrown when a point cannot be found in VTP file
+class BoundaryConditionPointNotFoundException : public BoundaryConditionBaseException {
+public:
+    explicit BoundaryConditionPointNotFoundException(double x, double y, double z)
+        : BoundaryConditionBaseException("Could not find matching point in VTP file for node at position (" +
+                                       std::to_string(x) + ", " + std::to_string(y) + ", " + std::to_string(z) + ")") {}
+};
+
 #endif // BOUNDARY_CONDITION_H
diff --git a/Code/Source/solver/RobinBoundaryCondition.h b/Code/Source/solver/RobinBoundaryCondition.h
@@ -70,7 +70,9 @@ class RobinBoundaryCondition : public BoundaryCondition {
     /// @param vtp_file_path Path to VTP file containing Stiffness and Damping point arrays
     /// @param normal_only Flag to apply only along normal direction
     /// @param face Face associated with the Robin BC
-    /// @throws std::runtime_error if file cannot be read or arrays are missing
+    /// @throws BoundaryConditionFileException if file cannot be read
+    /// @throws BoundaryConditionVtpArrayException if arrays are missing
+    /// @throws BoundaryConditionValidationException if values are invalid
     RobinBoundaryCondition(const std::string& vtp_file_path, bool normal_only, const faceType& face)
         : BoundaryCondition(vtp_file_path, std::vector<std::string>{"Stiffness", "Damping"}, StringBoolMap{{"normal_direction_only", normal_only}}, face) {}
 
@@ -80,22 +82,29 @@ class RobinBoundaryCondition : public BoundaryCondition {
     /// @param uniform_damping Uniform damping value for all nodes
     /// @param normal_only Flag to apply only along normal direction
     /// @param face Face associated with the Robin BC
+    /// @throws BoundaryConditionValidationException if values are invalid
     RobinBoundaryCondition(double uniform_stiffness, double uniform_damping, bool normal_only, const faceType& face)
         : BoundaryCondition({{"Stiffness", uniform_stiffness}, {"Damping", uniform_damping}}, StringBoolMap{{"normal_direction_only", normal_only}}, face) {}
  
     /// @brief Apply only along normal direction (getter)
+    /// @return true if BC should be applied only along normal direction
+    /// @throws BoundaryConditionFlagException if "normal_direction_only" flag not found
     bool normal_direction_only() const { return this->get_flag("normal_direction_only"); }
  
     /// @brief Get stiffness value for a specific node (convenience method)
     /// @param node_id Node index on the face
     /// @return Stiffness value for the node
+    /// @throws BoundaryConditionArrayException if "Stiffness" array not found
+    /// @throws BoundaryConditionNodeIdException if node_id is out of range
     double get_stiffness(int node_id) const {
         return get_value("Stiffness", node_id);
     }
     
     /// @brief Get damping value for a specific node (convenience method)
     /// @param node_id Node index on the face
     /// @return Damping value for the node
+    /// @throws BoundaryConditionArrayException if "Damping" array not found
+    /// @throws BoundaryConditionNodeIdException if node_id is out of range
     double get_damping(int node_id) const {
         return get_value("Damping", node_id);
     }
@@ -109,7 +118,7 @@ class RobinBoundaryCondition : public BoundaryCondition {
     /// @brief Validate array values for Robin BC
     /// @param array_name Name of the array being validated
     /// @param value Value to validate
-    /// @throws std::runtime_error if validation fails
+    /// @throws BoundaryConditionValidationException if validation fails
     void validate_array_value(const std::string& array_name, double value) const override {
         if (value < 0.0) {
             throw BoundaryConditionValidationException(array_name, value);
diff --git a/Code/Source/solver/distribute.cpp b/Code/Source/solver/distribute.cpp
@@ -802,8 +802,8 @@ void dist_bc(ComMod& com_mod, const CmMod& cm_mod, const cmType& cm, bcType& lBc
 
   // Communicating Robin BC
   //
-  bool has_robin_bc = lBc.robin_bc.is_defined();
-  cm.bcast(cm_mod, &has_robin_bc);
+  bool has_robin_bc = lBc.robin_bc.is_initialized();
+  cm.bcast(cm_mod, &has_robin_bc); // Master process broadcasts the flag to all processes
 
   if (has_robin_bc) {
     lBc.robin_bc.distribute(com_mod, cm_mod, cm, com_mod.msh[lBc.iM].fa[lBc.iFa]);
diff --git a/Code/Source/solver/set_bc.cpp b/Code/Source/solver/set_bc.cpp
@@ -1470,7 +1470,7 @@ void set_bc_neu_l(ComMod& com_mod, const CmMod& cm_mod, const bcType& lBc, const
     }
   }
   // Now treat Robin BC (stiffness and damping) here
-  if (lBc.robin_bc.is_defined()) {
+  if (lBc.robin_bc.is_initialized()) {
     set_bc_rbnl(com_mod, lFa, lBc.robin_bc, Yg, Dg);
   }
 }

Original file line number	Diff line number	Diff line change
`@@ -1470,7 +1470,7 @@ void set_bc_neu_l(ComMod& com_mod, const CmMod& cm_mod, const bcType& lBc, const`
`1470`	`1470`	`}`
`1471`	`1471`	`}`
`1472`	`1472`	`// Now treat Robin BC (stiffness and damping) here`
`1473`		`- if (lBc.robin_bc.is_defined()) {`
	`1473`	`+ if (lBc.robin_bc.is_initialized()) {`
`1474`	`1474`	`set_bc_rbnl(com_mod, lFa, lBc.robin_bc, Yg, Dg);`
`1475`	`1475`	`}`
`1476`	`1476`	`}`