'----------------------------------------------------
'				F i x F i l e   S c r i p t
'6/13/06
'----------------------------------------------------
'This program was initiated on Spike2 by Robi and is
'based on previous utilites that ran on the mac 
'including FixFile and SumAndScale.

	const
		kFalse						:= 0,
		kTrue 						:= 1,

		kProcess1Button%			:= 0,
		kProcess2button%			:= 1,
		kCancelButton%				:= 2,
		kProcess3button%			:= 3,
		kProcess4button%			:= 4;
	
	var 
		gQuitButton					:= 1,
		gOpenButton					:= 3,
		gSaveButton					:= 4,
		gProcessButton				:= 6,
		gFourthChButton			:= 7,
		gThirddChButton			:= 8,
		gSecondChButton			:= 9,
		gFirsttChButton			:= 10,
	
		gDataFile%,
		gFilename$,
		gFileType$,
		gLastTrace%					:= kProcess1Button%,
	
		gFix[4],
		gFil[4],
		gOff[4],
		gSca[4],
		gCmp[4],
		gHan[4],
		gMemch%[4],
		gMemErrch%[4],
		gMemVelch%[4],
		gMemVelchOrig%[4],

		gTraceNames$[40],
		gTraceHandles[40];

	gFix[0] := 0;
	gFix[1] := 1;
	gFix[2] := 6;
	gFix[3] := 7;

	gOff[0] := 0;
	gOff[1] := 0;
	gOff[2] := 0;
	gOff[3] := 0;

	gSca[0] := 1;
	gSca[1] := 1;
	gSca[2] := 1;
	gSca[3] := 1;

	gCmp[0] := 2;
	gCmp[1] := 3;
	gCmp[2] := 2;
	gCmp[3] := 3;



	ToolbarClear();
	DoToolbar();
'end of main program



'----------------------------------------------------
'						D o T o o l b a r
'<6/12/06
'----------------------------------------------------
proc DoToolbar()
	ToolbarSet(gQuitButton,"Quit", Quit%);						'Set up toolbar buttons
	ToolbarSet(gOpenButton,"Open New File", Open%);
	ToolbarSet(gProcessButton,"Apply Trace Actions", DialogAction%);

	if viewKind(gDataFile%) < 0 then
		ToolbarSet(gFourthChButton, "Display Fourth Chan", Draw4%);
		ToolbarSet(gThirddChButton, "Display Third  Chan", Draw3%);
		ToolbarSet(gSecondChButton, "Display Second Chan", Draw2%);
		ToolbarSet(gFirsttChButton, "Display First  Chan", Draw1%);
	else
		ToolbarSet(gFourthChButton, "Display " + gTraceNames$[gFix[3]], Draw4%);
		ToolbarSet(gThirddChButton, "Display " + gTraceNames$[gFix[2]], Draw3%);
		ToolbarSet(gSecondChButton, "Display " + gTraceNames$[gFix[1]], Draw2%);
		ToolbarSet(gFirsttChButton, "Display " + gTraceNames$[gFix[0]], Draw1%);
	endif	

	ToolbarSet(gSaveButton,"Save Changes", Save%);


	ToolbarEnable(gQuitButton,1);
	ToolbarEnable(gOpenButton,1);
	if viewKind(gDataFile%) < 0 then
		ToolbarEnable(gFourthChButton,0);
		ToolbarEnable(gThirddChButton,0);
		ToolbarEnable(gSecondChButton,0);
		ToolbarEnable(gFirsttChButton,0);
		ToolbarEnable(gSaveButton,0);
		ToolbarEnable(gProcessButton,0);
	else
		ToolbarEnable(gFourthChButton,1);
		ToolbarEnable(gThirddChButton,1);
		ToolbarEnable(gSecondChButton,1);
		ToolbarEnable(gFirsttChButton,1);
		ToolbarEnable(gSaveButton,1);
		ToolbarEnable(gProcessButton,1);
	endif

	Toolbar("", 1023);

end;		'DoToolbar



'----------------------------------------------------
'							Q u i t
'<6/12/06
'----------------------------------------------------
func Quit%()
	FileClose(-1,-1);
	halt;
