Struct libceed::elem_restriction::ElemRestriction

pub struct ElemRestriction<'a> { /* fields omitted */ }

Implementations

impl<'a> ElemRestriction<'a>

pub fn create(
    ceed: &'a Ceed,
    nelem: usize,
    elemsize: usize,
    ncomp: usize,
    compstride: usize,
    lsize: usize,
    mtype: MemType,
    offsets: &[i32]
) -> Result<Self, CeedError>

pub fn create_strided(
    ceed: &'a Ceed,
    nelem: usize,
    elemsize: usize,
    ncomp: usize,
    lsize: usize,
    strides: [i32; 3]
) -> Result<Self, CeedError>

pub fn create_lvector(&self) -> Result<Vector<'_>, CeedError>

Create an Lvector for an ElemRestriction

let nelem = 3;
let mut ind: Vec<i32> = vec![0; 2 * nelem];
for i in 0..nelem {
    ind[2 * i + 0] = i as i32;
    ind[2 * i + 1] = (i + 1) as i32;
}
let r = ceed
    .elem_restriction(nelem, 2, 1, 1, nelem + 1, MemType::Host, &ind)
    .unwrap();

let lvector = r.create_lvector().unwrap();

assert_eq!(lvector.length(), nelem + 1, "Incorrect Lvector size");

pub fn create_evector(&self) -> Result<Vector<'_>, CeedError>

Create an Evector for an ElemRestriction

let nelem = 3;
let mut ind: Vec<i32> = vec![0; 2 * nelem];
for i in 0..nelem {
    ind[2 * i + 0] = i as i32;
    ind[2 * i + 1] = (i + 1) as i32;
}
let r = ceed
    .elem_restriction(nelem, 2, 1, 1, nelem + 1, MemType::Host, &ind)
    .unwrap();

let evector = r.create_evector().unwrap();

assert_eq!(evector.length(), nelem * 2, "Incorrect Evector size");

pub fn create_vectors(&self) -> Result<(Vector<'_>, Vector<'_>), CeedError>

Create Vectors for an ElemRestriction

let nelem = 3;
let mut ind: Vec<i32> = vec![0; 2 * nelem];
for i in 0..nelem {
    ind[2 * i + 0] = i as i32;
    ind[2 * i + 1] = (i + 1) as i32;
}
let r = ceed
    .elem_restriction(nelem, 2, 1, 1, nelem + 1, MemType::Host, &ind)
    .unwrap();

let (lvector, evector) = r.create_vectors().unwrap();

assert_eq!(lvector.length(), nelem + 1, "Incorrect Lvector size");
assert_eq!(evector.length(), nelem * 2, "Incorrect Evector size");

pub fn apply(
    &self,
    tmode: TransposeMode,
    u: &Vector<'_>,
    ru: &mut Vector<'_>
) -> Result<i32, CeedError>

Restrict an Lvector to an Evector or apply its transpose

arguments

• tmode - Apply restriction or transpose
• u - Input vector (of size lsize when TransposeMode::NoTranspose)
• ru - Output vector (of shape [nelem * elemsize] when TransposeMode::NoTranspose). Ordering of the Evector is decided by the backend.

let nelem = 3;
let mut ind: Vec<i32> = vec![0; 2 * nelem];
for i in 0..nelem {
    ind[2 * i + 0] = i as i32;
    ind[2 * i + 1] = (i + 1) as i32;
}
let r = ceed
    .elem_restriction(nelem, 2, 1, 1, nelem + 1, MemType::Host, &ind)
    .unwrap();

let x = ceed.vector_from_slice(&[0., 1., 2., 3.]).unwrap();
let mut y = ceed.vector(nelem * 2).unwrap();
y.set_value(0.0);

r.apply(TransposeMode::NoTranspose, &x, &mut y).unwrap();

y.view().iter().enumerate().for_each(|(i, arr)| {
    assert_eq!(
        *arr,
        ((i + 1) / 2) as f64,
        "Incorrect value in restricted vector"
    );
});

pub fn comp_stride(&self) -> usize

Returns the Lvector component stride

let nelem = 3;
let compstride = 1;
let mut ind: Vec<i32> = vec![0; 2 * nelem];
for i in 0..nelem {
    ind[2 * i + 0] = i as i32;
    ind[2 * i + 1] = (i + 1) as i32;
}
let r = ceed
    .elem_restriction(nelem, 2, 1, compstride, nelem + 1, MemType::Host, &ind)
    .unwrap();

