Skip to content

viz/applications.py

VizApplications 

VizApplications(dpi: int = 150, font_size: int = 11, font_family: str = 'Arial')


              flowchart TD
              wmbe.viz.applications.VizApplications[VizApplications]
              wmbe.viz.base.VizBase[VizBase]

                              wmbe.viz.base.VizBase --> wmbe.viz.applications.VizApplications
                


              click wmbe.viz.applications.VizApplications href "" "wmbe.viz.applications.VizApplications"
              click wmbe.viz.base.VizBase href "" "wmbe.viz.base.VizBase"

Model application visualization class.

Methods:

Source code in wmbe/viz/base.py 
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
def __init__(
        self, 
        dpi: int=150, 
        font_size: int=11, 
        font_family: str="Arial",
    ) -> None:
    self.dpi = dpi
    self.fdict = {}
    try:
        mpl.rc("font", size=font_size, family=font_family)
    except:
        mpl.rc("font", size=font_size, family="")

    self.markers = {
        'o': 'circle', 
        'v': 'triangle_down', 
        '^': 'triangle_up', 
        '<': 'triangle_left', 
        '>': 'triangle_right', 
        #  '1': 'tri_down', '2': 'tri_up', 
        #  '3': 'tri_left', '4': 'tri_right',
        #  's': 'square', 
        '8': 'octagon', 
        'p': 'pentagon', 
        # '*': 'star', 
        'h': 'hexagon1',
        'H': 'hexagon2', 
        #  '+': 'plus', 'x': 'x', 
        'D': 'diamond', 
        'd': 'thin_diamond', 
        '|': 'vline', 
        '_': 'hline', 
        'P': 'plus_filled', 
        'X': 'x_filled', 
        #  0: 'tickleft', 1: 'tickright', 
        #  2: 'tickup', 3: 'tickdown', 
        #  4: 'caretleft', 5: 'caretright', 6: 'caretup',
        #  7: 'caretdown', 8: 'caretleftbase', 
        #  9: 'caretrightbase', 10: 'caretupbase', 11: 'caretdownbase'
    }

channel_generic 

channel_generic(
    name: str,
    title: str | None = None,
    zys: Sequence | None = None,
    do_equal_aspect: bool = False,
    text_labels: Sequence | None = None,
    fig_size: tuple[float, float] = (6, 4),
) -> None

Plot numerical solutions applied to channel cross-section model (vertical profiles).

Parameters:

  • name

    (str) –

    key for figure dictionary

  • title

    (str | None, default: None ) –

    optional title for figure

  • zys

    (Sequence | None, default: None ) –

    numerical solutions to plot

  • do_equal_aspect

    (bool, default: False ) –

    flag whether to force equal sizing of x and y axis scales

  • text_labels

    (Sequence | None, default: None ) –

    text annotations as sequence of tuples of form [(x-y coordinate, string, font size)]

  • fig_size

    (tuple[float, float], default: (6, 4) ) –

    tuple (x,y) in inches (!)

Source code in wmbe/viz/applications.py 
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
def channel_generic(
        self, 
        name: str,
        title: str|None=None,
        zys: Sequence|None=None, 
        do_equal_aspect: bool=False,
        text_labels: Sequence|None=None,
        fig_size: tuple[float,float]=(6, 4,),
    ) -> None:            
    """
    Plot numerical solutions applied to channel cross-section model 
    (vertical profiles).

    Args:
        name: key for figure dictionary
        title: optional title for figure
        zys: 
            numerical solutions to plot
        do_equal_aspect: 
            flag whether to force equal sizing of x and y axis scales
        text_labels: 
            text annotations as sequence of tuples of form 
            [(x-y coordinate, string, font size)]
        fig_size: tuple (x,y) in inches (!)
    """
    _ = self.create_figure(name=name, size=fig_size,)
    if title is None:
        plt.title(title, fontdict={"fontsize": 11.5})

    zy=zys[0]
    plt.plot(
        zy[2], zy[0], label=zy[4], color="k",
    )
    plt.ylabel(zy[1])
    plt.xlabel(zy[3])
    axes = plt.gca()
    if do_equal_aspect:
        axes.set_aspect("equal")
    else:
        pass
    if text_labels is not None:
        for text_label in text_labels:
            plt.text(
                *text_label[0], 
                text_label[1], 
                color=text_label[3], 
                size=text_label[2],
                verticalalignment="center", 
                horizontalalignment="center",
                transform=axes.transAxes, 
                rotation=text_label[4],
            )
    if len(zys)>=2:
        zy=zys[1]
        plt.plot(0,0, label=zy[4], color="forestgreen",)
    plt.legend()
    if len(zys)>=2:
        zy=zys[1]
        alt_axes = axes.twiny()
        alt_axes.plot(zy[2], zy[0], label=zy[4], color="forestgreen",)
        alt_axes.set_xlabel(zy[3], color="forestgreen",)
    plt.grid(ls=":")

