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