Skip to content

mibiscreen.visualize API reference

mibiscreen module for data visualization.

activity

Activity plot.

@author: alraune

activity(data, save_fig=False, **kwargs)

Function creating activity plot.

Activity plot showing scatter of total number of metabolites vs total concentration of contaminant per well with color coding of NA traffic lights: red/yellow/green corresponding to no natural attenuation going on (red), limited/unknown NA activity (yellow) or active natural attenuation (green)

Input
data: list or pandas.DataFrame
    quantities required in plot:
        - total concentration of contaminants per sample
        - total count of metabolites per sample
        - traffic light on NA activity per sample
    if DataFrame, it contains the three required quantities with their standard names
    if list of arrays: the three quantities are given order above
    if list of pandas-Series, quantities given in standard names
save_fig: Boolean or string, optional, default is False.
    Flag to save figure to file with name provided as string. =
**kwargs: dict
    dictionary with plot settings
Output
fig : Figure object
    Figure object of created activity plot.
ax :  Axes object
    Axes object of created activity plot.
Source code in mibiscreen/visualize/activity.py 
 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
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
def activity(
        data,
        save_fig=False,
        **kwargs,
        ):
    """Function creating activity plot.

    Activity plot showing scatter of total number of metabolites vs total concentration
    of contaminant per well with color coding of NA traffic lights: red/yellow/green
    corresponding to no natural attenuation going on (red), limited/unknown NA activity (yellow)
    or active natural attenuation (green)

    Input
    ----------
        data: list or pandas.DataFrame
            quantities required in plot:
                - total concentration of contaminants per sample
                - total count of metabolites per sample
                - traffic light on NA activity per sample
            if DataFrame, it contains the three required quantities with their standard names
            if list of arrays: the three quantities are given order above
            if list of pandas-Series, quantities given in standard names
        save_fig: Boolean or string, optional, default is False.
            Flag to save figure to file with name provided as string. =
        **kwargs: dict
            dictionary with plot settings

    Output
    -------
        fig : Figure object
            Figure object of created activity plot.
        ax :  Axes object
            Axes object of created activity plot.

    """
    settings = copy.copy(DEF_settings)
    settings.update(**kwargs)

    ### ---------------------------------------------------------------------------
    ### Handling of input data
    if isinstance(data, pd.DataFrame):
        meta_count = data[name_metabolites_variety].values
        tot_cont = data[name_total_contaminants].values
        well_color = data[name_na_traffic_light].values
    elif isinstance(data, list) and len(data)>=3:
        if isinstance(data[0], pd.Series) and isinstance(data[1], pd.Series) and isinstance(data[2], pd.Series):
            for series in data:
                if series.name == name_metabolites_variety:
                    meta_count = series.values
                if series.name == name_total_contaminants:
                    tot_cont = series.values
                if series.name == name_na_traffic_light:
                    well_color = series.values
        elif isinstance(data[0], (np.ndarray, list)):
            tot_cont = data[0]
            meta_count = data[1]
            well_color = data[2]
            # print("MATCH")
        else:
            raise ValueError("List elements in data must be lists, np.arrays or pd.series.")
        if len(tot_cont) != len(meta_count) or len(tot_cont) != len(well_color):
            raise ValueError("Provided arrays/lists/series of data must have the same length.")
    else:
        raise ValueError("Data needs to be DataFrame or list of at least three lists/np.arrays/pd.series.")

    if len(tot_cont) <= 1:
        raise ValueError("Too little data for activity plot. At least two values per quantity required.")

    ### ---------------------------------------------------------------------------
    ### Creating Figure
    fig, ax = plt.subplots(figsize=settings['figsize'])
    ax.scatter(tot_cont,
               meta_count,
               c=well_color,
               zorder = 3,
               s = settings['markersize'],
               ec = settings['ec'],
               lw = settings['lw'],
               )

    ### generate legend labels
    if "green" in well_color:
        ax.scatter([], [],
                   label="available",
                   c="green",
                   s = settings['markersize'],
                   ec = settings['ec'],
                   lw = settings['lw'],
                   )
    if "y" in well_color:
        ax.scatter([], [],
                   label="limited/unknown",
                   c="y",
                   s = settings['markersize'],
                   ec = settings['ec'],
                   lw = settings['lw'],
                   )
    if "red" in well_color:
        ax.scatter([], [],
                   label="depleted",
                   c="red",
                   s = settings['markersize'],
                   ec = settings['ec'],
                   lw = settings['lw'],
                   )

    ### ---------------------------------------------------------------------------
    ### Adapt plot optics
    ax.set_xlabel(r"Concentration contaminants [$\mu$g/L]",fontsize=settings['textsize'])
    ax.set_ylabel("Metabolite variety", fontsize=settings['textsize'])
    ax.grid()
    ax.minorticks_on()
    ax.tick_params(axis="both", which="major", labelsize=settings['textsize'])
    ax.tick_params(axis="both", which="minor", labelsize=settings['textsize'])
    plt.legend(title = 'Electron acceptors:',loc =settings['loc'], fontsize=settings['textsize'] )
    fig.tight_layout()

    ### ---------------------------------------------------------------------------
    ### Save figure to file if file path provided
    if save_fig is not False:
        try:
            plt.savefig(save_fig,dpi = settings['dpi'])
            print("Save Figure to file:\n", save_fig)
        except OSError:
            print("WARNING: Figure could not be saved. Check provided file path and name: {}".format(save_fig))

    return fig, ax

