#include "fesa/elements/euler_beam_3d.h"

#include <algorithm>
#include <array>
#include <cmath>
#include <limits>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>

#include "fesa/math/vector3.h"
#include "fesa/model/model_types.h"
#include "math/dense_blas_internal.h"

namespace fesa {

EulerBeam3DDefinition::EulerBeam3DDefinition(
    SourceEntityId source_id_value,
    std::array<EntityIndex, 2> node_indices_value,
    const EntityIndex material_index_value,
    const EntityIndex section_index_value, SourceLocation location_value)
    : source_id{std::move(source_id_value)},
      node_indices{std::move(node_indices_value)},
      material_index{material_index_value},
      section_index{section_index_value},
      location{std::move(location_value)},
      node_indices_view_{node_indices.begin(), node_indices.end()} {}

ElementDefinitionKind EulerBeam3DDefinition::Kind() const noexcept {
  return ElementDefinitionKind::kEulerBeam3D;
}

const SourceEntityId& EulerBeam3DDefinition::SourceId() const noexcept {
  return source_id;
}

std::string_view EulerBeam3DDefinition::SourceElementType() const noexcept {
  return "B33";
}

const std::vector<EntityIndex>& EulerBeam3DDefinition::NodeIndices()
    const noexcept {
  return node_indices_view_;
}

EntityIndex EulerBeam3DDefinition::MaterialIndex() const noexcept {
  return material_index;
}

EntityIndex EulerBeam3DDefinition::PropertyIndex() const noexcept {
  return section_index;
}

void EulerBeam3DDefinition::SynchronizeNodeIndices() {
  node_indices_view_.assign(node_indices.begin(), node_indices.end());
}

namespace {

constexpr std::size_t kElementDofCount = 12U;
constexpr std::size_t kGeneralizedComponentCount = 4U;
constexpr double kGeometryTolerance = 1.0e-12;
constexpr double kStiffnessInvariantTolerance = 1.0e-12;

std::string ElementIdentity(const Node& first_node, const Node& second_node) {
  return first_node.source_id.instance_name + ":" +
         first_node.source_id.source_label_text + "-" +
         second_node.source_id.source_label_text;
}

Result<EulerBeam3D> ModelFailure(const std::string& code,
                                 const SourceLocation& location,
                                 const std::string& identity,
                                 const std::string& message) {
  return Result<EulerBeam3D>::Failure(Status::Failure(
      FailureCategory::kModel,
      {{Severity::kError, code, location, "*ELEMENT", identity, message}}));
}

/// @brief Creates a structured failure at the runtime element boundary.
template <class T>
Result<T> RuntimeFailure(const SourceLocation& location,
                         const SourceEntityId& source_id,
                         const std::string& message) {
  return Result<T>::Failure(
      Status::Failure(FailureCategory::kModel,
                      {{Severity::kError, "invalid-runtime-element", location,
                        "*ELEMENT", source_id.source_label_text, message}}));
}

/// @brief Reports whether every fixed-size recovery component is finite.
template <class T, std::size_t Size>
bool IsFinite(const std::array<T, Size>& values) {
  return std::all_of(values.begin(), values.end(), [](const auto& value) {
    if constexpr (std::is_arithmetic_v<T>) {
      return std::isfinite(value);
    } else {
      return IsFinite(value);
    }
  });
}

/// @brief Repeats the local-axis rotation in stable nodal translation and
/// rotation blocks.
Matrix Transformation(const std::array<double, 9>& rotation) {
  Matrix result{kElementDofCount, kElementDofCount};
  // Blocks preserve [translation, rotation] at node 1 then node 2.
  for (std::size_t block = 0; block < 4U; ++block) {
    for (std::size_t row = 0; row < 3U; ++row) {
      for (std::size_t column = 0; column < 3U; ++column) {
        result(block * 3U + row, block * 3U + column) =
            rotation[row * 3U + column];
      }
    }
  }
  return result;
}

/// @brief Builds the reviewed axial, twist, and signed curvature operator.
/// @warning The theta-y and theta-z signs are formulation contracts.
Matrix StrainDisplacement(double xi, double length) {
  Matrix b{kGeneralizedComponentCount, kElementDofCount};
  const double r = 0.5 * (1.0 + xi);
  const double inverse_length = 1.0 / length;
  const double inverse_length_squared = inverse_length * inverse_length;

  b(0U, 0U) = -inverse_length;
  b(0U, 6U) = inverse_length;
  b(1U, 3U) = -inverse_length;
  b(1U, 9U) = inverse_length;

  // theta_y=-w' makes kappa_y=-w''; theta_z=v' makes kappa_z=v''.
  b(2U, 2U) = (6.0 - 12.0 * r) * inverse_length_squared;
  b(2U, 4U) = (-4.0 + 6.0 * r) * inverse_length;
  b(2U, 8U) = (-6.0 + 12.0 * r) * inverse_length_squared;
  b(2U, 10U) = (-2.0 + 6.0 * r) * inverse_length;

  b(3U, 1U) = (-6.0 + 12.0 * r) * inverse_length_squared;
  b(3U, 5U) = (-4.0 + 6.0 * r) * inverse_length;
  b(3U, 7U) = (6.0 - 12.0 * r) * inverse_length_squared;
  b(3U, 11U) = (-2.0 + 6.0 * r) * inverse_length;
  return b;
}

std::array<double, kGeneralizedComponentCount> ConstitutiveDiagonal(
    double youngs_modulus, double shear_modulus, double area, double iy,
    double iz, double torsional_constant) {
  return {youngs_modulus * area, shear_modulus * torsional_constant,
          youngs_modulus * iy, youngs_modulus * iz};
}

/// @brief Builds the independent closed-form stiffness used as a Gauss-rule
/// invariant.
Matrix ClosedStiffness(
    double length,
    const std::array<double, kGeneralizedComponentCount>& diagonal) {
  Matrix closed{kElementDofCount, kElementDofCount};
  const auto add_block = [&closed](const std::array<std::size_t, 2>& indices,
                                   double coefficient) {
    closed(indices[0], indices[0]) = coefficient;
    closed(indices[0], indices[1]) = -coefficient;
    closed(indices[1], indices[0]) = -coefficient;
    closed(indices[1], indices[1]) = coefficient;
  };
  add_block({0U, 6U}, diagonal[0U] / length);
  add_block({3U, 9U}, diagonal[1U] / length);

  const auto add_bending_block = [&closed, length](
                                     const std::array<std::size_t, 4>& indices,
                                     double flexural_rigidity,
                                     double rotation_sign) {
    const double value = 12.0 * flexural_rigidity / (length * length * length);
    const double coupling =
        rotation_sign * 6.0 * flexural_rigidity / (length * length);
    const double diagonal_rotation = 4.0 * flexural_rigidity / length;
    const double off_diagonal_rotation = 2.0 * flexural_rigidity / length;
    const std::array<double, 16> block = {value,     coupling,
                                          -value,    coupling,
                                          coupling,  diagonal_rotation,
                                          -coupling, off_diagonal_rotation,
                                          -value,    -coupling,
                                          value,     -coupling,
                                          coupling,  off_diagonal_rotation,
                                          -coupling, diagonal_rotation};
    for (std::size_t row = 0; row < indices.size(); ++row) {
      for (std::size_t column = 0; column < indices.size(); ++column) {
        closed(indices[row], indices[column]) =
            block[row * indices.size() + column];
      }
    }
  };
  add_bending_block({1U, 5U, 7U, 11U}, diagonal[3U], 1.0);
  add_bending_block({2U, 4U, 8U, 10U}, diagonal[2U], -1.0);
  return closed;
}

double NormalizedMatrixError(const Matrix& lhs, const Matrix& rhs) {
  double maximum_difference = 0.0;
  double scale_value = 1.0;
  for (std::size_t row = 0; row < lhs.Rows(); ++row) {
    for (std::size_t column = 0; column < lhs.Columns(); ++column) {
      const double lhs_value = lhs(row, column);
      const double rhs_value = rhs(row, column);
      if (!std::isfinite(lhs_value) || !std::isfinite(rhs_value)) {
        return std::numeric_limits<double>::infinity();
      }
      const double difference = std::abs(lhs_value - rhs_value);
      if (!std::isfinite(difference)) {
        return std::numeric_limits<double>::infinity();
      }
      maximum_difference = (std::max)(maximum_difference, difference);
      scale_value = (std::max)(scale_value, std::abs(lhs_value));
      scale_value = (std::max)(scale_value, std::abs(rhs_value));
    }
  }
  if (!std::isfinite(maximum_difference) || !std::isfinite(scale_value) ||
      !(scale_value > 0.0)) {
    return std::numeric_limits<double>::infinity();
  }
  const double normalized_error = maximum_difference / scale_value;
  return std::isfinite(normalized_error)
             ? normalized_error
             : std::numeric_limits<double>::infinity();
}

/// @brief Recovers generalized strain in fixed component and DOF order.
std::array<double, kGeneralizedComponentCount> GeneralizedStrain(
    const Matrix& b, const Vector& local_displacement) {
  std::array<double, kGeneralizedComponentCount> strain{};
  const auto product = b.Multiply(local_displacement);
  for (std::size_t component = 0; component < strain.size(); ++component) {
    strain[component] = product[component];
  }
  return strain;
}

/// @brief Applies the diagonal section law without changing component order.
std::array<double, kGeneralizedComponentCount> GeneralizedResultant(
    const std::array<double, kGeneralizedComponentCount>& strain,
    const std::array<double, kGeneralizedComponentCount>& diagonal) {
  std::array<double, kGeneralizedComponentCount> resultant{};
  for (std::size_t component = 0; component < resultant.size(); ++component) {
    resultant[component] = diagonal[component] * strain[component];
  }
  return resultant;
}

/// @brief Builds signed Hermite interpolation for endpoint recovery.
Matrix KinematicInterpolation(double xi, double length) {
  Matrix interpolation{4U, kElementDofCount};
  const double r = 0.5 * (1.0 + xi);
  const double r_squared = r * r;
  const double r_cubed = r_squared * r;
  const double n1 = 1.0 - r;
  const double n2 = r;
  const double h1 = 1.0 - 3.0 * r_squared + 2.0 * r_cubed;
  const double h2 = length * (r - 2.0 * r_squared + r_cubed);
  const double h3 = 3.0 * r_squared - 2.0 * r_cubed;
  const double h4 = length * (-r_squared + r_cubed);

  interpolation(0U, 0U) = n1;
  interpolation(0U, 6U) = n2;
  interpolation(1U, 1U) = h1;
  interpolation(1U, 5U) = h2;
  interpolation(1U, 7U) = h3;
  interpolation(1U, 11U) = h4;
  interpolation(2U, 2U) = h1;
  interpolation(2U, 4U) = -h2;
  interpolation(2U, 8U) = h3;
  interpolation(2U, 10U) = -h4;
  interpolation(3U, 3U) = n1;
  interpolation(3U, 9U) = n2;
  return interpolation;
}

}  // namespace

Result<EulerBeam3D> EulerBeam3D::Create(const Node& first_node,
                                        const Node& second_node,
                                        const GeneralBeamSection& section,
                                        const LinearElasticMaterial& material) {
  const std::string identity = ElementIdentity(first_node, second_node);
  const Vector3 first{first_node.coordinates};
  const Vector3 second{second_node.coordinates};
  const Vector3 delta = second - first;
  const double length = delta.Norm();
  const double coordinate_scale =
      (std::max)({1.0, first.Norm(), second.Norm()});
  if (!first.IsFinite() || !second.IsFinite() || !delta.IsFinite() ||
      !std::isfinite(length) || !std::isfinite(coordinate_scale) ||
      !(length > kGeometryTolerance * coordinate_scale)) {
    return ModelFailure(
        "invalid-beam-length", first_node.location, identity,
        "Beam length must exceed the scale-aware geometry threshold.");
  }

  const Vector3 ex = delta / length;
  const Vector3 guide{section.first_axis};
  const double guide_norm = guide.Norm();
  const double guide_projection = guide.Dot(ex);
  const Vector3 ey_trial = guide - guide_projection * ex;
  const double ey_trial_norm = ey_trial.Norm();
  if (!guide.IsFinite() || !std::isfinite(guide_norm) || !ey_trial.IsFinite() ||
      !std::isfinite(ey_trial_norm) ||
      !(ey_trial_norm > kGeometryTolerance * (std::max)(1.0, guide_norm))) {
    return ModelFailure(
        "invalid-beam-guide-vector", section.location, identity,
        "Beam guide vector must define a scale-aware transverse direction.");
  }

  if (!std::isfinite(section.i12)) {
    return ModelFailure("invalid-beam-property", section.location, identity,
                        "Beam section properties must be finite and positive.");
  }
  if (section.i12 != 0.0) {
    return ModelFailure("unsupported-coupled-section", section.location,
                        identity,
                        "The Euler beam kernel requires exact I12=0.");
  }

  const double shear_modulus =
      material.youngs_modulus / (2.0 * (1.0 + material.poisson_ratio));
  const std::array<double, 6> positive_properties = {
      material.youngs_modulus,
      shear_modulus,
      section.area,
      section.i11,
      section.i22,
      section.torsional_constant};
  if (!std::isfinite(material.poisson_ratio) ||
      std::any_of(positive_properties.begin(), positive_properties.end(),
                  [](double property) {
                    return !std::isfinite(property) || !(property > 0.0);
                  })) {
    return ModelFailure("invalid-beam-property", section.location, identity,
                        "E, G, A, Iy, Iz, and J must be finite and positive.");
  }

  const auto derived_rigidity = ConstitutiveDiagonal(
      material.youngs_modulus, shear_modulus, section.area, section.i11,
      section.i22, section.torsional_constant);
  const double length_squared = length * length;
  const double length_cubed = length_squared * length;
  // These are every distinct positive magnitude used by the exact axial,
  // torsion, and two bending closed-form blocks. Reject arithmetic
  // overflow/underflow without introducing a conditioning threshold.
  const std::array<double, 14> required_stiffness_magnitudes = {
      derived_rigidity[0U],
      derived_rigidity[1U],
      derived_rigidity[2U],
      derived_rigidity[3U],
      derived_rigidity[0U] / length,
      derived_rigidity[1U] / length,
      12.0 * derived_rigidity[2U] / length_cubed,
      6.0 * derived_rigidity[2U] / length_squared,
      4.0 * derived_rigidity[2U] / length,
      2.0 * derived_rigidity[2U] / length,
      12.0 * derived_rigidity[3U] / length_cubed,
      6.0 * derived_rigidity[3U] / length_squared,
      4.0 * derived_rigidity[3U] / length,
      2.0 * derived_rigidity[3U] / length};
  if (std::any_of(required_stiffness_magnitudes.begin(),
                  required_stiffness_magnitudes.end(), [](double magnitude) {
                    return !std::isfinite(magnitude) || !(magnitude > 0.0);
                  })) {
    return ModelFailure(
        "invalid-beam-property", section.location, identity,
        "Derived beam stiffness coefficients must be finite and positive.");
  }

  const Vector3 ey = ey_trial / ey_trial_norm;
  const Vector3 ez = ex.Cross(ey);
  // Rows map global vectors to the approved right-handed local (ex,ey,ez)
  // basis.
  const std::array<double, 9> rotation = {ex[0], ex[1], ex[2], ey[0], ey[1],
                                          ey[2], ez[0], ez[1], ez[2]};

  return Result<EulerBeam3D>::Success(
      EulerBeam3D{length, material.youngs_modulus, shear_modulus, section.area,
                  section.i11, section.i22, section.torsional_constant,
                  rotation, section.section_points});
}

Matrix EulerBeam3D::LocalStiffness() const {
  const auto diagonal = ConstitutiveDiagonal(
      youngs_modulus_, shear_modulus_, area_, iy_, iz_, torsional_constant_);
  Matrix stiffness{kElementDofCount, kElementDofCount};
  const double inverse_sqrt_three = 1.0 / std::sqrt(3.0);
  const std::array<double, 2> gauss_points = {-inverse_sqrt_three,
                                              inverse_sqrt_three};
  const double jacobian = 0.5 * length_;

  // Both Gauss points are required: a one-point bending rule loses two ranks.
  for (const double xi : gauss_points) {
    const Matrix b = StrainDisplacement(xi, length_);
    Matrix weighted_b = b;
    for (std::size_t component = 0; component < diagonal.size(); ++component)
      for (std::size_t column = 0; column < kElementDofCount; ++column)
        weighted_b(component, column) *= diagonal[component];
    const auto contribution =
        dense_blas_internal::MultiplyTransposeLeft(b, weighted_b);
    for (std::size_t row = 0; row < kElementDofCount; ++row) {
      for (std::size_t column = 0; column < kElementDofCount; ++column) {
        stiffness(row, column) += contribution(row, column) * jacobian;
      }
    }
  }

  const Matrix closed = ClosedStiffness(length_, diagonal);
  if (NormalizedMatrixError(stiffness, closed) > kStiffnessInvariantTolerance) {
    throw std::logic_error{
        "Two-point Euler beam stiffness violated the closed-form invariant."};
  }
  return stiffness;
}

Matrix EulerBeam3D::GlobalStiffness() const {
  const Matrix local = LocalStiffness();
  const Matrix transform = Transformation(rotation_);
  const Matrix local_times_transform = local.Multiply(transform);
  // Kg=T^T*Kl*T while dl=T*dg.
  return dense_blas_internal::MultiplyTransposeLeft(transform,
                                                    local_times_transform);
}

Vector EulerBeam3D::LocalEquivalentLoad(
    const ConstantLocalLineLoad& load) const {
  const std::array<double, 4> components = {load.px, load.py, load.pz, load.mx};
  Matrix component_column{components.size(), 1U};
  for (std::size_t component = 0; component < components.size(); ++component)
    component_column(component, 0U) = components[component];
  Vector equivalent{kElementDofCount};
  const double inverse_sqrt_three = 1.0 / std::sqrt(3.0);
  const std::array<double, 2> gauss_points = {-inverse_sqrt_three,
                                              inverse_sqrt_three};
  const double jacobian = 0.5 * length_;
  for (const double xi : gauss_points) {
    const Matrix interpolation = KinematicInterpolation(xi, length_);
    const auto contribution = dense_blas_internal::MultiplyTransposeLeft(
        interpolation, component_column);
    for (std::size_t dof = 0; dof < equivalent.Size(); ++dof) {
      equivalent[dof] += contribution(dof, 0U) * jacobian;
    }
  }
  return equivalent;
}

BeamRecovery EulerBeam3D::RecoverBeam(
    const Vector& global_element_displacement) const {
  const Matrix transform = Transformation(rotation_);
  const Vector local_displacement =
      transform.Multiply(global_element_displacement);
  const auto diagonal = ConstitutiveDiagonal(
      youngs_modulus_, shear_modulus_, area_, iy_, iz_, torsional_constant_);
  BeamRecovery recovery{};

  // With parser/CLI distributed loading excluded, Kl*dl is the local outward
  // end action.
  const Vector end_action = LocalStiffness().Multiply(local_displacement);
  for (std::size_t endpoint = 0; endpoint < 2U; ++endpoint) {
    for (std::size_t component = 0; component < 6U; ++component) {
      recovery.equilibrium_end_actions[endpoint][component] =
          end_action[endpoint * 6U + component];
    }

    const double xi = endpoint == 0U ? -1.0 : 1.0;
    recovery.endpoint_section_resultants[endpoint] = GeneralizedResultant(
        GeneralizedStrain(StrainDisplacement(xi, length_), local_displacement),
        diagonal);
  }

  const double inverse_sqrt_three = 1.0 / std::sqrt(3.0);
  const std::array<double, 2> gauss_points = {-inverse_sqrt_three,
                                              inverse_sqrt_three};
  for (std::size_t point = 0; point < gauss_points.size(); ++point) {
    recovery.gauss_generalized_strains[point] = GeneralizedStrain(
        StrainDisplacement(gauss_points[point], length_), local_displacement);
    recovery.gauss_generalized_resultants[point] = GeneralizedResultant(
        recovery.gauss_generalized_strains[point], diagonal);

    if (section_points_.empty()) {
      recovery.stress_points.push_back(
          {static_cast<int>(point + 1U), 0U, 0.0, 0.0,
           youngs_modulus_ * recovery.gauss_generalized_strains[point][0U],
           "fesa-default"});
      continue;
    }

    for (std::size_t section_point = 0; section_point < section_points_.size();
         ++section_point) {
      const double x1 = section_points_[section_point][0U];
      const double x2 = section_points_[section_point][1U];
      const auto& strain = recovery.gauss_generalized_strains[point];
      // x1=y and x2=z: S11=E(epsilon0+x2*kappa_y-x1*kappa_z).
      recovery.stress_points.push_back(
          {static_cast<int>(point + 1U), section_point + 1U, x1, x2,
           youngs_modulus_ * (strain[0U] + x2 * strain[2U] - x1 * strain[3U]),
           "input"});
    }
  }
  return recovery;
}

const ElementDofLayout& EulerBeam3D::DofLayout() const noexcept {
  return dof_layout_;
}

Result<ElementStiffnessContribution> EulerBeam3D::ComputeStiffness() const {
  if (dof_layout_.node_indices.size() != 2U ||
      dof_layout_.components_per_node.size() != 6U) {
    return RuntimeFailure<ElementStiffnessContribution>(
        runtime_location_, dof_layout_.source_id,
        "B33 runtime stiffness requires a bound two-node six-DOF layout.");
  }
  try {
    return Result<ElementStiffnessContribution>::Success(
        {dof_layout_, GlobalStiffness()});
  } catch (const std::exception& error) {
    return RuntimeFailure<ElementStiffnessContribution>(
        runtime_location_, dof_layout_.source_id, error.what());
  }
}

Result<ElementResultBundle> EulerBeam3D::Recover(
    const Vector& element_displacement) const {
  if (dof_layout_.node_indices.size() != 2U ||
      dof_layout_.components_per_node.size() != 6U ||
      node_source_ids_.size() != 2U ||
      element_displacement.Size() != kElementDofCount) {
    return RuntimeFailure<ElementResultBundle>(
        runtime_location_, dof_layout_.source_id,
        "B33 runtime recovery requires a bound two-node layout and 12 DOFs.");
  }
  for (std::size_t dof = 0U; dof < element_displacement.Size(); ++dof) {
    if (!std::isfinite(element_displacement[dof])) {
      return RuntimeFailure<ElementResultBundle>(
          runtime_location_, dof_layout_.source_id,
          "B33 runtime recovery displacement must be finite.");
    }
  }

  BeamRecovery recovered{};
  try {
    recovered = RecoverBeam(element_displacement);
  } catch (const std::exception& error) {
    return RuntimeFailure<ElementResultBundle>(
        runtime_location_, dof_layout_.source_id, error.what());
  }

  BeamElementResultRows rows{};
  rows.endpoint_rows.reserve(2U);
  rows.gauss_rows.reserve(2U);
  rows.stress_rows.reserve(recovered.stress_points.size());
  for (std::size_t endpoint = 0U; endpoint < 2U; ++endpoint) {
    if (!IsFinite(recovered.equilibrium_end_actions[endpoint]) ||
        !IsFinite(recovered.endpoint_section_resultants[endpoint])) {
      return RuntimeFailure<ElementResultBundle>(
          runtime_location_, dof_layout_.source_id,
          "B33 endpoint recovery values must be finite.");
    }
    rows.endpoint_rows.push_back(
        {element_index_, static_cast<int>(endpoint), node_source_ids_[endpoint],
         recovered.equilibrium_end_actions[endpoint],
         recovered.endpoint_section_resultants[endpoint]});
  }
  for (std::size_t gauss = 0U; gauss < 2U; ++gauss) {
    if (!IsFinite(recovered.gauss_generalized_strains[gauss]) ||
        !IsFinite(recovered.gauss_generalized_resultants[gauss])) {
      return RuntimeFailure<ElementResultBundle>(
          runtime_location_, dof_layout_.source_id,
          "B33 Gauss recovery values must be finite.");
    }
    rows.gauss_rows.push_back({element_index_, static_cast<int>(gauss + 1U),
                               recovered.gauss_generalized_strains[gauss],
                               recovered.gauss_generalized_resultants[gauss]});
  }
  for (const auto& point : recovered.stress_points) {
    if ((point.gauss_point != 1 && point.gauss_point != 2) ||
        !std::isfinite(point.x1) || !std::isfinite(point.x2) ||
        !std::isfinite(point.s11)) {
      return RuntimeFailure<ElementResultBundle>(
          runtime_location_, dof_layout_.source_id,
          "B33 stress recovery identity and values must be finite.");
    }
    rows.stress_rows.push_back({element_index_, point.gauss_point,
                                point.section_point, point.x1, point.x2,
                                point.s11, point.source});
  }
  return Result<ElementResultBundle>::Success(
      {dof_layout_.source_id, std::move(rows)});
}

void EulerBeam3D::BindRuntime(ElementDofLayout layout,
                              const EntityIndex element_index,
                              std::vector<SourceEntityId> node_source_ids,
                              SourceLocation location) {
  dof_layout_ = std::move(layout);
  element_index_ = element_index;
  node_source_ids_ = std::move(node_source_ids);
  runtime_location_ = std::move(location);
}

EulerBeam3D::EulerBeam3D(double length, double youngs_modulus,
                         double shear_modulus, double area, double iy,
                         double iz, double torsional_constant,
                         std::array<double, 9> rotation,
                         std::vector<std::array<double, 2>> section_points)
    : length_{length},
      youngs_modulus_{youngs_modulus},
      shear_modulus_{shear_modulus},
      area_{area},
      iy_{iy},
      iz_{iz},
      torsional_constant_{torsional_constant},
      rotation_{rotation},
      section_points_{std::move(section_points)} {}

}  // namespace fesa