CI is now reporting a new crop of formatting errors. This fixes them

Exawind · Oct 1, 2024 · 36c762e · 36c762e
1 parent 1f52662
commit 36c762e
Show file tree

Hide file tree

Showing 32 changed files with 156 additions and 98 deletions.
diff --git a/src/beams/create_beams.hpp b/src/beams/create_beams.hpp
@@ -91,14 +91,16 @@ inline Beams CreateBeams(const BeamsInput& beams_input) {
         "InterpolateQPPosition", beams.num_elems,
         InterpolateQPPosition{
             beams.num_nodes_per_element, beams.num_qps_per_element, beams.shape_interp,
-            beams.node_x0, beams.qp_x0}
+            beams.node_x0, beams.qp_x0
+        }
     );
 
     Kokkos::parallel_for(
         "InterpolateQPRotation", beams.num_elems,
         InterpolateQPRotation{
             beams.num_nodes_per_element, beams.num_qps_per_element, beams.shape_interp,
-            beams.node_x0, beams.qp_r0}
+            beams.node_x0, beams.qp_r0
+        }
     );
 
     Kokkos::parallel_for(
@@ -120,7 +122,8 @@ inline Beams CreateBeams(const BeamsInput& beams_input) {
             beams.num_nodes_per_element, beams.num_qps_per_element, beams.shape_interp,
             beams.shape_deriv, beams.qp_jacobian, beams.node_u, beams.node_u_dot, beams.node_u_ddot,
             beams.qp_x0, beams.qp_r0, beams.qp_u, beams.qp_u_prime, beams.qp_r, beams.qp_r_prime,
-            beams.qp_u_dot, beams.qp_omega, beams.qp_u_ddot, beams.qp_omega_dot, beams.qp_x}
+            beams.qp_u_dot, beams.qp_omega, beams.qp_u_ddot, beams.qp_omega_dot, beams.qp_x
+        }
     );
     return beams;
 }