ordination_plot

Ordination plot.

@author: Alraune Zech

ordination_plot(ordination_output, plot_loadings=True, plot_scores=True, rescale_loadings_scores=False, adjust_text=True, scale_focus='loadings', axis_ranges=False, save_fig=False, **kwargs)

Function creating ordination plot.

Based on ordination analysis providing ordination loadings and scores.

Input
ordination_output : Dictionary
    contains ordination results:
        - as numpy arrays; ordination loading and scores
        - names of the samples and the Environmental and Species variables
        - method : String (pca, cca, rda) The ordination method used in the analysis.
plot_loadings : Boolean; default is True
    flag to plot the ordination loadings
plot_scores : Boolean; default is True
    flag to plot the ordiantion scores
rescale_loadings_scores : Boolean; default is False
    flag to rescale loadings and scores to have a loading close to 1
adjust_text : Boolean, default is True
    flag to perform automized adjustment of text labes of loadings and scores to avoid overlap
scale_focus : String, default is "loadings"
    flag to specify if scaling focusses on either 'loadings' or 'scores' or 'none'.
axis_ranges : Boolean or list/array of 4 values, default is False,
    if array or list it gives fixed x and y axis dimensions [x_min, x_maxm y_min, y_max]
save_fig: Boolean or string, optional, default is False.
    Flag to save figure to file with name provided as string.
**kwargs: dict
    dictionary with plot settings (e.g. fonts, arrow specifics, etc)
Output
fig : Figure object
    Figure object of created activity plot.
ax :  Axes object
    Axes object of created activity plot.
