Data file format for Ana


Version 6.0, note that the current version is 7.0 (ask the author for an update if you are interested)
 

Michael Pusch, Istituto di Biofisica, Genova, email: pusch@ge.ibf.cnr.it 
Last change: 7.11.2002

Back to manual

The data file (version 6.0) is written by the following procedure that uses 2 basic subroutines:

WriteBytes(CFile * fp, UINT pos /* unused! */, UINT NumberOfBytes, BYTE * variable);
and

"WriBy" that is a macro that writes a variable in binary format using the size of the type as the number of bytes. It is defined by
#define WriBy(x) WriteBytes(fp, pos, sizeof(x), &(x));

Following is the code of the data-saving procedure:

WriteBytes(fp, pos, 64, Version);// 64 bytes version: currently: "6.0"
WriteBytes(fp, pos, 12, MainUnits);// 12 bytes units, eg "pA", however unused
WriBy(ADCConversion); //8 bytes double
WriBy(NumberOfChannels);// 2 bytes __int16
WriBy(Temperature);// 8 bytes double
WriteBytes(fp, pos, 256, buff);// 256 bytes
RootText.WriteOnFile(pos, fp);// /* Writes the text assigned to the root. See Item Text */
WriBy(NEntries);// 4 bytes __int32
WriBy(NSeries);// 4 bytes __int32
for (__int32 i=0; i<NEntries; i++){
WriBy(entries[i].NData); //4 bytes __int32
WriBy(entries[i].FilePos);// 4 bytes __int32 (UNUSED)
WriBy(entries[i].P4Present);// 2 bytes __int16
WriBy(entries[i].Temperature); //8 bytes double
WriBy(entries[i].Time);// 8 bytes double
WriBy(entries[i].IsBold); //2 bytes __int16
WriBy(entries[i].s1); // unused variables; 8 bytes double
WriBy(entries[i].s2); //8 bytes double
WriBy(entries[i].s3); //8 bytes double
WriBy(entries[i].s4); //8 bytes double
entries[i].EntryText.WriteOnFile(pos, fp);// See Item Text

} // end for entries
for ( i=0; i<NSeries; i++){
WriBy(series[i].VHold); //8 bytes double
WriBy(series[i].Filter);// 8 bytes double
WriBy(series[i].StimInterval);// 8 bytes double
WriBy(series[i].SampleTime);// 8 bytes double
WriBy(series[i].Gain); //8 bytes double
WriteBytes(fp, pos, SERIESCOMMENTSIZE, series[i].Comment); //100 bytes
WriBy(series[i].firstrec);// 4 bytes __int32
WriBy(series[i].NPulses);// 4 bytes __int32
WriBy(series[i].NumAveraged);// 4 bytes __int32
WriBy(series[i].P4Present);// 2 bytes __int16
WriBy(series[i].P4VHold);// 8 bytes double
series[i].SeriesText.WriteOnFile(pos, fp);// See Item Text

WriBy(series[i].NSegs);// 2 bytes __int16
for (int k=0; k<series[i].NSegs; k++){
WriBy(series[i].Pulses[k].A);// 8 bytes double
WriBy(series[i].Pulses[k].T);// 8 bytes double
WriBy(series[i].Pulses[k].SV);// 8 bytes double
WriBy(series[i].Pulses[k].ST);// 8 bytes double
WriBy(series[i].Pulses[k].FV);// 8 bytes double
WriBy(series[i].Pulses[k].FT);// 8 bytes double
WriBy(series[i].Pulses[k].SK);// 2 bytes __int16
WriBy(series[i].Pulses[k].s1);// 8 bytes double
WriBy(series[i].Pulses[k].s2);// 8 bytes double
WriBy(series[i].Pulses[k].s3);// 8 bytes double
WriBy(series[i].Pulses[k].s4);// 8 bytes double
}
WriBy(series[i].IsBold);// 2 bytes __int16
WriBy(series[i].s1);// 8 bytes double
WriBy(series[i].s2);// 8 bytes double
WriBy(series[i].s3);// 8 bytes double
WriBy(series[i].s4);// 8 bytes double
WriteNoise(fp, pos, i);// See Noise
WriteSpectrum(fp, pos, i);// See Spectrum
series[i].Histo.Write(fp, pos);// See Amplitude Histogram
series[i].VM.Write(fp, pos);// See Variance Mean
series[i].Lore.Write(fp, pos);// See Lorentz Fit
series[i].SF.Write(fp, pos);// See Series Fit
series[i].DwellTimes.Write(fp, pos);// See Dwell-Times
for (int kk=0; kk<19; kk++){
BOOL dummy=FALSE;
WriBy(dummy);// 4 bytes BOOL
}
}
for (i=0; i<NEntries; i++){
WriteBytes(fp, pos, entries[i].NData*2, entries[i].IntData);//NData*2 bytes
if (entries[i].P4Present) {
WriteBytes(fp, pos, entries[i].NData*2,entries[i].P4Data);//NData *2 bytes
}
WriteFit(fp, pos, i);// See Trace Fit
results[i].Write(fp, pos);// See Results
for (int kk=0; kk<20; kk++){
BOOL dummy=FALSE;
WriBy(dummy);// 4 bytes BOOL
}
}
END OF DATA WRITING PROCEDURE
 