end;		'Quit


	
'----------------------------------------------------
'							O p e n
'6/12/06
'----------------------------------------------------
func Open%()
	var
		i%,
		aRow%,
		item%,
		aTrace%,
		aSize,
		okay%,
		aTab1,aTab2,aTab3,aTab4,aTab5;

	aTab1 := 0;
	aTab2 := aTab1 + 23;
	aTab3 := aTab2 + 20;
	aTab4 := aTab3 + 20;
	aTab5 := aTab4 + 20;


	FileClose(-1,-1);															'close any open files
	gDataFile% := FileOpen("",0,1);
	if gDataFile% < 0 then
		Message("Error opening file, try again.");
		FileClose(-1,-1);
		DoToolbar();
	endif;

	gFilename$ := FileName$(3);
   gFileType$ := FileName$(5);
	aTrace% := 0;
	for i% := 1 to 40 do 
		'6/16/06, had to make memchan be realwaves or else the were cutoff at +/-5 volts.
		if (chanKind(i%) = 1)  or  (chanKind(i%) = 9) then
			aSize := Binsize(i%);
			if aSize >= 0.001 then											'exclude spike traces
				aSize := inStr(lcase$(ChanTitle$(i%)), "spike");	'exclude spike traces
				if aSize = 0 then
					gTraceNames$[aTrace%] := ChanTitle$(i%);
					gTraceHandles[aTrace%] := i%;
					aTrace% := aTrace% + 1;
				endif
			endif
		endif
	next

	DlgCreate("Fix File -- Select the Traces You Want to Fix");
	aRow% 	:= 2;
	item%	:= 0;

	dlgtext("Channel to Fix: ", aTab1, aRow%);
	item% := item% + 1;
	dlgList(item%,"",gTraceNames$[],99,aTab2,aRow%);
	item% := item% + 1;
	dlgList(item%,"",gTraceNames$[],99,aTab3,aRow%);
	item% := item% + 1;
	dlgList(item%,"",gTraceNames$[],99,aTab4,aRow%);
	item% := item% + 1;
	dlgList(item%,"",gTraceNames$[],99,aTab5,aRow%);
	aRow% := aRow% + 1;

	dlgtext("Error comparison with: ", aTab1, aRow%);
	item% := item% + 1;
	dlgList(item%,"",gTraceNames$[],99,aTab2,aRow%);
	item% := item% + 1;
	dlgList(item%,"",gTraceNames$[],99,aTab3,aRow%);
	item% := item% + 1;
	dlgList(item%,"",gTraceNames$[],99,aTab4,aRow%);
	item% := item% + 1;
	dlgList(item%,"",gTraceNames$[],99,aTab5,aRow%);
	item% := item% + 1;
	aRow% := aRow% + 1;
	dlgtext("", aTab1, aRow%);

	okay% := DlgShow(gFix[],gCmp[]);


	if okay% = 0 then	
		FileClose(-1,-1);		'user clicked CANCEL
		DoToolbar();
	else

		'Get the chosen trace handles.  Do each group so they are sequential with in the group
		'6/16/06, had to make memchan be realwaves or else the were cutoff at +/-5 volts.
		for i% := 0 to 3 do
			gHan[i%] := gTraceHandles[gFix[i%]];		
		next

		'must be waveform because it is saved back to digitized file, must use ChanScale to make it appear correctly
		for i% := 0 to 3 do
			gMemch%[i%] := MemChan(1,0,BinSize(gHan[i%]));					'create 16-bit integer waveform memory chans
			ChanScale(gMemch%[i%],ChanScale(gHan[i%]));
			MemImport(gMemch%[i%], gHan[i%], 0, MaxTime());					'fill 'em with data
		next
	
		'using realwave because error signal not saved back to digitized file, don't have to use ChanScale
		for i% := 0 to 3 do
			gMemErrch%[i%] := MemChan(9,0,BinSize(gHan[i%]));				'create 32-bit real waveform memory chans
			ChannelError(gMemErrch%[i%],gTraceHandles[gCmp[i%]],gMemch%[i%]);
		next

		'using realwave because velocities not saved back to digitized file, don't have to use ChanScale
		for i% := 0 to 3 do
			gMemVelch%[i%] := MemChan(9,0,BinSize(gHan[i%]));				'create 32-bit real waveform memory chans
			ChannelDifference(gMemVelch%[i%], gHan[i%]);	

			gMemVelchOrig%[i%] := MemChan(9,0,BinSize(gHan[i%]));			'create 32-bit real waveform memory chans
			MemImport(gMemVelchOrig%[i%], gMemVelch%[i%], 0, MaxTime());'get new data
		next

		for i% := 0 to 3 do
			'ChanScale(gMemch%[i%],ChanScale(gHan[i%]));

			yrange(gHan[i%], -25, 25);												'scale the original traces
			yrange(gMemch%[i%], -25, 25);											'scale their new memchan
			yrange(gMemErrch%[i%], -25, 25);										'scale their new memchan
			yrange(gTraceHandles[gCmp[i%]], -25, 25);							'target
			yrange(gMemVelch%[i%], -500, 500);									'scale their new memchan
			yrange(gMemVelchOrig%[i%], -500, 500);								'scale their new memchan

			ChanTitle$(gMemch%[i%], "m_"+gTraceNames$[gFix[i%]]);			'label the new memcha
			ChanTitle$(gMemErrch%[i%], "err_"+gTraceNames$[gFix[i%]]);	'label the new memcha
			ChanTitle$(gMemVelch%[i%], "vel_"+gTraceNames$[gFix[i%]]);	'label the new memcha
			ChanTitle$(gMemVelchOrig%[i%], "vel_original");					'label the new memcha

			ChanColour(gTraceHandles[gCmp[i%]], 1, 16);						'red
			ChanColour(gMemch%[i%], 1, 0);										'black
			ChanColour(gMemVelch%[i%], 1, 32);									'magenta
			ChanColour(gMemVelchOrig%[i%], 1, 8);								'green
			ChanColour(gMemErrch%[i%], 1, 24);									'blue
		next

		DrawTraces(gLastTrace%);
		xrange(0,10);
		hcursornew(gMemch%[gLastTrace%],0);
		hcursornew(gMemErrch%[gLastTrace%],0);
		hcursornew(gMemVelch%[gLastTrace%],0);
		DialogAction%();
	endif