Source code in mibiscreen/visualize/ordination_plot.py 
 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
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
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
def ordination_plot(ordination_output,
                    plot_loadings = True,
                    plot_scores = True,
                    rescale_loadings_scores = False,
                    adjust_text = True,
                    scale_focus = "loadings",
                    axis_ranges = False,
                    save_fig=False,
                    **kwargs,
                    ):
    """Function creating ordination plot.

    Based on ordination analysis providing ordination loadings and scores.

    Input
    -----
        ordination_output : Dictionary
            contains ordination results:
                - as numpy arrays; ordination loading and scores
                - names of the samples and the Environmental and Species variables
                - method : String (pca, cca, rda) The ordination method used in the analysis.
        plot_loadings : Boolean; default is True
            flag to plot the ordination loadings
        plot_scores : Boolean; default is True
            flag to plot the ordiantion scores
        rescale_loadings_scores : Boolean; default is False
            flag to rescale loadings and scores to have a loading close to 1
        adjust_text : Boolean, default is True
            flag to perform automized adjustment of text labes of loadings and scores to avoid overlap
        scale_focus : String, default is "loadings"
            flag to specify if scaling focusses on either 'loadings' or 'scores' or 'none'.
        axis_ranges : Boolean or list/array of 4 values, default is False,
            if array or list it gives fixed x and y axis dimensions [x_min, x_maxm y_min, y_max]
        save_fig: Boolean or string, optional, default is False.
            Flag to save figure to file with name provided as string.
        **kwargs: dict
            dictionary with plot settings (e.g. fonts, arrow specifics, etc)

    Output
    ------
        fig : Figure object
            Figure object of created activity plot.
        ax :  Axes object
            Axes object of created activity plot.
    """
    settings = copy.copy(DEF_settings)
    settings.update(**kwargs)

    ### ---------------------------------------------------------------------------
    ### check on completeness of input ordination_output

    if not isinstance(ordination_output,dict):
        raise TypeError("Input data must be given as dictionary with standard output of ordination methods.")

    if "loadings_independent" not in ordination_output.keys():
        raise KeyError("Input dictionary does not contain data on loadings ('loadings_independent')")
    else:
        loadings_independent = ordination_output["loadings_independent"]
        names_independent = ordination_output["names_independent"]
        if len(loadings_independent) == 0:
            loadings_independent = np.array([[],[]]).T

    if "scores" not in ordination_output.keys():
        raise KeyError("Input dictionary does not contain data on scores ('scores')")
    else:
        scores = ordination_output["scores"]

    if "sample_index" not in ordination_output.keys():
        sample_index = np.arange(scores.shape[0])
    else:
        sample_index = ordination_output["sample_index"]

    if "loadings_dependent" in ordination_output.keys():
        loadings_dependent = ordination_output["loadings_dependent"]
        names_dependent = ordination_output["names_dependent"]
        if len(loadings_dependent) == 0:
            loadings_dependent = np.array([[],[]]).T
        loadings = np.append(loadings_independent, loadings_dependent, axis=0)
    else:
        loadings = loadings_independent

    ### ---------------------------------------------------------------------------
    ### Rescale ordination_output given plot specifics

    # Determing the largest values in the PCA scores.
    max_load = np.max(np.abs(loadings))
    max_score = np.max(np.abs(scores))

    if max_load > 1 or rescale_loadings_scores:
        # loadings = loadings / (max_load*1.05)
        loadings = loadings / (max_load)
    if max_score > 1 or rescale_loadings_scores:
        # scores = scores / (max_score*1.05)
        scores = scores / (max_score)

    if axis_ranges is not False:
        # Takes the given axis dimensions for both ordination axes
        x_lim_neg,x_lim_pos,y_lim_neg,y_lim_pos = axis_ranges
    else:
        # Adjusts axis dimensions for both ordination axes to ordination_output
        if plot_scores and plot_loadings:
            # When plotting both scores and loadings, scores or loadings are scaled
            # depending on the extent of the other. Depends on the input of Scale_focus.
            if scale_focus == "loadings":
                scores = scores * np.max(np.abs(loadings))
            elif scale_focus == "scores":
                loadings = loadings *  np.max(np.abs(scores))
            full_coords = np.append(loadings, scores, axis=0)
        elif plot_loadings:
            full_coords = loadings
        else:
            full_coords = scores

        x_lim_pos = 0.11*np.ceil(np.max(full_coords[:,0])*10)
        y_lim_pos = 0.11*np.ceil(np.max(full_coords[:,1])*10)
        x_lim_neg = 0.11*np.floor(np.min(full_coords[:,0])*10)
        y_lim_neg = 0.11*np.floor(np.min(full_coords[:,1])*10)

    ### ---------------------------------------------------------------------------
    ### Create Figure, finally!
    fig, ax = plt.subplots(figsize=settings['figsize'])
    texts = []

    # Plotting the ordination scores by iterating over every coordinate
    # in the scores array, if the Plot_scores parameter is set to true.
    if plot_scores:
        for i, (x, y) in enumerate(scores):
            plt.scatter(x, y,
                        color=settings['score_color'],
                        marker = settings['score_marker'],
                        s = settings['score_marker_size'],
                        facecolor=settings['score_facecolor'],
                        edgecolor=settings['score_edgecolor'],
                        zorder = 7,
                        )
            # Plotting the name of the scores and storing it in a list for the purpose of adjusting the position later
            tex = plt.text(x, y, sample_index[i], color='black', fontsize = settings['score_fontsize'],zorder = 9)
            texts.append(tex)

    if plot_loadings:
        # Plots independent (=environmental) and dependent (=species) variables
        # with different colours and text formatting.
        for i, (x, y) in enumerate(loadings_independent):
            plt.arrow(0, 0, x, y,
                      color = settings['arrow_color_independent'],
                      width = settings['arrow_width'],
                      head_length = settings['arrow_head_length'],
                      head_width = settings['arrow_head_width'],
                      zorder = 10,
                      )
            #Plotting the name of the loading
            tex = plt.text(x, y, names_independent[i],
                            color='black',
                            fontstyle = settings['fontstyle_independent'],
                            weight = settings['weight_independent'],
                            fontsize = settings['loading_fontsize'],
                            zorder = 11,
                            )
            texts.append(tex)
        if "loadings_dependent" in ordination_output.keys():
            for i, (x, y) in enumerate(loadings_dependent):
                plt.arrow(0, 0, x, y,
                          color=settings['arrow_color_dependent'],
                          width = settings['arrow_width'],
                          head_length = settings['arrow_head_length'],
                          head_width = settings['arrow_head_width'],
                          zorder = 8,
                          )
                tex = plt.text(x, y, names_dependent[i],
                                color='black',
                                fontstyle = settings['fontstyle_dependent'],
                                weight = settings['weight_dependent'],
                                fontsize = settings['loading_fontsize'],
                                zorder = 9,
                                )
                # and storing it in a list for the purpose of adjusting the position later
                texts.append(tex)

    ### ---------------------------------------------------------------------------
    ### Adapt plot optics

    # Plotting lines that indicate the origin
    plt.plot([-1, 1], [0, 0], color='grey', linewidth=0.75, linestyle='--')
    plt.plot([0, 0], [-1, 1], color='grey', linewidth=0.75, linestyle='--')

    # Setting the x and y axis limits with the previously determined values
    plt.xlim(x_lim_neg, x_lim_pos)
    plt.ylim(y_lim_neg, y_lim_pos)
    plt.tick_params(axis="both",which="major",labelsize=settings['label_fontsize'])

    if ordination_output["method"]=='pca':
        percent_explained = ordination_output["percent_explained"]
        plt.xlabel('PC1 ({:.1f}%)'.format(percent_explained[0]), fontsize = settings['label_fontsize'])
        plt.ylabel('PC2 ({:.1f}%)'.format(percent_explained[1]), fontsize = settings['label_fontsize'])
    else:
        plt.xlabel('ordination axis 1', fontsize = settings['label_fontsize'])
        plt.ylabel('ordination axis 2', fontsize = settings['label_fontsize'])

    if adjust_text:
        try:
            from adjustText import adjust_text
            adjust_text(texts)
        except ImportError:
            print("WARNING: packages 'adjustText' not installed.")
            print(" For making text adjustment, install package 'adjustText'.")

    ### ---------------------------------------------------------------------------
    ### Save figure to file if file path provided

    if isinstance(settings['title'],str):
        plt.title(settings['title'],fontsize = settings['label_fontsize'])

    plt.tight_layout()
    if save_fig is not False:
        try:
            plt.savefig(save_fig,dpi = settings['dpi'])
            print("Figure saved to file:\n", save_fig)
        except OSError:
            print("WARNING: Figure could not be saved. Check provided file path and name: {}".format(save_fig))

    return fig, ax

