Struct QFunction

pub struct QFunction<'a> { /* private fields */ }

Implementations

impl<'a> QFunction<'a>

pub fn create( ceed: &Ceed, vlength: usize, user_f: Box<QFunctionUserClosure>, ) -> Result<Self>

pub fn apply(&self, Q: usize, u: &[Vector<'_>], v: &[Vector<'_>]) -> Result<i32>

Apply the action of a QFunction

• Q - The number of quadrature points
• input - Array of input Vectors
• output - Array of output Vectors

let mut user_f = |[u, weights, ..]: QFunctionInputs, [v, ..]: QFunctionOutputs| {
    // Iterate over quadrature points
    v.iter_mut()
        .zip(u.iter().zip(weights.iter()))
        .for_each(|(v, (u, w))| *v = u * w);

    // Return clean error code
    0
};

let qf = ceed
    .q_function_interior(1, Box::new(user_f))?
    .input("u", 1, EvalMode::Interp)?
    .input("weights", 1, EvalMode::Weight)?
    .output("v", 1, EvalMode::Interp)?;

const Q: usize = 8;
let mut w = [0.; Q];
let mut u = [0.; Q];
let mut v = [0.; Q];

for i in 0..Q {
    let x = 2. * (i as Scalar) / ((Q as Scalar) - 1.) - 1.;
    u[i] = 2. + 3. * x + 5. * x * x;
    w[i] = 1. - x * x;
    v[i] = u[i] * w[i];
}

let uu = ceed.vector_from_slice(&u)?;
let ww = ceed.vector_from_slice(&w)?;
let mut vv = ceed.vector(Q)?;
vv.set_value(0.0);
{
    let input = vec![uu, ww];
    let mut output = vec![vv];
    qf.apply(Q, &input, &output)?;
    vv = output.remove(0);
}

vv.view()?
    .iter()
    .zip(v.iter())
    .for_each(|(computed, actual)| {
        assert_eq!(
            *computed, *actual,
            "Incorrect value in QFunction application"
        );
    });

pub fn input( self, fieldname: &str, size: usize, emode: EvalMode, ) -> Result<Self>

Add a QFunction input

• fieldname - Name of QFunction field
• size - Size of QFunction field, (ncomp * dim) for Grad or (ncomp * 1) for None, Interp, and Weight
• emode - EvalMode::None to use values directly, EvalMode::Interp to use interpolated values, EvalMode::Grad to use gradients, EvalMode::Weight to use quadrature weights

let mut user_f = |[u, weights, ..]: QFunctionInputs, [v, ..]: QFunctionOutputs| {
    // Iterate over quadrature points
    v.iter_mut()
        .zip(u.iter().zip(weights.iter()))
        .for_each(|(v, (u, w))| *v = u * w);

    // Return clean error code
    0
};

let mut qf = ceed.q_function_interior(1, Box::new(user_f))?;

qf = qf.input("u", 1, EvalMode::Interp)?;
qf = qf.input("weights", 1, EvalMode::Weight)?;

pub fn output( self, fieldname: &str, size: usize, emode: EvalMode, ) -> Result<Self>

Add a QFunction output

• fieldname - Name of QFunction field
• size - Size of QFunction field, (ncomp * dim) for Grad or (ncomp * 1) for None and Interp
• emode - EvalMode::None to use values directly, EvalMode::Interp to use interpolated values, EvalMode::Grad to use gradients

let mut user_f = |[u, weights, ..]: QFunctionInputs, [v, ..]: QFunctionOutputs| {
    // Iterate over quadrature points
    v.iter_mut()
        .zip(u.iter().zip(weights.iter()))
        .for_each(|(v, (u, w))| *v = u * w);

    // Return clean error code
    0
};

let mut qf = ceed.q_function_interior(1, Box::new(user_f))?;

qf.output("v", 1, EvalMode::Interp)?;

pub fn inputs(&self) -> Result<&[QFunctionField<'_>]>

Get a slice of QFunction inputs

let mut user_f = |[u, weights, ..]: QFunctionInputs, [v, ..]: QFunctionOutputs| {
    // Iterate over quadrature points
    v.iter_mut()
        .zip(u.iter().zip(weights.iter()))
        .for_each(|(v, (u, w))| *v = u * w);

    // Return clean error code
    0
};

let mut qf = ceed
    .q_function_interior(1, Box::new(user_f))?
    .input("u", 1, EvalMode::Interp)?
    .input("weights", 1, EvalMode::Weight)?;

let inputs = qf.inputs()?;

assert_eq!(inputs.len(), 2, "Incorrect inputs array");

pub fn outputs(&self) -> Result<&[QFunctionField<'_>]>

Get a slice of QFunction outputs

let mut user_f = |[u, weights, ..]: QFunctionInputs, [v, ..]: QFunctionOutputs| {
    // Iterate over quadrature points
    v.iter_mut()
        .zip(u.iter().zip(weights.iter()))
        .for_each(|(v, (u, w))| *v = u * w);

    // Return clean error code
    0
};

let mut qf = ceed
    .q_function_interior(1, Box::new(user_f))?
    .output("v", 1, EvalMode::Interp)?;

let outputs = qf.outputs()?;

assert_eq!(outputs.len(), 1, "Incorrect outputs array");

Trait Implementations

impl<'a> Display for QFunction<'a>

View a QFunction

let mut user_f = |[u, weights, ..]: QFunctionInputs, [v, ..]: QFunctionOutputs| {
    // Iterate over quadrature points
    v.iter_mut()
        .zip(u.iter().zip(weights.iter()))
        .for_each(|(v, (u, w))| *v = u * w);

    // Return clean error code
    0
};

let qf = ceed
    .q_function_interior(1, Box::new(user_f))?
    .input("u", 1, EvalMode::Interp)?
    .input("weights", 1, EvalMode::Weight)?
    .output("v", 1, EvalMode::Interp)?;

println!("{}", qf);

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Drop for QFunction<'a>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a> From<&'a QFunction<'_>> for QFunctionOpt<'a>

Construct a QFunctionOpt reference from a QFunction reference

fn from(qfunc: &'a QFunction<'_>) -> Self

Converts to this type from the input type.