end		'Open



'----------------------------------------------------
'					C h a n n e l C o p y 	
'Makes an independent copy of a channel.  Any channel
'ChanDup makes changes as the original changes.
'
'6/19/06  
'----------------------------------------------------
func ChannelCopy(dest%, source%)
	var 
		DataLength%;

	DataLength% := (MaxTime()-0)/BinSize(source%) + 1;
	var 
		aData1[DataLength%];

	ChanData(source%, aData1[], 0, MaxTime());

	chanwritewave(dest%,aData1[],0);
	return DataLength%;
end		'ChannelCopy



'----------------------------------------------------
'			C h a n n e l D i f f e r e n c e	
'5 coefficient FIR derivative
'<6/12/06  Robi's routine from Saccade
'----------------------------------------------------
func ChannelDifference(dest%, source%)
	var 
		DataLength%;

	DataLength% := (MaxTime()-0)/BinSize(source%) + 1;
	var 
		aData1[DataLength%];

	ChanData(source%, aData1[], 0, MaxTime());

	ArrayDifference(aData1[],BinSize(source%));
	chanwritewave(dest%,aData1[],0);
	return DataLength%;
end		'ChannelDifference



'----------------------------------------------------
'				A r r a y D i f f e r e n c e
' put the data to be differentiated in dest[], it will 
' be replaced by its derivative
' TimeStep is in second
'< 3/10/04  Robi's routine from Saccade.
'----------------------------------------------------
func ArrayDifference(dest[], TimeStep)
	var 
		coeffFIR[5];

	coeffFIR[0] := -0.2;
	coeffFIR[1] := -0.1;
	coeffFIR[2] := 0;
	coeffFIR[3] := 0.1;
	coeffFIR[4] := 0.2;
	ArrFilt(dest[],coeffFIR[]);
	ArrDiv(dest[],TimeStep);
	return TimeStep;
end		'ArrayDifference



'----------------------------------------------------
'					C h a n n e l E r r o r 
' put the data to be differentiated in dest[], it will 
' be replaced by its derivative
' TimeStep is in second
'<6/12/06	Robi's routine
'----------------------------------------------------
func ChannelError(dest%, source1%, source2%)
	var 
		DataLength%;
	
	DataLength%:=(MaxTime()-0)/BinSize(source1%) + 1;
	var 
		aData1[DataLength%],data2[DataLength%];
	
	ChanData(source1%, aData1[], 0, MaxTime());
	ChanData(source2%, data2[], 0, MaxTime());
	ArrSub(aData1[],data2[]);
	chanwritewave(dest%,aData1[],0);
	return DataLength%;
end;		'ChannelError



'----------------------------------------------------
'					C h a n n e l F i l t e r
'<6/12/06  Robi's routine
'----------------------------------------------------
func ChannelFilter(source%, aWhich%)
	var 
		aDataLength%;
	
	aDataLength% := MaxTime()/BinSize(source%) + 1;
	var 
		aData1[aDataLength%];

	ChanData(source%, aData1[], 0, MaxTime());

	docase
		case aWhich% = 1 then
			ArrayFilter10Hz(aData1[]);
		case aWhich% = 2 then
			ArrayFilter20Hz(aData1[]);
		case aWhich% = 3 then
			ArrayFilter75Hz(aData1[]);
		case aWhich% = 4 then
			ArrayFilter90Hz(aData1[]);
	endcase

	ChanWriteWave(source%, aData1[],0);
	return aDataLength%;
end;		'ChannelFilter



