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.
I think the Neuromatic package includes an ABF loader, at least on Windows. You can get it for free here: http://www.NeuroMatic.ThinkRandom.com/
If you're importing ABF files, you may find useful functionality in Neuromatic.
Any success? I am having the same problem.
I downloaded the neuromatic "loader." It runs, but Y=0 for all waves points.
To convert Clampex 10 (.ABF 2.X ) files to Igor use this free program called 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.
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.
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.
Submenu "ABF Loaders"
"Load Clampex Data - Direct ABF", LoadClampex()
"Load ClampFit Data - Modified ABF", LoadClampFit()
// ABF Loaders
//integer files: (output from Clampex >v10.0.2)
//byte order = low first
//bytes header = 6144
//input = 16bit int
//output = single float
//scale = 1/32.768
//float files: (after clampfit >v10 modify)
//header = 3584
//byte order = low
//input = single float
//output = single float
//scale = 1
SampleRateKHz = (SampleRateKHz *1000)
Variable startsecondsinms = 6144+(samplerateKHz*startseconds)
Variable endsecondsinms = 6144+(samplerateKHz*endseconds)
timescale = (startsecondsinms+(p/(samplerateKHz)))
Rename wave0, Current
Rename wave1, Potential
Display Current vs timescale
Hope these help.
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.
number_of_episodes = HEADERFILE0
number_of_channels = HEADERFILE0
DataStart = (HEADERFILE0)*512
Here's the description of the abf file header, from ProtocolStructs.hpp
// After this point there is no need to be the same as the ABF 1 equivalent.
// 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 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
where an ABS_section is defined as:
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
void Set( const UINT p_uBlockIndex, const UINT p_uBytes, const LONGLONG p_llNumEntries );
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.
Back to top