CDMATH/postprocessing/resultsBase.py

   1 import glob
   2 # import pdb
   3 import string
   4 import os
   5 import re
   6 import numpy as np
   7 import matplotlib.pyplot as plt
   8 import matplotlib.ticker as mtick
   9 import dpath
  10 import VTK_routines
  11 import PV_routines
  12 import MED_routines
  13 # import pprint as pp
  14 import logging
  15 from matplotlib.pyplot import xlabel
  16 import __main__
  17
  18
  19 # TODO : to be replaced with a proper log system
  20 try:
  21     LOG_FILE_NAME = os.path.splitext(__main__.__file__)[0] + '.log'
  22 except:
  23     LOG_FILE_NAME = 'resultsBaseProcess.log'
  24 logging.basicConfig(filename=LOG_FILE_NAME, level=logging.DEBUG)
  25 # logging.basicConfig(filename=__main__.__file__+'resDb.log', level=logging.WARNING)
  26
  27 # TODO : shouldn't we use join??
  28
  29
  30 def create_file_list(workDir, ext=None, fname_glob=None):
  31     expanded_path = os.path.expanduser(workDir)
  32     abs_path = os.path.abspath(expanded_path)
  33     # TODO : we should test if directory exists
  34     if fname_glob is None:
  35         pattern_for_files = abs_path + '/*' + ext
  36     elif ext is None:
  37         pattern_for_files = abs_path + '/' + fname_glob
  38     file_list = glob.glob(pattern_for_files)
  39     return file_list
  40
  41 # TODO : we should use regexp instead?
  42
  43
  44
  45 # TODO : the new tag system should be implemented
  46 class Result:
  47     def __init__(self, file_name,
  48                  variable,
  49                  dimension,
  50                  instant=None,
  51                  step=None,
  52                  solver=None,
  53                  tags=[],
  54                  code=None,
  55                  is_stationnary=True
  56                  ):
  57         self.file_name = os.path.abspath(file_name)
  58         absolute_root_name, ext = os.path.splitext(self.file_name)
  59         root_name = os.path.basename(absolute_root_name)
  60         self.root_name = root_name
  61         self.file_extension = ext
  62         self.tags = set()
  63         self.tags.update(set(tags))
  64         self.code = code
  65         self.solver = solver
  66         self.variable = variable
  67         self.instant = instant
  68         self.step = step
  69         self.is_stationnary = is_stationnary
  70         self.dim = dimension
  71         self.default_probe = self.create_default_probe()
  72 #        self.checkResFieldIsValid() # useless
  73         for k in ['file_extension', 'code', 'variable',
  74                   'instant', 'step', 'is_stationnary', 'dim', 'default_probe', 'solver']:
  75             self.tags.add('required:{}={}'.format(k, self.__dict__[k]))
  76
  77     def __repr__(self):
  78         txt = ""
  79         for k, v in self.__dict__.items():
  80             txt += "\t{}={}\n".format(k, v)
  81         return txt
  82
  83 # does this really make sense?
  84     @property
  85     # TODO : can be replaced with a prop
  86     def setTags(self, newTags):
  87         self.tags + newTags
  88
  89 class Probe:
  90     def __init__(self, file_name,variable_name,
  91                  name,
  92                  line=None,
  93                  ExtractData=None,
  94                  tags=[]
  95                  ):
  96         self.file_name = file_name
  97         self.variable_name=variable_name
  98         self.probe_name = name
  99         self.line = line
 100         self.extract_data = ExtractData
 101         self._tags = set(['required:probe_id={}'.format(self)])
 102         self._tags.update(tags)
 103
 104     @property
 105     def tags(self):
 106         return self._tags.union(self.field_result.tags)
 107
 108     @property
 109     def master_tag(self):
 110         return string.join(self._tags.union(self.field_result.tags), sep=";")
 111
 112     @property
 113     def data(self):
 114         return self.extract_data(self)
 115
 116     @property
 117     def variable_name(self):
 118         return self.variable_name
 119
 120     @property
 121     def file_name(self):
 122         return self.file_name
 123
 124
 125 # is it really useful?
 126 def build_marker_default(probe):
 127     return "-"
 128
 129 # is it really useful?
 130 def build_color_default(probe):
 131     return "red"
 132
 133
 134 class DataView():
 135     def __init__(self):
 136         self.x_range = []
 137         self.y_range = []
 138         self.title = "empty title"
 139         self.x_label = "xLabel"
 140         self.y_label = "yLabel"
 141         self.probes = []
 142
 143     def __repr__(self):
 144         repr_str = '''\txRange={}
 145         \tyRange={}
 146         \ttitle={}
 147         \txLabel={}
 148         \tyLabel={}
 149         '''.format(self.x_range, self.y_range, self.title, self.x_label, self.y_label)
 150         repr_str += "\tprobeList=\n"
 151         for p in self.probes:
 152             repr_str += "\t{}\n".format(p.name)
 153         return repr_str
 154
 155 # the following seems quite useless
 156 # # TODO: wtf! use attribute or property
 157 #     def set_xRange(self, xRange):
 158 #         self.xRange = xRange
 159
 160 # # TODO: wtf! use attribute or property
 161 #     def set_yRange(self, yRange):
 162 #         self.yRange = yRange
 163
 164 # # TODO: wtf! use attribute or property
 165 #     def set_xLabel(self, xLabel):
 166 #         self.xLabel = xLabel
 167
 168 # # TODO: wtf! use attribute or property
 169 #     def set_yLabel(self, yLabel):
 170 #         self.yLabel = yLabel
 171
 172 # TODO: use join instead?
 173
 174     def reset_probes(self):
 175         del self.probes
 176         self.probes = []
 177
 178     def append_probes(self, new_probes):
 179         self.probes += new_probes
 180
 181 # TODO: wtf! use attribute or property
 182     def set_title(self, title):
 183         self.title = title
 184
 185     def plot(self,
 186              view_settings={},
 187              build_label=build_label_default,
 188              build_marker=build_marker_default,
 189              build_color=build_color_default
 190              ):
 191
 192         probe_view_settings = {k: {} for k in self.probes}
 193         logging.debug(probe_view_settings)
 194
 195         master_tag_dict = {p.master_tag: p for p in self.probes}
 196         # TODO: can the following nested loop be recast into a single loop?
 197         for pattern, settings in view_settings.items():
 198             for p in dpath.search(master_tag_dict, "/" + pattern).values():
 199                 probe_view_settings[p].update(settings)
 200
 201         logging.debug(probe_view_settings)
 202
 203         fig = plt.figure(figsize=(10, 10))
 204         plt.xlabel(self.x_label)
 205         plt.ylabel(self.y_label)
 206         plt.title(self.title)
 207         plt.grid(True)
 208         plt.gca().ticklabel_format(useOffset=False, style='sci')
 209         tickFormat = mtick.FormatStrFormatter("%.4e")
 210         plt.gca().get_yaxis().set_major_formatter(tickFormat)
 211         if len(self.x_range) > 0:
 212             plt.xlim(self.x_range[0], self.x_range[1])
 213         if len(self.y_range) > 0:
 214             plt.ylim(self.y_range[0], self.y_range[1])
 215
 216         for probe in self.probes:
 217             logging.debug(probe.file_name
 218                           + " "
 219                           + probe.variable_name)
 220             x, var = probe.data
 221             # TODO : can we write this if-then in a more pythonist way?
 222             if build_label == None:
 223                 probe_label = None
 224             else:
 225                 probe_label = build_label(probe)
 226             if build_color == None:
 227                 probe_color = None
 228             else:
 229                 probe_color = build_color(probe)
 230
 231             plot_args = probe_view_settings[probe]
 232 #             plotArgs.update({'label' : probe_label})
 233             plot_args['label'] = probe_label
 234 #            logging.debug(plotArgs)
 235             plt.plot(x, var, **plot_args)
 236
 237         plt.legend(loc='best', frameon=False)
 238         plt.show(fig)
 239
 240
 241 def plot_all_probes(db, variable_list, view_settings={}, x_range={}, y_range={}, x_label={}, y_label={}):
 242     if x_label == {}:
 243         x_label = {k: 'x' for k in variable_list}
 244     if y_label == {}:
 245         y_label = dict(zip(variable_list, variable_list))
 246     for variable in variable_list:
 247         probe_list = [f.get_default_probe()
 248                       for f in db if f.variable == variable]
 249         data_view = DataView()
 250         data_view.append_probes(probe_list)
 251         data_view.y_label = y_label.get(variable, [])
 252         data_view.x_label = x_label.get(variable, [])
 253         data_view.x_range = x_range.get(variable, [])
 254         data_view.y_range = y_range.get(variable, [])
 255         data_view.set_title(variable)
 256         data_view.plot(view_settings=view_settings)