ABF Files from Clampex 10.2 and Igor
Dan11
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
If you're importing ABF files, you may find useful functionality in Neuromatic.
John Weeks
WaveMetrics, Inc.
support@wavemetrics.com
November 1, 2011 at 09:02 am - Permalink
Any success? I am having the same problem.
I downloaded the neuromatic "loader." It runs, but Y=0 for all waves points.
Thanks,
Sweetma
December 2, 2011 at 09:24 am - Permalink
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
December 2, 2011 at 09:52 am - Permalink
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
January 15, 2012 at 11:52 am - Permalink
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
July 7, 2012 at 03:52 am - Permalink
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:
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
July 15, 2012 at 03:55 am - Permalink
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">
July 24, 2012 at 12:46 am - Permalink
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.
August 2, 2012 at 11:20 am - Permalink