Struct Model 

pub struct Model {

    pub epsilon: f64,
    pub dimension: u8,
    pub degrees_of_freedom: u8,
    pub f: Vector,
    pub u: Vector,
    pub m: CooMat,
    pub f_r: Vector,
    pub u_r: Vector,
    pub m_r: CooMat,
    pub u_boundary_conditions: Vec<Option<f64>>,
    pub elements: HashMap<Vec<usize>, Box<Element>>,
    pub nodes: Vec<Rc<Node>>,
    pub materials: Vec<Rc<Material>>,
    pub sections: Vec<Rc<Section>>,
}

Fields

epsilon: f64

dimension: u8

degrees_of_freedom: u8

f: Vector

u: Vector

m: CooMat

f_r: Vector

u_r: Vector

m_r: CooMat

u_boundary_conditions: Vec<Option<f64>>

elements: HashMap<Vec<usize>, Box<Element>>

nodes: Vec<Rc<Node>>

materials: Vec<Rc<Material>>

sections: Vec<Rc<Section>>

Implementations

impl Model

pub fn new(dim: u8, epsilon: f64) -> Self

pub fn save(&self, file: &str)

pub fn load(file: &str) -> Self

pub fn add_element( &mut self, element: ElementType, nodes: Vec<usize>, material: usize, section: usize, ) -> &mut Self

pub fn add_node(&mut self, node: Node) -> &mut Self

pub fn add_material(&mut self, material: Material) -> &mut Self

pub fn add_section(&mut self, section: Section) -> &mut Self

pub fn solve(&mut self) -> &mut Self

pub fn reduce(&mut self) -> &mut Self

pub fn developp(&mut self) -> &mut Self

pub fn add_u_boundary_condition( &mut self, node: usize, field: u8, value: f64, ) -> &mut Self

pub fn remove_u_boundary_condition( &mut self, node: usize, field: u8, ) -> &mut Self

pub fn set_force(&mut self, node: usize, field: u8, value: f64) -> &mut Self

Trait Implementations

impl Debug for Model

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Model

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Model

fn eq(&self, other: &Model) -> 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 Serialize for Model

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Model