system_selection.cpp system_data.hpp serif/backend/mfem/operators/volume_field_block.hpp algorithm limits utility serif/utils/error/errors.hpp serif/backend/mfem/discretization/basis_evaluation.hpp serif/backend/mfem/discretization/coefficient_tracking.hpp serif/backend/mfem/discretization/dof_map.hpp serif/backend/mfem/discretization/element_coordinates.hpp serif/backend/mfem/discretization/quadrature/concepts.hpp serif/backend/mfem/discretization/quadrature/configure.hpp serif/backend/mfem/discretization/quadrature/mfem_resolver.hpp serif/backend/mfem/discretization/quadrature/mfem_static_order.hpp serif/backend/mfem/discretization/quadrature/order.hpp serif/backend/mfem/discretization/reconstruction.hpp serif/backend/mfem/discretization/tensor_basis.hpp serif/backend/mfem/discretization/term_binding.hpp serif/backend/mfem/discretization/term_coefficients.hpp serif/backend/mfem/mapping/compactification/compactification.hpp serif/backend/mfem/mapping/compactification/input_result.hpp serif/backend/mfem/mapping/compactification/kelvin.hpp serif/backend/mfem/mapping/compactification/variation.hpp serif/backend/mfem/mapping/context.hpp serif/backend/mfem/mapping/data.hpp serif/backend/mfem/mapping/domain_mapper.hpp serif/backend/mfem/mapping/status.hpp serif/backend/mfem/mapping/transformations.hpp serif/backend/mfem/mapping/variation.hpp serif/backend/mfem/mapping/volume_cache.hpp serif/backend/mfem/model/system.hpp serif/backend/mfem/operators/actions.hpp serif/backend/mfem/operators/element_data.hpp serif/backend/mfem/operators/element_evaluation.hpp serif/backend/mfem/operators/element_transpose.hpp serif/backend/mfem/operators/linearized_block.hpp serif/backend/mfem/operators/operand_evaluation.hpp serif/backend/mfem/operators/quadrature.hpp serif/backend/mfem/operators/volume_application.hpp serif/backend/mfem/operators/volume_data.hpp serif/backend/mfem/operators/volume_field_block.hpp serif/backend/mfem/operators/volume_inputs.hpp serif/backend/mfem/operators/workspace.hpp serif/backend/mfem/shared/parallel.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/runtime.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/traits.hpp serif/discretization/domain/types.hpp serif/discretization/forms/concept.hpp serif/discretization/forms/form_traits.hpp serif/discretization/forms/forms.hpp serif/discretization/forms/operands.hpp serif/discretization/forms/runtime.hpp serif/discretization/forms/value.hpp serif/discretization/functional_space/space.hpp serif/discretization/quadrature/policy.hpp serif/discretization/quadrature/query.hpp serif/discretization/quadrature/rules.hpp serif/discretization/reconstruction/surface_power.hpp serif/equations/concepts.hpp serif/equations/contributions.hpp serif/equations/point.hpp serif/meta/enums.hpp serif/meta/names.hpp serif/operators/concepts.hpp serif/operators/plan.hpp serif/utils/dependencies/binding.hpp serif/utils/dependencies/dependency_context.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/format/strings.hpp serif/utils/misc/compensated_sum.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 serif/utils/user_options/mapping/compactification/kelvin.hpp serif/utils/user_options/mapping/domain_mapper.hpp system_data.hpp src/lib/serif/backend/mfem/model/system_selection.cpp algorithm array cmath compare concepts cstddef cstdint cstdio cstdlib exception expected format functional iostream limits magic_enum/magic_enum_all.hpp memory mfem/fem/doftrans.hpp mfem/fem/eltrans.hpp mfem/fem/fe/fe_base.hpp mfem/fem/fe/fe_h1.hpp mfem/fem/fe/fe_l2.hpp mfem/fem/fespace.hpp mfem/fem/geom.hpp mfem/fem/gridfunc.hpp mfem/fem/intrules.hpp mfem/fem/pfespace.hpp mfem/linalg/densemat.hpp mfem/linalg/operator.hpp mfem/linalg/sparsemat.hpp mfem/linalg/vector.hpp mfem/mesh/mesh.hpp nameof.hpp numeric optional 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 serif::model::backend::mfem::detail #include"system_data.hpp" #include"serif/backend/mfem/operators/volume_field_block.hpp" #include<algorithm> #include<limits> #include<utility> #include"serif/utils/error/errors.hpp" namespaceserif::model::backend::mfem::detail{ namespace{ structSelectedRange{ intsource; intdestination; intsize; }; structSelectedContribution{ LinearizedBlockblock; std::vector<std::pair<int,int>>rows; std::vector<SelectedRange>columns; }; structSelection{ std::shared_ptr<constSystemData>data; std::vector<SelectedContribution>contributions; introws; intcolumns; }; [[nodiscard]]intselected_size(std::span<constCoordinateRange>ranges,intextent){ intsize=0; for(constCoordinateRangerange:ranges){ validate_range(range.offset,range.size,extent); utils::errors::serif_ensure<utils::errors::SERiFErrorCode::INVALID_DOF_COUNT>(range.size<=std::numeric_limits<int>::max()-size, "SelectedmodelcoordinatesexceedMFEM'sintegerindexrange.Selectfewerequationorstatecoordinates."); size+=range.size; } returnsize; } [[nodiscard]]std::vector<SelectedRange>selected_ranges(std::span<constCoordinateRange>ranges,intsource_offset,intsize){ std::vector<SelectedRange>result; intdestination=0; for(constCoordinateRangerange:ranges){ constintfirst=std::max(source_offset,range.offset); constintend=std::min(source_offset+size,range.offset+range.size); if(first<end){ result.push_back({first-source_offset,destination+first-range.offset,end-first}); } destination+=range.size; } returnresult; } voidadd_selection(Selection&selection,LinearizedBlockblock,intsource_column,std::span<constCoordinateRange>columns,std::vector<std::pair<int,int>>rows){ autoselected_columns=selected_ranges(columns,source_column,block.action()->Width()); if(!rows.empty()&&!selected_columns.empty()){ selection.contributions.push_back({std::move(block),std::move(rows),std::move(selected_columns)}); } } [[nodiscard]]std::shared_ptr<constSelection>make_selection(std::shared_ptr<constSystemData>data,std::span<constCoordinateRange>rows,std::span<constCoordinateRange>columns,boolcomplete_action){ autoselection=std::make_shared<Selection>(Selection{data,{},selected_size(rows,data->rows),selected_size(columns,data->columns)}); constauto&contributions=complete_action&&selection->data->complete_actions?*selection->data->complete_actions:selection->data->jacobian; for(constauto&contribution:contributions){ std::vector<std::pair<int,int>>selected_rows; for(constSelectedRangerange:selected_ranges(rows,contribution.row_offset,contribution.block.action()->Height())){ for(intindex=0;index<range.size;++index){ if(!selection->data->replaced_rows[contribution.row_offset+range.source+index]){ selected_rows.emplace_back(range.source+index,range.destination+index); } } } add_selection(*selection,contribution.block,contribution.column_offset,columns,std::move(selected_rows)); } for(constauto&replacement:selection->data->replacements){ std::vector<std::pair<int,int>>selected_rows; intdestination=0; for(constCoordinateRangerange:rows){ for(std::size_tindex=0;index<replacement.selected_rows.size();++index){ constintrow=replacement.selected_rows[index]; if(row>=range.offset&&row<range.offset+range.size){ selected_rows.emplace_back(static_cast<int>(index),destination+row-range.offset); } } destination+=range.size; } for(constauto&contribution:replacement.jacobian){ add_selection(*selection,contribution.block,contribution.column_offset,columns,selected_rows); } } returnselection; } voidapply_selection(constSelection&selection,const::mfem::Vector&input,::mfem::Vector&output,booltranspose,::mfem::Vector&direction,::mfem::Vector&result){ for(constauto&contribution:selection.contributions){ constauto&action=contribution.block.action(); direction.SetSize(transpose?action->Height():action->Width()); result.SetSize(transpose?action->Width():action->Height()); direction=0.0; result=0.0; if(transpose){ for(constauto[source,destination]:contribution.rows){ direction[source]+=input[destination]; } action->MultTranspose(direction,result); utils::errors::serif_ensure<utils::errors::SERiFErrorCode::MATRIX_SHAPE_ERROR>(result.Size()==action->Width(),"Aselectedmodeltransposechangeditsdeclaredoutputsize."); for(constSelectedRangerange:contribution.columns){ for(intindex=0;index<range.size;++index){ output[range.destination+index]+=result[range.source+index]; } } } else{ for(constSelectedRangerange:contribution.columns){ for(intindex=0;index<range.size;++index){ direction[range.source+index]+=input[range.destination+index]; } } action->Mult(direction,result); utils::errors::serif_ensure<utils::errors::SERiFErrorCode::MATRIX_SHAPE_ERROR>(result.Size()==action->Height(),"Aselectedmodelactionchangeditsdeclaredoutputsize."); for(constauto[source,destination]:contribution.rows){ output[destination]+=result[source]; } } } } voidapply_selection_many(constSelection&selection,std::span<const::mfem::Vector*const>inputs,std::span<::mfem::Vector*const>outputs,std::vector<::mfem::Vector>&directions,std::vector<::mfem::Vector>&results){ directions.resize(inputs.size()); results.resize(inputs.size()); std::vector<const::mfem::Vector*>active_directions; std::vector<::mfem::Vector*>active_results; std::vector<std::size_t>active; for(constauto&contribution:selection.contributions){ constauto&action=contribution.block.action(); active.clear(); active_directions.clear(); active_results.clear(); for(std::size_tk=0;k<inputs.size();++k){ auto&direction=directions[k]; direction.SetSize(action->Width()); direction=0.0; boolnonzero=false; for(constSelectedRangerange:contribution.columns){ for(intindex=0;index<range.size;++index){ direction[range.source+index]+=(*inputs[k])[range.destination+index]; nonzero=nonzero||direction[range.source+index]!=0.0; } } if(nonzero){ results[k].SetSize(action->Height()); results[k]=0.0; active.push_back(k); active_directions.push_back(&direction); active_results.push_back(&results[k]); } } if(active.empty()){ continue; } operators::backend::mfem::apply_many(*action,active_directions,active_results); for(conststd::size_tk:active){ utils::errors::serif_ensure<utils::errors::SERiFErrorCode::MATRIX_SHAPE_ERROR>(results[k].Size()==action->Height(),"Aselectedmodelactionchangeditsdeclaredoutputsize."); for(constauto[source,destination]:contribution.rows){ (*outputs[k])[destination]+=results[k][source]; } } } } [[nodiscard]]std::shared_ptr<const::mfem::SparseMatrix>assemble_selection(constSelection&selection){ std::vector<std::shared_ptr<const::mfem::SparseMatrix>>matrices; matrices.reserve(selection.contributions.size()); for(constauto&contribution:selection.contributions){matrices.push_back(checked_assembly(contribution.block));} //Destinationrow->(contribution,sourcerow)ininsertionorder. std::vector<int>offsets(static_cast<std::size_t>(selection.rows)+1,0); for(constauto&contribution:selection.contributions){ for(constauto[source,destination]:contribution.rows){++offsets[static_cast<std::size_t>(destination)+1];} } for(introw=0;row<selection.rows;++row){offsets[row+1]+=offsets[row];} std::vector<std::pair<int,int>>incidence(static_cast<std::size_t>(offsets.back())); { std::vector<int>cursor(offsets.begin(),offsets.end()-1); for(intindex=0;index<static_cast<int>(selection.contributions.size());++index){ for(constauto[source,destination]:selection.contributions[static_cast<std::size_t>(index)].rows){ incidence[static_cast<std::size_t>(cursor[static_cast<std::size_t>(destination)]++)]={index,source}; } } } structRowScratch{ std::vector<int>slot_of_column; std::vector<int>columns; std::vector<double>values; }; std::vector<std::vector<int>>row_columns(static_cast<std::size_t>(selection.rows)); std::vector<std::vector<double>>row_values(static_cast<std::size_t>(selection.rows)); std::vector<RowScratch>scratch(static_cast<std::size_t>(utils::parallel::worker_count())); utils::parallel::for_each_index(selection.rows,[&](constintrow,constintworker){ RowScratch&local=scratch[static_cast<std::size_t>(worker)]; local.slot_of_column.resize(static_cast<std::size_t>(selection.columns),-1); local.columns.clear(); local.values.clear(); for(intentry=offsets[row];entry<offsets[row+1];++entry){ constauto[index,source]=incidence[static_cast<std::size_t>(entry)]; constauto&matrix=*matrices[static_cast<std::size_t>(index)]; constauto&ranges=selection.contributions[static_cast<std::size_t>(index)].columns; constint*columns=matrix.GetRowColumns(source); constdouble*values=matrix.GetRowEntries(source); for(intk=0;k<matrix.RowSize(source);++k){ for(constSelectedRangerange:ranges){ constintcolumn=columns[k]-range.source; if(column>=0&&column<range.size){ int&slot=local.slot_of_column[static_cast<std::size_t>(range.destination+column)]; if(slot<0){ slot=static_cast<int>(local.columns.size()); local.columns.push_back(range.destination+column); local.values.push_back(0.0); } local.values[static_cast<std::size_t>(slot)]+=values[k]; } } } } auto&columns=row_columns[static_cast<std::size_t>(row)]; auto&values=row_values[static_cast<std::size_t>(row)]; for(std::size_tslot=local.columns.size();slot-->0;){ local.slot_of_column[static_cast<std::size_t>(local.columns[slot])]=-1; if(local.values[slot]==0.0){continue;} columns.push_back(local.columns[slot]); values.push_back(local.values[slot]); } }); returnoperators::backend::mfem::detail::make_csr(row_columns,row_values,selection.rows,selection.columns); } [[nodiscard]]intdiagonal_column(constSelectedContribution&contribution,introw){ for(constSelectedRangerange:contribution.columns){ if(row>=range.destination&&row<range.destination+range.size){ returnrange.source+row-range.destination; } } return-1; } [[nodiscard]]booluses_child_diagonal(constSelectedContribution&contribution){ for(constauto[source,destination]:contribution.rows){ constintcolumn=diagonal_column(contribution,destination); if(column>=0&&source!=column){ returnfalse; } } returncontribution.block.action()->Height()==contribution.block.action()->Width()&&contribution.block.has_diagonal(); } [[nodiscard]]std::vector<double>selection_diagonal(constSelection&selection){ std::vector<double>result(selection.rows,0.0); for(constauto&contribution:selection.contributions){ if(uses_child_diagonal(contribution)){ constautodiagonal=checked_diagonal(contribution.block); for(constauto[source,destination]:contribution.rows){ if(diagonal_column(contribution,destination)>=0){ result[destination]+=diagonal[source]; } } } else{ constautomatrix=checked_assembly(contribution.block); for(constauto[source,destination]:contribution.rows){ constintcolumn=diagonal_column(contribution,destination); if(column>=0){ for(intindex=0;index<matrix->RowSize(source);++index){ if(matrix->GetRowColumns(source)[index]==column){ result[destination]+=matrix->GetRowEntries(source)[index]; } } } } } } returnresult; } }//namespace LinearizedBlockselect_block(std::shared_ptr<constSystemData>data,std::span<constCoordinateRange>rows,std::span<constCoordinateRange>columns,boolcomplete_action){ constautoselection=make_selection(data,rows,columns,complete_action); constautometadata=complete_action&&data->complete_actions?make_selection(std::move(data),rows,columns,false):selection; constautoaction=operators::backend::mfem::linearized_action(selection->rows,selection->columns,[selection,direction=::mfem::Vector{},result=::mfem::Vector{}](constauto&input,auto&output)mutable{ apply_selection(*selection,input,output,false,direction,result); },[selection,direction=::mfem::Vector{},result=::mfem::Vector{}](constauto&input,auto&output)mutable{ apply_selection(*selection,input,output,true,direction,result); },[selection,directions=std::vector<::mfem::Vector>{},results=std::vector<::mfem::Vector>{}](std::span<const::mfem::Vector*const>inputs,std::span<::mfem::Vector*const>outputs)mutable{ apply_selection_many(*selection,inputs,outputs,directions,results); directions={}; results={}; }); LinearizedBlock::Diagonaldiagonal; LinearizedBlock::Assemblyassembly; if(selection->rows==selection->columns&&std::ranges::all_of(metadata->contributions,[](constauto&entry){ returnuses_child_diagonal(entry)||entry.block.has_assembly(); })){ diagonal=[metadata](){ returnselection_diagonal(*metadata); }; } if(std::ranges::all_of(metadata->contributions,[](constauto&entry){ returnentry.block.has_assembly(); })){ assembly=[metadata](){ returnassemble_selection(*metadata); }; } returnLinearizedBlock(action.action(),std::move(diagonal),std::move(assembly)); } }//namespaceserif::model::backend::mfem::detail