Save String

int l=string.GetLength();
SaveInt(l, file);// 4 bytes int
TCHAR t;
for (int i=0; i<l; i++){
t=string.GetAt( i ) ;
file.Write(&t, sizeof(TCHAR));// 1 byte chars
}

Item Text

WriBy(UseDefault);// BOOL 4 bytes
WriBy(CountUp);// BOOL 4 bytes
SaveString(Text, *(fp));// see Save String

Noise

WriBy(series[s].NoisePresent);// BOOL 4 bytes
if (!series[s].NoisePresent) return TRUE;
NoiseType & N = series[s].Noise;
WriBy(N.from);// 4 bytes __int32
WriBy(N.to);// 4 bytes __int32
WriBy(N.NData);// 4 bytes __int32
WriBy(N.NTraces);// 4 bytes __int32
WriBy(N.BackGround);// 8 bytes double
WriteBytes(fp, pos, N.NData*sizeof(N.MeanTrace[0]), &(N.MeanTrace[0]));// 8 bytes *NData
WriteBytes(fp, pos, N.NData*sizeof(N.NoiseTrace[0]), &(N.NoiseTrace[0]));// 8 bytes *NData
WriBy(N.NPoints);// 4 bytes __int32
WriteBytes(fp, pos, N.NPoints*sizeof(N.MeanPoints[0]), &(N.MeanPoints[0]));// 8 bytes *NPoints
WriteBytes(fp, pos, N.NPoints*sizeof(N.VarPoints[0]), &(N.VarPoints[0]));// 8 bytes *NPoints
WriteBytes(fp, pos, N.NPoints*sizeof(N.VarVarPoints[0]), &(N.VarVarPoints[0]));// 8 bytes *NPoints
 

Spectrum

WriBy(series[s].SpectrumPresent);// BOOL 4 bytes
if (!series[s].SpectrumPresent) return TRUE;
SpectrumType & S = series[s].Spectrum;
WriBy(S.from);// 4 bytes __int32
WriBy(S.to);// 4 bytes __int32
WriBy(S.NFreq);// 4 bytes __int32
WriBy(S.maxfreq);// 8 bytes double
WriBy(S.nback);// 4 bytes __int32
WriteBytes(fp, pos, S.NFreq*sizeof(S.Spec[0]), &(S.Spec[0]));// 8 bytes *NFreq
WriteBytes(fp, pos, S.NFreq*sizeof(S.BackGround[0]), &(S.BackGround[0]));// 8 bytes *NFreq
 
 

AmplitudeHistogram

