ABF Files from Clampex 10.2 and Igor

I've fruitlessly searched the internet for an answer to this, so now I'm here to ask you fine people :)

My lab uses the Axon Systems suite, which includes obviously all the pClamp software. I'm currently using Clampex 10.2 as my data acquisition software, which saves files in what I think is ABF 2.X (I don't know if it's 2.0 or 2.1 or what). Please correct me if I'm wrong about that.

I need to import these files into Igor for analysis, but I'm having some difficulty. The "Load AxonBinary File" macro is not work, which I was expecting since it's only compatible to up to ABF 1.5 (as far as I know).

One of the labs I previously worked in I know converted the ABF files to another axon file format (whether this was an older format such as ABF 1.5 to allow the usage of the macro or some other type of format, I do not know) to allow it to be imported into Igor. I don't remember the procedure, though, and I'm pretty much out of ideas of how to get these files into Igor.

I know there's a way to import them, but I'm just unsure of how. Hopefully someone here can shed some light on the issue.

Thanks :)

Dan
Dan,

Any success? I am having the same problem.

I downloaded the neuromatic "loader." It runs, but Y=0 for all waves points.

Thanks,
Sweetma
Sweetma wrote:
Any success? I am having the same problem.

I downloaded the neuromatic "loader." It runs, but Y=0 for all waves points.

Perhaps you should send an e-mail to Jason Rothman Jason@ThinkRandom.com about the problem. If the ABF file format has been updated, he may be able to modify his loader to accommodate it. He's generally pretty responsive to e-mails.

John Weeks
WaveMetrics, Inc.
support@wavemetrics.com
To convert Clampex 10 (.ABF 2.X ) files to Igor use this free program called Stimfit:

http://code.google.com/p/stimfit/

Load your .ABF file and export to Igor format from there. Multiple sweeps (I/V plot, for instance) are saved as Igor Multidimensional wave.
Best

Carlos Rozas
Columbia University
Hi Dan:

I'm sure you've solved this already by now, but for future reference...

Open Igor and click on Data
Load General Binary Data
set input data to 16 bit signed integer
set byte order to low byte first
click file and find the abf file you want to load
output wave is double float

Then you need to scale as follows...
wave0 = wave0*(20000/(65536*Gain))
where Gain is the gain setting you used to collect the data (i.e. 10)

You may need to delete a few points at the start of the file. I haven't optimized this yet, but
it may get you started.

Joe
Hi,
These are my loaders for pClamp ABF files.
If you use the ABF files directly (that is without modification) then you use the Direct ABF Loader.
However, once you have made changes to the file in ClampFit or another package and re-save the ABF, it seems to change the ABF number format to a single float vs 16bitInt.
This did stump me for a while, but the solutions are below:

#pragma rtGlobals=1     // Use modern global access method.
Menu "Macros"
    Submenu "ABF Loaders"
        "Load Clampex Data - Direct ABF", LoadClampex()
        "Load ClampFit Data - Modified ABF", LoadClampFit()
    End
End


// ABF Loaders
Function LoadClampex()
//integer files: (output from Clampex >v10.0.2)
GBLoadWave/O/Q/B/V/N=wave/T={16,2}/Y={0, 1/32.768}/S=6144/W=2
//byte order = low first
//bytes header = 6144
//input = 16bit int
//output = single float
//scale = 1/32.768
End Function

Function LoadClampFit()
//float files: (after clampfit >v10 modify)
GBLoadWave/O/Q/B/V/N=wave/T={2,2}/Y={0, 1}/S=(32*112)/W=2
//header = 3584
//byte order = low
//input = single float
//output = single float
//scale = 1
End Function

Function LoadSectionABF(samplerateKhz,startseconds,endseconds)
Variable sampleratekHz,startseconds,endseconds
SampleRateKHz = (SampleRateKHz *1000)
Variable startsecondsinms = 6144+(samplerateKHz*startseconds)
Variable endsecondsinms = 6144+(samplerateKHz*endseconds)
GBLoadWave/O/Q/B/V/N=wave/T={16,2}/Y={0, 1/32.768}/S=(startsecondsinms)/W=2/U=(endsecondsinms)
Make/O/N=(numpnts(wave0)) timescale
timescale = (startsecondsinms+(p/(samplerateKHz)))
Rename wave0, Current
Rename wave1, Potential
Display Current vs timescale
End Function


Hope these help.
Jason
It turns out that reading in the abf file in chunks of 4-bytes gives a wave that is pretty easy to interpret, matched with the description of the abf header. As best I can tell, the block position (in bytes) of the start of the data section is given by the 60th element of such a wave. The actual byte number where the data starts is that number (typically between 10-15, according to MDC) multiplied by 512 bytes.