diff --git a/src/beams/interpolate_to_quadrature_points.hpp b/src/beams/interpolate_to_quadrature_points.hpp
@@ -55,27 +55,30 @@ struct InterpolateToQuadraturePoints {
             Kokkos::TeamThreadRange(member, num_qps),
             InterpolateQPVector{
                 i_elem, num_nodes, shape_interp,
-                Kokkos::subview(node_u_dot, Kokkos::ALL, Kokkos::ALL, Kokkos::pair(0, 3)), qp_u_dot}
+                Kokkos::subview(node_u_dot, Kokkos::ALL, Kokkos::ALL, Kokkos::pair(0, 3)), qp_u_dot
+            }
         );
         Kokkos::parallel_for(
             Kokkos::TeamThreadRange(member, num_qps),
             InterpolateQPVector{
                 i_elem, num_nodes, shape_interp,
-                Kokkos::subview(node_u_dot, Kokkos::ALL, Kokkos::ALL, Kokkos::pair(3, 6)), qp_omega}
+                Kokkos::subview(node_u_dot, Kokkos::ALL, Kokkos::ALL, Kokkos::pair(3, 6)), qp_omega
+            }
         );
         Kokkos::parallel_for(
             Kokkos::TeamThreadRange(member, num_qps),
             InterpolateQPVector{
                 i_elem, num_nodes, shape_interp,
-                Kokkos::subview(node_u_ddot, Kokkos::ALL, Kokkos::ALL, Kokkos::pair(0, 3)),
-                qp_u_ddot}
+                Kokkos::subview(node_u_ddot, Kokkos::ALL, Kokkos::ALL, Kokkos::pair(0, 3)), qp_u_ddot
+            }
         );
         Kokkos::parallel_for(
             Kokkos::TeamThreadRange(member, num_qps),
             InterpolateQPVector{
                 i_elem, num_nodes, shape_interp,
                 Kokkos::subview(node_u_ddot, Kokkos::ALL, Kokkos::ALL, Kokkos::pair(3, 6)),
-                qp_omega_dot}
+                qp_omega_dot
+            }
         );
         Kokkos::parallel_for(
             Kokkos::TeamThreadRange(member, num_qps),

diff --git a/src/constraints/calculate_constraint_force.hpp b/src/constraints/calculate_constraint_force.hpp
@@ -23,7 +23,8 @@ struct CalculateConstraintForce {
             case ConstraintType::kRevoluteJoint: {
                 // Applies the torque from a revolute joint constraint to the system residual
                 CalculateRevoluteJointForce{
-                    target_node_index, axes, inputs, node_u, system_residual_terms}(i_constraint);
+                    target_node_index, axes, inputs, node_u, system_residual_terms
+                }(i_constraint);
             } break;
             default: {
                 // Do nothing

diff --git a/src/constraints/calculate_constraint_output.hpp b/src/constraints/calculate_constraint_output.hpp
@@ -26,20 +26,23 @@ struct CalculateConstraintOutput {
             case ConstraintType::kRevoluteJoint: {
                 // Axis of rotation unit vector
                 const auto joint_axis0_data = Kokkos::Array<double, 3>{
-                    axes(i_constraint, 0, 0), axes(i_constraint, 0, 1), axes(i_constraint, 0, 2)};
+                    axes(i_constraint, 0, 0), axes(i_constraint, 0, 1), axes(i_constraint, 0, 2)
+                };
                 const auto joint_axis0 = View_3::const_type{joint_axis0_data.data()};
 
                 // Target node index
                 auto i_node = target_node_index(i_constraint);
 
                 // Target node initial rotation
                 const auto R0_data = Kokkos::Array<double, 4>{
-                    node_u(i_node, 3), node_u(i_node, 4), node_u(i_node, 5), node_u(i_node, 6)};
+                    node_u(i_node, 3), node_u(i_node, 4), node_u(i_node, 5), node_u(i_node, 6)
+                };
                 const auto R0 = View_Quaternion::const_type{R0_data.data()};
 
                 // Target node rotational displacement
                 const auto R_data = Kokkos::Array<double, 4>{
-                    node_u(i_node, 3), node_u(i_node, 4), node_u(i_node, 5), node_u(i_node, 6)};
+                    node_u(i_node, 3), node_u(i_node, 4), node_u(i_node, 5), node_u(i_node, 6)
+                };
                 const auto R = View_Quaternion::const_type{R_data.data()};
 
                 // Calculate current orientation
@@ -54,12 +57,14 @@ struct CalculateConstraintOutput {
 
                 // Target node rotational velocity vector
                 auto omega_data = Kokkos::Array<double, 3>{
-                    node_udot(i_node, 3), node_udot(i_node, 4), node_udot(i_node, 5)};
+                    node_udot(i_node, 3), node_udot(i_node, 4), node_udot(i_node, 5)
+                };
                 auto omega = View_3{omega_data.data()};
 
                 // Target node rotational acceleration vector
                 auto omega_dot_data = Kokkos::Array<double, 3>{
-                    node_uddot(i_node, 3), node_uddot(i_node, 4), node_uddot(i_node, 5)};
+                    node_uddot(i_node, 3), node_uddot(i_node, 4), node_uddot(i_node, 5)
+                };
                 auto omega_dot = View_3{omega_dot_data.data()};
 
                 // Calculate joint axis in current configuration

diff --git a/src/constraints/calculate_fixed_bc_constraint.hpp b/src/constraints/calculate_fixed_bc_constraint.hpp
@@ -23,7 +23,8 @@ struct CalculateFixedBCConstraint {
 
         // Initial difference between nodes
         const auto X0_data = Kokkos::Array<double, 3>{
-            X0_(i_constraint, 0), X0_(i_constraint, 1), X0_(i_constraint, 2)};
+            X0_(i_constraint, 0), X0_(i_constraint, 1), X0_(i_constraint, 2)
+        };
         const auto X0 = View_3::const_type{X0_data.data()};
 
         // Base node displacement