stable_isotope_plots

Linear regression plots for stable isotope analysis in mibiscreen.

@author: Alraune Zech

Keeling_plot(concentration, delta, coefficients, relative_abundance=None, save_fig=False, **kwargs)

Creating a Keeling plot.

A Keeling plot is an approach to identify the isotopic composition of a contaminating source from measured concentrations and isotopic composition (delta) of a target species in the mix of the source and a pool. It is based on the linear relationship of the concentration and the delta-value which are measured over time or across a spatial interval.

The plot shows the inverse concentration data against the delta-values along the linear regression line. For gaining the regression coefficients perform a linear fitting or run

Keeling_regression() [in the module analysis]

The parameter of interest, the delta (or relative_abundance, respectively) of the source quantity is the intercept of linear fit with the y-axis, or in other words, the absolute value of the linear fit function.

Input
c_mix : np.array, pd.dataframe
    total molecular mass/molar concentration of target substance
    at different locations (at a time) or at different times (at one location)
delta_mix : np.array, pd.dataframe (same length as c_mix)
    relative isotope ratio (delta-value) of target substance
relative_abundance : None or np.array, pd.dataframe (same length as c_mix), default None
    if not None it replaces delta_mix in the inverse estimation and plotting
    relative abundance of target substance
coefficients : tuple of lenght 2
    containing coefficients of the linear fit