'----------------------------------------------------
'					D i a l o g A c t i o n 
'6/14/06
'----------------------------------------------------
func DialogAction%()
	var
		item%,
		aRow%,
		okay%,
		aTab1,aTab2,aTab3,aTab4,aTab5;

	aTab1 := 0;
	aTab2 := aTab1 + 23;
	aTab3 := aTab2 + 20;
	aTab4 := aTab3 + 20;
	aTab5 := aTab4 + 20;


	DlgCreate("Fix File -- Filter, Offset and Scale the Channels");
	aRow% := 1;
	item% := 0;

	dlgtext("These parameters are always applied to the original traces and the results will be shown to you.", aTab1, aRow%);
	aRow% := aRow% + 1;
	dlgtext("Nothing is permanent until you save the file.", aTab1, aRow%);
	aRow% := aRow% + 2;
	
	dlgtext("Channel to Fix: ", aTab1, aRow%);
	item% := item% + 1;
	dlgLabel(item%,gTraceNames$[gFix[0]],aTab2,aRow%);
	item% := item% + 1;
	dlgLabel(item%,gTraceNames$[gFix[1]],aTab3,aRow%);
	item% := item% + 1;
	dlgLabel(item%,gTraceNames$[gFix[2]],aTab4,aRow%);
	item% := item% + 1;
	dlgLabel(item%,gTraceNames$[gFix[3]],aTab5,aRow%);
	aRow% := aRow% + 1;

	dlgtext("Low Pass Filter: ", aTab1, aRow%);
	item% := item% + 1;
	dlgList(item%,"","no filtering|10Hz|20Hz|75Hz|90Hz",99,aTab2,aRow%);
	item% := item% + 1;
	dlgList(item%,"","no filtering|10Hz|20Hz|75Hz|90Hz",99,aTab3,aRow%);
	item% := item% + 1;
	dlgList(item%,"","no filtering|10Hz|20Hz|75Hz|90Hz",99,aTab4,aRow%);
	item% := item% + 1;
	dlgList(item%,"","no filtering|10Hz|20Hz|75Hz|90Hz",99,aTab5,aRow%);
	aRow% := aRow% + 1;

	dlgtext("Offset: ", aTab1, aRow%);
	item% := item% + 1;
	dlgReal(item%,"",-100,100,aTab2,aRow%);
	item% := item% + 1;
	dlgReal(item%,"",-100,100,aTab3,aRow%);
	item% := item% + 1;
	dlgReal(item%,"",-100,100,aTab4,aRow%);
	item% := item% + 1;
	dlgReal(item%,"",-100,100,aTab5,aRow%);
	aRow% := aRow% + 1;
	
	dlgtext("Scale: ", aTab1, aRow%);
	item% := item% + 1;
	dlgReal(item%,"",0,100,aTab2,aRow%);
	item% := item% + 1;
	dlgReal(item%,"",0,100,aTab3,aRow%);
	item% := item% + 1;
	dlgReal(item%,"",0,100,aTab4,aRow%);
	item% := item% + 1;
	dlgReal(item%,"",0,100,aTab5,aRow%);
	aRow% := aRow% + 1;	
	dlgtext("", aTab1, aRow%);
	
	dlgButton(0, "Cancel");
	dlgButton(1, "Apply These Actions to the Traces");

	okay% := DlgShow(gFix[],gFil[],gOff[],gSca[]);

	if okay% <> 0 then			'cancel = 0
		TraceActions();
		DrawTraces(gLastTrace%);
	endif
	DoToolbar();
end		'DialogAction



'----------------------------------------------------
'					T r a c e A c t i o n s
'6/15/06
'----------------------------------------------------
proc TraceActions();
	var
		i%;

	for i% := 0 to 3 do
		MemImport(gMemch%[i%], gHan[i%], 0, MaxTime());								'get new data

		if gFil[i%] > 0 then
			ChannelFilter(gMemch%[i%], gFil[i%]);										'apply selected filter
		endif

		if gOff[i%] <> 0 then
			ChannelOffset%(gMemch%[i%], gOff[i%]);										'apply appropriate offset
		endif

		if gSca[i%] <> 1 then
			ChannelScale%(gMemch%[i%], gSca[i%]);										'apply scaling
		endif

		ChannelError(gMemErrch%[i%],gTraceHandles[gCmp[i%]],gMemch%[i%]);		'compute the error trace
		ChannelDifference(gMemVelch%[i%], gMemch%[i%]);								'compute the velocity trace
	next
end		'TraceActions



'----------------------------------------------------
'					C h a n n e l S c a l e
'<6/12/06	Robi's routine
'----------------------------------------------------
func ChannelScale%(destin%, aScale)
	var 
		aDataLength%;

	aDataLength% := maxTime()/BinSize(destin%) + 1;
	var
		aData1[aDataLength%];
	
	ChanData(destin%, aData1[], 0, maxTime());
	ArrMul(aData1[], aScale);
	chanwritewave(destin%, aData1[], 0);
	return 1;
end		'ChannelScale



'----------------------------------------------------
'					C h a n n e l O f f s e t
'<6/12/06	Robi's routine
'----------------------------------------------------
func ChannelOffset%(destin%, aOffset)
	var 
		aDataLength%;

	aDataLength% := maxTime()/BinSize(destin%) + 1;
	var 
		aData1[aDataLength%];

	ChanData(destin%, aData1[], 0, maxTime());
	ArrAdd(aData1[], aOffset);
	chanwritewave(destin%, aData1[], 0);
	return 1;
end		'ChannelOffset



'----------------------------------------------------
'							D r a w 1
'6/15/06
'----------------------------------------------------
func Draw1%();
	DrawTraces(kProcess1Button%);
	gLastTrace% := kProcess1Button%;
	return kTrue;
end		'Draw1



'----------------------------------------------------
'							D r a w 2
'6/15/06
'----------------------------------------------------
func Draw2%();
	DrawTraces(kProcess2Button%);
	gLastTrace% := kProcess2Button%;
	return kTrue;
end		'Draw2



'----------------------------------------------------
'							D r a w 3
'6/15/06
'----------------------------------------------------
func Draw3%();
	DrawTraces(kProcess3Button%);
	gLastTrace% := kProcess3Button%;
	return kTrue;
end		'Draw3



'----------------------------------------------------
'							D r a w 4
'6/15/06
'----------------------------------------------------
func Draw4%();
	DrawTraces(kProcess4Button%);
	gLastTrace% := kProcess4Button%;
	return kTrue;
end		'Draw4