@@ -34,7 +35,8 @@ struct CalculateFixedBCConstraint {
 
         // Target node displacement
         const auto R2_data = Kokkos::Array<double, 4>{
-            node_u(i_node2, 3), node_u(i_node2, 4), node_u(i_node2, 5), node_u(i_node2, 6)};
+            node_u(i_node2, 3), node_u(i_node2, 4), node_u(i_node2, 5), node_u(i_node2, 6)
+        };
         const auto R2 = Kokkos::View<double[4]>::const_type{R2_data.data()};
         const auto u2_data =
             Kokkos::Array<double, 3>{node_u(i_node2, 0), node_u(i_node2, 1), node_u(i_node2, 2)};

diff --git a/src/constraints/calculate_prescribed_bc_constraint.hpp b/src/constraints/calculate_prescribed_bc_constraint.hpp
@@ -23,23 +23,27 @@ struct CalculatePrescribedBCConstraint {
 
         // Initial difference between nodes
         const auto X0_data = Kokkos::Array<double, 3>{
-            X0_(i_constraint, 0), X0_(i_constraint, 1), X0_(i_constraint, 2)};
+            X0_(i_constraint, 0), X0_(i_constraint, 1), X0_(i_constraint, 2)
+        };
         const auto X0 = View_3::const_type{X0_data.data()};
 
         // Base node displacement
         const auto u1_data = Kokkos::Array<double, 3>{
             constraint_inputs(i_constraint, 0), constraint_inputs(i_constraint, 1),
-            constraint_inputs(i_constraint, 2)};
+            constraint_inputs(i_constraint, 2)
+        };
         auto u1 = View_3::const_type{u1_data.data()};
 
         const auto R1_data = Kokkos::Array<double, 4>{
             constraint_inputs(i_constraint, 3), constraint_inputs(i_constraint, 4),
-            constraint_inputs(i_constraint, 5), constraint_inputs(i_constraint, 6)};
+            constraint_inputs(i_constraint, 5), constraint_inputs(i_constraint, 6)
+        };
         const auto R1 = Kokkos::View<double[4]>::const_type{R1_data.data()};
 
         // Target node displacement
         const auto R2_data = Kokkos::Array<double, 4>{
-            node_u(i_node2, 3), node_u(i_node2, 4), node_u(i_node2, 5), node_u(i_node2, 6)};
+            node_u(i_node2, 3), node_u(i_node2, 4), node_u(i_node2, 5), node_u(i_node2, 6)
+        };
         const auto R2 = Kokkos::View<double[4]>::const_type{R2_data.data()};
         const auto u2_data =
             Kokkos::Array<double, 3>{node_u(i_node2, 0), node_u(i_node2, 1), node_u(i_node2, 2)};

diff --git a/src/constraints/calculate_revolute_joint_constraint.hpp b/src/constraints/calculate_revolute_joint_constraint.hpp
@@ -27,20 +27,23 @@ struct CalculateRevoluteJointConstraint {
 
         // Initial difference between nodes
         const auto X0_data = Kokkos::Array<double, 3>{
-            X0_(i_constraint, 0), X0_(i_constraint, 1), X0_(i_constraint, 2)};
+            X0_(i_constraint, 0), X0_(i_constraint, 1), X0_(i_constraint, 2)
+        };
         const auto X0 = View_3::const_type{X0_data.data()};
 
         // Base node displacement
         const auto u1_data =
             Kokkos::Array<double, 3>{node_u(i_node1, 0), node_u(i_node1, 1), node_u(i_node1, 2)};
         const auto u1 = View_3::const_type{u1_data.data()};
         const auto R1_data = Kokkos::Array<double, 4>{
-            node_u(i_node1, 3), node_u(i_node1, 4), node_u(i_node1, 5), node_u(i_node1, 6)};
+            node_u(i_node1, 3), node_u(i_node1, 4), node_u(i_node1, 5), node_u(i_node1, 6)
+        };
         const auto R1 = Kokkos::View<double[4]>::const_type{R1_data.data()};
 
         // Target node displacement
         const auto R2_data = Kokkos::Array<double, 4>{
-            node_u(i_node2, 3), node_u(i_node2, 4), node_u(i_node2, 5), node_u(i_node2, 6)};
+            node_u(i_node2, 3), node_u(i_node2, 4), node_u(i_node2, 5), node_u(i_node2, 6)
+        };
         const auto R2 = Kokkos::View<double[4]>::const_type{R2_data.data()};
         const auto u2_data =
             Kokkos::Array<double, 3>{node_u(i_node2, 0), node_u(i_node2, 1), node_u(i_node2, 2)};
