surface_potential.cpp serif/backend/mfem/model/surface_potential.hpp cmath algorithm array limits memory vector mfem/fem/intrules.hpp serif/backend/mfem/shared/boundary_elements.hpp serif/backend/mfem/shared/parallel.hpp serif/backend/mfem/geometry/deformation/reference_geometry.hpp serif/backend/mfem/discretization/dof_map.hpp serif/backend/mfem/discretization/reconstruction.hpp serif/backend/mfem/geometry/deformation/inputs.hpp serif/backend/mfem/geometry/deformation/reference_geometry.hpp serif/backend/mfem/model/surface_potential.hpp serif/backend/mfem/shared/boundary_elements.hpp serif/backend/mfem/shared/parallel.hpp serif/backend/mfem/shared/reference_tracking.hpp serif/dimensions/dimensions.hpp serif/dimensions/quantities.hpp serif/discretization/blocks/base.hpp serif/discretization/blocks/concepts.hpp serif/discretization/blocks/fields.hpp serif/discretization/blocks/traits.hpp serif/discretization/domain/concepts.hpp serif/discretization/domain/ids/boundary.hpp serif/discretization/domain/ids/concepts.hpp serif/discretization/domain/ids/domain.hpp serif/discretization/domain/ids/lists/concepts.hpp serif/discretization/domain/ids/lists/lists.hpp serif/discretization/domain/ids/lists/traits.hpp serif/discretization/domain/ids/validation/concepts.hpp serif/discretization/domain/ids/validation/unique_ids.hpp serif/discretization/domain/physical_domains.hpp serif/discretization/domain/relation/concepts.hpp serif/discretization/domain/relation/lists/concepts.hpp serif/discretization/domain/relation/lists/relation_list.hpp serif/discretization/domain/relation/lists/traits.hpp serif/discretization/domain/relation/relations.hpp serif/discretization/domain/relation/validation/concepts.hpp serif/discretization/domain/relation/validation/validation.hpp serif/discretization/domain/resolver.hpp serif/discretization/domain/schema/concepts.hpp serif/discretization/domain/schema/domain_schema.hpp serif/discretization/domain/schema/schemas.hpp serif/discretization/domain/schema/traits.hpp serif/discretization/domain/types.hpp serif/discretization/forms/operands.hpp serif/discretization/forms/value.hpp serif/discretization/functional_space/space.hpp serif/discretization/reconstruction/surface_power.hpp serif/equations/companion.hpp serif/equations/point.hpp serif/equations/rigid_rotation.hpp serif/equations/surface_potential.hpp serif/geometry/deformation/actions.hpp serif/geometry/deformation/composition.hpp serif/geometry/deformation/computations.hpp serif/geometry/deformation/detail/action_storage.hpp serif/geometry/deformation/failure.hpp serif/geometry/deformation/linearization.hpp serif/geometry/deformation/models.hpp serif/geometry/deformation/reference_surface.hpp serif/geometry/deformation/spaces.hpp serif/geometry/deformation/surface_embedding.hpp serif/geometry/deformation/workspace.hpp serif/meta/enums.hpp serif/meta/names.hpp serif/utils/dependencies/binding.hpp serif/utils/dependencies/computation.hpp serif/utils/dependencies/computation_graph.hpp serif/utils/dependencies/dependency_context.hpp serif/utils/dependencies/detail/graph.hpp serif/utils/dependencies/detail/type_lists.hpp serif/utils/dependencies/key_list.hpp serif/utils/dependencies/key_list_operations.hpp serif/utils/dependencies/resource.hpp serif/utils/dependencies/snapshot.hpp serif/utils/error/codes.hpp serif/utils/error/errors.hpp serif/utils/error/nonfinite.hpp serif/utils/misc/concepts/concat.hpp serif/utils/misc/concepts/exceptions.hpp serif/utils/misc/concepts/numeric.hpp serif/utils/misc/concepts/type_uniqueness.hpp serif/utils/misc/std_helper/cleaning.hpp serif/utils/misc/std_helper/variadic_cleaning.hpp serif/utils/misc/terminal/colors.hpp serif/utils/misc/traits/type_uniqueness.hpp serif/utils/types/strings.hpp serif/utils/types/type_list.hpp src/lib/serif/backend/mfem/model/surface_potential.cpp algorithm array cmath compare concepts cstddef cstdint cstdio cstdlib exception expected format functional initializer_list iostream limits magic_enum/magic_enum_all.hpp memory mfem/fem/fe/fe_base.hpp mfem/fem/fespace.hpp mfem/fem/intrules.hpp mfem/fem/pfespace.hpp mfem/linalg/densemat.hpp mfem/linalg/sparsemat.hpp nameof.hpp numeric optional ranges span stdexcept string string_view tuple type_traits unistd.h unordered_map utility vector version serif serif::model serif::model::backend serif::model::backend::mfem #include"serif/backend/mfem/model/surface_potential.hpp" #include<cmath> #include<algorithm> #include<array> #include<limits> #include<memory> #include<vector> #include"mfem/fem/intrules.hpp" #include"serif/backend/mfem/shared/boundary_elements.hpp" #include"serif/backend/mfem/shared/parallel.hpp" #include"serif/backend/mfem/geometry/deformation/reference_geometry.hpp" namespaceserif::model::backend::mfem{ namespace{ classOrderedAccumulator{ public: OrderedAccumulator(constintheight,constintwidth): m_height(height),m_width(width),m_values(static_cast<std::size_t>(height)*static_cast<std::size_t>(width),0.0), m_present(m_values.size(),0),m_order(static_cast<std::size_t>(height)){} voidadd(constintrow,constintcolumn,constdoublevalue){ conststd::size_tentry=static_cast<std::size_t>(row)*static_cast<std::size_t>(m_width)+static_cast<std::size_t>(column); if(m_present[entry]==0){ m_present[entry]=1; m_order[static_cast<std::size_t>(row)].push_back(column); } m_values[entry]+=value; } [[nodiscard]]std::shared_ptr<::mfem::SparseMatrix>finalize()const{ int*I=newint[static_cast<std::size_t>(m_height)+1]; I[0]=0; for(introw=0;row<m_height;++row){ intkept=0; for(constintcolumn:m_order[static_cast<std::size_t>(row)]){kept+=value(row,column)!=0.0;} I[row+1]=I[row]+kept; } int*J=newint[static_cast<std::size_t>(I[m_height])]; double*A=newdouble[static_cast<std::size_t>(I[m_height])]; boolsorted=true; for(introw=0,next=0;row<m_height;++row){ intlast_column=-1; constauto&order=m_order[static_cast<std::size_t>(row)]; for(autocolumn=order.rbegin();column!=order.rend();++column){ if(value(row,*column)==0.0){continue;} J[next]=*column; A[next]=value(row,*column); if(last_column>*column){sorted=false;} last_column=*column; ++next; } } returnstd::make_shared<::mfem::SparseMatrix>(I,J,A,m_height,m_width,true,true,sorted); } private: [[nodiscard]]doublevalue(constintrow,constintcolumn)const{ returnm_values[static_cast<std::size_t>(row)*static_cast<std::size_t>(m_width)+static_cast<std::size_t>(column)]; } intm_height; intm_width; std::vector<double>m_values; std::vector<unsignedchar>m_present; std::vector<std::vector<int>>m_order; }; } SurfacePotentialLinearizationassemble_surface_potential( constequations::SurfacePotentialBalance&equation, constgeometry::deformation::backend::mfem::SurfaceDiscretization&discretization, constgeometry::deformation::ReferenceSurface&reference, constgeometry::deformation::SurfaceEmbedding&embedding, conststd::span<constdouble>displacement, constdiscretization::backend::mfem::DofMap&potential_binding, const::mfem::Vector&potential,constdoublelevel,constdoubleangular_velocity){ usingnamespaceutils::errors; namespacedeformation=geometry::deformation::backend::mfem; namespaceboundary=::serif::backend::mfem::shared; usingEquation=equations::SurfacePotentialBalance; potential_binding.validate(); constautotrace_status=deformation::validate_surface_trace(discretization.scalar_space, discretization.surface_attribute,reference,embedding); serif_ensure<SERiFErrorCode::INVALID_ARGUMENT>(trace_status.has_value(), "Surfacepotentialassemblyrequiresacompatiblereferencesurfaceandradialembedding:{}", trace_status?"":trace_status.error().message); serif_ensure<SERiFErrorCode::INVALID_DOF_COUNT>(embedding.input_size()<=static_cast<std::size_t>(std::numeric_limits<int>::max())&& displacement.size()==embedding.output_size()&&potential.Size()==potential_binding.size(), "Surfacepotentialassemblyreceivedincompatiblecoefficientcounts."); serif_ensure<SERiFErrorCode::CACHE_FE_BINDING_ERROR>(potential_binding.space().GetMesh()==discretization.scalar_space.GetMesh()&& potential_binding.space().GetVDim()==1, "Surfacepotentialandreferencegeometrymustusescalartracesonthesamemesh."); serif_ensure<SERiFErrorCode::NON_FINITE_VALUE_ERROR>(std::isfinite(level)&&std::isfinite(angular_velocity), "Surfacepotentiallevelandangularvelocitymustbefinite."); constintcount=static_cast<int>(embedding.input_size()); SurfacePotentialLinearizationresult{ .residual=std::vector<double>(count,0.0), .potential=nullptr, .shape=nullptr, .level=std::make_shared<::mfem::DenseMatrix>(count,1), .angular_velocity=std::make_shared<::mfem::DenseMatrix>(count,1)}; *result.level=0.0; *result.angular_velocity=0.0; OrderedAccumulatorpotential_matrix(count,potential_binding.size()),shape_matrix(count,count); doublereference_area=0.0; constautostatus=boundary::for_each_boundary_element(discretization.scalar_space, discretization.surface_attribute,reference.scalar_dofs, [&](constboundary::BoundaryElement&element)->boundary::BoundaryStatus{ //MFEMidentifiesaboundarytransformationbyitsboundary-elementindex. constintboundary_index=element.transformation.ElementNo; constauto&potential_element=*potential_binding.space().GetBE(boundary_index); ::mfem::Array<int>potential_dofs; if(potential_binding.space().GetBdrElementDofs(boundary_index,potential_dofs)!=nullptr|| potential_dofs.Size()!=potential_element.GetDof()){ returnstd::unexpected(boundary::BoundaryFailure{.message="Potentialsurfaceassemblyrequiresacanonicalscalarnodaltrace."}); } constintorder=3*element.finite_element.GetOrder()+potential_element.GetOrder()+element.transformation.OrderW(); constauto&rule=::mfem::IntRules.Get(element.finite_element.GetGeomType(),order); //Nodalshapefunctionsarelocal.Harmonicmodeshaveglobalsupport. std::vector<int>parameters; if(embedding.has_nodal_parameters()){ parameters.assign(element.selected_nodes.begin(),element.selected_nodes.end()); }else{ for(intparameter=0;parameter<count;++parameter){parameters.push_back(parameter);} } constintactive=static_cast<int>(parameters.size()); constintpoints=rule.GetNPoints(); constintgeometry_count=element.finite_element.GetDof(),potential_count=potential_element.GetDof(); constboolnodal_parameters=embedding.has_nodal_parameters(); constautonodal_basis=embedding.nodal_basis(); constautoradial_directions=embedding.radial_directions(); //1.Theboundarytransformationissharedstate,soitssamplesaretakenserially. std::vector<double>weights(static_cast<std::size_t>(points)); std::vector<double>geometry_shapes(static_cast<std::size_t>(points*geometry_count)); std::vector<double>potential_shapes(static_cast<std::size_t>(points*potential_count)); std::vector<double>positions(static_cast<std::size_t>(points*3)); { ::mfem::Vectorgeometry_shape(geometry_count),potential_shape(potential_count),position(3); for(intquadrature=0;quadrature<points;++quadrature){ constauto&point=rule.IntPoint(quadrature); element.transformation.SetIntPoint(&point); weights[static_cast<std::size_t>(quadrature)]=point.weight*element.transformation.Weight(); element.finite_element.CalcShape(point,geometry_shape); potential_element.CalcShape(point,potential_shape); element.transformation.Transform(point,position); std::copy_n(geometry_shape.GetData(),geometry_count,geometry_shapes.begin()+quadrature*geometry_count); std::copy_n(potential_shape.GetData(),potential_count,potential_shapes.begin()+quadrature*potential_count); std::copy_n(position.GetData(),3,positions.begin()+quadrature*3); } } //2.Eachpoint'stestfunctions,surfacemotionsandbalance,independently. structPointBalance{ doubleresidual,level,angular_velocity,potential; std::array<double,3>position_derivative; }; std::vector<double>tests(static_cast<std::size_t>(points)*static_cast<std::size_t>(active)); std::vector<discretization::forms::VectorValue>motions(static_cast<std::size_t>(points)*static_cast<std::size_t>(active)); std::vector<PointBalance>balances(static_cast<std::size_t>(points)); utils::parallel::for_each_index(points,[&](constintquadrature,int){ constdouble*geometry_shape=geometry_shapes.data()+quadrature*geometry_count; constdouble*potential_shape=potential_shapes.data()+quadrature*potential_count; double*test=tests.data()+static_cast<std::size_t>(quadrature)*static_cast<std::size_t>(active); auto*motion=motions.data()+static_cast<std::size_t>(quadrature)*static_cast<std::size_t>(active); equations::EquationPoint<Equation::Operands>physical; for(intaxis=0;axis<3;++axis){physical.position[axis]=positions[static_cast<std::size_t>(quadrature*3+axis)];} for(intlocal=0;local<geometry_count;++local){ constintnode=element.selected_nodes[local]; constdoublevalue=geometry_shape[local]*(element.encoded_dofs[local]<0?-1.0:1.0); for(intaxis=0;axis<3;++axis){physical.position[axis]+=value*displacement[3*node+axis];} for(intparameter=0;parameter<active;++parameter){ doublebasis=0.0; if(nodal_parameters){ basis=parameters[parameter]==node?1.0:0.0; }else{ basis=nodal_basis[static_cast<std::size_t>(node)*count+parameters[parameter]]; } test[parameter]+=value*basis; for(intaxis=0;axis<3;++axis){ motion[parameter][axis]+=value*basis*radial_directions[node][axis]; } } } for(intlocal=0;local<potential_count;++local){ constdoublevalue=potential_shape[local]*(potential_dofs[local]<0?-1.0:1.0); boolsupported=false; potential_binding.for_each_coefficient(::mfem::FiniteElementSpace::DecodeDof(potential_dofs[local]),[&](constintindex,constdoubleweight){ supported=true; physical.fields.get<Equation::Potential>()+=value*weight*potential[index]; }); serif_ensure<SERiFErrorCode::INVALID_DOF_COUNT>(supported,"Apotentialtracenodehasnosupportedcoefficient."); } physical.fields.get<Equation::SurfaceLevel>()=level; physical.fields.get<Equation::AngularVelocity>()=angular_velocity; constautobalance=equation.evaluate(physical); constdoubleweight=weights[static_cast<std::size_t>(quadrature)]; serif_ensure<SERiFErrorCode::NON_FINITE_VALUE_ERROR>(std::isfinite(weight)&&weight>0.0&&std::isfinite(balance.residual), "Surfacepotentialintegrationrequiresfinitegeometryandfields."); balances[static_cast<std::size_t>(quadrature)]={balance.residual,balance.field_derivatives.get<Equation::SurfaceLevel>(), balance.field_derivatives.get<Equation::AngularVelocity>(),balance.field_derivatives.get<Equation::Potential>(), {balance.position_derivative[0],balance.position_derivative[1],balance.position_derivative[2]}}; }); for(constdoubleweight:weights){reference_area+=weight;} //3.Accumulatebyrow:eachrowstillsumsitspointsinorder,soeveryvalueandinsertionorderisunchanged. utils::parallel::for_each_index(active,[&](constintrow,int){ constinttarget=parameters[row]; for(intquadrature=0;quadrature<points;++quadrature){ constauto&balance=balances[static_cast<std::size_t>(quadrature)]; constdouble*potential_shape=potential_shapes.data()+quadrature*potential_count; constauto*motion=motions.data()+static_cast<std::size_t>(quadrature)*static_cast<std::size_t>(active); constdoubletested_weight=weights[static_cast<std::size_t>(quadrature)]* tests[static_cast<std::size_t>(quadrature)*static_cast<std::size_t>(active)+static_cast<std::size_t>(row)]; result.residual[target]+=tested_weight*balance.residual; (*result.level)(target,0)+=tested_weight*balance.level; (*result.angular_velocity)(target,0)+=tested_weight*balance.angular_velocity; for(intcolumn=0;column<active;++column){ doublederivative=0.0; for(intaxis=0;axis<3;++axis){ derivative+=tested_weight*balance.position_derivative[axis]*motion[column][axis]; } if(derivative!=0.0){shape_matrix.add(target,parameters[column],derivative);} } for(intlocal=0;local<potential_count;++local){ potential_binding.for_each_coefficient(::mfem::FiniteElementSpace::DecodeDof(potential_dofs[local]),[&](constintindex,constdoubleweight){ //Aseparatestatementkeepstheproductunfused,aswhenitwaspassedtoSparseMatrix::Add. constdoublecontribution=tested_weight*balance.potential* potential_shape[local]*(potential_dofs[local]<0?-1.0:1.0)*weight; potential_matrix.add(target,index,contribution); }); } } }); return{}; }); serif_ensure<SERiFErrorCode::INVALID_ARGUMENT>(status.has_value(), "Surfacepotentialintegrationrejectedboundaryelement{}:{}", status?-1:status.error().element,status?"":status.error().message); serif_ensure<SERiFErrorCode::INVALID_ARGUMENT>(std::isfinite(reference_area)&&reference_area>0.0, "Surfacepotentialintegrationrequiresanonemptysurfaceofpositivefinitereferencearea."); result.potential=potential_matrix.finalize(); result.shape=shape_matrix.finalize(); *result.potential*=1.0/reference_area; *result.shape*=1.0/reference_area; *result.level*=1.0/reference_area; *result.angular_velocity*=1.0/reference_area; for(double&value:result.residual){value/=reference_area;} returnresult; } }