'----------------------------------------------------
'						D r a w T r a c e s
'6/15/06
'----------------------------------------------------
func DrawTraces(okay%);
	var
		i%;

	chanhide(-1);											'hide all the traces
	docase
		case okay% = kProcess1Button% then
			i% := 0;
		case okay% = kProcess2button% then
			i% := 1;
		case okay% = kProcess3button% then
			i% := 2;
		case okay% = kProcess4button% then
			i% := 3;
		endcase

		chanshow(gMemch%[i%], gMemErrch%[i%], gMemVelch%[i%],gMemVelchOrig%[i%], gTraceHandles[gCmp[i%]]);	'just the related traces

		ChanOrder(-1);
		ChanOrder(gTraceHandles[gCmp[i%]], 0, gMemch%[i%]);
		YAxisLock(gTraceHandles[gCmp[i%]],1);
		ChanOrder(gMemVelch%[i%], 0, gMemVelchOrig%[i%]);
		YAxisLock(gMemVelch%[i%],1);
		WindowTitle$(gTraceNames$[gFix[i%]] + "  from  " + gFilename$);
	 return 1
end		'DrawTraces
	


'----------------------------------------------------
'								S a v e
'<6/12/06
'----------------------------------------------------
func Save%()
	var
		aResult%,
		aName$,
		i%;

	aResult% := Query("Are you sure that you want over-write the input file?","Cancel","Yes");
	if aResult% = 0 then
		'write over existing file  = yes
		'save the memory channels to real channels
		view((gDataFile%));
		for i% := 0 to 3 do
			aName$ := ChanTitle$(gHan[i%]);				'get the original channel name
			ChanDelete(gHan[i%]);							'delete the original channel
			MemSave(gMemch%[i%], gHan[i%],0);			'replace the channel with the filtered, offset, scaled version
			ChanTitle$(gHan[i%], aName$);					'give it the original channel name
		next
	endif

	aResult% := FileClose(-1);		'#1--lose all window, query about each window
	DoToolbar();
	return 1;
end;		'Save



'----------------------------------------------------
'						ArrayFilter10Hz
' FIR Coefficients for 10Hz lpf, -6db at cf
'<6/12/06
'----------------------------------------------------
func ArrayFilter10Hz(dest[])
	var 
		coeff[101];

	coeff[000]:=   0.00000000000000000007387334;
	coeff[001]:=   0.00003908811837950445100000;
	coeff[002]:=   0.00008232460279008877900000;
	coeff[003]:=   0.00013249427294631890000000;
	coeff[004]:=   0.00019251615101165430000000;
	coeff[005]:=   0.00026540550527967988000000;
	coeff[006]:=   0.00035423351028315820000000;
	coeff[007]:=   0.00046208501623877209000000;
	coeff[008]:=   0.00059201495338988611000000;
	coeff[009]:=   0.00074700392283314897000000;
	coeff[010]:=   0.00092991354439110022000000;
	coeff[011]:=   0.00114344214369811020000000;
	coeff[012]:=   0.00139008136467425940000000;
	coeff[013]:=   0.00167207428984541200000000;
	coeff[014]:=   0.00199137563950563000000000;
	coeff[015]:=   0.00234961460159232180000000;
	coeff[016]:=   0.00274806081754157100000000;
	coeff[017]:=   0.00318759401559911550000000;
	coeff[018]:=   0.00366867774246901900000000;
	coeff[019]:=   0.00419133759726845240000000;
	coeff[020]:=   0.00475514431909313060000000;
	coeff[021]:=   0.00535920202173445060000000;
	coeff[022]:=   0.00600214180694983580000000;
	coeff[023]:=   0.00668212092195879200000000;
	coeff[024]:=   0.00739682755835845750000000;
	coeff[025]:=   0.00814349131930562630000000;
	coeff[026]:=   0.00891889931050880020000000;
	coeff[027]:=   0.00971941773924390320000000;
	coeff[028]:=   0.01054101883518580900000000;
	coeff[029]:=   0.01137931283826340000000000;
	coeff[030]:=   0.01222958473290688400000000;
	coeff[031]:=   0.01308683534583953600000000;
	coeff[032]:=   0.01394582636680486700000000;
	coeff[033]:=   0.01480112879909211700000000;
	coeff[034]:=   0.01564717430013974300000000;
	coeff[035]:=   0.01647830883249495200000000;
	coeff[036]:=   0.01728884801253790400000000;
	coeff[037]:=   0.01807313351910306100000000;
	coeff[038]:=   0.01882558990680677900000000;
	coeff[039]:=   0.01954078115977766700000000;
	coeff[040]:=   0.02021346632073370600000000;
	coeff[041]:=   0.02083865353799795400000000;
	coeff[042]:=   0.02141165188902128400000000;
	coeff[043]:=   0.02192812036310659900000000;
	coeff[044]:=   0.02238411341801467900000000;
	coeff[045]:=   0.02277612256458587400000000;
	coeff[046]:=   0.02310111347994210300000000;
	coeff[047]:=   0.02335655820265641900000000;
	coeff[048]:=   0.02354046202182327400000000;
	coeff[049]:=   0.02365138473548697800000000;
	coeff[050]:=   0.02368845602157667100000000;
	coeff[051]:=   0.02365138473548697800000000;
	coeff[052]:=   0.02354046202182327400000000;
	coeff[053]:=   0.02335655820265641900000000;
	coeff[054]:=   0.02310111347994210300000000;
	coeff[055]:=   0.02277612256458587400000000;
	coeff[056]:=   0.02238411341801467900000000;
	coeff[057]:=   0.02192812036310659900000000;
	coeff[058]:=   0.02141165188902128400000000;
	coeff[059]:=   0.02083865353799795400000000;
	coeff[060]:=   0.02021346632073370600000000;
	coeff[061]:=   0.01954078115977766700000000;
	coeff[062]:=   0.01882558990680677900000000;
	coeff[063]:=   0.01807313351910306100000000;
	coeff[064]:=   0.01728884801253790400000000;
	coeff[065]:=   0.01647830883249495200000000;
	coeff[066]:=   0.01564717430013974300000000;
	coeff[067]:=   0.01480112879909211700000000;
	coeff[068]:=   0.01394582636680486700000000;
	coeff[069]:=   0.01308683534583953600000000;
	coeff[070]:=   0.01222958473290688400000000;
	coeff[071]:=   0.01137931283826340000000000;
	coeff[072]:=   0.01054101883518580900000000;
	coeff[073]:=   0.00971941773924390320000000;
	coeff[074]:=   0.00891889931050880020000000;
	coeff[075]:=   0.00814349131930562630000000;
	coeff[076]:=   0.00739682755835845750000000;
	coeff[077]:=   0.00668212092195879200000000;
	coeff[078]:=   0.00600214180694983580000000;
	coeff[079]:=   0.00535920202173445060000000;
	coeff[080]:=   0.00475514431909313060000000;
	coeff[081]:=   0.00419133759726845240000000;
	coeff[082]:=   0.00366867774246901900000000;
	coeff[083]:=   0.00318759401559911550000000;
	coeff[084]:=   0.00274806081754157100000000;
	coeff[085]:=   0.00234961460159232180000000;
	coeff[086]:=   0.00199137563950563000000000;
	coeff[087]:=   0.00167207428984541200000000;
	coeff[088]:=   0.00139008136467425940000000;
	coeff[089]:=   0.00114344214369811020000000;
	coeff[090]:=   0.00092991354439110022000000;
	coeff[091]:=   0.00074700392283314897000000;
	coeff[092]:=   0.00059201495338988611000000;
	coeff[093]:=   0.00046208501623877209000000;
	coeff[094]:=   0.00035423351028315820000000;
	coeff[095]:=   0.00026540550527967988000000;
	coeff[096]:=   0.00019251615101165430000000;
	coeff[097]:=   0.00013249427294631890000000;
	coeff[098]:=   0.00008232460279008877900000;
	coeff[099]:=   0.00003908811837950445100000;
	coeff[100]:= 	0.00000000000000000007387334;

	ArrFilt(dest[],coeff[]);
	return 1;