@@ -55,13 +58,16 @@ struct CalculateRevoluteJointConstraint {
 
         // Revolute joint constraint data
         const auto x0_data = Kokkos::Array<double, 3>{
-            axes(i_constraint, 0, 0), axes(i_constraint, 0, 1), axes(i_constraint, 0, 2)};
+            axes(i_constraint, 0, 0), axes(i_constraint, 0, 1), axes(i_constraint, 0, 2)
+        };
         const auto x0 = View_3::const_type{x0_data.data()};
         const auto y0_data = Kokkos::Array<double, 3>{
-            axes(i_constraint, 1, 0), axes(i_constraint, 1, 1), axes(i_constraint, 1, 2)};
+            axes(i_constraint, 1, 0), axes(i_constraint, 1, 1), axes(i_constraint, 1, 2)
+        };
         const auto y0 = View_3::const_type{y0_data.data()};
         const auto z0_data = Kokkos::Array<double, 3>{
-            axes(i_constraint, 2, 0), axes(i_constraint, 2, 1), axes(i_constraint, 2, 2)};
+            axes(i_constraint, 2, 0), axes(i_constraint, 2, 1), axes(i_constraint, 2, 2)
+        };
         const auto z0 = View_3::const_type{z0_data.data()};
         auto x_data = Kokkos::Array<double, 3>{};
         const auto x = View_3{x_data.data()};

diff --git a/src/constraints/calculate_revolute_joint_force.hpp b/src/constraints/calculate_revolute_joint_force.hpp
@@ -23,15 +23,17 @@ struct CalculateRevoluteJointForce {
 
         // Initial difference between nodes
         const auto X0_data = Kokkos::Array<double, 3>{
-            axes(i_constraint, 0, 0), axes(i_constraint, 0, 1), axes(i_constraint, 0, 2)};
+            axes(i_constraint, 0, 0), axes(i_constraint, 0, 1), axes(i_constraint, 0, 2)
+        };
         const auto X0 = View_3::const_type{X0_data.data()};
 
         auto R2_X0_data = Kokkos::Array<double, 3>{};
         const auto R2_X0 = Kokkos::View<double[3]>{R2_X0_data.data()};
 
         // Target node displacement
         const auto R2_data = Kokkos::Array<double, 4>{
-            node_u(i_node2, 3), node_u(i_node2, 4), node_u(i_node2, 5), node_u(i_node2, 6)};
+            node_u(i_node2, 3), node_u(i_node2, 4), node_u(i_node2, 5), node_u(i_node2, 6)
+        };
         const auto R2 = Kokkos::View<double[4]>::const_type{R2_data.data()};
 
         //----------------------------------------------------------------------

diff --git a/src/constraints/calculate_rigid_joint_constraint.hpp b/src/constraints/calculate_rigid_joint_constraint.hpp
@@ -26,20 +26,23 @@ struct CalculateRigidJointConstraint {
 
         // Initial difference between nodes
         const auto X0_data = Kokkos::Array<double, 3>{
-            X0_(i_constraint, 0), X0_(i_constraint, 1), X0_(i_constraint, 2)};
+            X0_(i_constraint, 0), X0_(i_constraint, 1), X0_(i_constraint, 2)
+        };
         const auto X0 = View_3::const_type{X0_data.data()};
 
         // Base node displacement
         const auto u1_data =
             Kokkos::Array<double, 3>{node_u(i_node1, 0), node_u(i_node1, 1), node_u(i_node1, 2)};
         const auto u1 = View_3::const_type{u1_data.data()};
         const auto R1_data = Kokkos::Array<double, 4>{
-            node_u(i_node1, 3), node_u(i_node1, 4), node_u(i_node1, 5), node_u(i_node1, 6)};
+            node_u(i_node1, 3), node_u(i_node1, 4), node_u(i_node1, 5), node_u(i_node1, 6)
+        };
         const auto R1 = Kokkos::View<double[4]>::const_type{R1_data.data()};
 
         // Target node displacement
         const auto R2_data = Kokkos::Array<double, 4>{
-            node_u(i_node2, 3), node_u(i_node2, 4), node_u(i_node2, 5), node_u(i_node2, 6)};
+            node_u(i_node2, 3), node_u(i_node2, 4), node_u(i_node2, 5), node_u(i_node2, 6)
+        };
         const auto R2 = Kokkos::View<double[4]>::const_type{R2_data.data()};
         const auto u2_data =
             Kokkos::Array<double, 3>{node_u(i_node2, 0), node_u(i_node2, 1), node_u(i_node2, 2)};

