Struct Network 

pub struct Network(/* private fields */);

A network which is valid for performing mesh and nodal analysis.

This struct represents a network which can be solved via MeshAnalysis and NodalAnalysis. It is essentially a newtype wrapper around a UnGraph<usize, Excitation> which forms a valid electrical circuit. Please see BuildError for all the possible ways a graph can fail to represent a valid electrical circuit.

Sign conventions

The sign of an edge is oriented from source to target. If the following network has a current source at edge 0 and resistances everywhere else and all edges are oriented clockwise (e.g source of edge 0 is at edge 3 and target of edge 0 is at edge 1), an input of -5 at the current source results in an edge current of -5 over all edges.

     ┌──[1]──┐
  |  │       │
 5| [0]     [2]
  V  │       │
     └──[3]──┘

Likewise, if edge 2 is “flipped” (source at edge 3, target at edge 1), its edge current would be +5.

If edge 0 is a voltage source with value +3 instead (i.e high potential at the source, low potential at the target) and all resistances have the value 1 (resistances must always be positive), the current going through all edges would be -1 (since the voltage drop must be -1 over all resistances so the entire loop adds up to a voltage of 0).

     ┌──[1]──┐
  ^  │       │
 3| [0]     [2]
  |  │       │
     └──[3]──┘

Constructing a Network

The following constructor methods are available:

• Network::new (using a graph)
• Network::from_node_edges (using a slice of NodeEdge)
• Network::from_edge_list_edges (using a slice of EdgeListEdge)

Please see the docstrings of the methods for examples.

Serialization and deserialization

This struct serializes into a Vec<NodeEdge> and can be (fallible) deserialized from the following types:

• Vec<NodeEdge>
• Vec<EdgeListEdge>
• UnGraph<usize, Type>

Available when the feature serde is enabled.

Implementations

impl Network

pub fn new(graph: UnGraph<usize, Type>) -> Result<Self, BuildError>

A graph is a valid network if it fulfills the conditions outlined in the docstring of Network. The edge weights define whether the edge is a resistance, a current source or a voltage source.

pub fn from_node_edges(edges: &[NodeEdge]) -> Result<Self, BuildError>

Creates a new instance of Self from a slice of NodeEdge. See the docstring of NodeEdge for an example.

pub fn from_edge_list_edges( edge_list_edges: &[EdgeListEdge], ) -> Result<Self, BuildError>

Creates a new instance of Self from a slice of EdgeListEdge.

See the docstring of EdgeListEdge for an example.

pub fn graph(&self) -> &UnGraph<usize, Type>

Accesses the [petgraph::stable_graph::UnGraph] representation of the network.

The network analysis structs MeshAnalysis and NodalAnalysis use petgraphs UnGraph when they are created from a Network instance. This method allows accessing the graph directly. Please be aware that Network holds more information than just the graph (i.e. the edge source type information) and can therefore not be losslessly represented by a UnGraph (otherwise, the need for this type would not exist in the first place).

Examples

use network_analysis::{EdgeListEdge, Network, Type};
use petgraph::algo::dijkstra;
use petgraph::visit::NodeIndexable;

let network = Network::from_edge_list_edges(
&[
        EdgeListEdge::new(vec![3], vec![1], Type::Voltage),
        EdgeListEdge::new(vec![0], vec![2], Type::Resistance),
        EdgeListEdge::new(vec![1], vec![3], Type::Resistance),
        EdgeListEdge::new(vec![2], vec![0], Type::Resistance),
    ]
).expect("valid network");
let g = network.graph();

// Now use some of the functionality provided by petgraph, e.g. the "dijkstra" path finding algorithm
let node_map = dijkstra(&g, 0.into(), Some(2.into()), |_| 1);
assert_eq!(&2i32, node_map.get(&g.from_index(2)).unwrap());

pub fn voltage_source_count(&self) -> usize

Returns the number of voltage sources by counting all edges where edge.edge_type == Type::Voltage.

Examples

use network_analysis::{EdgeListEdge, Network, Type};

let network = Network::from_edge_list_edges(
&[
        EdgeListEdge::new(vec![3], vec![1], Type::Voltage),
        EdgeListEdge::new(vec![0], vec![2], Type::Resistance),
        EdgeListEdge::new(vec![1], vec![3], Type::Current),
        EdgeListEdge::new(vec![2], vec![0], Type::Voltage),
    ]
).expect("valid network");
assert_eq!(network.voltage_source_count(), 2);

pub fn current_source_count(&self) -> usize

Returns the number of current sources by counting all edges where edge.edge_type == Type::Current.

Examples

use network_analysis::{EdgeListEdge, Network, Type};

let network = Network::from_edge_list_edges(
&[
        EdgeListEdge::new(vec![3], vec![1], Type::Voltage),
        EdgeListEdge::new(vec![0], vec![2], Type::Resistance),
        EdgeListEdge::new(vec![1], vec![3], Type::Current),
        EdgeListEdge::new(vec![2], vec![0], Type::Voltage),
    ]
).expect("valid network");
assert_eq!(network.current_source_count(), 1);

Trait Implementations

impl Clone for Network

fn clone(&self) -> Network

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Network

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

Formats the value using the given formatter.