channel_ref_weathering_rate_ref_erosion_rate_W 

channel_ref_weathering_rate_ref_erosion_rate_W(
    name: str,
    title: str | None = None,
    model: ChannelWall | None = None,
    text_label: Sequence | None = None,
    fig_size: tuple[float, float] = (6, 4),
) -> None

Plot numerical solutions applied to channel cross-section model (vertical profiles).

Parameters:

  • name

    (str) –

    key for figure dictionary

  • title

    (str | None, default: None ) –

    optional title for figure

  • model

    (ChannelWall | None, default: None ) –

    instance of model class that simulates channel cross-sectional geometry

  • text_label

    (Sequence | None, default: None ) –

    text annotation as tuple of form (x-y coordinate, string, font size)

  • fig_size

    (tuple[float, float], default: (6, 4) ) –

    tuple (x,y) in inches (!)

Source code in wmbe/viz/applications.py 
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
def channel_ref_weathering_rate_ref_erosion_rate_W(
        self, 
        name: str,
        title: str|None=None,
        model: ChannelWall|None=None, 
        text_label: Sequence|None=None,
        fig_size: tuple[float,float]=(6,4,),
    ) -> None:   
    """
    Plot numerical solutions applied to channel cross-section model 
    (vertical profiles).

    Args:
        name: key for figure dictionary
        title: optional title for figure
        model: 
            instance of model class that simulates channel cross-sectional 
            geometry
        text_label: 
            text annotation as tuple of form 
            (x-y coordinate, string, font size)
        fig_size: tuple (x,y) in inches (!)
    """
    _ = self.create_figure(name=name, size=fig_size,)
    if title is None:
        plt.title(title, fontdict={"fontsize": 11.5})

    plt.plot(
        model.w0_array/model.physical_parameters[k], 
        model.z_array, 
        label=r"$w_0/k$",
    )
    plt.plot(
        model.v0_array, 
        model.z_array, 
        label=r"$u_0$",
    )
    x_limits = plt.xlim()
    y_limits = plt.ylim()
    plt.plot(
        (-1, -1,), 
        label=r"${\mathcal{W}}=w_0/{u_0} k$", 
        color="forestgreen",
    )
    plt.plot(
        model.vs_array,
        model.z_array, 
        label=r"$v_s$", 
        color="k", 
        lw=2,
    )
    plt.xlim(x_limits)
    plt.ylim(y_limits)
    plt.xlabel(r"Speeds $w_0(z)/k$, $u_0(z)$, $v_s(z)$")
    plt.ylabel(r"Height above bed  $z$")
    plt.legend(loc="upper center")
    plt.grid(ls=":")

    axes = plt.gca()
    alt_axes = axes.twiny()
    alt_axes.plot(
        model.W_array,  
        model.z_array, 
        label=r"${\mathcal{W}}$", 
        color="forestgreen",
    )
    alt_axes.set_xlabel(
        r"Weathering number  ${\mathcal{W}}(z)$", 
        color="forestgreen",
    )
    x_limits = axes.get_xlim()
    axes.set_xlim(x_limits[0], x_limits[1]*1.05)

    if text_label is not None:
        plt.text(
            *text_label[0], 
            text_label[1], 
            color="k", 
            size=text_label[2],
            verticalalignment="center", 
            horizontalalignment="center",
            transform=axes.transAxes,
        )

create_figure 

create_figure(
    name: str, size: tuple[float, float] | None = None, dpi: int | None = None
) -> Figure

Initialize a Pyplot figure.

Set its size and DPI. Append it to the figures dictionary.

Parameters:

  • name

    (str) –

    name of figure; used as key in figures dictionary

  • size

    (tuple[float, float] | None, default: None ) –

    optional width and height of figure in inches

  • dpi

    (int | None, default: None ) –

    rasterization resolution

Returns:

  • Figure –

    reference to MatPlotLib/Pyplot figure

Source code in wmbe/viz/base.py 
 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
110
111
112
113
114
115
116
117
118
119
120
def create_figure(
    self,
    name: str,
    size: tuple[float, float] | None = None,
    dpi: int | None = None,
) -> Figure:
    """
    Initialize a Pyplot figure.

    Set its size and DPI. Append it to the figures dictionary.

    Args:
        name:
            name of figure; used as key in figures dictionary
        size:
            optional width and height of figure in inches
        dpi:
            rasterization resolution

    Returns:
        reference to MatPlotLib/Pyplot figure
    """
    fig_size_: tuple[float, float] = (
        (6, 4,) if size is None else size
    )
    dpi_: float = self.dpi if dpi is None else dpi
    logging.info(
        "Viz:\n   "
        + f"Creating plot: {name} size={fig_size_} @ {dpi_} dpi"
    )
    fig = plt.figure()
    self.fdict.update({name: fig})
    if fig_size_ is not None:
        fig.set_size_inches(*fig_size_)
    fig.set_dpi(dpi_)
    return fig