lib/results.py

   1 #!/usr/bin/env python\r
   2 \r
   3 '''\r
   4 results.py\r
   5 \r
   6 Result and Results classes for Hooke.\r
   7 \r
   8 Copyright 2009 by Dr. Rolf Schmidt (Concordia University, Canada)\r
   9 \r
  10 This program is released under the GNU General Public License version 2.\r
  11 '''\r
  12 \r
  13 from numpy import nan\r
  14 \r
  15 import prettyformat\r
  16 import lib.curve\r
  17 \r
  18 DEFAULT_COLOR = 'green'\r
  19 DEFAULT_DECIMAL = 2\r
  20 DEFAULT_STYLE = 'scatter'\r
  21 \r
  22 class Result(lib.curve.Curve):\r
  23     def __init__(self):\r
  24         lib.curve.Curve.__init__(self)\r
  25         self.color = DEFAULT_COLOR\r
  26         self.result = {}\r
  27         self.style = DEFAULT_STYLE\r
  28 \r
  29 class Results(object):\r
  30     def __init__(self):\r
  31         self.columns = []\r
  32         self.decimals = {}\r
  33         self.has_multipliers = False\r
  34         self.multipliers = {}\r
  35         self.results = []\r
  36         self.separator='\t'\r
  37         self.units = {}\r
  38 \r
  39     def get_pretty_value(self, column, value):\r
  40         if self.has_multipliers and self.has_results():\r
  41             multiplier = self.multipliers[column]\r
  42             decimals = self.decimals[column]\r
  43             return prettyformat.pretty_format(value, '', decimals, multiplier, True)\r
  44         return str(value)\r
  45 \r
  46     #def get_fit_result(self):\r
  47         #if not(self.has_multipliers):\r
  48             #self.set_multipliers()\r
  49 \r
  50         #sResult = 'Contour length ['+prettyformat.get_prefix(self.multiplierContourLength) + 'm]' + self.separator\r
  51         #sResult += prettyformat.pretty_format(self.contourLength[0], '', self.decimals, self.multiplierContourLength, True) + '\n'\r
  52         #sResult += 'Persistence length ['+prettyformat.get_prefix(self.multiplierPersistenceLength) + 'm]' + self.separator\r
  53         #sResult += prettyformat.pretty_format(self.persistenceLength[0], '', self.decimals, self.multiplierPersistenceLength, True) + '\n'\r
  54         #sResult += 'Rupture force ['+prettyformat.get_prefix(self.multiplierRuptureForce) + 'N]' + self.separator\r
  55         #sResult += prettyformat.pretty_format(self.ruptureForces[0], '', self.decimals, self.multiplierRuptureForce, True) + '\n'\r
  56         #sResult += 'Slope ['+prettyformat.get_prefix(self.multiplierSlope) + 'N/m]' + self.separator\r
  57         #sResult += prettyformat.pretty_format(self.slopes[0], '', self.decimals, self.multiplierSlope, True)+'\n'\r
  58         #sResult += 'Sigma contour ['+prettyformat.get_prefix(self.multiplierContourLength) + 'm]' + self.separator\r
  59         #sResult += prettyformat.pretty_format(self.contourLengthSigma[0], '', self.decimals, self.multiplierContourLength, True) + '\n'\r
  60         #sResult += 'Sigma persistence ['+prettyformat.get_prefix(self.multiplierPersistenceLength) + 'm]' + self.separator\r
  61         #sResult += prettyformat.pretty_format(self.persistenceLengthSigma[0], '', self.decimals, self.multiplierPersistenceLength, True)\r
  62 \r
  63         #return sResult\r
  64 \r
  65     #def get_fit_results(self, index):\r
  66         #if index >= 0 and index < len(self.contourLength):\r
  67             #if not(self.has_multipliers):\r
  68                 #self.set_multipliers()\r
  69             #sLine = prettyformat.pretty_format(self.contourLength[index], '', self.decimals, self.multiplierContourLength, True) + self.separator\r
  70             #sLine += prettyformat.pretty_format(self.persistenceLength[index], '', self.decimals, self.multiplierPersistenceLength, True) + self.separator\r
  71             #sLine += prettyformat.pretty_format(self.ruptureForces[index], '', self.decimals, self.multiplierRuptureForce, True) + self.separator\r
  72             #sLine += prettyformat.pretty_format(self.slopes[index], '', self.decimals, self.multiplierSlope, True) + self.separator\r
  73             #sLine += prettyformat.pretty_format(self.contourLengthSigma[index], '', self.decimals, self.multiplierContourLength, True) + self.separator\r
  74             #sLine += prettyformat.pretty_format(self.persistenceLengthSigma[index], '', self.decimals, self.multiplierPersistenceLength, True)\r
  75 \r
  76             #return sLine\r
  77         #else:\r
  78             #return ''\r
  79 \r
  80     def has_results(self):\r
  81         return len(self.results) > 0\r
  82 \r
  83     def get_header_as_list(self):\r
  84         header_list = []\r
  85         if self.has_results():\r
  86             if not self.has_multipliers:\r
  87                 self.set_multipliers()\r
  88             for column in self.columns:\r
  89                 unit_str = ''.join([prettyformat.get_prefix(self.multipliers[column]), self.units[column]])\r
  90                 header_str = ''.join([column, ' [', unit_str, ']'])\r
  91                 header_list.append(header_str)\r
  92         return header_list\r
  93 \r
  94     def get_header_as_str(self, separator=None):\r
  95         if separator is None:\r
  96             separator = self.separator\r
  97         return separator.join(map(str, self.get_header_as_list()))\r
  98 \r
  99     def get_result_as_list(self, index=0):\r
 100         if index >= 0 and index < len(self.results):\r
 101             result_list = []\r
 102             if self.has_results():\r
 103                 if not self.has_multipliers:\r
 104                     self.set_multipliers()\r
 105                 for column in self.columns:\r
 106                     result_str = prettyformat.pretty_format(self.results[index].result[column], '', self.decimals[column], self.multipliers[column], True)\r
 107                     result_list.append(result_str)\r
 108             return result_list\r
 109         else:\r
 110             return None\r
 111 \r
 112     def get_result_as_string(self, index=0):\r
 113         results_list = self.get_result_as_list(index)\r
 114         if results_list is not None:\r
 115             return self.separator.join(map(str, results_list))\r
 116         else:\r
 117             return ''\r
 118 \r
 119     def set_decimal(self, column, decimal=DEFAULT_DECIMAL):\r
 120         if self.decimals.has_key(column):\r
 121             self.decimals[column] = decimal\r
 122 \r
 123     def set_decimals(self, decimals=DEFAULT_DECIMAL):\r
 124         if decimals < 0:\r
 125             #set default value if necessary\r
 126             decimals = DEFAULT_DECIMAL\r
 127         for column in self.columns:\r
 128             self.decimals[column] = decimals\r
 129 \r
 130     def set_multipliers(self, index=0):\r
 131         if self.has_results():\r
 132             for column in self.columns:\r
 133                 #result will contain the results dictionary at 'index'\r
 134                 result = self.results[index].result\r
 135                 #in position 0 of the result we find the value\r
 136                 self.multipliers[column] = prettyformat.get_multiplier(result[column])\r
 137             self.has_multipliers = True\r
 138         else:\r
 139             self.has_multipliers = False\r
 140 \r
 141     def update(self):\r
 142         pass\r
 143 \r
 144 \r
 145 class ResultsFJC(Results):\r
 146     def __init__(self):\r
 147         Results.__init__(self)\r
 148         self.columns = ['Contour length', 'sigma contour length', 'Kuhn length', 'sigma Kuhn length', 'Rupture force', 'Slope', 'Loading rate']\r
 149         self.units['Contour length'] = 'm'\r
 150         self.units['sigma contour length'] = 'm'\r
 151         self.units['Kuhn length'] = 'm'\r
 152         self.units['sigma Kuhn length'] = 'm'\r
 153         self.units['Rupture force'] = 'N'\r
 154         self.units['Slope'] = 'N/m'\r
 155         self.units['Loading rate'] = 'N/s'\r
 156         self.set_decimals(2)\r
 157 \r
 158     def set_multipliers(self, index=0):\r
 159         if self.has_results():\r
 160             for column in self.columns:\r
 161                 #result will contain the results dictionary at 'index'\r
 162                 result = self.results[index].result\r
 163                 #in position 0 of the result we find the value\r
 164                 if column == 'sigma contour length':\r
 165                     self.multipliers[column] = self.multipliers['Contour length']\r
 166                 elif column == 'sigma Kuhn length':\r
 167                     self.multipliers[column] = self.multipliers['Kuhn length']\r
 168                 else:\r
 169                     self.multipliers[column] = prettyformat.get_multiplier(result[column])\r
 170             self.has_multipliers = True\r
 171         else:\r
 172             self.has_multipliers = False\r
 173 \r
 174 class ResultsMultiDistance(Results):\r
 175     def __init__(self):\r
 176         Results.__init__(self)\r
 177         self.columns = ['Distance']\r
 178         self.units['Distance'] = 'm'\r
 179         self.set_decimals(2)\r
 180 \r
 181     def update(self):\r
 182         if (self.results) > 0:\r
 183             for result in self.results:\r
 184                 if result.visible:\r
 185                     reference_peak = result.x\r
 186                     break\r
 187 \r
 188             for result in self.results:\r
 189                 if result.visible:\r
 190                     result.result['Distance'] = reference_peak - result.x\r
 191                     reference_peak = result.x\r
 192                 else:\r
 193                     result.result['Distance'] = nan\r
 194 \r
 195 \r
 196 class ResultsWLC(Results):\r
 197     def __init__(self):\r
 198         Results.__init__(self)\r
 199         self.columns = ['Contour length', 'sigma contour length', 'Persistence length', 'sigma persistence length', 'Rupture force', 'Slope', 'Loading rate']\r
 200         self.units['Contour length'] = 'm'\r
 201         self.units['sigma contour length'] = 'm'\r
 202         self.units['Persistence length'] = 'm'\r
 203         self.units['sigma persistence length'] = 'm'\r
 204         self.units['Rupture force'] = 'N'\r
 205         self.units['Slope'] = 'N/m'\r
 206         self.units['Loading rate'] = 'N/s'\r
 207         self.set_decimals(2)\r
 208 \r
 209     def set_multipliers(self, index=0):\r
 210         if self.has_results():\r
 211             for column in self.columns:\r
 212                 #result will contain the results dictionary at 'index'\r
 213                 result = self.results[index].result\r
 214                 #in position 0 of the result we find the value\r
 215                 if column == 'sigma contour length':\r
 216                     self.multipliers[column] = self.multipliers['Contour length']\r
 217                 elif column == 'sigma persistence length':\r
 218                     self.multipliers[column] = self.multipliers['Persistence length']\r
 219                 else:\r
 220                     self.multipliers[column] = prettyformat.get_multiplier(result[column])\r
 221             self.has_multipliers = True\r
 222         else:\r
 223             self.has_multipliers = False\r