save_fig: Boolean or string, optional, default is False.
    Flag to save figure to file with name provided as string. =
**kwargs: dict
    dictionary with plot settings

fig : Figure object
    Figure object of created activity plot.
ax :  Axes object
    Axes object of created activity plot.
Source code in mibiscreen/visualize/stable_isotope_plots.py 
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
def Keeling_plot(concentration,
                 delta,
                 coefficients,
                 relative_abundance = None,
                 save_fig = False,
                 **kwargs,
                 ):
    """Creating a Keeling plot.

    A Keeling plot is an approach to identify the isotopic composition of a
    contaminating source from measured concentrations and isotopic composition
    (delta) of a target species in the mix of the source and a pool. It is based
    on the linear relationship of the concentration and the delta-value
    which are measured over time or across a spatial interval.

    The plot shows the inverse concentration data against the delta-values
    along the linear regression line. For gaining the regression coefficients
    perform a linear fitting or run

        Keeling_regression() [in the module analysis]

    The parameter of interest, the delta (or relative_abundance, respectively)
    of the source quantity is the intercept of linear fit with the y-axis,
    or in other words, the absolute value of the linear fit function.

    Input
    -----
        c_mix : np.array, pd.dataframe
            total molecular mass/molar concentration of target substance
            at different locations (at a time) or at different times (at one location)
        delta_mix : np.array, pd.dataframe (same length as c_mix)
            relative isotope ratio (delta-value) of target substance
        relative_abundance : None or np.array, pd.dataframe (same length as c_mix), default None
            if not None it replaces delta_mix in the inverse estimation and plotting
            relative abundance of target substance
        coefficients : tuple of lenght 2
            containing coefficients of the linear fit
        save_fig: Boolean or string, optional, default is False.
            Flag to save figure to file with name provided as string. =
        **kwargs: dict
            dictionary with plot settings

    Returns:
    --------
        fig : Figure object
            Figure object of created activity plot.
        ax :  Axes object
            Axes object of created activity plot.

    """
    settings = copy.copy(DEF_settings)
    settings.update(**kwargs)

    if relative_abundance is not None:
        y = relative_abundance
        text = 'x'
    else:
        y = delta
        text = r"\delta"

    x = 1/concentration

    ### ---------------------------------------------------------------------------
    ### create plot
    fig, ax = plt.subplots(figsize=settings['figsize'])
    ax.scatter(x,y, marker=settings['marker'], zorder = 3,label = 'data')

    ### ---------------------------------------------------------------------------
    ### plot linear regression trend line

    polynomial = np.poly1d(coefficients)
    trendline_x = np.linspace(min(0,np.min(x)),np.max(x), 100)
    trendline_y = polynomial(trendline_x)

    ax.plot(trendline_x, trendline_y, color= settings['fit_color'], label='linear fit')
    ax.text(0.5, 0.1,
            r"${}_{{source}} = {:.3f}$".format(text,coefficients[1]),
             bbox=dict(boxstyle="round", facecolor='w'),#,alpha=0.5)
             transform=ax.transAxes,
             fontsize=settings['fontsize'])
    ax.scatter(0,coefficients[1],
               c = settings['intercept_color'],
               zorder = 3,
               label = r'intercept: ${}_{{source}}$'.format(text),
               )

    ### ---------------------------------------------------------------------------
    ### Adapt plot optics

    ax.set_xlabel('Inverse concentration $1/c$',fontsize=settings['fontsize'])
    ax.set_ylabel('${}$'.format(text),fontsize=settings['fontsize'])
    ax.grid(True,zorder = 0)
    ax.set_xlim([0-x[-1]*0.05, x[-1]*1.05])
    ax.legend(loc =settings['loc'], fontsize=settings['fontsize'])
    if isinstance(settings['title'],str):
        ax.set_title(settings['title'],fontsize = settings['fontsize'])
    fig.tight_layout()

    ### ---------------------------------------------------------------------------
    ### Save figure to file if file path provided
    if save_fig is not False:
        try:
            plt.savefig(save_fig,dpi = settings['dpi'])
            print("Save Figure to file:\n", save_fig)
        except OSError:
            print("WARNING: Figure could not be saved. Check provided file path and name: {}".format(save_fig))

    return fig,ax

