Struct Point

pub struct Point {
    pub e: Group,
    pub t: Group,
    pub i: f64,
    pub j: f64,
    pub k: f64,
    pub kind: PointKind,
}

Generic representation of a point in the mesh geometry

A Point represents a location somewhere in the mesh data. It must specify the time and energy groups, the (i,j,k) coordinates, and how these values should be interpreted.

Fields

e: Group

Energy Group

t: Group

Time Group

i: f64

i coordinate

j: f64

j coordinate

k: f64

k coordinate

kind: PointKind

Coordiante system

Implementations

impl Point

pub fn new() -> Point

Create a new Point with the default values

pub fn from_xyz<T, U, V>(x: T, y: U, z: V) -> Point

where T: Into<f64> + Copy, U: Into<f64> + Copy, V: Into<f64> + Copy,

Create a Point from (x,y,z) cartesian coordinates

Anything that can be turned into an f64 value will work. For example:

assert_eq!( Point::from_xyz(1, 2.0, 3),
            Point{
                i: 1.0,
                j: 2.0,
                k: 3.0,
                kind: PointKind::Rectangular,
                ..Default::default()})

pub fn from_rzt<T, U, V>(r: T, z: U, t: V) -> Point

where T: Into<f64> + Copy, U: Into<f64> + Copy, V: Into<f64> + Copy,

Create a Point from (r,z,t) cylindrical coordinates

Anything that can be turned into an f64 value will work. For example:

assert_eq!( Point::from_rzt(1, 10, 0.5),
            Point{
                i: 1.0,
                j: 10.0,
                k: 0.5,
                kind: PointKind::Cylindrical,
                ..Default::default()})

pub fn from_ijk<T, U, V>(i: T, j: U, k: V) -> Point

where T: Into<f64> + Copy, U: Into<f64> + Copy, V: Into<f64> + Copy,

Create a Point from (i,j,k) indexing

Note that any non-exact values will be cast to usize at the time of use. For example:

assert_eq!( Point::from_ijk(1, 2, 3),
            Point{
                i: 1.0,
                j: 2.0,
                k: 3.0,
                kind: PointKind::Index,
                ..Default::default()})

pub fn from_xyz_vec<T>(values: &[T]) -> Result<Point, Error>

where T: Into<f64> + Copy,

Create a Point from an array of [x,y,z] cartesian coordinates

Anything that can be turned into an f64 value will work. For example:

let xyz = vec![1.0, 2.0, 3.0];
assert_eq!( Point::from_xyz_vec(&xyz).unwrap(),
            Point{
                i: 1.0,
                j: 2.0,
                k: 3.0,
                kind: PointKind::Rectangular,
                ..Default::default()})

pub fn from_rzt_vec<T>(values: &[T]) -> Result<Point, Error>

where T: Into<f64> + Copy,

Create a Point from an array of [r,z,t] cylindrical coordinates

Anything that can be turned into an f64 value will work. For example:

let rzt = vec![1.0, 2.0, 3.0];
assert_eq!( Point::from_rzt_vec(&rzt).unwrap(),
            Point{
                i: 1.0,
                j: 2.0,
                k: 3.0,
                kind: PointKind::Cylindrical,
                ..Default::default()})

pub fn from_ijk_vec<T>(values: &[T]) -> Result<Point, Error>

where T: Into<f64> + Copy,

Create a Point from an array of [i,j,k] indices

Note that any non-exact values will be cast to usize at the time of use. For example:

let ijk = vec![1, 2, 3];
assert_eq!( Point::from_ijk_vec(&ijk).unwrap(),
            Point{
                i: 1.0,
                j: 2.0,
                k: 3.0,
                kind: PointKind::Index,
                ..Default::default()})

pub fn as_array(&self) -> [f64; 3]

Turn point into an array

For example:

let point = Point{  i: 1.0,
                    j: 2.0,
                    k: 3.0,
                    ..Default::default()};
assert_eq!( point.as_array(), [1.0, 2.0, 3.0] )

Trait Implementations

impl Clone for Point

fn clone(&self) -> Point

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Point

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

Formats the value using the given formatter.

impl Default for Point

fn default() -> Point

Returns the “default value” for a type.

impl Display for Point

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

Formats the value using the given formatter.

impl PartialEq for Point

fn eq(&self, other: &Point) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Point