WriBy(Present);// BOOL 4 bytes
if (!Present) return TRUE;
WriBy(dmin);// 8 bytes double
WriBy(dmax);// 8 bytes double
WriBy(ngausscurs);// 4 bytes __int32
WriBy(NGauss);// 4 bytes __int32
WriBy(FromGauss);// 4 bytes __int32
WriBy(ToGauss);// 4 bytes __int32
WriBy(NData);// 4 bytes __int32
WriBy(maxhist);// 4 bytes __int32
WriteBytes(fp, pos, NData*sizeof(xdata[0]), &(xdata[0]));// 8 bytes * NData
WriteBytes(fp, pos, NData*sizeof(data[0]), &(data[0]));// 4 bytes * NData
WriteBytes(fp, pos, MAXGAUSSPARAM*sizeof(GaussParam[0]), &(GaussParam[0]));// 8 bytes * 100
WriBy(Equidistant);// BOOL 4 bytes
WriBy(GaussBinWidthInpA);// 8 bytes double
WriteBytes(fp, pos, MAXBETAPARAM*sizeof(BetaParam[0]), &(BetaParam[0]));// 8 bytes * 10
 
 

Variance Mean

WriBy(Present);// BOOL 4 bytes
if (!Present) return TRUE;
WriBy(NVarMean);// 4 bytes __int32
WriteBytes(fp, pos, NVarMean*sizeof(Mean[0]), &(Mean[0]));// 8 bytes * NVarMean
WriteBytes(fp, pos, NVarMean*sizeof(Var[0]), &(Var[0]));// 8 bytes * NVarMean
WriteBytes(fp, pos, NVarMean*sizeof(VarVar[0]), &(VarVar[0]));// 8 bytes * NVarMean
WriteBytes(fp, pos, NVarMean*sizeof(FitVar[0]), &(FitVar[0]));// 8 bytes * NVarMean
WriBy(BackGroundNoise);// 8 bytes double
WriBy(SeriesVar);// 4 bytes __int32
WriBy(ifit);// 8 bytes double
WriBy(Nfit);// 8 bytes double
WriBy(leakfit);// 8 bytes double
 
 

Lorentz Fit

WriBy(Present);// BOOL 4 bytes
if (!Present) return TRUE;
WriBy(NLorenz);// 4 bytes __int32
WriBy(NLorenzData);// 4 bytes __int32
WriBy(Freq1Fit);// 8 bytes double
WriBy(Freq2Fit);// 8 bytes double
WriBy(Fit1OverF);// BOOL 4 bytes
WriBy(Bessel);// BOOL 4 bytes
WriBy(nf1);// 4 bytes __int32
WriBy(nf2);// 4 bytes __int32
WriteBytes(fp, pos, NLorenzData*sizeof(freqdata[0]), &(freqdata[0]));// 8 bytes * NLorenzData
WriteBytes(fp, pos, NLorenzData*sizeof(specdata[0]), &(specdata[0]));// 8 bytes * NLorenzData
WriteBytes(fp, pos, NLorenzData*sizeof(fitspec[0]), &(fitspec[0]));// 8 bytes * NLorenzData
WriBy(SeriesSpec);// 4 bytes __int32
WriteBytes(fp, pos, MAXLORENZPARAM*sizeof(LorenzParam[0]), &(LorenzParam[0]));// 8 bytes * 100
 
 

Series Fit

WriBy(Present);// BOOL 4 bytes
if (!Present) return TRUE;
WriBy(Npoints);// 4 bytes __int32
WriBy(SeriesFitStartEntry);// 4 bytes __int32
WriBy(SeriesFitStopEntry);// 4 bytes __int32
WriBy(npoly);// 4 bytes __int32
WriBy(seg1);// 4 bytes __int32
WriBy(FitFunc);// 4 bytes __int32
WriteBytes(fp, pos, MAXSERIESPARAM*sizeof(SeriesParam[0]), &(SeriesParam[0]));// 8 bytes * 100
WriteBytes(fp, pos, Npoints*sizeof(x[0]), &(x[0]));;// 8 bytes * Npoints
WriteBytes(fp, pos, Npoints*sizeof(y[0]), &(y[0]));;// 8 bytes * Npoints
WriBy(MaxIndexUsed);// 4 bytes __int32
WriteBytes(fp, pos, MAXARRAYPARAMS*sizeof(A[0]), &(A[0]));;// 8 bytes * 128
WriBy(l);// 4 bytes __int32
if (l>0){
TCHAR t;
for (int i=0; i<l; i++){
t=UserFunctionString[i];
WriBy(t);// char 1 byte
} }
 

