hooke/driver/mfp3d.py

   1 # Copyright (C) 2008-2010 A. Seeholzer
   2 #                         Alberto Gomez-Casado
   3 #                         Richard Naud <richard.naud@epfl.ch>
   4 #                         Rolf Schmidt <rschmidt@alcor.concordia.ca>
   5 #                         W. Trevor King <wking@drexel.edu>
   6 #
   7 # This file is part of Hooke.
   8 #
   9 # Hooke is free software: you can redistribute it and/or modify it
  10 # under the terms of the GNU Lesser General Public License as
  11 # published by the Free Software Foundation, either version 3 of the
  12 # License, or (at your option) any later version.
  13 #
  14 # Hooke is distributed in the hope that it will be useful, but WITHOUT
  15 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  16 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
  17 # Public License for more details.
  18 #
  19 # You should have received a copy of the GNU Lesser General Public
  20 # License along with Hooke.  If not, see
  21 # <http://www.gnu.org/licenses/>.
  22
  23 """Driver for MFP-3D files.
  24
  25 This driver reads IGOR binary waves.
  26
  27 AUTHORS:
  28 Matlab version: Richard Naud August 2008 (http://lcn.epfl.ch/~naud/)
  29 Python port: A. Seeholzer October 2008
  30 Hooke submission: Rolf Schmidt, Alberto Gomez-Casado 2009
  31 """
  32
  33 import copy
  34 import pprint
  35
  36 import numpy
  37
  38 from .. import curve as curve
  39 from .. import experiment as experiment
  40 from ..config import Setting
  41 from . import Driver as Driver
  42 from .igorbinarywave import loadibw
  43
  44
  45 __version__='0.0.0.20100604'
  46
  47
  48 class MFP3DDriver (Driver):
  49     """Handle Asylum Research's MFP3D data format.
  50     """
  51     def __init__(self):
  52         super(MFP3DDriver, self).__init__(name='mfp3d')
  53
  54     def is_me(self, path):
  55         """Look for identifying fields in the IBW note.
  56         """
  57         if not path.endswith('.ibw'):
  58             return False
  59         targets = ['Version:', 'XOPVersion:', 'ForceNote:']
  60         found = [False]*len(targets)
  61         for line in open(path, 'rU'):
  62             for i,ft in enumerate(zip(found, targets)):
  63                 f,t = ft
  64                 if f == False and line.startswith(t):
  65                     found[i] = True
  66         if min(found) == True:
  67             return True
  68         return False
  69
  70     def read(self, path, info=None):
  71         data,bin_info,wave_info = loadibw(path)
  72         approach,retract = self._translate_ibw(data, bin_info, wave_info)
  73
  74         info = {'filetype':self.name, 'experiment':experiment.VelocityClamp}
  75         return ([approach, retract], info)
  76
  77     def _translate_ibw(self, data, bin_info, wave_info):
  78         if bin_info['version'] != 5:
  79             raise NotImplementedError('IBW version %d (< 5) not supported'
  80                                       % bin_info['version'])
  81             # We need version 5 for multidimensional arrays.
  82
  83         # Parse the note into a dictionary
  84         note = {}
  85         for line in bin_info['note'].split('\r'):
  86             fields = [x.strip() for x in line.split(':', 1)]
  87             key = fields[0]
  88             if len(fields) == 2:
  89                 value = fields[1]
  90             else:
  91                 value = None
  92             note[key] = value
  93         bin_info['note'] = note
  94         if note['VerDate'] not in ['80501.041', '80501.0207']:
  95             raise Exception(note['VerDate'])
  96             raise NotImplementedError(
  97                 '%s file version %s not supported (yet!)\n%s'
  98                 % (self.name, note['VerDate'], pprint.pformat(note)))
  99
 100         info = {
 101             'raw info':{'bin':bin_info,
 102                         'wave':wave_info},
 103             'time':wave_info['creationDate'],
 104             'spring constant (N/m)':note['SpringConstant'],
 105             }
 106         # MFP3D's native data dimensions match Hooke's (<point>, <column>) layout.
 107         approach = self._scale_block(data[:wave_info['npnts']/2,:], info, 'approach')
 108         retract = self._scale_block(data[wave_info['npnts']/2:,:], info, 'retract')
 109         return (approach, retract)
 110
 111     def _scale_block(self, data, info, name):
 112         """Convert the block from its native format to a `numpy.float`
 113         array in SI units.
 114         """
 115         shape = 3
 116         # raw column indices
 117         columns = info['raw info']['bin']['dimLabels'][1]
 118         # Depending on your MFP3D version:
 119         #   VerDate 80501.0207: ['Raw', 'Defl', 'LVDT', 'Time']
 120         #   VerDate 80501.041:  ['Raw', 'Defl', 'LVDT']
 121         if 'Time' in columns:
 122             n_col = 3
 123         else:
 124             n_col = 2
 125         ret = curve.Data(
 126             shape=(data.shape[0], n_col),
 127             dtype=numpy.float,
 128             info=copy.deepcopy(info)
 129             )
 130         ret.info['name'] = name
 131         ret.info['raw data'] = data # store the raw data
 132
 133         z_rcol = columns.index('LVDT')
 134         d_rcol = columns.index('Defl')
 135
 136         # scaled column indices
 137         ret.info['columns'] = ['z piezo (m)', 'deflection (m)']
 138         z_scol = ret.info['columns'].index('z piezo (m)')
 139         d_scol = ret.info['columns'].index('deflection (m)')
 140
 141         # Leading '-' because increasing voltage extends the piezo,
 142         # moving the tip towards the surface (positive indentation),
 143         # but it makes more sense to me to have it increase away from
 144         # the surface (positive separation).
 145         ret[:,z_scol] = -data[:,z_rcol].astype(ret.dtype)
 146
 147         # Leading '-' because deflection voltage increases as the tip
 148         # moves away from the surface, but it makes more sense to me
 149         # to have it increase as it moves toward the surface (positive
 150         # tension on the protein chain).
 151         ret[:,d_scol] = -data[:,d_rcol]
 152
 153         if 'Time' in columns:
 154             ret.info['columns'].append('time (s)')
 155             t_rcol = columns.index('Time')
 156             t_scol = ret.info['columns'].index('time (s)')
 157             ret[:,t_scol] = data[:,t_rcol]
 158
 159         return ret