ABF Files from Clampex 10.2 and Igor
| November 1, 2011 - 08:02 | |||
|---|---|---|---|
|
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. John Weeks |
|||
| Sweetma | December 2, 2011 - 09:21 | ||
|---|---|---|---|
|
|
|||
| December 2, 2011 - 09:52 | |||
|---|---|---|---|
|
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 |
|||
| carlosro | January 15, 2012 - 11:41 | ||
|---|---|---|---|
 |
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. Carlos Rozas [ last edited January 15, 2012 - 11:52 ]
|
||
| JR1 | July 7, 2012 - 02:51 | ||
|---|---|---|---|
|
Hi Dan: I'm sure you've solved this already by now, but for future reference... Open Igor and click on Data Then you need to scale as follows... You may need to delete a few points at the start of the file. I haven't optimized this yet, but Joe [ last edited July 7, 2012 - 02:52 ]
|
|||
| pczjrh | July 15, 2012 - 02:55 | ||
|---|---|---|---|
|
Hi, #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. |
|||
| cpg | July 18, 2012 - 15:02 | ||
|---|---|---|---|
|
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 <ccode> 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: <ccode> 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 ); }; /<ccode> [ last edited July 23, 2012 - 23:46 ]
|
|||
| yamad | August 2, 2012 - 10:19 | ||
|---|---|---|---|
|
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. [ last edited August 2, 2012 - 10:20 ]
|
|||
Joined: 2011-10-28
Location: United States
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