Lambda_plot(delta_C, delta_H, coefficients, save_fig=False, **kwargs)

Creating a Lambda plot.

A Lambda plot shows the δ13C versus δ2H signatures of a chemical compound. Relative changes in the carbon and hydrogen isotope ratios can indicate the occurrence of specific enzymatic degradation reactions. The relative changes are indicated by the lambda-H/C value which is the slope of the linear regression of hydrogen versus carbon isotope signatures. For gaining the regression coefficients perform a linear fitting or run

 Lambda_regression() [in the module analysis]
Lambda-values linking to specific enzymatic reactions

To be added!

Details provided in Vogt et al. [2016, 2020].

References

C. Vogt, C. Dorer, F. Musat, and H. H. Richnow. Multi-element isotope fractionation concepts to characterize the biodegradation of hydrocarbons - from enzymes to the environment. Current Opinion in Biotechnology, 41:90–98, 2016. C. Vogt, F. Musat, and H.-H. Richnow. Compound-Specific Isotope Analysis for Studying the Biological Degradation of Hydrocarbons. In Anaerobic Utilization of Hydrocarbons, Oils, and Lipids, pages 285-321. Springer Nature Switzerland, 2020.

A. Fischer, I. Herklotz, S. Herrmann, M. Thullner, S. A. Weelink, A. J. Stams, M. Schl ̈omann, H.-H. Richnow, and C. Vogt. Combined Carbon and Hydrogen Isotope Fractionation Investigations for Elucidating Benzene Biodegradation Pathways. Environmental Science and Technology, 42:4356–4363, 2008.

S. Kuemmel, F.-A. Herbst, A. Bahr, M. Arcia Duarte, D. H. Pieper, N. Jehmlich, J. Seifert, M. Von Bergen, P. Bombach, H. H. Richnow, and C. Vogt. Anaerobic naphthalene degradation by sulfate-reducing Desulfobacteraceae from various anoxic aquifers. FEMS Microbiology Ecology, 91(3), 2015.

Input
delta_C : np.array, pd.series
    relative isotope ratio (delta-value) of carbon of target molecule
delta_H : np.array, pd.series (same length as delta_C)
    relative isotope ratio (delta-value) of hydrogen of target molecule
coefficients : tuple of lenght 2
    containing coefficients of the linear fit
save_fig: Boolean or string, optional, default is False.
    Flag to save figure to file with name provided as string.
**kwargs: dict
    dictionary with plot settings

fig : Figure object
    Figure object of created activity plot.
ax :  Axes object
    Axes object of created activity plot.
Source code in mibiscreen/visualize/stable_isotope_plots.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
 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