let c = r.comp_stride();
assert_eq!(c, compstride, "Incorrect component stride");

pub fn num_elements(&self) -> usize

Returns the total number of elements in the range of a ElemRestriction

let nelem = 3;
let mut ind: Vec<i32> = vec![0; 2 * nelem];
for i in 0..nelem {
    ind[2 * i + 0] = i as i32;
    ind[2 * i + 1] = (i + 1) as i32;
}
let r = ceed
    .elem_restriction(nelem, 2, 1, 1, nelem + 1, MemType::Host, &ind)
    .unwrap();

let n = r.num_elements();
assert_eq!(n, nelem, "Incorrect number of elements");

pub fn elem_size(&self) -> usize

Returns the size of elements in the ElemRestriction

let nelem = 3;
let elem_size = 2;
let mut ind: Vec<i32> = vec![0; 2 * nelem];
for i in 0..nelem {
    ind[2 * i + 0] = i as i32;
    ind[2 * i + 1] = (i + 1) as i32;
}
let r = ceed
    .elem_restriction(nelem, elem_size, 1, 1, nelem + 1, MemType::Host, &ind)
    .unwrap();

let e = r.elem_size();
assert_eq!(e, elem_size, "Incorrect element size");

pub fn lvector_size(&self) -> usize

Returns the size of the Lvector for an ElemRestriction

let nelem = 3;
let mut ind: Vec<i32> = vec![0; 2 * nelem];
for i in 0..nelem {
    ind[2 * i + 0] = i as i32;
    ind[2 * i + 1] = (i + 1) as i32;
}
let r = ceed
    .elem_restriction(nelem, 2, 1, 1, nelem + 1, MemType::Host, &ind)
    .unwrap();

let lsize = r.lvector_size();
assert_eq!(lsize, nelem + 1);

pub fn num_components(&self) -> usize

Returns the number of components in the elements of an ElemRestriction

let nelem = 3;
let ncomp = 42;
let mut ind: Vec<i32> = vec![0; 2 * nelem];
for i in 0..nelem {
    ind[2 * i + 0] = i as i32;
    ind[2 * i + 1] = (i + 1) as i32;
}
let r = ceed
    .elem_restriction(nelem, 2, 42, 1, ncomp * (nelem + 1), MemType::Host, &ind)
    .unwrap();

let n = r.num_components();
assert_eq!(n, ncomp, "Incorrect number of components");

pub fn multiplicity(&self, mult: &mut Vector<'_>) -> Result<i32, CeedError>

Returns the multiplicity of nodes in an ElemRestriction

let nelem = 3;
let mut ind: Vec<i32> = vec![0; 2 * nelem];
for i in 0..nelem {
    ind[2 * i + 0] = i as i32;
    ind[2 * i + 1] = (i + 1) as i32;
}
let r = ceed
    .elem_restriction(nelem, 2, 1, 1, nelem + 1, MemType::Host, &ind)
    .unwrap();

let mut mult = ceed.vector(nelem + 1).unwrap();
mult.set_value(0.0);

r.multiplicity(&mut mult).unwrap();

mult.view().iter().enumerate().for_each(|(i, arr)| {
    assert_eq!(
        if (i == 0 || i == nelem) { 1. } else { 2. },
        *arr,
        "Incorrect multiplicity array"
    );
});

Trait Implementations

impl<'a> Display for ElemRestriction<'a>

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

View an ElemRestriction

let nelem = 3;
let mut ind: Vec<i32> = vec![0; 2 * nelem];
for i in 0..nelem {
    ind[2 * i + 0] = i as i32;
    ind[2 * i + 1] = (i + 1) as i32;
}
let r = ceed
    .elem_restriction(nelem, 2, 1, 1, nelem + 1, MemType::Host, &ind)
    .unwrap();
println!("{}", r);

impl<'a> Drop for ElemRestriction<'a>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a> From<&'a ElemRestriction<'_>> for ElemRestrictionOpt<'a>

Construct a ElemRestrictionOpt reference from a ElemRestriction reference

fn from(restr: &'a ElemRestriction<'_>) -> Self

Performs the conversion.