sim_params['radiusPlasma'] = rp sim_params['radiusRBC'] = rp - sleeve_thickness sim_params['radiusWall'] = rp + wall_thickness print sim_params['radiusPlasma'], sim_params['radiusRBC'], sim_params['radiusWall'] analytical_ivr_radius_plasma[i] = intravascularResistanceAnalytical(sim_params) fig, ax = plt.subplots(1) ax.plot(1e6*radius_rbc_fit_values, 1e-6*ivr_fitted_on_radius_rbc, 'k.-') ax.plot(1e6*radius_rbc_fit_values, 1e-6*analytical_ivr_radius_rbc, 'k--') # plt.gca().set_xlim([min(1e6*radius_rbc_fit_values), max(1e6*radius_rbc_fit_values)]) plt.plot([2.0, 2.0], [0, 10], color='k', linestyle='dotted') # ax.text(2.03, 4.1, '$r_p = 2.0 \, \muup m$') ax.set_xlim([min(1e6*radius_rbc_fit_values), 2.5]) ax.set_xticks([1.5, 1.7, 1.9, 2.1, 2.3, 2.5]) labels.setXLabel('r_c', 'um') labels.setYLabel('K_{IV,0.5}', 'IVR') axtop = ax.twiny() plt.plot(1e6*radius_plasma_fit_values, 1e-6*ivr_fitted_on_radius_plasma, '.-', color=plasma_color) plt.plot(1e6*radius_plasma_fit_values, 1e-6*analytical_ivr_radius_plasma, '--', color=plasma_color) axtop.set_xlim([min(1e6*radius_plasma_fit_values), max(1e6*radius_plasma_fit_values)]) axtop.set_ylim([2, 7]) labels.setXLabel('r_p', 'um') axtop.xaxis.label.set_color(plasma_color) for t1 in axtop.get_xticklabels(): t1.set_color(plasma_color) fig_options.saveFig('plotIVR')
results_uniform = MultiCaseResults( [TissueVolumeResults(case_path) for case_path in case_paths_uniform_inlet], np.hstack) results_random = MultiCaseResults( [TissueVolumeResults(case_path) for case_path in case_paths_random_inlet], np.hstack) plotter = TissueVolumeCombinedPlotter([results_random, results_uniform]) plt.clf() plotter.plot_histogram_tissue_radii_multipanel( functional_colors=[ style_scheme['int_func_radii_random_inlet_face_color'], style_scheme['int_func_radii_face_color'] ], functional_labels=['functional (random)', 'functional (constant)']) fig_options.saveFig('plotCombinedHistogramTissueRadii') topol_radii = 1e6 * np.array(results_uniform.topological_tissue_radii()) func_uniform_radii = 1e6 * np.array(results_uniform.functional_tissue_radii()) func_random_radii = 1e6 * np.array(results_random.functional_tissue_radii()) print print '{:<30s} {:7.5g} +/- {:.5g} um'.format('Topological radii:', np.mean(topol_radii), np.std(topol_radii)) print '{:<30s} {:7.5g} +/- {:.5g} um'.format('Functional radii (constant):', np.mean(func_uniform_radii), np.std(func_uniform_radii)) print '{:<30s} {:7.5g} +/- {:.5g} um'.format('Functional radii (random):', np.mean(func_random_radii), np.std(func_random_radii))
if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('--P50', '-p', type=float, help='PO2 at half saturation', default=47.9) parser.add_argument('-n', type=float, help='Hill exponent', default=2.64) figOptions = FigureOptions(parser) args = parser.parse_args() P50 = args.P50 nHill = args.n figOptions.parseOptions(args) P = np.linspace(0, 100, 200) S = np.linspace(0, 0.99, 200) bloodChem = BloodChemistry(nHill, P50) plotHillEquation(bloodChem, P) figOptions.saveFig('hillEquation') plt.clf() plotHillEquation(bloodChem, P, reversed=True) figOptions.saveFig('hillEquationReversed') plt.clf() plotdPdS(bloodChem, S) figOptions.saveFig('hillEquation_dPdS') plt.clf()
figOptions = FigureOptions(parser) args = parser.parse_args() case_path = args.caseName nAverage = args.nAverage nPlot = args.nPlot figOptions.parseOptions(args) postprocessor = make_post_processor(case_path) plotter = COSHPlotter(postprocessor) if args.multipanel: panel_layout = (2, 1) if not args.panelLayout else args.panelLayout fig, axs = plt.subplots(*panel_layout, sharex=True) plt.sca(axs[0]) plotHbProfiles(plotter) annotate_axis_corner(axs[0], 'A') if panel_layout[1] == 1: axs[0].set_xlabel('') plt.sca(axs[1]) plotStdHbProfiles(plotter) annotate_axis_corner(axs[1], 'B') figOptions.saveFig('plotCOSHHbProfilesMultipanel') else: plotHbProfiles(plotter) figOptions.saveFig('plotCOSHHbProfiles') plt.figure() plotStdHbProfiles(plotter) figOptions.saveFig('plotCOSHStdProfiles') plt.gca().set_yscale('log') figOptions.saveFig('plotCOSHStdProfilesLogScale')
parser.add_argument('--paramFile', help='Path to parameter study file', default='params.json') parser.add_argument('--methodName', '-m', help='Name of the plotting method to call') fig_options = FigureOptions(parser) args = parser.parse_args() file_name = args.paramFile method_name = args.methodName fig_options.parseOptions(args) fig, axs = plt.subplots(2, 2, sharey=True) flattened_axs = [ax for sublist in axs for ax in sublist] for study, ax, text in zip(studies, flattened_axs, annotations): path_to_study_file = os.path.join(path_to_parameter_studies, study, file_name) param_study = ParameterStudyFactory().makeParameterStudy( path_to_study_file) postprocessor = make_param_study_post_processor(param_study) plotter = COSHParamStudyPlotter(postprocessor, fig_options) plt.sca(ax) getattr(plotter, method_name)() annotate_axis_corner(ax, text) axs[0, 1].set_ylabel('') axs[1, 1].set_ylabel('') fig_options.saveFig('plotCOSHMulti_{:s}'.format(method_name))
default = 2.0) parser.add_argument('--step', type=float, help='Time difference between plots that contains all lines', \ default = 0.1) figOptions = FigureOptions(parser) args = parser.parse_args() fieldNames = args.fields x = args.x all_times = args.alltimes min_time = args.min_time max_time = args.max_time step = args.step figOptions.parseOptions(args) createPlotDirectory() if all_times: times = time_dirs('domain') if '0' in times: times.remove('0') else: n = int(round((max_time-min_time)/step) + 1) times = np.linspace(min_time, max_time, n) for time in times: plotRadialProfile('domain', x, float(time), fieldNames) figOptions.adjustAxes() figOptions.setGrid() figOptions.saveFig(plotName('domain', float(time), x)) plt.clf()
model_names.remove('linearized_ODE') except ValueError: pass figOptions.parseOptions(args) parallel_capillaries = ParallelCapillaries.fromKeyValueFile('geometricData', 2) simParams = IOHbO2ParametersStraightCapillaries('.') postprocessor = make_post_processor('.') plot_name_suffix = '' if simParams.cocurrentFlow() else '_countercurrent' if model_only: for model_name in postprocessor.integrators: plotter = DiffusiveInteractionModelPlotter( postprocessor.integrators[model_name]) plotter.plotAll() figOptions.saveFig('plot_{:s}_modelDiffusiveInteraction_Hb{:s}'.\ format(model_name, plot_name_suffix)) plt.clf() else: plotter = DiffusiveInteractionComparisonPlotter(postprocessor, model_names) if args.multipanel: panel_layout = (2, 1) if not args.panelLayout else args.panelLayout fig, axs = plt.subplots(*panel_layout, sharex=True) plt.sca(axs[0]) plotter.plotHbProfiles(plot_mean=plot_mean) annotate_axis_corner(axs[0], 'A') if panel_layout[1] == 1: axs[0].set_xlabel('') plt.sca(axs[1]) plotter.plotHbDiffProfiles(exponential_fit=exponential_fit, linearized_ode=linearized_ode) # legend = create_COSH_legend(axs[1], bbox_to_anchor=(1, 0.86))
path_to_study_file = os.path.join(path_to_parameter_studies, study, file_name) param_study = ParameterStudyFactory().makeParameterStudy( path_to_study_file) postprocessor = make_param_study_post_processor(param_study) plotter = DiffusiveInteractionParameterStudyPlotter( postprocessor, fig_options, model_names) plt.sca(ax) plotter.plotComparisonSaturationDifferenceDecayTime(color=color) ax.xaxis.label.set_color(color) for t1 in ax.get_xticklabels(): t1.set_color(color) # adapt axes limits and tick locations ax2.set_ylim(100, 200) ax2.yaxis.set_major_locator(MultipleLocator(20)) ax3.set_ylim(100, 200) ax3.yaxis.set_major_locator(MultipleLocator(20)) ax2.xaxis.set_major_locator(MultipleLocator(0.2)) # RBC velocity ax3.xaxis.set_major_locator(MultipleLocator(0.4)) # M_0 # if panel_layout[0] == 1: # ax3.set_ylabel('') # ax3.tick_params(labelleft='off') annotate_axis_corner(ax1, 'A', xy=(0.90, 0.88)) annotate_axis_corner(ax2, 'B', xy=(0.90, 0.88)) annotate_axis_corner(ax3, 'C', xy=(0.90, 0.88)) fig_options.saveFig('plotDecayTimesDiffusiveInteractionTheoreticalAndTwinAxes')
args = parser.parse_args() case_name = args.caseName settings_file = args.settingsFile error_bars = not args.noErrorBars figOptions.parseOptions(args) postprocessor = make_post_processor(case_name, param_file=settings_file) plotter = HemoglobinOnWholePathsPlotter(postprocessor) path_ids = postprocessor.selected_path_indices() if postprocessor.selection_mode == 'nPath': suffix = '_n_{:d}'.format(postprocessor.n_path) elif postprocessor.selection_mode == 'firstTime': suffix = '_fromTime_{:g}'.format(postprocessor.selection_first_time) else: suffix = '' average_suffix = '_hbAveraged' if postprocessor.integrator.average_hb else '' style_scheme = StyleSchemeCOSH() sim_linestyle = style_scheme['individualRBCWholePath'] symbol_style = style_scheme['individualRBCWholePath'] int_linestyle = {'color': '0.2', 'alpha': 1.0} annotations = ('A', 'B', 'C', 'D') # annotations = ('E', 'F', 'G', 'H') plotter.plot_compared_hb_distal_distribution_multipanel( panel_annotation=annotations) figOptions.saveFig('plotComparedHbDistalDistributionMultiPanel' + suffix + average_suffix)
fig, axs = plt.subplots(*panel_layout, sharey=True) all_axs = [[ax, ax.twiny()] for ax in axs] flattened_axs = [ax for sublist in all_axs for ax in sublist] style_scheme = styles.StyleSchemeCOSH() twin_axes_color = style_scheme['twinAxis']['color'] colors = ['k', twin_axes_color, 'k', twin_axes_color] for study, ax, color in zip(studies, flattened_axs, colors): path_to_study_file = os.path.join(path_to_parameter_studies, study, file_name) param_study = ParameterStudyFactory().makeParameterStudy(path_to_study_file) postprocessor = make_param_study_post_processor(param_study) plotter = COSHParamStudyPlotter(postprocessor, fig_options) plt.sca(ax) getattr(plotter, method_name)(style={'color': color}) ax.xaxis.label.set_color(color) for t1 in ax.get_xticklabels(): t1.set_color(color) axs[0].xaxis.set_major_locator(MultipleLocator(0.4)) axs[0].yaxis.set_major_locator(MultipleLocator(10)) flattened_axs[1].xaxis.set_major_locator(MultipleLocator(0.1)) flattened_axs[2].xaxis.set_major_locator(MultipleLocator(0.02)) flattened_axs[3].xaxis.set_major_locator(MultipleLocator(0.2)) if panel_layout[0] == 1: axs[1].set_ylabel('') annotate_axis_corner(axs[0], 'A') annotate_axis_corner(axs[1], 'B') fig_options.saveFig('plotCOSHTwinAxes_{:s}'.format(method_name))
""" import argparse import numpy as np from HbO2.setup.simulationParameters import IOHbO2ParametersAxisymmetric from plot.figureoptions import FigureOptions from plot.plotHbProfileAnalytical import plotHbProfile if __name__ == '__main__': parser = argparse.ArgumentParser() figOptions = FigureOptions(parser) args = parser.parse_args() figOptions.parseOptions(args) simParams = IOHbO2ParametersAxisymmetric('.') taperedStyle = {'style': {'color': 'k', 'linestyle': '-'}} straightStyle = {'style': {'color': 'b', 'linestyle': '--'}} plotHbProfile(simParams, **taperedStyle) Ra = simParams['radiusTissueLeft'] Rv = simParams['radiusTissueRight'] equivalentRadius = np.sqrt(1. / 3. * (Ra**2 + Ra * Rv + Rv**2)) simParams['radiusTissueLeft'] = equivalentRadius simParams['radiusTissueRight'] = equivalentRadius plotHbProfile(simParams, **straightStyle) figOptions.saveFig('plotHbProfileTaperedAndStraightCylinders')
parser.add_argument('--paramFile', help='Path to parameter study file', default='params.json') parser.add_argument('--manual-labels', action='store_true', help='Whether to set manually the contour labels') parser.add_argument('--settingsFile', help='Relative path to the file with postprocessing settings', default='postprocess.json') fig_options = FigureOptions(parser) args = parser.parse_args() file_name = args.paramFile manual_labels = args.manual_labels settings_file = args.settingsFile fig_options.parseOptions(args) fig, axs = plt.subplots(1, 2, sharey=True) twin_axs = [] for study, ax, text in zip(studies, axs, annotations): path_to_study_file = os.path.join(path_to_parameter_studies, study, file_name) param_study = ParameterStudyFactory().makeParameterStudy(path_to_study_file) postprocessor = make_param_study_post_processor(param_study) plotter = PlasmaOxygenationParamStudyPlotter(postprocessor, fig_options) plt.sca(ax) plotter.contour_delta_po2(manual_labels=manual_labels) twin_axs.append(plt.gca()) # hack to get the twin axes annotate_axis_corner(ax, text, xy=(0.94, 0.92)) twin_axs[0].set_ylabel('') twin_axs[0].set_yticklabels([]) axs[1].set_ylabel('') fig_options.saveFig('plotPlasmaOxygenation_rc_1.5um_2.0um')
fig_options.parseOptions(args) case_names = [os.path.join(param_study_path, case_name_profile) for param_study_path in parameter_studies] panel_layout = (2, 1) if not args.panelLayout else args.panelLayout fig, axs = plt.subplots(*panel_layout) plt.sca(axs[0]) case_name = os.path.join(parameter_studies[1], case_name_profile) postprocessor = make_post_processor(case_name) plotter = DiffusiveInteractionComparisonPlotter(postprocessor, model_names) plotter.plotHbProfiles() add_arrows(axs[0]) plt.sca(axs[1]) styles = [{'style': {'linestyle': '-', 'color': 'k'}}, {'style': {'linestyle': '--', 'color': 'k', 'dashes': (4, 4)}}] for param_study_path, style in zip(parameter_studies, styles): param_study_file = os.path.join(param_study_path, file_name) param_study = ParameterStudyFactory().makeParameterStudy(param_study_file) settings_dict = load_settings_file(param_study_path) postprocessor = ParameterStudyPostProcessor(param_study, settings_dict) plotter = DiffusiveInteractionParameterStudyPlotter(postprocessor, fig_options, model_names) getattr(plotter, method_name)(**style) annotate_axis_corner(axs[0], 'A') annotate_axis_corner(axs[1], 'B') fig_options.saveFig('plotDiffusiveCountercurrentComparison_{:s}'.format(method_name))
help='Maximal time difference used for the linear fit') figOptions = FigureOptions(parser) args = parser.parse_args() case_name = args.caseName eids = args.edgeIndices n_profile_min = args.nProfileMin time_diff_max_fit = args.timeDiffMaxFit figOptions.parseOptions(args) postprocessor = make_post_processor(case_name) plotter = HemoglobinOnSegmentsPlotter(postprocessor, n_profile_min=n_profile_min) fig, axs = plt.subplots(len(eids), 2) flattened_axs = [ax for sublist in axs for ax in sublist] for i, (ei, annot) in enumerate(zip(eids, annotations)): plt.sca(axs[i, 0]) plotter.plot_hb_profiles(ei) plotter.plot_hb_mean_pm_std(ei) plotter.restrict_x_limits_to_defined_values(ei) annotate_axis_corner(axs[i, 0], annot[0]) plt.sca(axs[i, 1]) plotter.plot_hb_drop_vs_time_to_previous_rbc(ei, threshold=time_diff_max_fit) annotate_axis_corner(axs[i, 1], annot[1]) e_string = '_'.join(['{:d}'.format(ei) for ei in eids]) figOptions.saveFig( 'plotHbProfilesWithDropVsRBCSpacing_e_{:s}'.format(e_string))
plotters = [TissueVolumePlotter(res) for res in results] combined_results = MultiCaseResults(results, np.hstack) combined_plotter = TissueVolumePlotter(combined_results) styles = [dict() for _ in plotters] labels = [] for case_path, style in zip(case_paths, styles): if '20151213' in case_path or 'MVN1' in case_path: style.update(style_scheme['MVN1']) style.update({'label': 'MVN 1'}) elif '20150715' in case_path or 'MVN2' in case_path: style.update(style_scheme['MVN2']) style.update({'label': 'MVN 2'}) plt.clf() combined_plotter.plot_histogram_tissue_radii() fig_options.saveFig('plotHistogramTissueRadii') plt.clf() for plotter, style in zip(plotters, styles): plotter.plot_functional_vs_topological_tissue_radii(**style) cosh_styles.create_COSH_legend(plt.gca(), loc='upper left', markerscale=0.7, handletextpad=0, handlelength=2.5) fig_options.saveFig('plotFunctionalVsTopologicalTissueRadii') plt.clf() for plotter, style in zip(plotters, styles): plotter.plot_tissue_radii_vs_hb_mean(**style) cosh_styles.create_COSH_legend(plt.gca(),
parser.add_argument('--min-time', type=float, help='Smallest time that should be used', default = 0.0) parser.add_argument('--max-time', type=float, help='Largest time that should be used', default = 2.0) parser.add_argument('--step', type=float, help='Time difference between plots that contains all lines', \ default = 0.1) figOptions = FigureOptions(parser) args = parser.parse_args() fieldName = args.field all_times = args.alltimes min_time = args.min_time max_time = args.max_time step = args.step figOptions.parseOptions(args) createPlotDirectory() if all_times: times = time_dirs('domain') if '0' in times: times.remove('0') else: n = int(round((max_time-min_time)/step) + 1) times = np.linspace(min_time, max_time, n) for time in times: plotPO2ProfileEulerian('domain', float(time), fieldName) figOptions.adjustAxes() figOptions.saveFig(plotName('.', float(time))) plt.clf()
plotter = AxisymmetricCasePlotter(postprocessor) plotter.plot_field_average_profile('Hb_mean', n_average=1) def plotHbSimulatedGraph(caseName): postprocessor = GraphCasePostProcessor(caseName) plotter = GraphCasePlotter(postprocessor) plotter.plotFieldAverageProfile('Hb_mean', 0, nAverage=10) def plotHbSimulatedAndAnalytical(caseName, simParams, **kwargs): if isGraphCase(caseName): plotHbSimulatedGraph(caseName) elif isAxisymmetricCase(caseName): plotHbSimulatedAxisymmetric(caseName) plotHbProfile(simParams, **kwargs) # plt.legend(['Simulated', 'ODE model']) if __name__ == '__main__': parser = argparse.ArgumentParser() figOptions = FigureOptions(parser) args = parser.parse_args() figOptions.parseOptions(args) analyticalLineStyle = {'color': 'k', 'linestyle': '-', 'dashes': (4, 2.5)} simParams = SimulationParametersFactory().make_sim_params('.') plotHbSimulatedAndAnalytical('.', simParams, style=analyticalLineStyle) figOptions.saveFig('plotHbSimulatedAndAnalytical')
from HbO2.setup.simulationParameters import IOHbO2ParametersAxisymmetric from plot.figureoptions import FigureOptions from plot.plotPO2ProfileAnalytical import plotPO2Profile parser = argparse.ArgumentParser() parser.add_argument('--cases', nargs='+', help='Relative paths of folders to plot', default=['.']) parser.add_argument('-r', type=float, help='Radius for PO2 calculation', default=17.6e-6) fig_options = FigureOptions(parser) args = parser.parse_args() fig_options.parseOptions(args) cases = args.cases radius = args.r styles = [{'color': 'k'}, {'color': 'b'}, {'color': 'r'}] for case, style in zip(cases, styles): sim_params = IOHbO2ParametersAxisymmetric(case) plotPO2Profile(sim_params, radius=radius, style=style) plt.legend([case.replace('_', '-') for case in cases]) plot_name = 'plot_compare_' + '_'.join(cases) + '_r_{:g}'.format(1e6 * radius) fig_options.saveFig(plot_name)
nargs='+', help='Models for which to plot results', default=['krogh', 'simple']) fig_options = FigureOptions(parser) args = parser.parse_args() file_name = args.paramFile method_name = args.methodName model_names = args.modelNames fig_options.parseOptions(args) fig, axs = plt.subplots(2, 2, sharey=True) flattened_axs = [ax for sublist in axs for ax in sublist] for study, ax, text in zip(studies, flattened_axs, annotations): path_to_study = os.path.join(path_to_parameter_studies, study) path_to_study_param_file = os.path.join(path_to_study, file_name) param_study = ParameterStudyFactory().makeParameterStudy( path_to_study_param_file) settings_dict = load_settings_file(path_to_study) postprocessor = ParameterStudyPostProcessor(param_study, settings_dict) plotter = DiffusiveInteractionParameterStudyPlotter( postprocessor, fig_options, model_names) plt.sca(ax) getattr(plotter, method_name)() annotate_axis_corner(ax, text) axs[0, 1].set_ylabel('') axs[1, 1].set_ylabel('') fig_options.saveFig('plotDiffusiveInteractionMulti_{:s}'.format(method_name))
average_suffix = '_hbAveraged' if postprocessor.integrator.average_hb else '' integrated_suffix = '_withIntegrated' if integrated_profiles else '' style_scheme = StyleSchemeCOSH() sim_linestyle = style_scheme['individualRBCWholePath'] symbol_style = style_scheme['individualRBCWholePath'] int_linestyle = {'color': '0.2', 'alpha': 1.0} if integrated_profiles: plotter.plot_integrated_hb_profile_vs_path_length(style=int_linestyle) plotter.plot_distal_hb_vs_path_length_with_paths( path_ids, path_style=sim_linestyle, symbol_style=style_scheme['distalHbMarker'], error_bars=error_bars) figOptions.saveFig('plotHbWholePathVsPathLength' + suffix + integrated_suffix) plt.clf() if integrated_profiles: plotter.plot_integrated_hb_profile_vs_transit_time(style=int_linestyle) plotter.plot_distal_hb_vs_transit_time_with_paths( path_ids, path_style=sim_linestyle, symbol_style=style_scheme['distalHbMarker'], error_bars=error_bars) figOptions.saveFig('plotHbWholePathVsTransitTime' + suffix + integrated_suffix) plt.clf() plotter.plot_hb_drop_vs_transit_time() figOptions.saveFig('plotHbDropVsTransitTime' + suffix)
plotter.kroghSol.LD = LD plotter.kroghSol.vRBC = U plt.sca(ax) plotter.plotPO2DerivativeRatio() xlabel = ax.get_xlabel() xticklabels = ax.get_xticks().tolist() xticklabels = ['%i' % label for label in xticklabels] ax.set_xlabel('') ax.set_xticklabels(['']) # ylabel = ax.get_ylabel() # yticklabels = ax.get_yticks().tolist() # yticklabels = ['%i' % label for label in yticklabels] # ax.set_ylabel('') # ax.set_yticklabels(['']) axs[-1].set_xlabel(xlabel) axs[-1].set_xticklabels(xticklabels) # axs[0].set_ylabel(ylabel) # axs[0].set_yticklabels(yticklabels) figOptions.adjustAxes() # put A, B, C at the top right corner of each plot axs[0].annotate(r'$\mathbf{A}$', xy=(0.90, 0.91), xycoords='axes fraction') axs[1].annotate(r'$\mathbf{B}$', xy=(0.90, 0.91), xycoords='axes fraction') axs[2].annotate(r'$\mathbf{C}$', xy=(0.90, 0.91), xycoords='axes fraction') plotName = 'plotMultiPO2DerivativeRatio' # plotName = 'plotMultiPO2DerivativeRatioHorizontal' figOptions.saveFig(plotName)
style.update(style_scheme['MVN2']) if args.multipanel: panel_layout = (2, 1) if not args.panelLayout else args.panelLayout fig, axs = plt.subplots(*panel_layout, sharex=True) plt.sca(axs[0]) for plotter, style in zip(plotters, styles): plotter.plot_std_difference_vs_upstream_std(**style) if panel_layout[1] == 1: axs[0].set_xlabel('') annotate_axis_corner(axs[0], 'A') plt.sca(axs[1]) for plotter, style in zip(plotters, styles): plotter.plot_std_slope_vs_upstream_std(**style) annotate_axis_corner(axs[1], 'B') figOptions.saveFig('plotStdDifferenceAndSlopeVsUpstreamStd') else: plt.clf() for plotter, style in zip(plotters, styles): plotter.plot_std_difference_vs_upstream_std(**style) figOptions.saveFig('plotStdDifferenceVsUpstreamStd') plt.clf() for plotter, style in zip(plotters, styles): plotter.plot_std_slope_vs_upstream_std(**style) xlim = (-0.001, plt.gca().get_xlim()[1]) plt.gca().set_xlim(xlim) figOptions.saveFig('plotStdSlopeVsUpstreamStd') plt.clf() for plotter, style in zip(plotters, styles):