jpk.py

   1 #!/usr/bin/env python
   2
   3 import string
   4 import libhookecurve as lhc
   5
   6 class DataChunk(list):
   7     #Dummy class to provide ext and ret methods to the data list.
   8
   9     def ext(self):
  10         halflen=(len(self)/2)
  11         return self[0:halflen]
  12
  13     def ret(self):
  14         halflen=(len(self)/2)
  15         return self[halflen:]
  16
  17 class jpkDriver(lhc.Driver):
  18
  19     def __init__(self, filename):
  20         self.filename=filename #self.filename can always be useful, and should be defined
  21         self.filedata = open(filename,'r') #We open the file
  22         self.filelines=self.filedata.readlines()
  23         self.filedata.close()
  24         '''These are two strings that can be used by Hooke commands/plugins to understand what they are looking at. They have no other
  25         meaning. They have to be somehow defined however - commands often look for those variables.
  26
  27         self.filetype should contain the name of the exact filetype defined by the driver (so that filetype-specific commands can know
  28                       if they're dealing with the correct filetype)
  29         self.experiment should contain instead the type of data involved (for example, various drivers can be used for force-clamp experiments,
  30                       but hooke commands could like to know if we're looking at force clamp data, regardless of their origin, and not other
  31                       kinds of data)
  32
  33         Of course, all other variables you like can be defined in the class.
  34         '''
  35         self.filetype = 'jpk'
  36         self.experiment = 'smfsz'
  37
  38
  39
  40     def __del__(self):
  41         self.filedata.close()
  42
  43     def is_me(self):
  44         '''
  45         we define our magic heuristic for HemingClamp files
  46         '''
  47         myfile=file(self.filename)
  48         headerlines=myfile.readlines()[0:3]
  49         myfile.close()
  50         if headerlines[0][0:11]=='# xPosition' and headerlines[1][0:11]=='# yPosition':
  51             return True
  52         else:
  53             return False
  54
  55     def close_all(self):
  56         self.filedata.close()
  57
  58     def _read_data_segment(self):
  59         #routine that actually reads the data
  60
  61         height_ms=[]
  62         height_m=[]
  63         height=[]
  64         v_deflection=[]
  65         h_deflection=[]
  66
  67         self.springconstant=0 #if we don't meet any spring constant, use deflection...
  68
  69         for line in self.filelines:
  70             #we meet the segment defining the order of data columns
  71
  72             if line[0:9]=='# columns':
  73                 splitline=line.split()[2:]
  74                 height_ms_index=splitline.index('smoothedStrainGaugeHeight')
  75                 height_m_index=splitline.index('strainGaugeHeight')
  76                 height_index=splitline.index('height')
  77                 v_deflection_index=splitline.index('vDeflection')
  78                 #h_deflection=splitline.index('hDeflection')
  79
  80             if line[0:16]=='# springConstant':
  81                 self.springconstant=float(line.split()[2])
  82
  83             if line[0] != '#' and len(line.split())>1:
  84                 dataline=line.split()
  85                 height_ms.append(float(dataline[height_ms_index]))
  86                 height_m.append(float(dataline[height_m_index]))
  87                 height.append(float(dataline[height_index]))
  88                 v_deflection.append(float(dataline[v_deflection_index]))
  89                 #h_deflection.append(float(dataline[h_deflection_index]))
  90
  91         if self.springconstant != 0:
  92             force=[item*self.springconstant for item in v_deflection]
  93         else: #we have measured no spring constant :(
  94             force=v_deflection
  95
  96         height_ms=[item*-1 for item in height_ms]
  97         height_m=[item*-1 for item in height_m]
  98         height=[item*-1 for item in height]
  99
 100         return DataChunk(height_ms),DataChunk(height_m),DataChunk(height),DataChunk(v_deflection),DataChunk(force)
 101
 102     def default_plots(self):
 103
 104         height_ms,height_m,height,v_deflection,force=self._read_data_segment()
 105
 106         height_ms_ext=height_ms.ext()
 107         height_ms_ret=height_ms.ret()
 108         force_ext=force.ext()
 109         force_ret=force.ret()
 110         #reverse the return data, to make it coherent with hooke standard
 111         height_ms_ret.reverse()
 112         force_ret.reverse()
 113
 114         main_plot=lhc.PlotObject()
 115         main_plot.add_set(height_ms_ext,force_ext)
 116         main_plot.add_set(height_ms_ret,force_ret)
 117
 118
 119
 120         if self.springconstant != 0:
 121             main_plot.units=['meters','force']
 122         else:
 123             main_plot.units=['meters','meters']
 124
 125         main_plot.normalize_vectors()
 126
 127         main_plot.destination=0
 128         main_plot.title=self.filename
 129
 130         return [main_plot]