angular_momentum.hpp cmath string_view serif/equations/contributions.hpp serif/equations/point.hpp serif/equations/rigid_rotation.hpp src/compile_time_checks/serif/model/barotropic_density.cpp src/compile_time_checks/serif/model/density_primal.cpp src/compile_time_checks/serif/model/execution_validation.cpp src/compile_time_checks/serif/model/normalization.cpp src/compile_time_checks/serif/operators/plan.cpp src/compile_time_checks/serif/solver/normalization/plan.cpp src/include/serif/equations/equations.hpp serif::equations::AngularMomentumConstraint serif serif::equations File containing the angular momentum constraint equation, which enforces a global constraint on the total angular momentum of a system. Emily M. Boudreaux The angular momentum constraint is a global constraint that is enforced by integrating the point-wise contributions of the angular momentum density over the entire domain. The integrand is given by $ j_\parallel = \rho \Omega s^2$, where $s^2 = |\hat{n} × (r − r_{c})|^2$ is the cylindrical radius squared, and $\hat{n}$ is the unit rotation axis. The solver will integrate this over the domain and compare it to the target angular momentum to enforce the constraint. A few important notes about the implementation The way the equation system plugs into the mfem backend is such that equations should only ever return point wise contributions to the residual, not a global integrated residual. This is why we return $ j_\parallel = \rho \Omega s^2$ as the residual, rather than $ j_\parallel - J_{\text{target}}$. However we still need to subtract the target angular momentum from the integrated residual to enforce the constraint. This is done by implementing the method ::residual_offset() which returns $ -J_{\text{target}}$. The backend will automatically detect and, if present, subtract this from the integrated residual to enforce the constraint. The solver can choose to validate the angular momentum constraint by integrating the ::validation_integrand() over the domain and then passing this result to ::validate_integral(double result). Note that this is not specific to this equation but a feature of the overall system #pragmaonce #include<cmath> #include<string_view> #include"serif/equations/contributions.hpp" #include"serif/equations/point.hpp" #include"serif/equations/rigid_rotation.hpp" namespaceserif::equations { classAngularMomentumConstraintfinal:publicContribution<discretization::forms::Operand<discretization::blocks::rotation::angular_velocity>> { public: usingDensity=discretization::blocks::density::mass; usingResidualQuantity=dimensions::AngularMomentum; usingAngularVelocity=discretization::blocks::rotation::angular_velocity; usingDensityValue=discretization::forms::Operand<Density>; usingAngularVelocityValue=discretization::forms::Operand<AngularVelocity>; usingOperands=utils::types::TypeList<DensityValue, AngularVelocityValue>; staticconstexprstd::string_viewname="angularmomentum"; explicitAngularMomentumConstraint( constdoubletarget_axial_angular_momentum, constRigidRotation::Vector&rotation_axis={0.0,0.0,1.0}, constRigidRotation::Vector&axis_origin={} ): m_target_axial_angular_momentum(target_axial_angular_momentum), m_unit_rotation(RigidRotation::unit_rotation(rotation_axis,axis_origin)) { usingnamespaceutils::errors; serif_ensure<SERiFErrorCode::INVALID_ARGUMENT,std::invalid_argument>(std::isfinite(target_axial_angular_momentum)&&target_axial_angular_momentum>=0.0,"Targetangularmomentummustbefiniteandnonnegative."); } [[nodiscard]]PointLinearization<Operands>evaluate(constEquationPoint<Operands>&point)const { constdoublemass_density=point.fields.get<Density>(); constdoubleangular_velocity=point.fields.get<AngularVelocity>(); //Unitrotation:s²=2Ψ₁=|n̂×(r−rₐ)|²;∇Ψ₁=λ⊥. constdoublecylindrical_radius_squared=2.0*m_unit_rotation.centrifugal_potential(point.position); //dI∥/dV=ρs²;λ⊥isthedisplacementperpendiculartotheaxis. constdoublemoment_of_inertia_density=mass_density*cylindrical_radius_squared; constautoperpendicular_displacement=m_unit_rotation.centrifugal_potential_gradient(point.position); PointLinearization<Operands>result; result.residual=angular_velocity*moment_of_inertia_density;//j∥=Ωρs². result.field_derivatives.get<Density>()=angular_velocity*cylindrical_radius_squared;//∂j∥/∂ρ=Ωs². result.field_derivatives.get<AngularVelocity>()=moment_of_inertia_density;//∂j∥/∂Ω=ρs². //∇j∥=2Ωρλ⊥,holdingρandΩfixed. for(intcomponent=0;component<3;++component) { result.position_derivative[component]=2.0*angular_velocity*mass_density*perpendicular_displacement[component]; } returnresult; } [[nodiscard]]staticintadditional_order(DensityValue,intposition_order) { return2*position_order; } [[nodiscard]]staticintadditional_order(AngularVelocityValue,intposition_order) { returnDensity::FunctionalSpace::order+2*position_order; } [[nodiscard]]doubleresidual_offset()const { return-m_target_axial_angular_momentum; } [[nodiscard]]staticdoublevalidation_integrand(constEquationPoint<Operands>&,constPointLinearization<Operands>&physics) { returnphysics.field_derivatives.get<AngularVelocity>(); } staticvoidvalidate_integral(constdoubleaxial_moment_of_inertia){ usingnamespaceutils::errors; serif_ensure<SERiFErrorCode::INVALID_ARGUMENT,std::domain_error>(std::isfinite(axial_moment_of_inertia)&&axial_moment_of_inertia>=0.0,"Themomentofinertiamustbefiniteandnonnegative."); } [[nodiscard]]constRigidRotation&rotation()constnoexcept{returnm_unit_rotation;} private: doublem_target_axial_angular_momentum; RigidRotationm_unit_rotation; }; }//namespaceserif::equations