Address feature review comments

Author: xuchenhan-tri

multibody/plant/deformable_ids.h

@@ -44,20 +44,23 @@ DeformableBodyId DeformableModel<T>::RegisterDeformableBody(
     ModelInstanceIndex model_instance,
     const fem::DeformableBodyConfig<T>& config, double resolution_hint) {
   this->ThrowIfSystemResourcesDeclared(__func__);
+  ThrowIfNotDiscrete(__func__);
   ThrowIfNotDouble(__func__);
   if (!(model_instance < this->plant().num_model_instances())) {
     throw std::logic_error(
-        "Invalid model instance specified. A valid model instance can be "
-        "obtained by calling MultibodyPlant::AddModelInstance().");
+        "RegisterDeformableBody(): Invalid model instance specified. A valid "
+        "model instance can be obtained by calling "
+        "MultibodyPlant::AddModelInstance().");
   }
   if constexpr (std::is_same_v<T, double>) {
     const std::string name = geometry_instance->name();
     if (HasBodyNamed(name, model_instance)) {
       const std::string& model_instance_name =
           this->plant().GetModelInstanceName(model_instance);
       throw std::logic_error(fmt::format(
-          "Model instance '{}' already contains a deformable body "
-          "named '{}'. Body names must be unique within a given model.",
+          "RegisterDeformableBody(): Model instance '{}' already contains a "
+          "deformable body named '{}'. Body names must be unique within a "
+          "given model.",
           model_instance_name, name));
     }
     /* Register the geometry with SceneGraph. */
@@ -162,6 +165,7 @@ void DeformableModel<T>::AddExternalForce(
     std::unique_ptr<ForceDensityFieldBase<T>> force_density) {
   this->ThrowIfSystemResourcesDeclared(__func__);
   ThrowIfNotDouble(__func__);
+  ThrowIfNotDiscrete(__func__);
   force_densities_.push_back(std::move(force_density));
 }
 
@@ -221,17 +225,18 @@ bool DeformableModel<T>::HasBodyNamed(const std::string& name) const {
 template <typename T>
 bool DeformableModel<T>::HasBodyNamed(const std::string& name,
                                       ModelInstanceIndex model_instance) const {
-  return !GetBodyIndicesByName(name, model_instance).empty();
+  return GetBodyIndexByName(name, model_instance).has_value();
 }
 
 template <typename T>
 const DeformableBody<T>& DeformableModel<T>::GetBodyByName(
     const std::string& name) const {
   const std::vector<DeformableBodyIndex> indices = GetBodyIndicesByName(name);
   if (indices.empty()) {
-    throw std::runtime_error(fmt::format(
-        "No deformable body with the given name {} has been registered.",
-        name));
+    throw std::runtime_error(
+        fmt::format("GetBodyByName(): No deformable body with the given name "
+                    "{} has been registered.",
+                    name));
   }
   if (indices.size() > 1) {
     throw std::runtime_error(
@@ -245,15 +250,15 @@ const DeformableBody<T>& DeformableModel<T>::GetBodyByName(
 template <typename T>
 const DeformableBody<T>& DeformableModel<T>::GetBodyByName(
     const std::string& name, ModelInstanceIndex model_instance) const {
-  const std::vector<DeformableBodyIndex> indices =
-      GetBodyIndicesByName(name, model_instance);
-  if (indices.empty()) {
+  const std::optional<DeformableBodyIndex> index =
+      GetBodyIndexByName(name, model_instance);
+  if (!index.has_value()) {
     throw std::runtime_error(
-        fmt::format("No deformable body with the given name {} in instance {}.",
+        fmt::format("GetBodyByName(): No deformable body with the given name "
+                    "{} in instance {}.",
                     name, model_instance));
   }
-  DRAKE_DEMAND(ssize(indices) == 1);
-  return deformable_bodies_.get_element(indices[0]);
+  return deformable_bodies_.get_element(index.value());
 }
 
 template <typename T>
@@ -364,7 +369,7 @@ DeformableModel<T>::CloneToSymbolic(
 template <typename T>
 void DeformableModel<T>::DoDeclareSystemResources() {
   if constexpr (!std::is_same_v<T, double>) {
-    /* A none double DeformableModel is always empty. */
+    /* A non-double DeformableModel is always empty. */
     DRAKE_DEMAND(is_empty());
     return;
   } else {
@@ -467,6 +472,15 @@ void DeformableModel<T>::ThrowIfNotDouble(const char* function_name) const {
                     function_name));
   }
 }
+template <typename T>
+void DeformableModel<T>::ThrowIfNotDiscrete(const char* function_name) const {
+  if (!this->plant().is_discrete()) {
+    throw std::logic_error(
+        fmt::format("Calls to {}() with a DeformableModel belonging to a "
+                    "continuous MultibodyPlant are not allowed.",
+                    function_name));
+  }
+}
 
 template <typename T>
 std::vector<DeformableBodyIndex> DeformableModel<T>::GetBodyIndicesByName(
@@ -481,18 +495,17 @@ std::vector<DeformableBodyIndex> DeformableModel<T>::GetBodyIndicesByName(
 }
 
 template <typename T>
-std::vector<DeformableBodyIndex> DeformableModel<T>::GetBodyIndicesByName(
+std::optional<DeformableBodyIndex> DeformableModel<T>::GetBodyIndexByName(
     const std::string& name, ModelInstanceIndex model_instance) const {
   /* Use the name lookup for its side-effect of throwing on an invalid index. */
   unused(this->plant().GetModelInstanceName(model_instance));
   auto [lower, upper] = deformable_bodies_.names_map().equal_range(name);
-  std::vector<DeformableBodyIndex> indices;
   for (auto it = lower; it != upper; ++it) {
     if (GetBody(it->second).model_instance() == model_instance) {
-      indices.push_back(it->second);
+      return it->second;
     }
   }
-  return indices;
+  return std::nullopt;
 }
 
 }  // namespace multibody

multibody/plant/deformable_model.cc

@@ -2,6 +2,7 @@
 
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 #include <unordered_map>
 #include <vector>
@@ -82,6 +83,8 @@ class DeformableModel final : public multibody::PhysicalModel<T> {
    @pre resolution_hint > 0.
    @throws std::exception if `this` %DeformableModel is not of scalar type
    double.
+   @throws std::exception if `this` %DeformableModel belongs to a continuous
+   MultibodyPlant.
    @throws std::exception if the model instance does not exist.
    @throws std::exception if a deformable body with the same name has already
    been registered to the model instance.
@@ -302,7 +305,7 @@ class DeformableModel final : public multibody::PhysicalModel<T> {
       DeformableBodyIndex index = GetBodyIndex(id);
       return deformable_bodies_.get_element(index);
     } else {
-      /* A none double DeformableModel is always empty. */
+      /* A non-double DeformableModel is always empty. */
       DRAKE_UNREACHABLE();
     }
   }
@@ -314,12 +317,12 @@ class DeformableModel final : public multibody::PhysicalModel<T> {
     if constexpr (std::is_same_v<T, double>) {
       return deformable_bodies_.get_element(index);
     } else {
-      /* A none double DeformableModel is always empty. */
+      /* A non-double DeformableModel is always empty. */
       DRAKE_UNREACHABLE();
     }
   }
 
-  /** Returns the deformable body with the given `id`.
+  /** Returns a mutable reference to the deformable body with the given `id`.
    @throws std::exception if no deformable body with the given `id` has been
    registered in this model. */
   DeformableBody<T>& GetMutableBody(DeformableBodyId id) {
@@ -328,7 +331,7 @@ class DeformableModel final : public multibody::PhysicalModel<T> {
       DeformableBodyIndex index = GetBodyIndex(id);
       return deformable_bodies_.get_mutable_element(index);
     } else {
-      /* A none double DeformableModel is always empty. */
+      /* A non-double DeformableModel is always empty. */
       DRAKE_UNREACHABLE();
     }
   }
@@ -344,12 +347,13 @@ class DeformableModel final : public multibody::PhysicalModel<T> {
 
   /** Returns the DeformableBody with the given name.
    @throws std::exception if there's no body with the given name or if more than
-   one model instance contains deformable body with the given name. */
+   one model instance contains a deformable body with the given name. */
   const DeformableBody<T>& GetBodyByName(const std::string& name) const;
 
-  /** Returns the DeformableBody with the given name.
-   @throws std::exception if there's no body with the given name or if more than
-   one model instance contains deformable body with the given name. */
+  /** Returns the DeformableBody with the given name from the given model
+   instance.
+   @throws std::exception if there's no body with the given name that is
+   registered with the given model instance. */
   const DeformableBody<T>& GetBodyByName(
       const std::string& name, ModelInstanceIndex model_instance) const;
 
@@ -472,14 +476,18 @@ class DeformableModel final : public multibody::PhysicalModel<T> {
    a DeformableModel that doesn't have scalar type double. */
   void ThrowIfNotDouble(const char* function_name) const;
 
+  /* Helper to throw a useful message if the given `function_name` is called on
+   a DeformableModel that belongs to a continuous plant. */
+  void ThrowIfNotDiscrete(const char* function_name) const;
+
   /* Returns all body indices with exactly this name (no model instance check).
    */
   std::vector<DeformableBodyIndex> GetBodyIndicesByName(
       const std::string& name) const;
 
-  /* Returns all body indices with this name *and* in the given model instance.
-   */
-  std::vector<DeformableBodyIndex> GetBodyIndicesByName(
+  /* Returns the index of the deformable body with this name *and* in the given
+   model instance if any; otherwise returns std::nullopt. */
+  std::optional<DeformableBodyIndex> GetBodyIndexByName(
       const std::string& name, ModelInstanceIndex model_instance) const;
 
   /* Data members. WARNING: if you add a field here be sure to update

multibody/plant/deformable_model.h

@@ -85,6 +85,15 @@ TEST_F(DeformableModelTest, RegisterDeformableBody) {
                                         make_unique<Sphere>(1), "sphere"),
           default_body_config_, kRezHint),
       ".*RegisterDeformableBody.*after system resources have been declared.*");
+
+  /* Registering a deformable body within a continous plant throws. */
+  MultibodyPlant<double> continuous_plant(0.0);
+  DRAKE_EXPECT_THROWS_MESSAGE(
+      continuous_plant.mutable_deformable_model().RegisterDeformableBody(
+          make_unique<GeometryInstance>(RigidTransformd(),
+                                        make_unique<Sphere>(1), "sphere"),
+          default_body_config_, kRezHint),
+      ".*RegisterDeformableBody.*continuous MultibodyPlant.*not allowed.*");
 }
 
 /* Coarsely tests that SetWallBoundaryCondition adds some sort of boundary
@@ -428,6 +437,13 @@ TEST_F(DeformableModelTest, ExternalForces) {
       EXPECT_EQ(force->EvaluateAt(*plant_context, p_WQ), scale * 3.14 * p_WQ);
     }
   }
+
+  /* Registering an external force within a continous plant throws. */
+  MultibodyPlant<double> continuous_plant(0.0);
+  DRAKE_EXPECT_THROWS_MESSAGE(
+      continuous_plant.mutable_deformable_model().AddExternalForce(
+          std::make_unique<ConstantForceDensityField>(force_field)),
+      ".*AddExternalForce.*continuous MultibodyPlant.*not allowed.*");
 }
 
 TEST_F(DeformableModelTest, CloneBeforeFinalizeThrows) {

multibody/plant/test/deformable_model_test.cc

@@ -197,7 +197,7 @@ template <typename T>
 std::unique_ptr<DeformableBody<double>> DeformableBody<T>::CloneToDouble()
     const {
   if constexpr (!std::is_same_v<T, double>) {
-    /* A none double body shouldn't exist in the first place. */
+    /* A non-double body shouldn't exist in the first place. */
     DRAKE_UNREACHABLE();
   } else {
     auto clone =

multibody/tree/deformable_body.cc

@@ -151,7 +151,7 @@ class MultibodyElement {
   virtual void DoSetDefaultParameters(systems::Parameters<T>*) const;
 
   /// Implementation of the NVI DeclareDiscreteState(). MultibodyElement-derived
-  /// objects may override to declare their specific parameters.
+  /// objects may override to declare their specific state variables.
   virtual void DoDeclareDiscreteState(internal::MultibodyTreeSystem<T>*);
 
   /// To be used by MultibodyElement-derived objects when declaring parameters