def make_post_processor(self, case_path):
"""
Abstract factory method for that produces a postprocessor
Args:
case_path (str): path to case
Returns:
postprocessor object, expected to be a derived class of casePostProcessor
"""
from HbO2.postprocess.factory.case import make_post_processor
return make_post_processor(case_path, settings_dict=self.post_processing_settings)
def plotProfiles(self):
for caseName in self.post_processor.param_study.caseNames():
print "Plotting profiles for %s" % caseName
postprocessor = make_post_processor(caseName)
plotter = COSHPlotter(postprocessor)
plotter.plotODEMeanHbProfile()
plotter.plotSimMeanHbProfile()
self.fig_options.saveFig('plotCOSHHbProfiles_%s' % caseName)
plt.clf()
plotter.plotODEStdHbProfile()
plotter.plotODELinearizedStdHbProfile()
plotter.plotSimStdHbProfile()
plotter.plotExponentialFitStdHb()
self.fig_options.saveFig('plotCOSHStdProfiles_%s' % caseName)
plt.gca().set_yscale('log')
self.fig_options.saveFig('plotCOSHStdProfilesLogScale_%s' %
caseName)
plt.clf()
#!/usr/bin/env python
"""
Postprocess hemoglobin values from simulations in a graph
"""
import argparse
from HbO2.postprocess.factory.case import make_post_processor
from utilities.arguments import add_case_argument
if __name__ == '__main__':
parser = argparse.ArgumentParser()
add_case_argument(parser)
parser.add_argument('--settingsFile', default='postprocess.json')
args = parser.parse_args()
case_name = args.caseName
settings_file = args.settingsFile
pp = make_post_processor(case_name, settings_file)
pp.write_results()
print 'Wrote results to {:s}'.format(pp.output_file_name)
print 'Inlet edges: ', pp.rbcDataPostProcessor.rbc_path_analyzer.inlet_edges(
)
print 'Outlet edges:', pp.rbcDataPostProcessor.rbc_path_analyzer.outlet_edges(
)
print 'Post-converging bifurcation edges:', pp.rbcDataPostProcessor.rbc_path_analyzer.\
post_converging_bifurcation_edges()
#!/usr/bin/env python
"""
Compute the hemoglobin saturation along a capillary network using the ODE model.
"""
import argparse
import cPickle as pickle
from HbO2.setup.graph import make_graph_from_post_processor, plot_graph
from HbO2.postprocess.factory.case import make_post_processor
from utilities.arguments import add_case_argument
if __name__ == '__main__':
parser = argparse.ArgumentParser()
add_case_argument(parser)
parser.add_argument('--settingsFile', default='postprocess.json')
parser.add_argument('--pickleName', default='graph.pkl')
args = parser.parse_args()
case_name = args.caseName
param_file = args.settingsFile
pickle_name = args.pickleName
pp = make_post_processor(case_name, param_file)
graph = make_graph_from_post_processor(pp)
plot_graph(graph)
pickle.dump(graph, open(pickle_name, 'wb'))
print "Wrote graph pickle to {:s}".format(pickle_name)
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('.')
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)
def plotHbSimulatedAxisymmetric(case_name):
postprocessor = make_post_processor(case_name)
plotter = AxisymmetricCasePlotter(postprocessor)
plotter.plot_field_average_profile('Hb_mean', n_average=1)
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:
sids = args.segmentIndices
if multipanel:
nrow = len(sids) / ncol
fig, axs = plt.subplots(nrow, ncol)
flattened_axs = [ax for sublist in axs for ax in sublist]
for si, ax, annotation in zip(sids, flattened_axs, annotations):
plt.sca(ax)
plotter.plot_hb_profiles(si)
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)
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)
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')
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:
