def __init__(self, case_path, graph, **kwargs):
"""
Constructor
Args:
case_path (str): path to current case
graph (igraph.Graph): directed graph with flow and geometry information
**topological_radii (bool): whether to use topological tissue radii (default: True)
**tissue_volumes_file (str): name of the file with the topological tissue volumes
**average_hb (bool): whether to average the hemoblogin saturation at converging
bifurcations
"""
self.case_path = case_path
self.graph = graph
self.sim_params = SimulationParametersFactory().make_sim_params(
case_path)
self.inlet_hb = GraphInletValue.from_json(
os.path.join(case_path, self.inlet_value_file))
self.use_topological_radii = kwargs.get('topological_radii', True)
self.tissue_volumes_results = TissueVolumeResults(case_path)
self.average_hb = kwargs.get('average_hb', False)
self.topological_tissue_volumes_dict = \
{ei: vt for ei, vt in zip(self.tissue_volumes_results.edge_ids(),
self.tissue_volumes_results.topological_tissue_volumes())}
self.functional_tissue_volumes_dict = \
{ei: vt for ei, vt in zip(self.tissue_volumes_results.edge_ids(),
self.tissue_volumes_results.functional_tissue_volumes())}
self.compute()
def __init__(self, case_path, sample_dir_name='sampleRBCHb'):
super(RBCDataSampled, self).__init__(case_path)
self.sim_params = SimulationParametersFactory().make_sim_params(
case_path)
self.rbc_fields = loadSampledRBCs(case_path,
sample_dir_name,
cache_paths=False)
self._change_rbc_field_names()
def plotPO2SimulatedAndAnalyticalYProfile(caseName, time, x, **kwargs):
simParams = SimulationParametersFactory().make_sim_params(caseName)
fieldNames = kwargs.get('fieldNames', ['PO2'])
plotPO2YProfiles.plotRadialProfile(caseName,
x,
float(time),
fieldNames,
plotFields=['PO2Mean'])
# plotPO2YProfiles.plotRadialProfileFromPath('PO2RBCAxialAveraged.txt')
plotPO2ProfileAnalytical.plotPO2YProfile(simParams, x, **kwargs)
def __init__(self, parameterStudyFile='params.json'):
super(ParameterStudy, self).__init__()
self['file'] = parameterStudyFile
jsonData = open(parameterStudyFile)
self.data = json.load(jsonData)
jsonData.close()
self['path'] = os.path.dirname(self['file'])
self['baseCaseName'] = self.data['baseCase']
self['baseCasePath'] = os.path.join(self['path'], self['baseCaseName'])
self.baseCaseSimParams = SimulationParametersFactory().make_sim_params(
self['baseCasePath'])
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')
def __init__(self, case_path):
self.case_path = case_path
self.simParams = SimulationParametersFactory().make_sim_params(case_path)
class CasePostProcessor(object):
"""
General post processor for an OpenFOAM case.
The attributes simParams, rbcData and rbcDataPostProcessor are constructed according to
the type of OpenFOAM case.
Results are accessible in string form, based on the class attributes result_output_dict
which should be redefined by subclasses.
Attributes:
case_path (str): path to case to postprocess
simParams (HbO2Parameters: simulation parameters
Lazy properties:
rbc_data (rbc_data): RBC data
rbcDataPostProcessor (RBCDataPostProcessor)
Class attributes:
result_output_dict (OrderedDict): dictionary that defines the postprocessor text output
output_file_name (str): name of the output file.
"""
output_file_name = 'results.txt'
# Dictionary that defines how to extract and display results in the method result_string.
# The syntax is:
# dict[headerName] = (methodName, args, formatString), where
# headerName (str): name of the header
# methodName: (str) method of postprocessor class to call
# args (tuple): method arguments
# formatString (str): string formatter for output
result_output_dict = OrderedDict()
def __init__(self, case_path):
self.case_path = case_path
self.simParams = SimulationParametersFactory().make_sim_params(case_path)
def run(self):
pass
def fieldTimeDirs(self):
"""Return the list of time folders where fields have been written."""
return time_dirs(os.path.join(self.case_path, 'domain'))
def sValues(self):
"""
Return the curvilinear coordinates to use on the edge.
For simulations in graphs, an offset might need to be added to self.xValues.
"""
if isAxisymmetricCase(self.case_path):
return self.xValues
elif isGraphStraightCapillariesCase(self.case_path):
return self.xValues + self.simParams.sCoordOffset()
else:
raise RuntimeError('Case type not supported')
@lazy_property
def rbc_data(self):
return make_rbc_data(self.case_path)
@lazy_property
def rbcDataPostProcessor(self):
if isGraphCase(self.case_path):
return RBCDataGraphPostProcessor(self.rbc_data)
elif isAxisymmetricCase(self.case_path):
return RBCDataPostProcessor(self.rbc_data)
def result_string(self, result_name, *args, **kwargs):
"""
Return a string with the a result value.
The resultName should be a key of the dictionary result_output_dict.
The method can also be a property of the class. In that case, getattr(self, method)
does not return a callable object and the value of getattr(self, method) is directly
used, without using the additional arguments.
Args:
result_name (str): name of result to compute
*args: additional argument to be passed to methods
**kwargs: dictionary-like arguments to be passed to methods
Returns:
string with the result value
"""
method, firstargs, format_str = self.result_output_dict[result_name]
if callable(getattr(self, method)):
result = getattr(self, method)(*(firstargs + args), **kwargs)
else:
result = getattr(self, method)
try:
return format_str.format(result)
except ValueError:
print 'Error with result', result_name, 'while formatting string', \
format_str, 'with result', result
raise
def output_files_and_result_strings(self, *args, **kwargs):
"""
Return a dictionary with the output file name as a key and a list with all strings
produced by the postprocessor as a value
Args:
*args: additional argument to be passed to methods
**kwargs: dictionary-like arguments to be passed to methods
Returns:
dictionary with list of results
"""
if self.result_output_dict:
return {self.output_file_name: [self.result_string(result_name, *args, **kwargs)
for result_name in self.result_output_dict.keys()]}
else:
return {}
def output_files_and_result_names(self):
"""
Return a dictionary with the output file name as a key and a list with the result names
as a value
Returns:
dictionary with header
"""
if self.result_output_dict:
return {self.output_file_name: self.result_output_dict.keys()}
else:
return {}
dependentVariables = copy.deepcopy(
IOHbO2ParametersStraightCapillaries.dependentVariables)
# no dependent variables are defined in HbO2SimulationParameters
dependentVariables['CFL'] = ['deltaT']
dependentVariables['dx'] = ['deltaT']
dependentVariables['RBCVelocity'] = ['deltaT']
def __init__(self, case_path='.'):
super(IOHbO2SimulationParametersStraightCapillaries,
self).__init__(case_path)
if __name__ == "__main__":
from HbO2.setup.case import SimulationParametersFactory
simParams = SimulationParametersFactory().make_sim_params(
'.', use_numerics=True)
if isAxisymmetricCase('.'):
print "Computed deltaT: %g" % simParams['deltaT']
print simParams
print "RBC length after setting the radiusRBC to radiusPlasma:"
simParams['radiusRBC'] = simParams['radiusPlasma']
print simParams['RBCLength'], simParams['RBCHalfLength']
print "RBC length after increasing RBC volume:"
simParams['RBCVolume'] = 69e-18
print simParams['RBCLength'], simParams['RBCHalfLength']
simParams.update_files()
elif isGraphCase('.'):
print "Computed PO2Tissue: {:g}".format(simParams['PO2Tissue'])
print "Computed HbInit: {:g}".format(simParams['HbInit'])
print "Computed deltaT: {:g}".format(simParams['deltaT'])
simParams.update_files()
def simParamsList(self):
"""Return a list of simulationParameter objects for the parameter study."""
# return map(lambda s: HbO2SimulationParametersAxisymmetric(s), self.casePaths())
return map(lambda s: SimulationParametersFactory().\
make_sim_params(s, use_numerics=True), self.casePaths())
def plotPO2SimulatedAndAnalyticalXProfile(caseName, time, radius, **kwargs):
simParams = SimulationParametersFactory().make_sim_params(caseName)
fieldName = kwargs.get('fieldName', 'PO2Mean')
plotPO2XProfiles.plotPO2ProfileEulerian(caseName, float(time), fieldName)
plotPO2ProfileAnalytical.plotPO2Profile(simParams, radius, **kwargs)