diff --git a/src/constraints/calculate_rotation_control_constraint.hpp b/src/constraints/calculate_rotation_control_constraint.hpp
@@ -27,20 +27,23 @@ struct CalculateRotationControlConstraint {
 
         // Initial difference between nodes
         const auto X0_data = Kokkos::Array<double, 3>{
-            X0_(i_constraint, 0), X0_(i_constraint, 1), X0_(i_constraint, 2)};
+            X0_(i_constraint, 0), X0_(i_constraint, 1), X0_(i_constraint, 2)
+        };
         const auto X0 = View_3::const_type{X0_data.data()};
 
         // Base node displacement
         const auto u1_data =
             Kokkos::Array<double, 3>{node_u(i_node1, 0), node_u(i_node1, 1), node_u(i_node1, 2)};
         const auto R1_data = Kokkos::Array<double, 4>{
-            node_u(i_node1, 3), node_u(i_node1, 4), node_u(i_node1, 5), node_u(i_node1, 6)};
+            node_u(i_node1, 3), node_u(i_node1, 4), node_u(i_node1, 5), node_u(i_node1, 6)
+        };
         const auto u1 = View_3::const_type{u1_data.data()};
         const auto R1 = Kokkos::View<double[4]>::const_type{R1_data.data()};
 
         // Target node displacement
         const auto R2_data = Kokkos::Array<double, 4>{
-            node_u(i_node2, 3), node_u(i_node2, 4), node_u(i_node2, 5), node_u(i_node2, 6)};
+            node_u(i_node2, 3), node_u(i_node2, 4), node_u(i_node2, 5), node_u(i_node2, 6)
+        };
         const auto R2 = Kokkos::View<double[4]>::const_type{R2_data.data()};
         const auto u2_data =
             Kokkos::Array<double, 3>{node_u(i_node2, 0), node_u(i_node2, 1), node_u(i_node2, 2)};

diff --git a/src/constraints/constraint.hpp b/src/constraints/constraint.hpp
@@ -74,7 +74,8 @@ struct Constraint {
                      v[2] * v[0] * k - v[1],
                      v[2] * v[1] * k + v[0],
                      v[2] * v[2] * k + c,
-                 }}};
+                 }}
+            };
 
             // Set orthogonal unit vectors from the rotation matrix
             x_axis = {R[0][0], R[1][0], R[2][0]};

diff --git a/src/model/node.hpp b/src/model/node.hpp
@@ -48,7 +48,8 @@ struct Node {
     void Rotate(const Array_3& axis, double angle) {
         auto q = Array_4{
             cos(angle / 2.), sin(angle / 2.) * axis[0], sin(angle / 2.) * axis[1],
-            sin(angle / 2.) * axis[2]};
+            sin(angle / 2.) * axis[2]
+        };
         Rotate(q);
     }
 };

diff --git a/src/solver/solver.hpp b/src/solver/solver.hpp
@@ -151,7 +151,8 @@ struct Solver {
             "PopulateSparseRowPtrsColInds_Constraints", 1,
             PopulateSparseRowPtrsColInds_Constraints<RowPtrType, IndicesType>{
                 constraint_type, constraint_base_node_index, constraint_target_node_index,
-                constraint_row_range, B_row_ptrs, B_col_ind}
+                constraint_row_range, B_row_ptrs, B_col_ind
+            }
         );
         auto B_values = ValuesType("B values", B_num_non_zero);
         KokkosSparse::sort_crs_matrix(B_row_ptrs, B_col_ind, B_values);
