import numpy as np
from HbO2.plot import styles as cosh_styles
from HbO2.plot.tissuevolumes import TissueVolumePlotter
from HbO2.postprocess.results import MultiCaseResults
from HbO2.postprocess.tissuevolumes import TissueVolumeResults
from plot.figureoptions import FigureOptions
from utilities.arguments import add_single_or_multi_case_group
style_scheme = cosh_styles.StyleSchemeCOSH()
plot_styles = [style_scheme['MVN1'], style_scheme['MVN2']]
parser = argparse.ArgumentParser()
add_single_or_multi_case_group(parser)
fig_options = FigureOptions(parser)
args = parser.parse_args()
multi_case = True if args.caseNames else False
if not multi_case:
case_paths = [args.caseName]
else:
case_paths = args.caseNames
fig_options.parseOptions(args)
results = [TissueVolumeResults(case_path) for case_path in case_paths]
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):
dPdS = bloodChem.dPdSHill(S)
plt.plot(S, dPdS)
labels.setXLabel('S', '-')
labels.setYLabel('dP/dS', 'mmHg')
plt.ylim(ymax=300)
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')
import matplotlib.pyplot as plt
from HbO2.model.coefficients import intravascularResistanceAnalytical
from HbO2.plot import labels
from HbO2.setup.simulationParameters import IOHbO2SimulationParametersAxisymmetric
from parse.readfile import load_numeric_to_dictionary
from plot.figureoptions import FigureOptions
script_path_env_var = 'OF_SCRIPTS'
radius_rbc_fit_file_path = 'input/IVRFittedOnRadiusRBCNew.txt'
radius_plasma_fit_file_path = 'input/IVRFittedOnRadiusPlasmaNew.txt'
plasma_color = [0, 0, 0.75]
parser = argparse.ArgumentParser()
fig_options = FigureOptions(parser)
args = parser.parse_args()
fig_options.parseOptions(args)
script_path = os.environ[script_path_env_var]
rbc_file_path = os.path.join(script_path, radius_rbc_fit_file_path)
plasma_file_path = os.path.join(script_path, radius_plasma_fit_file_path)
with open(rbc_file_path, 'r') as f:
data = load_numeric_to_dictionary(f)
radius_rbc_fit_values = data['radiusRBC']
ivr_fitted_on_radius_rbc = data['IVR']
with open(plasma_file_path, 'r') as f:
data = load_numeric_to_dictionary(f)
radius_plasma_fit_values = data['radiusPlasma']
ivr_fitted_on_radius_plasma = data['IVR']
parser.add_argument('--path',
'-p',
help='Path of the case to postprocess',
default='.')
parser.add_argument('--nAverage',
'-n',
type=int,
default=10,
help='Number of RBC paths used for averaging')
parser.add_argument(
'--nPlot',
type=int,
default=10,
help='Number of RBCs used for plotting individual paths')
add_multi_panel_parser_options(parser)
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')
import numpy as np
import os
import scipy.stats
from HbO2.plot import styles as cosh_styles
from HbO2.plot.tissuevolumes import TissueVolumeCombinedPlotter
from HbO2.postprocess.results import MultiCaseResults
from HbO2.postprocess.tissuevolumes import TissueVolumeResults
from plot.figureoptions import FigureOptions
style_scheme = cosh_styles.StyleSchemeCOSH()
plot_styles = [style_scheme['MVN1'], style_scheme['MVN2']]
parser = argparse.ArgumentParser()
fig_options = FigureOptions(parser)
args = parser.parse_args()
cbf_path = os.environ['OF_CBF']
func_net_path = 'HbO2/eulerGraph/COSH/functionalNetwork'
case_paths_uniform_inlet = [
os.path.join(cbf_path, func_net_path,
'funcNet20151213/d_mean_5_d_std_1.5/ROI2b-dx_1um-24proc-new'),
os.path.join(cbf_path, func_net_path,
'funcNet20150715/d_mean_5_d_std_1.5/ROI2-dx_1um-24proc-new')
]
case_paths_random_inlet = [
os.path.join(
cbf_path, func_net_path,
'funcNet20151213/d_mean_5_d_std_1.5/ROI2b-dx_1um-24proc-randomInletHb'
),
'PO2YProfiles_x_%g_t_%.5f' % (1e6*x, time))
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--fields', '-f', nargs='+', help='Fields to plot', default=['PO2'])
parser.add_argument('-x', type=float, help='x-coordinate to plot', default=50e-6)
parser.add_argument('--alltimes', '-a', help='Whether to plot all time folders',
action='store_true')
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()
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')
'-m',
help='Plot only model results',
action='store_true')
parser.add_argument(
'--modelNames',
nargs='+',
help='Models for which to plot results',
default=['krogh', 'simple', 'equal_outfluxes', 'linearized_ODE'])
parser.add_argument('--exponentialFit',
help='Whether to plot the exponential fit',
action='store_true')
parser.add_argument('--noMean',
help='Whether to plot the mean profiles',
action='store_false')
add_multi_panel_parser_options(parser)
figOptions = FigureOptions(parser)
args = parser.parse_args()
model_only = args.modelOnly
model_names = args.modelNames
exponential_fit = args.exponentialFit
plot_mean = not args.noMean
linearized_ode = 'linearized_ODE' in model_names
try:
model_names.remove('linearized_ODE')
except ValueError:
pass
figOptions.parseOptions(args)
parallel_capillaries = ParallelCapillaries.fromKeyValueFile('geometricData', 2)
simParams = IOHbO2ParametersStraightCapillaries('.')
postprocessor = make_post_processor('.')
import argparse
from HbO2.plot.styles import StyleSchemeCOSH
from HbO2.plot.hemoglobingraph import HemoglobinOnWholePathsPlotter
from HbO2.postprocess.factory.case import make_post_processor
from plot.figureoptions import FigureOptions
from utilities.arguments import add_case_argument
parser = argparse.ArgumentParser()
add_case_argument(parser)
parser.add_argument(
'--settingsFile',
help='Relative path to the file with postprocessing settings',
default='postprocess.json')
parser.add_argument('--noErrorBars', action='store_true')
figOptions = FigureOptions(parser)
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)
legend.get_frame().set_linewidth(0.5)
return legend
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--field', '-f', help='Field to plot', default='PO2')
parser.add_argument('--alltimes', '-a', help='Whether to plot all time folders',
action='store_true')
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:
Plot Hb profiles in a capillary using the analytical model.
One plot in the geometry read from simParams, the other in a
geometry which is a straight cylinder with the same tissue volume.
"""
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)
setYLabel('S', '')
parser = argparse.ArgumentParser()
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('--modelNames',
nargs='+',
help='Models for which to plot results',
default=['krogh', 'simple'])
add_panel_layout_parser_options(parser)
fig_options = FigureOptions(parser)
args = parser.parse_args()
file_name = args.paramFile
manual_labels = args.manual_labels
model_names = args.modelNames
fig_options.parseOptions(args)
panel_layout = (3, 1) if not args.panelLayout else args.panelLayout
if panel_layout[0] == 1:
ax1 = plt.subplot(131)
ax2 = plt.subplot(132)
ax3 = plt.subplot(133, sharey=ax2)
else:
ax1 = plt.subplot(311)
ax2 = plt.subplot(312)
ax3 = plt.subplot(313)
from plot.figureoptions import FigureOptions
from plot.utils import annotate_axis_corner
path_to_parameter_studies = "/local/aluecker/OpenFOAM/aluecker-2.3.0/run/cbf/HbO2/eulerAxisymmetric/PO2PlasmaVsHb"
studies = ["paramStudyShort_rc_1.5um_M0_200_2000_LD_0.1_0.9/",
"paramStudyShort_rc_2.0um_M0_200_2000_LD_0.1_0.9/"]
annotations = ['A', 'B']
parser = argparse.ArgumentParser()
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)
)
parameter_studies = [("/local/aluecker/OpenFOAM/aluecker-2.3.0/run/cbf/HbO2/eulerGraph/COSH"
"/straightCapillaryArray/diffusiveInteraction/deltaSStudy"),
("/local/aluecker/OpenFOAM/aluecker-2.3.0/run/cbf/HbO2/eulerGraph/COSH"
"/straightCapillaryArray/diffusiveInteraction/countercurrentFlow/deltaSStudy")]
case_name_profile = "case_deltaS_0.2"
model_names = ['krogh', 'equal_outfluxes']
parser = argparse.ArgumentParser()
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')
add_multi_panel_parser_options(parser)
fig_options = FigureOptions(parser)
args = parser.parse_args()
file_name = args.paramFile
method_name = args.methodName
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)
parser.add_argument('--edgeIndices',
'-e',
type=int,
nargs='+',
default=[],
help='Edge indices where to plot hemoglobin saturation')
parser.add_argument('--nProfileMin',
'-n',
type=int,
default=1,
help='Minimal number of profiles to plot')
parser.add_argument('--timeDiffMaxFit',
type=float,
default=np.inf,
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])
'--segmentIndices',
'-s',
type=int,
nargs='+',
default=[],
help='Segment indices where to plot hemoglobin saturation')
parser.add_argument('--integratedProfiles', action='store_true')
parser.add_argument('--nProfileMin',
'-n',
type=int,
default=2,
help='Minimal number of profiles to plot')
parser.add_argument('--multipanel',
action='store_true',
help='Whether to create multiple panels in one figure')
figOptions = FigureOptions(parser)
args = parser.parse_args()
case_name = args.caseName
settings_file = args.settingsFile
integrated_profiles = args.integratedProfiles
n_profile_min = args.nProfileMin
multipanel = args.multipanel
figOptions.parseOptions(args)
postprocessor = make_post_processor(case_name, param_file=settings_file)
plotter = HemoglobinOnSegmentsPlotter(postprocessor,
n_profile_min=n_profile_min)
if args.allSegments:
sids = plotter.edge_ids()
else:
parser = argparse.ArgumentParser()
parser.add_argument('--setup', '-s', action='store_true')
parser.add_argument('--postProcess', '-p', action='store_true')
parser.add_argument('--plot', action='store_true')
parser.add_argument('--paramFile',
help='Path to parameter study file',
default='params.json')
parser.add_argument(
'--settingsFile',
help='Relative path to the file with postprocessing settings',
default='postprocess.json')
parser.add_argument('--counter',
'-c',
help='Countercurrent flow',
action='store_true')
fig_options = FigureOptions(parser)
args = parser.parse_args()
doSetup = args.setup
doPostProcess = args.postProcess
doPlot = args.plot
fileName = args.paramFile
settings_file = args.settingsFile
cocurrent = not args.counter
param_study = ParameterStudyFactory().makeParameterStudy(fileName)
if doSetup:
param_study.setup()
else:
post_processor = make_param_study_post_processor(param_study)
if doPostProcess:
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.plot.hemoglobingraph import HemoglobinOnWholePathsPlotter
from HbO2.postprocess.factory.case import make_post_processor
from plot.figureoptions import FigureOptions
from utilities.arguments import add_case_argument
annotations = string.ascii_uppercase
parser = argparse.ArgumentParser()
add_case_argument(parser)
parser.add_argument(
'--settingsFile',
help='Relative path to the file with postprocessing settings',
default='postprocess.json')
parser.add_argument('--integratedProfiles', action='store_true')
parser.add_argument('--noErrorBars', action='store_true')
figOptions = FigureOptions(parser)
args = parser.parse_args()
case_name = args.caseName
settings_file = args.settingsFile
integrated_profiles = args.integratedProfiles
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':
studies = ["domainHeightStudy", "M0Study", "RBCVelocityStudy", "LDMeanStudy"]
annotations = ['A', 'B', 'C', 'D']
parser = argparse.ArgumentParser()
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')
parser.add_argument('--modelNames',
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)
path_to_parameter_studies = "/local/aluecker/OpenFOAM/aluecker-2.3.0/run/cbf/HbO2/eulerAxisymmetric/COSH"
studies = [
"O2ConsumptionStudyShort", "sigmaSStudy",
"LD_U_study/paramStudyShort2_slices/paramStudyShort2_LD_0.3",
"LD_U_study/paramStudyShort2_slices/paramStudyShort2_U_0.001"
]
annotations = ['A', 'B', 'C', 'D']
parser = argparse.ArgumentParser()
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)
# Plots results from plotPO2DerivativeRatioAnalytical for several values of (LD, v_RBC).
#
import argparse
import matplotlib.pyplot as plt
from HbO2.plot.analytical import PO2DerivativeRatioPlotter
from HbO2.setup.simulationParameters import IOHbO2ParametersAxisymmetric
from plot.figureoptions import FigureOptions
if __name__ == '__main__':
# parse arguments
parser = argparse.ArgumentParser()
figOptions = FigureOptions(parser)
args = parser.parse_args()
figOptions.parseOptions(args)
figOptions.applyOptions()
simParams = IOHbO2ParametersAxisymmetric('.')
plotter = PO2DerivativeRatioPlotter(simParams)
LDValues = [0.35, 0.2, 0.5]
UValues = [1.2e-3, 2e-3, 0.6e-3]
fig, axs = plt.subplots(3, 1)
# fig, axs = plt.subplots(1,3)
for (ax, LD, U) in zip(axs, LDValues, UValues):
from plot.utils import add_multi_panel_parser_options, annotate_axis_corner
style_scheme = styles.StyleSchemeCOSH()
parser = argparse.ArgumentParser()
parser.add_argument('--cases',
nargs='+',
default=['.'],
help='Cases for which to plot results')
parser.add_argument('--nProfileMin',
'-n',
type=int,
default=1,
help='Minimal number of profiles to plot')
add_multi_panel_parser_options(parser)
figOptions = FigureOptions(parser)
args = parser.parse_args()
cases = args.cases
n_profile_min = args.nProfileMin
figOptions.parseOptions(args)
postprocessors = [make_post_processor(case) for case in cases]
plotters = [
HemoglobinOnSegmentsPlotter(pp, n_profile_min=n_profile_min)
for pp in postprocessors
]
styles = [dict() for _ in plotters]
for case_path, style in zip(cases, styles):
if '20151213' in case_path:
style.update(style_scheme['MVN1'])