121
122
123
124
125
126
127
def Lambda_plot(delta_C,
                delta_H,
                coefficients,
                save_fig = False,
                **kwargs,
                ):
    """Creating a Lambda plot.

    A Lambda plot shows the δ13C versus δ2H signatures of a chemical compound.
    Relative changes in the carbon and hydrogen isotope ratios can indicate the
    occurrence of specific enzymatic degradation reactions. The relative changes
    are indicated by the lambda-H/C value which is the slope of the linear
    regression of hydrogen versus carbon isotope signatures. For gaining the
    regression coefficients perform a linear fitting or run

         Lambda_regression() [in the module analysis]

    Lambda-values linking to specific enzymatic reactions:
        To be added!

    Details provided in Vogt et al. [2016, 2020].

    References:
        C. Vogt, C. Dorer, F. Musat, and H. H. Richnow. Multi-element isotope
        fractionation concepts to characterize the biodegradation of hydrocarbons
        - from enzymes to the environment. Current Opinion in Biotechnology,
        41:90–98, 2016.
        C. Vogt, F. Musat, and H.-H. Richnow. Compound-Specific Isotope Analysis
        for Studying the Biological Degradation of Hydrocarbons. In Anaerobic
        Utilization of Hydrocarbons, Oils, and Lipids, pages 285-321.
        Springer Nature Switzerland, 2020.

        A. Fischer, I. Herklotz, S. Herrmann, M. Thullner, S. A. Weelink,
        A. J. Stams, M. Schl ̈omann, H.-H. Richnow, and C. Vogt. Combined Carbon
        and Hydrogen Isotope Fractionation Investigations for Elucidating
        Benzene Biodegradation Pathways. Environmental Science and Technology,
        42:4356–4363, 2008.

        S. Kuemmel, F.-A. Herbst, A. Bahr, M. Arcia Duarte, D. H. Pieper,
        N. Jehmlich, J. Seifert, M. Von Bergen, P. Bombach, H. H. Richnow,
        and C. Vogt. Anaerobic naphthalene degradation by sulfate-reducing
        Desulfobacteraceae from various anoxic aquifers.
        FEMS Microbiology Ecology, 91(3), 2015.

    Input
    -----
        delta_C : np.array, pd.series
            relative isotope ratio (delta-value) of carbon of target molecule
        delta_H : np.array, pd.series (same length as delta_C)
            relative isotope ratio (delta-value) of hydrogen of target molecule
        coefficients : tuple of lenght 2
            containing coefficients of the linear fit
        save_fig: Boolean or string, optional, default is False.
            Flag to save figure to file with name provided as string.
        **kwargs: dict
            dictionary with plot settings

    Returns:
    --------
        fig : Figure object
            Figure object of created activity plot.
        ax :  Axes object
            Axes object of created activity plot.

    """
    settings = copy.copy(DEF_settings)
    settings.update(**kwargs)

    fig, ax = plt.subplots(figsize=settings['figsize'])
    ax.scatter(delta_C, delta_H, marker=settings['marker'],zorder = 3,label= 'data')

    ### ---------------------------------------------------------------------------
    ### plot linear regression trend line

    polynomial = np.poly1d(coefficients)
    trendline_x = np.linspace(np.min(delta_C), np.max(delta_C), 100)
    trendline_y = polynomial(trendline_x)
    ax.plot(trendline_x, trendline_y, color= settings['fit_color'], label='linear fit')
    ax.text(0.4, 0.1,
             r"$\Lambda = {:.2f}$".format(coefficients[0]),
             bbox=dict(boxstyle="round", facecolor='w'),#,alpha=0.5),
             transform=ax.transAxes,
             fontsize=settings['fontsize'])
    ### ---------------------------------------------------------------------------
    ### Adapt plot optics

    ax.grid(True,zorder = 0)
    ax.set_xlabel(r'$\delta^{{13}}$C')
    ax.set_ylabel(r'$\delta^2$H')
    ax.legend(loc =settings['loc'], fontsize=settings['fontsize'])
    if isinstance(settings['title'],str):
        ax.set_title(settings['title'],fontsize = settings['fontsize'])
    fig.tight_layout()

    ### ---------------------------------------------------------------------------
    ### Save figure to file if file path provided
    if save_fig is not False:
        try:
            plt.savefig(save_fig,dpi = settings['dpi'])
            print("Save Figure to file:\n", save_fig)
        except OSError:
            print("WARNING: Figure could not be saved. Check provided file path and name: {}".format(save_fig))

    return fig,ax

Rayleigh_fractionation_plot(concentration, delta, coefficients, save_fig=False, **kwargs)

Creating a Rayleigh fractionation plot.

Rayleigh fractionation is a common application to characterize the removal of a substance from a finite pool using stable isotopes. It is based on the change in the isotopic composition of the pool due to different kinetics of the change in lighter and heavier isotopes.

We follow the most simple approach assuming that the substance removal follows first-order kinetics, where the rate coefficients for the lighter and heavier isotopes of the substance differ due to kinetic isotope fractionation effects. The isotopic composition of the remaining substance in the pool will change over time, leading to the so-called Rayleigh fractionation.

The plot shows the log-transformed concentration data against the delta-values along the linear regression line. For gaining the regression coefficients perform a linear fitting or run

Rayleigh_fractionation() [in the module analysis]

The parameter of interest, the kinetic fractionation factor (epsilon or alpha -1) of the removal process is the slope of the the linear trend line.