end;



'----------------------------------------------------
'						ArrayFilter20Hz
' FIR Coefficients for 20Hz lpf, -6db at cf
'<6/12/06
'----------------------------------------------------
func ArrayFilter20Hz(dest[])
	var 
		coeff[101];
	
	coeff[000]:=  -0.00000000000000000012425399;
	coeff[001]:=  -0.00006561597079494137100000;
	coeff[002]:=  -0.00013737703867626111000000;
	coeff[003]:=  -0.00021890628713438866000000;
	coeff[004]:=  -0.00031363657752729839000000;
	coeff[005]:=  -0.00042455980390358847000000;
	coeff[006]:=  -0.00055397583757541555000000;
	coeff[007]:=  -0.00070325055582820908000000;
	coeff[008]:=  -0.00087259238798383272000000;
	coeff[009]:=  -0.00106085653807515630000000;
	coeff[010]:=  -0.00126538545828339100000000;
	coeff[011]:=  -0.00148189326271944230000000;
	coeff[012]:=  -0.00170440060861242610000000;
	coeff[013]:=  -0.00192522516231891550000000;
	coeff[014]:=  -0.00213503115006955910000000;
	coeff[015]:=  -0.00232293971466226690000000;
	coeff[016]:=  -0.00247669991202022120000000;
	coeff[017]:=  -0.00258291824270423610000000;
	coeff[018]:=  -0.00262734268283624840000000;
	coeff[019]:=  -0.00259519531703637870000000;
	coeff[020]:=  -0.00247154594244340140000000;
	coeff[021]:=  -0.00224171746430124830000000;
	coeff[022]:=  -0.00189171259184579120000000;
	coeff[023]:=  -0.00140865031379458560000000;
	coeff[024]:=  -0.00078119992318626485000000;
	coeff[025]:=   0.00000000000000000083871443;
	coeff[026]:=   0.00094195023492230372000000;
	coeff[027]:=   0.00204893940235267810000000;
	coeff[028]:=   0.00332224374277788380000000;
	coeff[029]:=   0.00475988854643451510000000;
	coeff[030]:=   0.00635648016044827130000000;
	coeff[031]:=   0.00810311577537513840000000;
	coeff[032]:=   0.00998737622462052620000000;
	coeff[033]:=   0.01199340486922221600000000;
	coeff[034]:=   0.01410207334755789500000000;
	coeff[035]:=   0.01629123260960825900000000;
	coeff[036]:=   0.01853604529618041800000000;
	coeff[037]:=   0.02080939323344508900000000;
	coeff[038]:=   0.02308235165944282100000000;
	coeff[039]:=   0.02532471984572470800000000;
	coeff[040]:=   0.02750559608259675600000000;
	coeff[041]:=   0.02959398361205915800000000;
	coeff[042]:=   0.03155941306133706200000000;
	coeff[043]:=   0.03337256628475948600000000;
	coeff[044]:=   0.03500588628448951500000000;
	coeff[045]:=   0.03643415806132119900000000;
	coeff[046]:=   0.03763504584340132000000000;
	coeff[047]:=   0.03858957313915973400000000;
	coeff[048]:=   0.03928253343505241200000000;
	coeff[049]:=   0.03970282107202600200000000;
	coeff[050]:=   0.03984367384003621000000000;
	coeff[051]:=   0.03970282107202600200000000;
	coeff[052]:=   0.03928253343505241200000000;
	coeff[053]:=   0.03858957313915973400000000;
	coeff[054]:=   0.03763504584340132000000000;
	coeff[055]:=   0.03643415806132119900000000;
	coeff[056]:=   0.03500588628448951500000000;
	coeff[057]:=   0.03337256628475948600000000;
	coeff[058]:=   0.03155941306133706200000000;
	coeff[059]:=   0.02959398361205915800000000;
	coeff[060]:=   0.02750559608259675600000000;
	coeff[061]:=   0.02532471984572470800000000;
	coeff[062]:=   0.02308235165944282100000000;
	coeff[063]:=   0.02080939323344508900000000;
	coeff[064]:=   0.01853604529618041800000000;
	coeff[065]:=   0.01629123260960825900000000;
	coeff[066]:=   0.01410207334755789500000000;
	coeff[067]:=   0.01199340486922221600000000;
	coeff[068]:=   0.00998737622462052620000000;
	coeff[069]:=   0.00810311577537513840000000;
	coeff[070]:=   0.00635648016044827130000000;
	coeff[071]:=   0.00475988854643451510000000;
	coeff[072]:=   0.00332224374277788380000000;
	coeff[073]:=   0.00204893940235267810000000;
	coeff[074]:=   0.00094195023492230372000000;
	coeff[075]:=   0.00000000000000000083871443;
	coeff[076]:=  -0.00078119992318626485000000;
	coeff[077]:=  -0.00140865031379458560000000;
	coeff[078]:=  -0.00189171259184579120000000;
	coeff[079]:=  -0.00224171746430124830000000;
	coeff[080]:=  -0.00247154594244340140000000;
	coeff[081]:=  -0.00259519531703637870000000;
	coeff[082]:=  -0.00262734268283624840000000;
	coeff[083]:=  -0.00258291824270423610000000;
	coeff[084]:=  -0.00247669991202022120000000;
	coeff[085]:=  -0.00232293971466226690000000;
	coeff[086]:=  -0.00213503115006955910000000;
	coeff[087]:=  -0.00192522516231891550000000;
	coeff[088]:=  -0.00170440060861242610000000;
	coeff[089]:=  -0.00148189326271944230000000;
	coeff[090]:=  -0.00126538545828339100000000;
	coeff[091]:=  -0.00106085653807515630000000;
	coeff[092]:=  -0.00087259238798383272000000;
	coeff[093]:=  -0.00070325055582820908000000;
	coeff[094]:=  -0.00055397583757541555000000;
	coeff[095]:=  -0.00042455980390358847000000;
	coeff[096]:=  -0.00031363657752729839000000;
	coeff[097]:=  -0.00021890628713438866000000;
	coeff[098]:=  -0.00013737703867626111000000;
	coeff[099]:=  -0.00006561597079494137100000;
	coeff[100]:=  -0.00000000000000000012425399;
	
	ArrFilt(dest[],coeff[]);
	return 1;
