#include <ERF_SBMConstraintGroups.H>

Collaboration diagram for erf_sbm::ConstraintGroup:

[legend]

Public Member Functions
bool	contains (const int component) const noexcept

amrex::Real	evaluate (const LinearConstraint &constraint, const std::vector< amrex::Real > &state) const

bool	admissible (const std::vector< amrex::Real > &state, amrex::Real minimum_margin=nullptr, std::string failed_constraint=nullptr) const

Public Attributes
int	population_id {0}

int	bin {0}

std::string	semantic_id

MomentMode	moment_mode {MomentMode::OneMoment}

std::vector< int >	members

std::vector< int >	transport_members

std::vector< int >	attached_property_indices

std::vector< LinearConstraint >	constraints

Detailed Description

Complete atomic constraint group over one population bin.

Member Function Documentation

◆ admissible()

bool erf_sbm::ConstraintGroup::admissible	(	const std::vector< amrex::Real > &	state,
		amrex::Real *	minimum_margin = `nullptr`,
		std::string *	failed_constraint = `nullptr`
	)		const

 {
     amrex::Real minimum = std::numeric_limits<amrex::Real>::infinity();
     for (const auto& constraint : constraints) {
         const amrex::Real value = evaluate(constraint, state);
         if (!finite(value)) {
             if (failed_constraint) *failed_constraint = constraint.semantic_id;
             if (minimum_margin) *minimum_margin = value;
             return false;
         }
         minimum = std::min(minimum, value);
         const amrex::Real scale = [&]() {
             amrex::Real s = amrex::Real(0.0);
             for (const auto& term : constraint.terms) {
                 if (term.component >= 0 && term.component < static_cast<int>(state.size())) {
                     s += std::abs(term.coefficient * state[static_cast<std::size_t>(term.component)]);
                 }
             }
             return s;
         }();
         const amrex::Real tolerance = amrex::Real(128.0) *
             std::numeric_limits<amrex::Real>::epsilon() * scale;
         if (value < -tolerance) {
             if (failed_constraint) *failed_constraint = constraint.semantic_id;
             if (minimum_margin) *minimum_margin = value;
             return false;
         }
     }
     if (minimum_margin) *minimum_margin = minimum;
     return true;
 }

Here is the call graph for this function:

◆ contains()

bool erf_sbm::ConstraintGroup::contains ( const int component ) const

noexcept

 {
     for (const int member : members) if (member == component) return true;
     return false;
 }

◆ evaluate()

amrex::Real erf_sbm::ConstraintGroup::evaluate	(	const LinearConstraint &	constraint,
		const std::vector< amrex::Real > &	state
	)		const

 {
     amrex::Real result = amrex::Real(0.0);
     for (const auto& term : constraint.terms) {
         if (term.component < 0 || term.component >= static_cast<int>(state.size())) {
             throw std::out_of_range("constraint references an unavailable component");
         }
         result = std::fma(term.coefficient, state[static_cast<std::size_t>(term.component)], result);
     }
     return result;
 }