Input
concentration : np.array, pd.series
    total molecular mass/molar concentration of target substance
    at different locations (at a time) or at different times (at one location)
delta : np.array, pd.series (same length as concentration)
    relative isotope ratio (delta-value) of target substance
coefficients : tuple of lenght 2
    containing coefficients of the linear fit
save_fig: Boolean or string, optional, default is False.
    Flag to save figure to file with name provided as string. =
**kwargs: dict
    dictionary with plot settings

fig : Figure object
    Figure object of created activity plot.
ax :  Axes object
    Axes object of created activity plot.
Source code in mibiscreen/visualize/stable_isotope_plots.py 
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
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
def Rayleigh_fractionation_plot(concentration,
                                delta,
                                coefficients,
                                save_fig = False,
                                **kwargs,
                                ):
    """Creating a Rayleigh fractionation plot.

    Rayleigh fractionation is a common application to characterize the removal
    of a substance from a finite pool using stable isotopes. It is based on the
    change in the isotopic composition of the pool due to different kinetics of
    the change in lighter and heavier isotopes.

    We follow the most simple approach assuming that the substance removal follows
    first-order kinetics, where the rate coefficients for the lighter and heavier
    isotopes of the substance differ due to kinetic isotope fractionation effects.
    The isotopic composition of the remaining substance in the pool will change
    over time, leading to the so-called Rayleigh fractionation.

    The plot shows the log-transformed concentration data against the delta-values
    along the linear regression line. For gaining the regression coefficients
    perform a linear fitting or run

        Rayleigh_fractionation() [in the module analysis]

    The parameter of interest, the kinetic fractionation factor (epsilon or alpha -1)
    of the removal process is the slope of the the linear trend line.

    Input
    -----
        concentration : np.array, pd.series
            total molecular mass/molar concentration of target substance
            at different locations (at a time) or at different times (at one location)
        delta : np.array, pd.series (same length as concentration)
            relative isotope ratio (delta-value) of target substance
        coefficients : tuple of lenght 2
            containing coefficients of the linear fit
        save_fig: Boolean or string, optional, default is False.
            Flag to save figure to file with name provided as string. =
        **kwargs: dict
            dictionary with plot settings

    Returns:
    --------
        fig : Figure object
            Figure object of created activity plot.
        ax :  Axes object
            Axes object of created activity plot.

    """
    settings = copy.copy(DEF_settings)
    settings.update(**kwargs)

    x = np.log(concentration)
    ### ---------------------------------------------------------------------------
    ### create plot
    fig, ax = plt.subplots(figsize=settings['figsize'])
    ax.scatter(x,delta, marker=settings['marker'], zorder = 3,label = 'data')

    ### ---------------------------------------------------------------------------
    ### plot linear regression trend line

    polynomial = np.poly1d(coefficients)
    trendline_x = np.linspace(np.min(x), np.max(x), 100)
    trendline_y = polynomial(trendline_x)
    ax.plot(trendline_x, trendline_y, color= settings['fit_color'], label='linear fit')
    ax.text(0.1, 0.1,
             r"$\epsilon = 1-\alpha = {:.3f}$".format(coefficients[0]),
             bbox=dict(boxstyle="round", facecolor='w'),#,alpha=0.5),
             transform=ax.transAxes,
             fontsize=settings['fontsize'])

    ### ---------------------------------------------------------------------------
    ### Adapt plot optics

    ax.set_xlabel(r'log-concentration $\ln c$',fontsize=settings['fontsize'])
    ax.set_ylabel(r'$\delta$',fontsize=settings['fontsize'])
    ax.grid(True,zorder = 0)
    ax.legend(loc =settings['loc'], fontsize=settings['fontsize'])
    if isinstance(settings['title'],str):
        ax.set_title(settings['title'],fontsize = settings['fontsize'])
    fig.tight_layout()

    ### ---------------------------------------------------------------------------
    ### Save figure to file if file path provided
    if save_fig is not False:
        try:
            plt.savefig(save_fig,dpi = settings['dpi'])
            print("Save Figure to file:\n", save_fig)
        except OSError:
            print("WARNING: Figure could not be saved. Check provided file path and name: {}".format(save_fig))

    return fig,ax