end;



'----------------------------------------------------
'						ArrayFilter75Hz
' FIR Coefficients for 75Hz lpf, -6db at cf
'<6/12/06
'----------------------------------------------------
func ArrayFilter75Hz(dest[])
	var 
		coeff[55];

	coeff[000]:=   0.00014788126533547483;
	coeff[001]:=  -0.00031515097097424907;
	coeff[002]:=  -0.00083381258953706605;
	coeff[003]:=  -0.00136217269227995890;
	coeff[004]:=  -0.00176643292062556090;
	coeff[005]:=  -0.00182645940741005740;
	coeff[006]:=  -0.00129407685005234630;
	coeff[007]:=   0.00000000000000000131;
	coeff[008]:=   0.00202253685759350460;
	coeff[009]:=   0.00444530257450907050;
	coeff[010]:=   0.00663238686285731910;
	coeff[011]:=   0.00773884325749790280;
	coeff[012]:=   0.00692023883085744140;
	coeff[013]:=   0.00361443683160032930;
	coeff[014]:=  -0.00217586788655907150;
	coeff[015]:=  -0.00968720007244959840;
	coeff[016]:=  -0.01736466434021147900;
	coeff[017]:=  -0.02304145970876071000;
	coeff[018]:=  -0.02432112128774956800;
	coeff[019]:=  -0.01909752781924707300;
	coeff[020]:=  -0.00610092640665446050;
	coeff[021]:=   0.01466343275070632800;
	coeff[022]:=   0.04170555509264201000;
	coeff[023]:=   0.07214625193163108600;
	coeff[024]:=   0.10212568014590055000;
	coeff[025]:=   0.12745694524800519000;
	coeff[026]:=   0.14439373264956143000;
	coeff[027]:=   0.15034729730762691000;
	coeff[028]:=   0.14439373264956143000;
	coeff[029]:=   0.12745694524800519000;
	coeff[030]:=   0.10212568014590055000;
	coeff[031]:=   0.07214625193163108600;
	coeff[032]:=   0.04170555509264201000;
	coeff[033]:=   0.01466343275070632800;
	coeff[034]:=  -0.00610092640665446050;
	coeff[035]:=  -0.01909752781924707300;
	coeff[036]:=  -0.02432112128774956800;
	coeff[037]:=  -0.02304145970876071000;
	coeff[038]:=  -0.01736466434021147900;
	coeff[039]:=  -0.00968720007244959840;
	coeff[040]:=  -0.00217586788655907150;
	coeff[041]:=   0.00361443683160032930;
	coeff[042]:=   0.00692023883085744140;
	coeff[043]:=   0.00773884325749790280;
	coeff[044]:=   0.00663238686285731910;
	coeff[045]:=   0.00444530257450907050;
	coeff[046]:=   0.00202253685759350460;
	coeff[047]:=   0.00000000000000000131;
	coeff[048]:=  -0.00129407685005234630;
	coeff[049]:=  -0.00182645940741005740;
	coeff[050]:=  -0.00176643292062556090;
	coeff[051]:=  -0.00136217269227995890;
	coeff[052]:=  -0.00083381258953706605;
	coeff[053]:=  -0.00031515097097424907;
	coeff[054]:=   0.00014788126533547483;
	
	ArrFilt(dest[],coeff[]);
	return 1;