@@ -172,7 +173,8 @@ struct Solver {
             "PopulateSparseRowPtrsColInds_Transpose", 1,
             PopulateSparseRowPtrsColInds_Transpose<RowPtrType, IndicesType>{
                 B_num_rows, B_num_columns, B_row_ptrs, B_col_ind, col_count, tmp_row_ptrs,
-                B_t_row_ptrs, B_t_col_inds}
+                B_t_row_ptrs, B_t_col_inds
+            }
         );
         B_t = CrsMatrixType(
             "B_t", static_cast<int>(B_t_num_rows), static_cast<int>(B_t_num_columns),
@@ -203,7 +205,8 @@ struct Solver {
         Kokkos::parallel_for(
             "FillUnshiftedRowPtrs", num_dofs + 1,
             FillUnshiftedRowPtrs<RowPtrType>{
-                num_system_dofs, system_matrix.graph.row_map, system_matrix_full_row_ptrs}
+                num_system_dofs, system_matrix.graph.row_map, system_matrix_full_row_ptrs
+            }
         );
         system_matrix_full = CrsMatrixType(
             "system_matrix_full", static_cast<int>(num_dofs), static_cast<int>(num_dofs),
@@ -230,7 +233,8 @@ struct Solver {
         Kokkos::parallel_for(
             "FillUnshiftedRowPtrs", num_dofs + 1,
             FillUnshiftedRowPtrs<RowPtrType>{
-                num_system_dofs, B_t.graph.row_map, transpose_matrix_full_row_ptrs}
+                num_system_dofs, B_t.graph.row_map, transpose_matrix_full_row_ptrs
+            }
         );
         auto transpose_matrix_full_indices = IndicesType("transpose_matrix_full_indices", B_t.nnz());
         Kokkos::deep_copy(transpose_matrix_full_indices, static_cast<int>(num_system_dofs));

diff --git a/src/state/calculate_displacement.hpp b/src/state/calculate_displacement.hpp
@@ -19,7 +19,8 @@ struct CalculateDisplacement {
         }
 
         auto delta_data = Kokkos::Array<double, 3>{
-            h * q_delta(i_node, 3), h * q_delta(i_node, 4), h * q_delta(i_node, 5)};
+            h * q_delta(i_node, 3), h * q_delta(i_node, 4), h * q_delta(i_node, 5)
+        };
         auto delta =
             Kokkos::View<double[3], Kokkos::MemoryTraits<Kokkos::Unmanaged>>{delta_data.data()};
 
@@ -28,7 +29,8 @@ struct CalculateDisplacement {
             Kokkos::View<double[4], Kokkos::MemoryTraits<Kokkos::Unmanaged>>{quat_delta_data.data()};
         RotationVectorToQuaternion(delta, quat_delta);
         auto quat_prev_data = Kokkos::Array<double, 4>{
-            q_prev(i_node, 3), q_prev(i_node, 4), q_prev(i_node, 5), q_prev(i_node, 6)};
+            q_prev(i_node, 3), q_prev(i_node, 4), q_prev(i_node, 5), q_prev(i_node, 6)
+        };
         auto quat_prev =
             Kokkos::View<double[4], Kokkos::MemoryTraits<Kokkos::Unmanaged>>{quat_prev_data.data()};
         auto quat_new_data = Kokkos::Array<double, 4>{};

diff --git a/src/step/assemble_constraints_matrix.hpp b/src/step/assemble_constraints_matrix.hpp
@@ -26,7 +26,8 @@ inline void AssembleConstraintsMatrix(Solver& solver, Constraints& constraints)
             CopyConstraintsToSparseMatrix<Solver::CrsMatrixType>{
                 constraints.row_range, constraints.base_node_col_range,
                 constraints.target_node_col_range, solver.B, constraints.base_gradient_terms,
-                constraints.target_gradient_terms}
+                constraints.target_gradient_terms
+            }
         );
     }