Skip to content

mnns.fromtext

Not for production. Functions to create nanowire networks from text file.

Functions:

Name Description
create_NWN_from_txt

Create a nanowire network represented by a NetworkX graph. Wires are

create_NWN_from_txt 

create_NWN_from_txt(
    filename: str,
    conductance: float = 1.0,
    diameter: float = 1.0,
    resistivity: float = 1.0,
    units: Dict[str, float] = None,
) -> NanowireNetwork

Create a nanowire network represented by a NetworkX graph. Wires are represented by the graph's vertices, while the wire junctions are represented by the graph's edges.

The text file input is assumed to be in two columns: x and y. Each wire is a pair of rows, one row containing the start point and the following containing the end point. The first two pairs of rows are the electrodes.

Parameters:

Name Type Description Default
filename str

Text file containing the start and end locations of the wires.

 required
conductance float

The junction conductance of the nanowires where they intersect. Given in units of (Ron)^-1.

 1.0
diameter float

The diameter of each nanowire. Given in units of D0.

 1.0
resistivity float

The resistivity of each nanowire. Given in units of rho0.

 1.0
units dict

Dictionary of custom base units. Defaults to None which will use the default units given in units.py

 None

Returns:

Name Type Description
NWN Graph

The created random nanowire network.
Source code in mnns/fromtext.py 
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
def create_NWN_from_txt(
    filename: str,
    conductance: float = 1.0,
    diameter: float = 1.0,
    resistivity: float = 1.0,
    units: Dict[str, float] = None,
) -> NanowireNetwork:
    """
    Create a nanowire network represented by a NetworkX graph. Wires are
    represented by the graph's vertices, while the wire junctions are
    represented by the graph's edges.

    The text file input is assumed to be in two columns: x and y.
    Each wire is a pair of rows, one row containing the start point and the
    following containing the end point. The first two pairs of rows are the
    electrodes.

    Parameters
    ----------
    filename : str
        Text file containing the start and end locations of the wires.

    conductance : float, optional
        The junction conductance of the nanowires where they intersect.
        Given in units of (Ron)^-1.

    diameter : float, optional
        The diameter of each nanowire. Given in units of D0.

    resistivity : float, optional
        The resistivity of each nanowire. Given in units of rho0.

    units : dict, optional
        Dictionary of custom base units. Defaults to None which will use the
        default units given in `units.py`

    Returns
    -------
    NWN : Graph
        The created random nanowire network.

    """
    # Get coordinates from text file
    x, y = np.loadtxt(filename, unpack=True)

    # Convert to LineStrings
    line_list = []
    for i in range(0, len(x), 2):
        line_list.append(LineString([(x[i], y[i]), (x[i + 1], y[i + 1])]))

    # Find dimensions
    length = np.max(x) - np.min(x)
    width = np.max(y) - np.min(y)
    shape = (length, width)
    area = length * width

    # Get characteristic units
    units = NWNUnits(units)

    # Create NWN graph
    NWN = NanowireNetwork(
        wire_length=None,
        length=length,
        width=width,
        shape=shape,
        wire_density=0,
        wire_num=0,
        junction_conductance=conductance,
        junction_capacitance=None,
        wire_diameter=diameter,
        wire_resistivity=resistivity,
        electrode_list=[],
        lines=[],
        type="JDA",
        units=units,
        loc={},
        node_indices={},
    )

    # Split lines
    electrode_lines = line_list[0:2]
    wire_lines = line_list[2:]

    # Add wires to the graph
    add_wires(NWN, electrode_lines, [True] * len(electrode_lines))
    add_wires(NWN, wire_lines, [False] * len(wire_lines))

    # Find junction density
    NWN.graph["junction_density"] = len(NWN.graph["loc"].keys()) / area

    return NWN