end;



'----------------------------------------------------
'						ArrayFilter90Hz
' FIR Coefficients for 90Hz lpf, -6db at cf
'<6/12/06
'----------------------------------------------------
func ArrayFilter90Hz(dest[])
	var 
		coeff[55];

	coeff[0]:=   0.00040054480316383640;
	coeff[1]:=   0.00085690620706958451;
	coeff[2]:=   0.00117346271679676790;
	coeff[3]:=   0.00120343557986769870;
	coeff[4]:=   0.00075778779765828719;
	coeff[5]:=  -0.00028158173092148137;
	coeff[6]:=  -0.00180812127952662580;
	coeff[7]:=  -0.00338689549790561210;
	coeff[8]:=  -0.00429410286947358270;
	coeff[9]:=  -0.00374311242124440330;
	coeff[10]:=  -0.00125216642479979220;
	coeff[11]:=   0.00298092026309667660;
	coeff[12]:=   0.00787915375167618990;
	coeff[13]:=   0.01161679424396057000;
	coeff[14]:=   0.01212947638392876000;
	coeff[15]:=   0.00790115295910780000;
	coeff[16]:=  -0.00121777045992411030;
	coeff[17]:=  -0.01347766085695940900;
	coeff[18]:=  -0.02525614823656446200;
	coeff[19]:=  -0.03176017034793143800;
	coeff[20]:=  -0.02829163410508829900;
	coeff[21]:=  -0.01174349217539026900;
	coeff[22]:=   0.01813748714547966400;
	coeff[23]:=   0.05816656340105463800;
	coeff[24]:=   0.10208519665961896000;
	coeff[25]:=   0.14185912847378271000;
	coeff[26]:=   0.16959453586596018000;
	coeff[27]:=   0.17954062030701420000;
	coeff[28]:=   0.16959453586596018000;
	coeff[29]:=   0.14185912847378271000;
	coeff[30]:=   0.10208519665961896000;
	coeff[31]:=   0.05816656340105463800;
	coeff[32]:=   0.01813748714547966400;
	coeff[33]:=  -0.01174349217539026900;
	coeff[34]:=  -0.02829163410508829900;
	coeff[35]:=  -0.03176017034793143800;
	coeff[36]:=  -0.02525614823656446200;
	coeff[37]:=  -0.01347766085695940900;
	coeff[38]:=  -0.00121777045992411030;
	coeff[39]:=   0.00790115295910780000;
	coeff[40]:=   0.01212947638392876000;
	coeff[41]:=   0.01161679424396057000;
	coeff[42]:=   0.00787915375167618990;
	coeff[43]:=   0.00298092026309667660;
	coeff[44]:=  -0.00125216642479979220;
	coeff[45]:=  -0.00374311242124440330;
	coeff[46]:=  -0.00429410286947358270;
	coeff[47]:=  -0.00338689549790561210;
	coeff[48]:=  -0.00180812127952662580;
	coeff[49]:=  -0.00028158173092148137;
	coeff[50]:=   0.00075778779765828719;
	coeff[51]:=   0.00120343557986769870;
	coeff[52]:=   0.00117346271679676790;
	coeff[53]:=   0.00085690620706958451;
	coeff[54]:=   0.00040054480316383640;
	
	ArrFilt(dest[],coeff[]);
	return 1;
end;