GBLoadWave/O/Q/B/V/N=HEADERFILE/T={32+64,32+64}/Y={0, 1}/S=(0)/W=1

number_of_episodes = HEADERFILE0[3]
number_of_channels = HEADERFILE0[25]
DataStart = (HEADERFILE0[59])*512



Here's the description of the abf file header, from ProtocolStructs.hpp

<pre><code class="language-igor">
struct ABF_FileInfo
{
   UINT  uFileSignature;
   UINT  uFileVersionNumber;

   // After this point there is no need to be the same as the ABF 1 equivalent.
   UINT  uFileInfoSize;

   UINT  uActualEpisodes;
   UINT  uFileStartDate;
   UINT  uFileStartTimeMS;
   UINT  uStopwatchTime;
   short nFileType;
   short nDataFormat;
   short nSimultaneousScan;
   short nCRCEnable;
   UINT  uFileCRC;
   GUID  FileGUID;
   UINT  uCreatorVersion;
   UINT  uCreatorNameIndex;
   UINT  uModifierVersion;
   UINT  uModifierNameIndex;
   UINT  uProtocolPathIndex;  

   // New sections in ABF 2 - protocol stuff ...
   ABF_Section ProtocolSection;           // the protocol
   ABF_Section ADCSection;                // one for each ADC channel
   ABF_Section DACSection;                // one for each DAC channel
   ABF_Section EpochSection;              // one for each epoch
   ABF_Section ADCPerDACSection;          // one for each ADC for each DAC
   ABF_Section EpochPerDACSection;        // one for each epoch for each DAC
   ABF_Section UserListSection;           // one for each user list
   ABF_Section StatsRegionSection;        // one for each stats region
   ABF_Section MathSection;
   ABF_Section StringsSection;

   // ABF 1 sections ...
   ABF_Section DataSection;            // Data
   ABF_Section TagSection;             // Tags
   ABF_Section ScopeSection;           // Scope config
   ABF_Section DeltaSection;           // Deltas
   ABF_Section VoiceTagSection;        // Voice Tags
   ABF_Section SynchArraySection;      // Synch Array
   ABF_Section AnnotationSection;      // Annotations
   ABF_Section StatsSection;           // Stats config

etc...

where an ABS_section is defined as:
<pre><code class="language-igor">
struct ABF_Section
{
   UINT     uBlockIndex;            // ABF block number of the first entry
   UINT     uBytes;                 // size in bytes of of each entry
   LONGLONG llNumEntries;           // number of entries in this section

   ABF_Section();
   long GetNumEntries();
   void Set( const UINT p_uBlockIndex, const UINT p_uBytes, const LONGLONG p_llNumEntries );

};
/<pre><code class="language-igor">
I also struggled for a while to find a way to read ABF2 files into Igor. The easiest approach, obviously, is to buy something that can do it for you. Our lab uses the commercial product Bruxton DataAccess (http://www.bruxton.com/DataAccess/index.html). The most recent version supports ABF2 files.

As others have noted, there are free ways to get access to the data. One approach is to use Clampfit to down-convert the ABF2 files into ABF1 (http://mdc.custhelp.com/app/answers/detail/a_id/17379/kw/abf%20convert). stimfit also works, although it doesn't provide straightforward access to some of the auxiliary data like tags and strings. But if you are using pClamp 10 as your main acquisition suite and Igor as your main analysis platform, it can get sort of tiring to have to convert every data file you want to look at.

Of course, you could also write your own functions to read the files. One option, if you know C or C++ and need only Windows support, is to write an XOP on top of the dll support library released by Molecular Devices.

To read the data in Igor code alone, you need to process the binary data directly. cpg's approach will give you access to the raw data in the file. Note, however, that you'll need to do a bunch of further processing steps to get that raw data transformed into something usable. For instance, you'll need to de-multiplex the channels and apply a scaling factor and offset to get your original data back out. If you already have good routines for processing ABF1 data, though, those steps are mostly the same so would probably require relatively minor tweaks.

The file format is documented reasonably well by the File Support Packs released by Molecular Devices. For ABF2 files, there is relevant information in both the ABF1 and ABF2 support packs. The only significant change from ABF1 to ABF2 is a variable-size file header. In an ABF1 file, the location of every piece of information in the header was static and you could hardcode where to pluck out the relevant scaling factors. In an ABF2 file, the information moves around so you'll have to ask each file about where it stores the scaling factors, offsets, etc. Of course, if reading binary formats sounds like greek to you, then you are much better off going with DataAccess or using the Clampfit conversion facilities.