Dwell-Times

WriBy(Present);// BOOL 4 bytes
if (!Present) return TRUE;
WriBy(from);// 4 bytes __int32
WriBy(to);// 4 bytes __int32
WriBy(NLevels);// 4 bytes __int32
WriBy(MinDwell);// 4 bytes __int32
WriBy(MaxDwell);// 4 bytes __int32
WriBy(Gain);// 8 bytes double
WriBy(SampleTime);// 8 bytes double
WriteBytes(fp, pos, NLevels*sizeof(NEntries[0]), &(NEntries[0]));// 4 bytes *NLevels
WriteBytes(fp, pos, NLevels*sizeof(NRealEntries[0]), &(NRealEntries[0]));// 4 bytes *NLevels
WriteBytes(fp, pos, NLevels*sizeof(Level[0]), &(Level[0]));// 2 bytes *NLevels
WriteBytes(fp, pos, NLevels*sizeof(ExpsFitted[0]), &(ExpsFitted[0]));// 1 byte *NLevels
WriteBytes(fp, pos, NLevels*sizeof(Nexps[0]), &(Nexps[0]));// 4 bytes *NLevels
int i;
for (i=0; i<NLevels; i++){
WriteBytes(fp, pos, NEntries[i]*sizeof(Durations[i][0]), &(Durations[i][0]));// 4 bytes *NEntries[i]
int j;
for (j=0; j<MAXEXPSDWELLTIME; j++){
WriBy(tau[i][j]);// 8 bytes double
WriBy(a[i][j]);// 8 bytes double
}
}
WriBy(MinValueDwellTimeHistos);// 8 bytes double
WriBy(MinDwellInMsecs);// 8 bytes double
WriBy(BinWidthDwellTimesInms);// 8 bytes double
WriBy(BinWidthDwellTimesInsu);// 8 bytes double
WriteBytes(fp, pos, MAXLEVELSDWELLTIMES*sizeof(NDwellPoints[0]), &(NDwellPoints[0]));// 4 bytes *10
for (i=0; i<NLevels; i++){
if (NDwellPoints[i]>0){
WriteBytes(fp, pos, NDwellPoints[i]*sizeof(DwellHistoData[i][0]), &(DwellHistoData[i][0]));// 8 bytes *NDwellPoints[i]
}
}
 
 

TraceFit

FitTraceType & F = fits[e];
WriBy(F.FitPresent);// BOOL 4 bytes
if (!F.FitPresent) return TRUE;
WriBy(F.NPoints);// 4 bytes __int32
WriBy(F.firstindex);// 4 bytes __int32
WriteBytes(fp, pos, F.NPoints*sizeof(F.FitData[0]), &(F.FitData[0]));// 2 bytes *NPoints
 
 

Results

WriBy(x);// 8 bytes double
WriBy(mean);// 8 bytes double
WriBy(variance);// 8 bytes double
WriBy(peak);// 8 bytes double
WriBy(integral);// 8 bytes double
WriBy(IMax);// 8 bytes double
WriBy(TMax);// 8 bytes double
WriBy(SpecialI);// 8 bytes double
WriBy(cursormeasure);// 8 bytes double
WriBy(NComponents);// 2 bytes
WriteBytes(fp, pos, MaxTau*sizeof(taus[0]), &(taus[0])); 8 bytes *30
WriteBytes(fp, pos, (2*MaxTau+1)*sizeof(coeff[0]), &(coeff[0])); 8 bytes *61
WriBy(IMaxPos);// 8 bytes double
WriBy(IMaxNeg);// 8 bytes double
WriBy(IMaxData);// 8 bytes double
 
 
 

Back to manual