CORDUROY_ANALYSIS_utility.ipf

#pragma rtGlobals=2		// Use modern global access method.
#include "CORDUROY_ANALYSIS_imaging"
#include "CORDUROY_ANALYSIS_xcell"
#include "CORDUROY_ANALYSIS_behavior"
#include "CORDUROY_ANALYSIS_database"

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//	CORDUROY_ANALYSIS_utility
// 		Utility protocols that aid in analysis of electrophysiological data
//
//		Written by Joshua Dudman
//		Development begun January 2005
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function DisplayUtilitiesControlPanel()
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	CORD_CreatePaths()
	CORD_InitializeUtilityVars()	
	CORD_ListDataFolders_Util()
	
	variable/G root:Analysis:UtilityPanel:dispX = str2num(StringFromList(3, StringByKey("SCREEN1", IgorInfo(0)),","))
	variable/G root:Analysis:UtilityPanel:dispY = str2num(StringFromList(4, StringByKey("SCREEN1", IgorInfo(0)),","))
	
	DoWindow/F CORD_UtilitiesControlPanel
	if (V_Flag!=0)
		DoWindow/K CORD_UtilitiesControlPanel
	endif
	String thisDF = GetDataFolder(1)
	Execute "CORD_UtilitiesControlPanel()"
	Execute "ModifyPanel cbRGB = (20000,20000,20000)"
	DoWindow/K Table0
	
	CORD_DisplayAnalysisPanel(1)

	print " "
	print " "
	print "----------------------------------------------------"
	print "Welcome to Corduroy!"
	print date()
	print "----------------------------------------------------"
	Print "Igor Version: "+StringByKey("IGORVERS", IgorInfo(0))
	Print "OS: "+StringByKey("OS", IgorInfo(3))+"  "+StringByKey("OSVERSION", IgorInfo(3))
	Print "Display: "+StringFromList(3, StringByKey("SCREEN1", IgorInfo(0)),",")+" x "+ StringFromList(4, StringByKey("SCREEN1", IgorInfo(0)),",")
	if(RunningWindows())
		print "Data acquisition is supported."
	else
		print "Data acquisition is not currently supported."
	endif	
	print "----------------------------------------------------"
	print "*Igor Version 6.10 or higher necessary for long filenames on MacOS"
	print "    Lower versions can affect performance of some loading functions."
	print " "

End


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_ListDataFolders_Util()
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	string oldDF=GetDataFolder(1)
	variable AllFolders = CountObjects("root:",4)
	string tmp1 = ""
	SetDataFolder root:Analysis:UtilityPanel
	string/G FileList = ""
	variable index=0
	do
		if (index > AllFolders)
			break
		endif
		tmp1= GetIndexedObjName("root:",4,index)
		if(index==0)
			FileList = tmp1
		else
			FileList = FileList+";"+tmp1
		endif
		index+=1
	while(1)
	string popStr = GetIndexedObjName("root:",4,2)
	if(strlen(popStr)==0)
		SetDataFolder root:
	else
		SetDataFolder root:$popStr
	endif
	DoUpdate
end

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_SliderActive(name, value, event)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	String name	// name of this slider control
	Variable value	// value of slider
	Variable event	// bit field: bit 0: value set; 1: mouse down, 2: mouse up, 3: mouse moved
	if(event==4)
		NVAR CurrTrace = root:Analysis:UtilityPanel:CurrTrace
		NVAR NumTrace = root:Analysis:UtilityPanel:NumTrace
		if(CurrTrace > (NumTrace-1))
			print "Selected trace exceeds trace range"
			return 0
		endif
		NVAR autoS = root:Analysis:UtilityPanel:autoS
		string ChanA = WaveList("RecordA*",";","")
		string ChanB = WaveList("RecordB*",";","")
		if(autoS==1)
			string TopWin = WinName(0,1)
			strswitch(TopWin)
				case "ChannelA":
					CORD_PlotOneTrace(ChanA,"A")
					break
				case "ChannelA_SingleTrace":
					CORD_PlotOneTrace(ChanA,"A")
					break
				case "ChannelB":
					CORD_PlotOneTrace(ChanB,"B")
					break
			endswitch
			return 0
		else
			return 0
		endif
	else
		return 0
	endif
end //SlideActive


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_DefineSet(cntrlName) : ButtonControl
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		String cntrlName
// Define necessary strings and variables for function
		String oldDF = GetDataFolder(1)
		variable index=0
		
		NVAR SetDef = root:Analysis:UtilityPanel:SetDef
		switch(SetDef)	// numeric switch
			case 0:		// execute if case matches expression
				// Select members of new set from the Data Browser
				CORD_CreateList()
				SVAR SelectedWaves = root:Analysis:UtilityPanel:SelectedWaves
				break						// exit from switch
			case 1:		// execute if case matches expression
				// Prompt user for a relevant wild card and remind user that it only works in current DF
				string wildcard = "*"
				Prompt wildcard,"Type a match string:"
				DoPrompt "What is the template for the set definition?",wildcard
				if (V_Flag)
					Abort "Set was not defined; user cancelled"
				endif
				SVAR SelectedWaves = root:Analysis:UtilityPanel:SelectedWaves
				string LocalList = WaveList(wildcard, ";", "")
				string CurrWave = "", GlobalName=""
				SelectedWaves = ""
				for(index=0;index<ItemsInList(LocalList);index+=1)
					CurrWave = StringFromList(index, LocalList)
					GlobalName = oldDF+CurrWave
					SelectedWaves = AddListItem(GlobalName,SelectedWaves,";",Inf)
				endfor				
				break
		endswitch

// Get the current set list
		SVAR SetList = root:Analysis:UtilityPanel:Sets:SetList

// Move to the relevant data folder
		NewDataFolder/O/S root:Analysis:UtilityPanel:Sets
		SetDataFolder root:Analysis:UtilityPanel:Sets:

// Get the number of the next set
		variable nextSet = (ItemsInList(SetList) - 1)

// name the new set
		string newSet = "Set"+num2str(nextSet)
		String/G $newSet = SelectedWaves
		SetList = SetList+newSet+";"
		SetDataFolder oldDF

End // CordDefineSet


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function DisplayWaveListOneChannel(list,chanvar)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	String list		// A semicolon-separated list.
	Variable chanvar
	String theWave
	Variable index=0
	switch(chanvar)
	case 1:
		do
			// Get the next wave name
			theWave = StringFromList(index, list)
			if (strlen(theWave) == 0)
				break		// Ran out of waves
			endif
			if (index == 0)		// Is this the first wave?
				DoWindow/K ChannelA
				Display/K=1/W=(300,0,700,300) $theWave as "ChannelA"
				DoWindow/C ChannelA
				ShowInfo/W=ChannelA
				ModifyGraph/W=ChannelA grid(left)=2,zero(left)=1,zeroThick(left)=2
			else
				AppendToGraph/W=ChannelA $theWave
			endif
			index += 1
		while (1)		// Loop until break above
		break
	case 2:
		do
			// Get the next wave name
			theWave = StringFromList(index, list)
			if (strlen(theWave) == 0)
				break		// Ran out of waves
			endif
			if (index == 0)		// Is this the first wave?
				DoWindow/K ChannelB
				Display/K=1/W=(300,350,700,650) $theWave as "ChannelB"
				DoWindow/C ChannelB
				ShowInfo/W=ChannelB
				ModifyGraph/W=ChannelB grid(left)=2,zero(left)=1,zeroThick(left)=2
			else
				AppendToGraph/W=ChannelB $theWave
			endif
			index += 1
		while (1)		// Loop until break above
		break
	case 3:
		do
			// Get the next wave name
			theWave = StringFromList(index, list)
			if (strlen(theWave) == 0)
				break		// Ran out of waves
			endif
			if (index == 0)		// Is this the first wave?
				DoWindow/K Selected
				Display/K=1/W=(200,0,600,300) $theWave as "Selected"
				DoWindow/C Selected
				ShowInfo/W=Selected
				ModifyGraph/W=Selected grid(left)=2,zero(left)=1,zeroThick(left)=2
			else
				AppendToGraph/W=Selected $theWave
			endif
			index += 1
		while (1)		// Loop until break above
		break
	endswitch
	
	NVAR NumTrace = root:Analysis:UtilityPanel:NumTrace
	NumTrace = ItemsInList(list)
	
	DoUpdate
End


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function DisplayWaveListTwoChannel(list)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	String list		// A semicolon-separated list.
	String theWave
	Variable index=0
	do
		// Get the next wave name
		theWave = StringFromList(index, list)
		if (strlen(theWave) == 0)
			break		// Ran out of waves
		endif
		if (index == 0)		// Is this the first wave?
			Display/K=1/W=(300,0,700,200) $theWave as "ChannelA"
			DoWindow /C ChannelA
			ShowInfo/W=ChannelA
		else
			AppendToGraph/W=ChannelA $theWave
		endif
		index += 2
	while (1)		// Loop until break above
	index=1
	do
		// Get the next wave name
		theWave = StringFromList(index, list)
		if (strlen(theWave) == 0)
			break		// Ran out of waves
		endif
		if (index == 1)		// Is this the first wave?
			Display/K=1/W=(300,300,700,500) $theWave as "ChannelB"
			DoWindow /C ChannelB
			ShowInfo/W=ChannelB
		else
			AppendToGraph/W=ChannelB $theWave
		endif
		index += 2
	while (1)		// Loop until break above
	ModifyGraph/W=ChannelA grid=1
	ModifyGraph/W=ChannelB grid=1
End

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function CORD_PlotMatchWaves(matchstringY,matchstringX)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	string matchstringY, matchstringX
	
	string Ywaves = WaveList(matchstringY, ";", "")
	string Xwaves = WaveList(matchstringX, ";", "")
	string CurrentWaveY = "", CurrentWaveX = ""
	
	variable index
	
	for(index=0;index<ItemsInList(Ywaves);index+=1)
		CurrentWaveY = StringFromList(index, Ywaves)
		CurrentWaveX = StringFromList(index, Xwaves)
		if(strlen(CurrentWaveX)==0)
			if(index==0)
				Display $CurrentWaveY
			else
				AppendToGraph $CurrentWaveY
			endif
		else
			if(index==0)
				Display $CurrentWaveY vs $CurrentWaveX
			else
				AppendToGraph $CurrentWaveY vs $CurrentWaveX
			endif		
		endif
	endfor

End


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_CreateList()
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// DESCRIPTION: General function used to create the list of waves to be analyzed by subsequent functions
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		String cdfBefore = GetDataFolder(1)			// Save current data folder before.
		Execute "CreateBrowser prompt=\"Select list of waves or data folders and Click OK\", showVars=0, showStrs=0" //expandAll
		string cdfAfter = GetDataFolder(1)			// Save current data folder after.
		SetDataFolder cdfBefore						// Restore current data folder.
		SVAR S_BrowserList=S_BrowserList
		String/G root:Analysis:UtilityPanel:SelectedWaves = S_BrowserList
		NVAR V_Flag=V_Flag
		if(V_Flag==0)
			Print "Select cancelled"
		endif
		
end


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_PlotSet(cntrlName) : ButtonControl
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	string cntrlName

	string SetDir = "root:Analysis:UtilityPanel:Sets:"
	SVAR activeSet = $(SetDir+"activeSet")
	SVAR setString = $(SetDir+activeSet)
	string WavesToPlot = setString

	if(stringmatch(activeSet, "none"))
		Abort "No active set is selected..."
		CORD_CreateList() 													// Generate list of waves to analyze using CreateString function
		SVAR SelectedWaves = root:Analysis:UtilityPanel:SelectedWaves	// pass global string into current function
		WavesToPlot = SelectedWaves
	endif

	if(strlen(WavesToPlot)==0)
		Abort "Error in the set definition, please redefine the set..."
	endif
	
	DisplayWaveListOneChannel(WavesToPlot,3)

end // PlotSet


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_PlotActive(cntrlName) : ButtonControl
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	string cntrlName
// Get the list of waves in the current folder divided by channel
	string ChanA = WaveList("RecordA*",";","")
	string ChanB = WaveList("RecordB*",";","")
	NVAR plottypedef = root:Analysis:UtilityPanel:plottypedef
		
	if(strlen(ChanA)==0)
		Abort "Corduroy is confused about your current directory. Use the popup to re-select a directory before plotting."
	endif
	
	strswitch(cntrlName)
	
		case "GraphButton1":
	
			DoWindow/K ChannelA
			DoWindow/K ChannelB
			
			if(stringmatch(GetDataFolder(0),"Analyzed"))
				SVAR activePlot = root:Analysis:UtilityPanel:activePlot
				string fullName = "root:"+activePlot
				print fullName
				SetDataFolder fullName
				ChanA = WaveList("RecordA*",";","")
				ChanB = WaveList("RecordB*",";","")
			endif
	
	// Test whether the user wants to plot waves processed by the utility function
			if(DataFolderExists("Analyzed"))
				if(plottypedef==0)
					string RestoreDF = GetDataFolder(1)
					print "Utility Analysis folder exists"
					SetDataFolder Analyzed
					string tmp1 = WaveList("Record*", ";", ""), tmp5 = "Plot Original"
					variable tmp2 = ItemsInList(tmp1), index=0
					for(index=0;index<tmp2;index+=1)
						string tmp3 = StringFromList(index, tmp1)
						string tmp4 = StringFromList(1,tmp3,"_")
						if(!stringmatch("*"+tmp4+"*", tmp5))
							tmp5=tmp5+";"+tmp4
						endif
					endfor
			// Now use a pop-up to let the user select a type of wave to plot
					variable PlotType=0,MakeDef=0
					prompt PlotType, "Data type:", popup tmp5
					prompt MakeDef, "Make Default?", popup "Yes;No"
					DoPrompt "Select the wave type to plot", PlotType,MakeDef
						if( V_Flag )
							abort
						endif
					if(PlotType==1)
						SetDataFolder RestoreDF
					else
						string template = StringFromList(PlotType-1,tmp5)
						if(MakeDef==1)
							plottypedef = 1
							string/G root:Analysis:UtilityPanel:plottypetemp = template
						endif
						ChanA = WaveList("RecordA*"+template,";","")
						ChanB = WaveList("RecordB*"+template,";","")
					endif
				else
					SVAR templateG = root:Analysis:UtilityPanel:plottypetemp
					SetDataFolder Analyzed
					ChanA = WaveList("RecordA*"+templateG,";","")
					ChanB = WaveList("RecordB*"+templateG,";","")
				endif
			endif
					
	// Send selected list and channel to plot function
			DisplayWaveListOneChannel(ChanA,1)
			if(ItemsInList(ChanB)!=0)
				DisplayWaveListOneChannel(ChanB,2)
			endif
			break
	
		case "GraphButton4":
			string TopWin = WinName(0,1)
			strswitch(TopWin)
				case "ChannelA":
					CORD_PlotOneTrace(ChanA,"A")
					break
				case "ChannelA_SingleTrace":
					CORD_PlotOneTrace(ChanA,"A")
					break
				case "ChannelB":
					CORD_PlotOneTrace(ChanB,"B")
					break
			endswitch
			break
	endswitch
	
	NVAR NumTrace = root:Analysis:UtilityPanel:NumTrace
	NumTrace = ItemsInList(ChanA)
	DoUpdate
	
// Test for the presence of the Prairie images from an imaging experiment
	string ImgList = WaveList("RefImage*",";","")
	if(strlen(ImgList)>1)
		DoWindow/K RefImageWin
		Display/K=1/W=(300,600,700,900)
		DoWindow/C RefImageWin
		AppendImage/W=RefImageWin $(StringFromList(1, ImgList))
		SetAxis/A/R left
		AppendToGraph/W=RefImageWin PntsY vs PntsX
		ModifyGraph/W=RefImageWin mode=3,marker=8,msize=3,mrkThick=1.5
	endif
	
end // CORD_PlotActive


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_UndefaultPlot_Util()
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	NVAR plottypedef = root:Analysis:UtilityPanel:plottypedef
	plottypedef = 0

End
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_TakeGraphScaling(OldWin,NewWin)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	string OldWin, NewWin
	GetAxis/W=$OldWin/Q left
	SetAxis/W=$NewWin left V_min,V_max
	GetAxis/W=$OldWin/Q bottom
	SetAxis/W=$NewWin bottom V_min,V_max
	ModifyGraph/W=$NewWin grid(left)=2,zero(left)=1,zeroThick(left)=2
End
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_PlotOneTrace(PassedWaves,Chan)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	string PassedWaves, Chan
	string theWave
	DoWindow ChannelA_SingleTrace
	variable chanAExists = V_Flag
	DoWindow ChannelB_SingleTrace
	variable chanBExists = V_Flag
	NVAR CurrTrace = root:Analysis:UtilityPanel:CurrTrace
	NVAR NumTrace = root:Analysis:UtilityPanel:NumTrace
	if(CurrTrace > (NumTrace-1) )
		print "Selected trace exceeds trace range"
		return 0
	endif
	theWave = StringFromList(CurrTrace, PassedWaves)
	strswitch(Chan)
	case "A":
		if(chanAExists==1)
			print "Single trace viewer for channelA exists"
			string removeTrace = TraceNameList("ChannelA_SingleTrace",";",0)
			string ref = StringFromList(0,removeTrace,";")
			RemoveFromGraph/W=ChannelA_SingleTrace/Z $ref
			AppendToGraph/W=ChannelA_SingleTrace $theWave
			CORD_TakeGraphScaling("ChannelA","ChannelA_SingleTrace")
			break
		else
			Display/K=1/W=(0,0,400,300) $theWave as "ChannelA_SingleTrace"
			DoWindow/C ChannelA_SingleTrace
			ShowInfo/W=ChannelA_SingleTrace
			CORD_TakeGraphScaling("ChannelA","ChannelA_SingleTrace")
			break
		endif
		break
	case "B":
		Display/K=1/W=(400,350,800,650) $theWave as "ChannelB_SingleTrace"
		DoWindow/C ChannelB_SingleTrace
		ShowInfo/W=ChannelB_SingleTrace
		ModifyGraph/W=ChannelB_SingleTrace grid(left)=2,zero(left)=1,zeroThick(left)=2
		break
	endswitch
	Print "Plotted Record"+Chan+num2str(CurrTrace)+" in Channel"+Chan+"_SingleTrace"
end // CORD_PlotOneTrace


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_ZoomGlobal(cntrlName,popNum,popStr) : PopupMenuControl
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	String cntrlName
	Variable popNum	// which item is currently selected (1-based)
	String popStr		// contents of current popup item as string
	String thisDF = GetDataFolder(1)
	SetDataFolder root:Analysis:UtilityPanel
	variable/G zoomlevel = popNum
	SetDataFolder thisDF
	string printzoom = ""
	switch(zoomlevel)
			case 1:
				printzoom = "austoscale"
				break
			case 2:
				printzoom = "medium"
				break
			case 3:
				printzoom = "wide"
				break
			case 4:
				printzoom = "narrow"
	endswitch
//	print "New zoom level is "+printzoom
end


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_ChooseSet(cntrlName,popNum,popStr) : PopupMenuControl
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	String cntrlName
	Variable popNum	// which item is currently selected (1-based)
	String popStr		// contents of current popup item as string
	String oldDF = GetDataFolder(1)
	SetDataFolder root:Analysis:UtilityPanel:Sets:
	string/G activeSet = popStr
	print "Active set for analysis is: "+popStr
	SetDataFolder oldDF
End


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_PlotDF(cntrlName,popNum,popStr) : PopupMenuControl
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	String cntrlName
	Variable popNum	// which item is currently selected (1-based)
	String popStr		// contents of current popup item as string
	String thisDF = GetDataFolder(1)
	SetDataFolder root:Analysis:UtilityPanel
	string/G activePlot = popStr
	
// Get the folder number from the popStr and update the ELN display
	if(stringmatch(popStr,"*_*"))
		variable folder_num = str2num(StringFromList(1, popStr,"_"))
	endif

// Move to the new, active data folder
	SetDataFolder root:$popStr
	CORD_UpdateELNdata(2)
		
// update the slider max value
	variable numWaves = ItemsInList(WaveList("RecordA*", ";", ""))
	Slider GraphSlider1 limits={0,(numWaves-1),1}
	SetVariable GraphSetVar1,limits={0,(numWaves-1),1}
	variable/G root:Analysis:UtilityPanel:NumTrace = numWaves
	
End


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_DisplayZoom(cntrlName) : ButtonControl
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// A function to automatically set display axises to surround the region of interest
// 	three types of zoom level wide, medium and narrow which are 10, 5 & 3 respectively
// Also used by the analysis GUI which defaults to the medium zoom setting
		string cntrlName
		NVAR zoomlevel = root:Analysis:UtilityPanel:zoomlevel
		CORD_DisplayZoomEX(xcsr(A),xcsr(B),zoomlevel)

end


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_DisplayZoomEX(left_x,right_x,zoomlevel)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// A function to automatically set display axes to surround the region of interest
// 	three types of zoom level wide, medium and narrow which are 10, 5 & 3 respectively
// Also used by the analysis GUI which defaults to the medium zoom setting
		variable zoomlevel
		variable left_x
		variable right_x
		
		string exampleTrace = TraceNameList("", ";", 1)
		WAVE exampleTraceRef = TraceNameToWaveRef("", StringFromList(0,exampleTrace))
		WaveStats/M=1/R=(left_x, right_x)/Z exampleTraceRef

		variable zoom = 0

		switch(zoomlevel)
			case 1:
				zoom = 0
				SetAxis/A left;DelayUpdate
				SetAxis/A bottom
				break
			case 2:			
				zoom = 0.020
				break
			case 3:
				zoom = 0.200
				break
			case 4:
				zoom = 0.003
				break
		endswitch
		
		if(zoom==0)
		
			// Top graph autoscaled
			
		else

			// Reset the x-axis according to the positions of the cursors
			if( xcsr(B)!=0 )

				if((xcsr(A)-zoom) < 0)
					SetAxis bottom 0,right_x+zoom
				else
					SetAxis bottom left_x-zoom,right_x+zoom
				endif

				SetAxis left V_min-(0.05*abs(V_min)),V_max+(0.05*abs(V_max))

			endif

		endif
		
		DoUpdate

end


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_AutoZoom(ctrlName,checked) : CheckBoxControl
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		String ctrlName
		Variable checked			// 1 if selelcted, 0 if not
		NVAR autoZ = root:Analysis:UtilityPanel:autoZ
		autoZ = checked
		switch(checked)
			case 1:
				print "Auto zoom is on"
				break
			case 0:
				print "Auto zoom is off"
				break
		endswitch
end


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_AutoSlide(ctrlName,checked) : CheckBoxControl
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		String ctrlName
		Variable checked
		NVAR autoS = root:Analysis:UtilityPanel:autoS
		autoS = checked
		switch(checked)
			case 1:
				print "Auto slide is on"
				break
			case 0:
				print "Auto slide is off"
				break
		endswitch
end

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_SetDefault(ctrlName,checked) : CheckBoxControl
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		String ctrlName
		Variable checked
		NVAR SetDef = root:Analysis:UtilityPanel:SetDef
		SetDef = checked
		switch(checked)
			case 1:
				print "Define set will assume that a name will be used to create a set"
				break
			case 0:
				print "Define set will allow a user to graphically select the waves for a set"
				break
		endswitch
end

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_UtilButtons(cntrlName) : ButtonControl
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	string cntrlName
	
// If the first button is used, load the file before renaming the waves	
	strswitch(cntrlName)	// string switch
		case "UtilButton1":		// execute if case matches expression
			CORD_DispPersAnalysisPanel()
			break						// exit from switch
	endswitch

End

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_Rename()
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Get the list of waves
	string ListOfWaves = WaveList("*",";","")
	string CurrentWave="", CurrentTarget=""
	variable index
	
// Move through the waves and rename using the corduroy conventions
	for(index=0;index<ItemsInList(ListOfWaves);index+=1)

		CurrentWave = StringFromList(index,ListOfWaves, ";")
		CurrentTarget = "RecordA"+num2str(index)
		MoveWave $CurrentWave, $CurrentTarget

	endfor

// Clean up and re-list everything in the panel
	CORD_ListDataFolders_Util()

End

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_ic2vc(scalefactor)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	variable scalefactor

// Get the list of waves
	string ListOfWaves = WaveList("Record*",";","")
	string CurrentWave="", CurrentTarget=""
	variable index
	
// Move through the waves and rescale
	for(index=0;index<ItemsInList(ListOfWaves);index+=1)
		CurrentWave = StringFromList(index,ListOfWaves, ";")
		WAVE local = $CurrentWave
		local *= scalefactor
	endfor

	string LetHistoryKnow = GetDataFolder(1)+" was rescaled witht he CORD_ic2vc() command using a scale factor of "+num2str(scalefactor)
	print LetHistoryKnow

End

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_ChangePath()
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Prompt to figure out what path to change
	variable WhichPath = 0
	prompt WhichPath, "Name of path to change:", popup "Analysis Directory;DAQ Directory;Protocol Directory;Data Directory"
	DoPrompt "What symbolic path would you like to update?", WhichPath
		if( V_Flag )
			return 0 								
		endif
// Use prompt value to redefine path
	print WhichPath
	switch(WhichPath)
	case 1:
			string message3 = "Please select the directory to load data for Corduroy Analysis..."
			NewPath/O/M=message3 DataPath
			break
	case 2:
			string message2 = "Please select the directory to store data for Corduroy DAQ..."
			NewPath/O/M=message2 DAQDir
			break
	case 3:
			string message1 = "Please select the directory containing protocols for Corduroy DAQ..."
			NewPath/O/M=message1 ProtocolDir
			break
	case 4:
			string message4 = "Please select the directory containing protocols for Data Directory..."
			NewPath/O/M=message4 DataPath
			break			
	endswitch
End //CORD_ChangePath


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_LoadAxon() // MUST activate the include command before using
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	String cntrlName
	Execute "LoadAxonBinaryFile()"
End // CORD_LoadAxon


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_SelectUtil(cntrlName,popNum,popStr) : PopupMenuControl
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	String cntrlName
	Variable popNum	// which item is currently selected (1-based)
	String popStr		// contents of current popup item as string

	SVAR activeUtil = root:Analysis:UtilityPanel:activeUtil
	activeUtil = popStr

End


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_SelectCustom(cntrlName,popNum,popStr) : PopupMenuControl
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	String cntrlName
	Variable popNum	// which item is currently selected (1-based)
	String popStr		// contents of current popup item as string

	SVAR SelectedPanelType = root:Analysis:UtilityPanel:SelectedPanelType
	SelectedPanelType = popStr

End


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_RunUtil(cntrlName) : ButtonControl
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// This function controls the utility preferences, getting the list of waves to analyze as well as the control over where to save output
	string cntrlName
	SVAR activeUtil = root:Analysis:UtilityPanel:activeUtil
	if(stringmatch(activeUtil,"*one"))
		abort "Please select a type of utility function from the pulldown."
	endif
	
	SVAR util_lib_list = root:Analysis:UtilityPanel:util_lib_list
	string/G ListOfWaves=""
	string/G PossibleGraphs = WinList("*", ";", "WIN:1" )
	if(strlen(PossibleGraphs)==0)
		string/G PossibleGraphs = ""
		print "No graphs to use."
	else
		print PossibleGraphs
	endif
	
	SVAR activeSet = root:Analysis:UtilityPanel:Sets:activeSet
	if(!SVAR_Exists(activeSet))
		string/G root:Analysis:UtilityPanel:Sets:activeSet = "none"
	endif

	if(!stringmatch(activeSet,"none"))
		string setRef = "root:Analysis:UtilityPanel:Sets:"+activeSet
		SVAR setContents = $setRef
	endif

//// Create list of waves from appropriate source
//	NVAR SetDef = root:Analysis:UtilityPanel:SetDef
	variable Source=0
//	switch(SetDef)
//		case 0:
//		// Is there a relevant top graph?
			if(stringmatch(StringFromList(0,PossibleGraphs),"Channel*") || stringmatch(StringFromList(0,PossibleGraphs),"Set*")) 
				ListOfWaves = TraceNameList("", ";", 1)
				print "Using the top graph for analysis utility."
				Source = 0
			elseif(!stringmatch(activeSet,"none")) // Is there an active set?	
				ListOfWaves = setContents
				print "Using the active set for analysis utility."
				Source = 1
			else // Finally, let the user select waves to analyze
				print "Using a list of user selected waves to analyze with the utility function"
				CORD_CreateList()
				SVAR SelectedWaves = root:Analysis:UtilityPanel:SelectedWaves
				ListOfWaves = SelectedWaves
				Source = 2
			endif
//			break
//		case 1:
//			ListOfWaves = setContents
//			print "Using the active set (by default) for analysis utility."
//			Source = 1
//			break
//	endswitch

	if(Source>1 && stringmatch(activeUtil,"BASESUB"))
		Abort "You cannot use the baseline subtract function without a top graph with cursors placed on the region to mean and subtract."
	endif

// Call the library function while passing the list of wavenames and a flag for the types of references
	string ExStr=""
	
	if(stringmatch(cntrlName,"UtilButton4"))
		string FileTypeList="NEURON;MATLAB;ASCII"
		variable FileType=1
		prompt FileType, "Select output type", popup FileTypeList
		DoPrompt "Dimension wave with correct scaling", FileType
			if( V_Flag )
				Abort 
			endif
		ExStr = "CORD_"+StringFromList(FileType-1,FileTypeList)+"_Print_execute(ListOfWaves,"+num2str(Source)+")"
		print ExStr
		Execute ExStr
	else
		ExStr = "CORD_"+activeUtil+"_execute(ListOfWaves,"+num2str(Source)+")"
		print ExStr
		Execute ExStr	
	endif
	
	NVAR abortflag = abortflag
	if(abortflag)
		Abort
	endif

	print "Source= "+num2str(Source)
	
// Take the standard outputs from the analysis utilities and give them useful names (i.e. to preserve original data)
	string ListOfOutputWaves="",originalName="",newName="", DFName=""
	variable OutIndex=0
	
	SVAR suffix=suffix
	string WildCard = "*"+suffix

	if(!stringmatch(activeUtil,"RESCALE"))
		switch(Source)
			case 0: // Using the top graph
				print "Moving output to new sub-folder with prefix: "+activeUtil+"_"
				ListOfOutputWaves = WaveList(WildCard, ";", ""), originalName="", newName=""
				print ListOfOutputWaves
				DFName = ":Analyzed"
				NewDataFolder/O $DFName

				for(OutIndex=0;OutIndex<ItemsInList(ListOfOutputWaves);OutIndex+=1)
					originalName = StringFromList(OutIndex,ListOfOutputWaves)
					newName = DFName+":"+originalName
					KillWaves/Z $newName
					MoveWave $originalName, $newName
				endfor
				break
				
			case 1: // Using the active set
				print "Moving output to new data folder "+activeSet+" with prefix: "+activeUtil+"_"
				ListOfOutputWaves = WaveList(WildCard, ";", ""), originalName="", newName=""
				DFName = "root:"+activeSet
				NewDataFolder/O $DFName
				
				for(OutIndex=0;OutIndex<ItemsInList(ListOfOutputWaves);OutIndex+=1)
					originalName = StringFromList(OutIndex,ListOfOutputWaves)
					newName = DFName+":"+originalName
					KillWaves/Z $newName
					MoveWave $originalName, $newName
				endfor
				break
				
			case 2: // Using an online, user-selected group of waves
				print "Moving output to new data folder UserSelected with prefix: "+activeUtil+"_"
				ListOfOutputWaves = WaveList(WildCard, ";", ""), originalName="", newName=""
				
				if(DataFolderExists("root:UserSelected"))
					string currDF = GetDataFolder(1)
					SetDataFolder root:UserSelected
					string WhatsThere = WaveList("activeUtil*",";","")
					if(strlen(WhatsThere)>1)
						variable countItems = ItemsInList(WhatsThere)
						string LastItem = StringFromList(countItems-1, WhatsThere)
						string ItsIndex = StringFromList(1, LastItem,"_")
						variable UpdatedIndex = str2num(ItsIndex)+1
					endif
					SetDataFolder currDF
				else
					NewDataFolder/O $DFName
				endif
				
				for(OutIndex=0;OutIndex<ItemsInList(ListOfOutputWaves);OutIndex+=1)
					originalName = StringFromList(OutIndex,ListOfOutputWaves)
					newName = DFName+":"+originalName
					KillWaves/Z $newName
					MoveWave $originalName, $newName
				endfor
				break
				
		endswitch
	
	endif
	
//	CORD_ListDataFolders_Util() // Updates the listing of data folders in the main utility panel

End


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Window CORD_UtilitiesControlPanel() : Panel
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	PauseUpdate; Silent 1 // building the window...
	
	variable dispX = str2num(StringFromList(3, StringByKey("SCREEN1", IgorInfo(0)),","))
	variable dispY = str2num(StringFromList(4, StringByKey("SCREEN1", IgorInfo(0)),","))
	
	NewPanel/W=(dispX-350,0,dispX,270)/K=1 as "Corduroy Analysis - File Utilities"
	variable traces = NumVarOrDefault("root:Analysis:UtilityPanel:NumTrace", 10)
	SetDrawLayer ProgBack
	Print "Utility Procedures Panel launched at  "+time()+" on "+date()

GroupBox WaveGroup,pos={10,2},size={338,95},font="Verdana",fColor=(60000,20000,40000),fstyle=0,fsize=11,title="WAVE Utilities",labelBack=(60000,20000,40000)
	Button UtilButton1,pos={20,20},size={100,20}, proc=CORD_UtilButtons, title="Launch GUI", font="Verdana", fsize=10
	PopupMenu UtilPopup0,bodyWidth=120,font="Verdana", proc=CORD_SelectCustom,pos={288,23},title="Panel Type:",value="none;IMAGING;XCELL", fsize=10
	Button UtilButton2,pos={20,45},size={100,20}, proc=CORD_RunUtil, title="Run Wave Utility", font="Verdana", fsize=10
	PopupMenu UtilPopup1,bodyWidth=120,font="Verdana", proc=CORD_SelectUtil,pos={288,47},title="Utility Type:",value=root:Analysis:UtilityPanel:util_lib_list, fsize=10
// Add functionality to define sets: useful for batching analysis
	Button SetButton,pos={20,70},size={100,20}, proc=CORD_DefineSet, title="Define Set", font="Verdana", fsize=10
	PopupMenu Setpopup1,bodyWidth=85,font="Verdana",proc=CORD_ChooseSet,pos={225,71},title="Active Set:",value=root:Analysis:UtilityPanel:Sets:SetList, fsize=10
	CheckBox SetBox1,disable=0,mode=0, proc=CORD_SetDefault,pos={278,74},title="by name",value=0, font="Verdana", fsize=10	

GroupBox GraphGroup,pos={10,102},size={338,107},font="Verdana",fColor=(20000,60000,40000),fstyle=0,fsize=11,title="GRAPHING Utilities",labelBack=(20000,60000,40000)
	Button GraphButton1,pos={20,122},size={70,20}, proc=CORD_PlotActive, title="Plot", font="Verdana", fsize=10
	PopupMenu Graphpopup1,bodyWidth=100,font="Verdana", proc=CORD_PlotDF,pos={200,124},title="Data File:",value=root:Analysis:UtilityPanel:FileList, fsize=10
	Button GraphButton3,pos={260,122},size={70,20}, proc=CORD_PlotSet, title="Plot_Set", font="Verdana", fsize=10
	Button GraphButton2,pos={20,182},size={70,20}, proc=CORD_DisplayZoom, title="Zoom", font="Verdana", fsize=10
	CheckBox GraphBox1,disable=0,mode=0, proc=CORD_AutoZoom,pos={265,185},title="AutoZoom",value=0	, font="Verdana", fsize=10
	PopupMenu Graphpopup2,bodyWidth=100,font="Verdana", proc=CORD_ZoomGlobal,pos={200,182},title="Setting:",value="autoscale;medium;wide;narrow;", font="Verdana", fsize=10
	Button GraphButton4,pos={20,152},size={70,20}, proc=CORD_PlotActive, title="Plot_One", font="Verdana", fsize=10
	Slider GraphSlider1,pos={102,153},size={110,20},vert=0,limits={0,traces,1},ticks=0,side=2, font="Verdana", fsize=10
	Slider GraphSlider1,variable=root:Analysis:UtilityPanel:CurrTrace, proc=CORD_SliderActive, fsize=10
	CheckBox GraphBox2,disable=0,mode=0, proc=CORD_AutoSlide,pos={295,153},title="Auto",value=0, font="Verdana", fsize=10
	SetVariable GraphSetVar1,pos={225,153},size={70,20},title="Trace",font="Verdana",frame=0, fsize=10
	SetVariable GraphSetVar1,limits={0,30,1},variable=root:Analysis:UtilityPanel:CurrTrace, fsize=10

GroupBox PersonalGroup,pos={10,215},size={338,45},font="Verdana",fColor=(20000,40000,60000),fstyle=0,fsize=11,title="CUSTOM Utilities",labelBack=(20000,40000,60000)
	Button PersButton1,pos={20,233},size={100,20}, proc=CORD_RunPersonal, title="Run Custom", font="Verdana", fsize=10
	PopupMenu PersPopup1,bodyWidth=120,font="Verdana", proc=CORD_SelectPers,pos={292,233},title="Function Name:",value=root:Analysis:UtilityPanel:custom_lib_list, fsize=10

	ResumeUpdate

EndMacro


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_TmpProc()
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	Abort "Not yet implemented"
End


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_InitializeUtilityVars()
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	NewDataFolder/O root:Analysis
	NewDataFolder/O root:Analysis:UtilityPanel
	NewDataFolder/O root:Analysis:UtilityPanel:Sets
	variable/G root:Analysis:UtilityPanel:autoZ = 0
	variable/G root:Analysis:UtilityPanel:autoS = 0
	variable/G root:Analysis:UtilityPanel:SetDef = 0
	variable/G root:Analysis:UtilityPanel:CurrTrace
	variable/G root:Analysis:UtilityPanel:NumTrace =  10
	variable/G root:Analysis:UtilityPanel:zoomlevel =  1
	variable/G root:Analysis:UtilityPanel:plottypedef = 0	
	string/G root:Analysis:UtilityPanel:activeUtil = "none"
	string/G root:Analysis:UtilityPanel:util_lib_list = "none;AVERAGE;STDEV;CLEAN;CONCATENATE;RESCALE;BASESUB;FILTER;SMOOTH;DIFFERENTIATE;INTEGRATE"
	string/G root:Analysis:UtilityPanel:Sets:activeSet = "none"
	string/G root:Analysis:UtilityPanel:SelectedWaves = ""
	string sval=StrVarOrDefault("root:Analysis:UtilityPanel:Sets:SetList","none;")	
	string/G root:Analysis:UtilityPanel:Sets:SetList = sval
	string/G root:Analysis:UtilityPanel:SelectedPanelType = "NONE"

	CORD_CreatePersonalList()

End


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function RunningWindows()	// returns 0 if Macintosh, 1 if Windows
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	String platform= UpperStr(igorinfo(2))
	Variable pos= strsearch(platform,"WINDOWS",0)
	return pos >= 0

End


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function CORD_SpikeTriggeredWindows(TimeSourceName,WinSourceName,WindowLeft,WindowRight)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	string TimeSourceName
	string WinSourceName
	variable WindowLeft
	variable WindowRight

	wave TimeSource = $TimeSourceName
	wave WinSource = $WinSourceName

	string OutputBaseName = TimeSourceName+"_WIN"

	variable TotalSpikes = numpnts(TimeSource)
	print TotalSpikes
	variable index=0, CurrTrig=0,BeginL=0,EndR=0
	
	string WaveA="", WaveB="", tmpA="", tmpB=""
	
	for(index=0;index<TotalSpikes;index+=1)
		
		CurrTrig 	= TimeSource[index]
		BeginL		= CurrTrig - WindowLeft
		EndR		= CurrTrig + WindowRight
		
		tmpA		= OutputBaseName+num2str(index)

		Duplicate /O/R=(BeginL,EndR) WinSource, $tmpA
			SetScale /I x, (-1*WindowLeft), WindowRight, "s" $tmpA
		
	endfor


End


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_DispPersAnalysisPanel()
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	
	SVAR SelectedPanelType = root:Analysis:UtilityPanel:SelectedPanelType
	if(stringmatch(SelectedPanelType, "none"))
		Abort "Please select a type of analysis panel to launch from the dropdown"
	endif
	string NameOfSelectedPanel = "CORD_"+SelectedPanelType+"_Panel"
	string ExecutePanel = "CORD_"+SelectedPanelType+"_Panel()"
	
	DoWindow/F $NameOfSelectedPanel
	if (V_Flag!=0)
		DoWindow/K $NameOfSelectedPanel
	endif
	String thisDF = GetDataFolder(1)
	Execute ExecutePanel
	Execute "ModifyPanel cbRGB = (20000,20000,20000)"

End


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function CORD_GeneralTriggeredWindows(DataWaveName,TimesArray,WindowLeft,WindowRight)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	variable WindowLeft
	variable WindowRight
	string DataWaveName
	WAVE TimesArray

	WAVE DataWave = $DataWaveName
	WAVE TriggersW = TimesArray

	variable TotalSpikes = numpnts(TriggersW)
	variable index=0, CurrTrig=0,BeginL=0,EndR=0
	
	string WaveA="", WaveB="", tmpA="", tmpB=""
	
	for(index=0;index<TotalSpikes;index+=1)
		
		CurrTrig 	= TriggersW[index]
		BeginL		= CurrTrig - WindowLeft
		EndR		= CurrTrig + WindowRight
		
		tmpA		="WIN"+num2str(index)+"_"+DataWaveName

		Duplicate /O/R=(BeginL,EndR) DataWave, $tmpA
			SetScale /I x, (-1*WindowLeft), WindowRight, "s" $tmpA
		
	endfor


End

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_RotateAngles(angleWave,rotationAngle)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	wave angleWave
	variable rotationAngle

	Duplicate/O angleWave, rotatedAngles
	rotatedAngles = mod(angleWave+rotationAngle,2*pi)
	
end


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_BinAndMean(xWave,yWave,numBins)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// for a given x and y wave pair this function divides x into evenly spaced bins and calculates the mean and sem of y within each bin
	WAVE xWave
	WAVE yWave
	variable numBins
	
	WaveStats xWave
	variable xMax = V_max
	variable xMin = V_min
	
	variable binIncr = 0

	if(numBins<0)
		binIncr = xMax/-numBins
	else
		binIncr = xMax/numBins
	endif
	
	WaveStats yWave
	variable yMax = V_max
	variable yMin = V_min
	
	Make/O/N=(ceil(xMax/binIncr)) binMeans=0
	Make/O/N=(ceil(xMax/binIncr)) binCenters=0
	Make/O/N=(ceil(xMax/binIncr)) binCounts=0
	Make/O/N=(ceil(xMax/binIncr)) binErrs=0
	
	variable index, indexIntoMean
	
	for(index=0;index<numpnts(xWave);index+=1)
		indexIntoMean = floor(xWave[index]/binIncr)
		binMeans[indexIntoMean]+=yWave[index]
		binCounts[indexIntoMean]+=1
	endfor

	binMeans/=binCounts
	binCenters[] = (p*binIncr)+(binIncr/2)

	for(index=0;index<numpnts(xWave);index+=1)
		indexIntoMean = floor(xWave[index]/binIncr)
		binErrs[indexIntoMean]+=(yWave[index]-binMeans[indexIntoMean])^2
	endfor

	binErrs /= (binCounts-1)
	binErrs = sqrt(binErrs)
	binErrs /= sqrt(binCounts-1)

	for(index=0;index<numpnts(binCounts);index+=1)
		if(binCounts[index] < 3)
			binErrs[index] = NaN
		endif
	endfor	
	
end


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_ColorizeTraces(colorFlag,shiftFlag)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	variable colorFlag
	variable shiftFlag
	string AllWavesInTopGraph = TraceNameList("", ";",1)
	variable NumWaves = ItemsInList(AllWavesInTopGraph)
	variable index=0
	string CurrString=""
	
	variable colorIncremeter = 65535/NumWaves
	variable blueIncrementer = 43690/NumWaves
	GetAxis left
	variable shiftIncrementer = (V_max-V_min)/2
	Make/O/N=(NumWaves,3) colorsUsed 

	
	for(index=0;index<NumWaves;index+=1)
		
		CurrString = StringFromList(index, AllWavesInTopGraph)
		WAVE local = $CurrString

		if(colorFlag)
			ModifyGraph rgb($CurrString)=(65535-(colorIncremeter*(index+1)),(blueIncrementer*(index+1)),(colorIncremeter*(index+1)))
			colorsUsed[index][0] = 65535-(colorIncremeter*(index+1))
			colorsUsed[index][1] = blueIncrementer*(index+1)
			colorsUsed[index][2] = colorIncremeter*(index+1)
		endif

		if(shiftFlag)
			ModifyGraph offset($CurrString)={0,(shiftIncrementer*-NumWaves)-(shiftIncrementer*index)} 
		endif
	
	endfor

	if(!shiftFlag)
		Legend/C/N=text0/F=0/A=MC
	else
		ModifyGraph grid=0,tick(left)=3,zero=0,noLabel(left)=2;DelayUpdate
		ModifyGraph axRGB(left)=(65535,65535,65535),tlblRGB(left)=(65535,65535,65535);DelayUpdate
		ModifyGraph alblRGB(left)=(65535,65535,65535)		
	endif
	
End


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_ExtractCharacterizerData()
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

variable index=0,baseline=0,lengthOfWave=0,inPnts=0
string CurrWave =""

// FLUCTUATING STIM
// extract spike times [reliability], number of spikes, interspike intervals, 
// SLOW OSCILLATION 0, 3, 4
print "_____ANALYZING SLOW oscillating variable stimulus protocols..."
CORD_SpikeDetectorSimple("RecordA0",0.002)
CORD_SpikeDetectorSimple("RecordA3",0.002)
CORD_SpikeDetectorSimple("RecordA4",0.002)

WAVE local1 = SPLOC_RecordA0
WAVE local2 = SPLOC_RecordA3
WAVE local3 = SPLOC_RecordA4

variable SlowNumSpkRep1 = numpnts(local1)
variable SlowNumSpkRep2 = numpnts(local2)
variable SlowNumSpkRep3 = numpnts(local3)
variable/G SlowAvgSpikes = (SlowNumSpkRep1+SlowNumSpkRep2+SlowNumSpkRep3)/3

Make/O/N=1000 SlowSpikeDelta
SlowSpikeDelta[] = 0

for(index=0;index<numpnts(local1);index+=1)
	inPnts = (local1[index] - 1)*1000
	SlowSpikeDelta[inPnts] += 1
	inPnts = (local2[index] - 1)*1000
	SlowSpikeDelta[inPnts] += 1
	inPnts = (local3[index] - 1)*1000
	SlowSpikeDelta[inPnts] += 1
endfor

Make/N=4/O SlowSpikeDelta_Hist
Histogram/B={0,1,4} SlowSpikeDelta,SlowSpikeDelta_Hist

variable/g SlowFracReliable = (SlowSpikeDelta_Hist[2]*2+SlowSpikeDelta_Hist[3]*3)/(SlowNumSpkRep1+SlowNumSpkRep2+SlowNumSpkRep3)
print "Fraction of reliable spikes: "+num2str(SlowFracReliable)

WAVE local4 = SPLEV_RecordA0
WAVE local5 = SPLEV_RecordA3
WAVE local6 = SPLEV_RecordA4
Make/O/N=(SlowNumSpkRep1+SlowNumSpkRep2+SlowNumSpkRep3) SlowVoltThresh
SlowVoltThresh[0,SlowNumSpkRep1-1] = local4[p]
SlowVoltThresh[SlowNumSpkRep1,SlowNumSpkRep1+SlowNumSpkRep2-1] = local5[p-SlowNumSpkRep1]
SlowVoltThresh[SlowNumSpkRep2,SlowNumSpkRep1+SlowNumSpkRep2+SlowNumSpkRep3-1] = local6[p-SlowNumSpkRep2-SlowNumSpkRep1]
WaveStats/Q SlowVoltThresh
variable/G SlowThreshCV = V_sdev/abs(V_avg)
print "Threshold voltage CV: "+num2str(SlowThreshCV)
variable threshMeasure = V_avg
WaveStats/Q/R=(0,0.5) RecordA0
variable baselineS = V_avg
WaveStats/Q/R=(1.9,2.1) RecordA0
variable/G undershoot = abs(V_min-baselineS)
WaveStats/Q/R=(1.9,2.1) RecordA3
undershoot += abs(V_min-baselineS)
WaveStats/Q/R=(1.9,2.1) RecordA4
undershoot += abs(V_min-baselineS)
undershoot /= 3
print undershoot
print  abs(threshMeasure-baselineS)
variable/G FLUC_s_under = undershoot/abs(threshMeasure-baselineS)

//// MEDIUM OSCILLATION 1, 5, 8
print "_____ANALYZING MEDIUM oscillating variable stimulus protocols..."
CORD_SpikeDetectorSimple("RecordA1",0.002)
CORD_SpikeDetectorSimple("RecordA5",0.002)
CORD_SpikeDetectorSimple("RecordA8",0.002)

WAVE local1 = SPLOC_RecordA1
WAVE local2 = SPLOC_RecordA5
WAVE local3 = SPLOC_RecordA8

variable MedNumSpkRep1 = numpnts(local1)
variable MedNumSpkRep2 = numpnts(local2)
variable MedNumSpkRep3 = numpnts(local3)
variable/G MedAvgSpikes = (MedNumSpkRep1+MedNumSpkRep2+MedNumSpkRep3)/3

Make/O/N=1000 MedSpikeDelta
MedSpikeDelta[] = 0

for(index=0;index<numpnts(local1);index+=1)
	inPnts = (local1[index] - 1)*1000
	MedSpikeDelta[inPnts] += 1
	inPnts = (local2[index] - 1)*1000
	MedSpikeDelta[inPnts] += 1
	inPnts = (local3[index] - 1)*1000
	MedSpikeDelta[inPnts] += 1
endfor

Make/N=4/O MedSpikeDelta_Hist
Histogram/B={0,1,4} MedSpikeDelta,MedSpikeDelta_Hist

variable/g MedFracReliable = (MedSpikeDelta_Hist[2]*2+MedSpikeDelta_Hist[3]*3)/(MedNumSpkRep1+MedNumSpkRep2+MedNumSpkRep3)
print "Fraction of reliable spikes: "+num2str(MedFracReliable)

WAVE local4 = SPLEV_RecordA1
WAVE local5 = SPLEV_RecordA5
WAVE local6 = SPLEV_RecordA8
Make/O/N=(MedNumSpkRep1+MedNumSpkRep2+MedNumSpkRep3) MedVoltThresh
MedVoltThresh[0,MedNumSpkRep1-1] = local4[p]
MedVoltThresh[MedNumSpkRep1,MedNumSpkRep1+MedNumSpkRep2-1] = local5[p-MedNumSpkRep1]
MedVoltThresh[MedNumSpkRep2,MedNumSpkRep1+MedNumSpkRep2+MedNumSpkRep3-1] = local6[p-MedNumSpkRep2-MedNumSpkRep1]
WaveStats/Q MedVoltThresh
variable/G MedThreshCV = V_sdev/abs(V_avg)
print "Threshold voltage CV: "+num2str(MedThreshCV)

//
//// FAST OSCILLATION 2, 6, 7
print "_____ANALYZING FAST oscillating variable stimulus protocols..."
CORD_SpikeDetectorSimple("RecordA2",0.002)
CORD_SpikeDetectorSimple("RecordA6",0.002)
CORD_SpikeDetectorSimple("RecordA7",0.002)

WAVE local1 = SPLOC_RecordA2
WAVE local2 = SPLOC_RecordA6
WAVE local3 = SPLOC_RecordA7

variable FastNumSpkRep1 = numpnts(local1)
variable FastNumSpkRep2 = numpnts(local2)
variable FastNumSpkRep3 = numpnts(local3)
variable/G FastAvgSpikes = (FastNumSpkRep1+FastNumSpkRep2+FastNumSpkRep3)/3

Make/O/N=1000 FastSpikeDelta
FastSpikeDelta[] = 0

for(index=0;index<numpnts(local1);index+=1)
	inPnts = (local1[index] - 1)*1000
	FastSpikeDelta[inPnts] += 1
	inPnts = (local2[index] - 1)*1000
	FastSpikeDelta[inPnts] += 1
	inPnts = (local3[index] - 1)*1000
	FastSpikeDelta[inPnts] += 1
endfor

Make/N=4/O FastSpikeDelta_Hist
Histogram/B={0,1,4} FastSpikeDelta,FastSpikeDelta_Hist

variable/g FastFracReliable = (FastSpikeDelta_Hist[2]*2+FastSpikeDelta_Hist[3]*3)/(FastNumSpkRep1+FastNumSpkRep2+FastNumSpkRep3)
print "Fraction of reliable spikes: "+num2str(FastFracReliable)

WAVE local4 = SPLEV_RecordA2
WAVE local5 = SPLEV_RecordA6
WAVE local6 = SPLEV_RecordA7
Make/O/N=(FastNumSpkRep1+FastNumSpkRep2+FastNumSpkRep3) FastVoltThresh
FastVoltThresh[0,FastNumSpkRep1-1] = local4[p]
FastVoltThresh[FastNumSpkRep1,FastNumSpkRep1+MedNumSpkRep2-1] = local5[p-FastNumSpkRep1]
FastVoltThresh[FastNumSpkRep2,FastNumSpkRep1+FastNumSpkRep2+FastNumSpkRep3-1] = local6[p-FastNumSpkRep2-FastNumSpkRep1]
WaveStats/Q FastVoltThresh
variable/G FastThreshCV = V_sdev/abs(V_avg)
variable/G FastThresh = V_avg
print "Threshold voltage CV: "+num2str(FastThreshCV)

// AHP PROPERTIES
// voltage dependence for fast, medium and slow components 
// stored in RecordA19-26
print "_____ANALYZING AHP properties..."
Make/O/N=8 AHP_min
Make/O/N=8 AHP_fast
Make/O/N=8 AHP_med
Make/O/N=8 AHP_slow
Make/O/N=8 AHP_tau

Make/O/N=8 AHP_stim
AHP_stim[] = (7-p)*20

for(index=19;index<27;index+=1)
	CurrWave = "RecordA"+num2str(index)
	WAVE local = $CurrWave

	WaveStats /Q/R = (0,0.04) local
	baseline = V_avg
	
	WaveStats /Q/R = (0.05125,0.053) local // look for the minimum value on repolarization
	AHP_min[index-19] = V_min-baseline
	
	// select out fast, medium, and slow AHP components
	WaveStats /Q/R = (0.055,0.056) local
	AHP_fast[index-19] = V_avg-baseline
	WaveStats /Q/R = (0.069,0.07) local
	AHP_med[index-19] = V_avg-baseline
	WaveStats /Q/R = (0.08,0.0825) local
	AHP_slow[index-19] = V_avg-baseline

	CurveFit/N/Q/W=0 exp  local(0.055,0.08) /D 
	WAVE W_coef
	AHP_tau[index-19] = 1 / W_coef[2]
	
endfor

CurveFit/Q/NTHR=0 line  AHP_slow /X=AHP_stim /D 
WAVE W_coef = W_coef
variable/G AHP_s_slope = W_coef[1]*1000

CurveFit/Q/NTHR=0 line  AHP_med /X=AHP_stim /D 
WAVE W_coef = W_coef
variable/G AHP_m_slope = W_coef[1]*1000

CurveFit/Q/NTHR=0 line  AHP_fast /X=AHP_stim /D 
WAVE W_coef = W_coef
variable/G AHP_f_slope = W_coef[1]*1000

WaveStats/Q AHP_min
variable/G AHP_min_fracThresh = V_avg / (FastThresh-baseline)

// RAMPS
// for 3 positive ramps detect spikes and find rheobase current (RecordA13-15)
// numspikes rise vs. numspikes decay
// undershoot on decay
print "_____ANALYZING RAMPS protocols..."
Make/O/N=3 RAMP_rheoBase
Make/O/N=3 RAMP_firstSpk
Make/O/N=3 RAMP_rheoBaseF //rheobase as fraction of total ramp duration
Make/O/N=3 RAMP_rheoBaseFL //rheobase on falling side as fraction of total ramp duration

CORD_SpikeDetectorSimple("RecordA13",0.002)
WAVE raw = RecordA13
WAVE stim = root:DAQ:Protocols:CustomProtocol:seg_13_0
WAVE local = SPLOC_RecordA13
FindLevel /EDGE=1 /P/Q local, 2.4
variable/G RAMP_Slo_SpkIndex = ( (2*ceil(V_LevelX)) -numpnts(local) ) / numpnts(local)
RAMP_firstSpk[0] = local[0]
RAMP_rheoBase[0] = stim(local[0])*400
RAMP_rheoBaseF[0] = (local[0]-1)/1.4
RAMP_rheoBaseFL[0] = (local[numpnts(local)]-2.4)/1.4

CORD_SpikeDetectorSimple("RecordA14",0.002)
WAVE raw = RecordA14
WAVE stim = root:DAQ:Protocols:CustomProtocol:seg_14_0
WAVE local = SPLOC_RecordA14
FindLevel /EDGE=1 /P/Q local, 1.7
variable/G RAMP_Med_SpkIndex = ( (2*ceil(V_LevelX)) -numpnts(local) ) / numpnts(local)
RAMP_firstSpk[1] = local[0]
RAMP_rheoBase[1] = stim(local[0])*400
RAMP_rheoBaseF[1] = (local[0]-1)/0.7
RAMP_rheoBaseFL[1] = (local[numpnts(local)]-1.7)/0.7

CORD_SpikeDetectorSimple("RecordA15",0.002)
WAVE raw = RecordA15
WAVE stim = root:DAQ:Protocols:CustomProtocol:seg_15_0
WAVE local = SPLOC_RecordA15
FindLevel /EDGE=1 /P/Q local, 1.35
variable/G RAMP_Fast_SpkIndex = ( (2*ceil(V_LevelX)) -numpnts(local) ) / numpnts(local)
RAMP_firstSpk[2] = local[0]
RAMP_rheoBase[2] = stim(local[0])*400
RAMP_rheoBaseF[2] = (local[0]-1)/0.35
RAMP_rheoBaseFL[2] = (local[numpnts(local)]-1.35)/0.35

print "Spike rheobase (pA): 	s|" + num2str(RAMP_rheoBase[0]) + "		m|" + num2str(RAMP_rheoBase[1])+ "	f|" + num2str(RAMP_rheoBase[2])
print "Spike asymmetry: 		s|" + num2str(RAMP_Slo_SpkIndex) + "	m|" + num2str(RAMP_Med_SpkIndex)+ "	f|" + num2str(RAMP_Fast_SpkIndex)

// for negative ramps look for hysteresis, peak hyperpolarization (RecordA16-18)
Duplicate/O/R=(1,1.35) RecordA16, RA16_down
Duplicate/O/R=(1.35,1.7) RecordA16, RA16_up
WaveStats/Q/R=(0,1) RecordA16
RA16_down-=V_avg
RA16_up-=V_avg
Integrate RA16_up/D=RA16_up_INT
Integrate RA16_down/D=RA16_down_INT
variable/G RAMP_Hf_AIndex = (RA16_down_INT[numpnts(RA16_down_INT)]-RA16_up_INT[numpnts(RA16_up_INT)]) / (RA16_up_INT[numpnts(RA16_up_INT)]+RA16_down_INT[numpnts(RA16_down_INT)])

Duplicate/O/R=(1,1.7) RecordA17, RA17_down
Duplicate/O/R=(1.7,2.4) RecordA17, RA17_up
WaveStats/Q/R=(0,1) RecordA17
RA17_down-=V_avg
RA17_up-=V_avg
Integrate RA17_up/D=RA17_up_INT
Integrate RA17_down/D=RA17_down_INT
variable/G RAMP_Hm_AIndex = (RA17_down_INT[numpnts(RA17_down_INT)]-RA17_up_INT[numpnts(RA17_up_INT)]) / (RA17_up_INT[numpnts(RA17_up_INT)]+RA17_down_INT[numpnts(RA17_down_INT)])

Duplicate/O/R=(1,2.4) RecordA18, RA18_down
Duplicate/O/R=(2.4,3.8) RecordA18, RA18_up
WaveStats/Q/R=(0,1) RecordA18
RA18_down-=V_avg
RA18_up-=V_avg
Integrate RA18_up/D=RA18_up_INT
Integrate RA18_down/D=RA18_down_INT
variable/G RAMP_Hs_AIndex = (RA18_down_INT[numpnts(RA18_down_INT)]-RA18_up_INT[numpnts(RA18_up_INT)]) / (RA18_up_INT[numpnts(RA18_up_INT)]+RA18_down_INT[numpnts(RA18_down_INT)])

// MINISTEPS
// difference in i vs. v slopes for negative and positive steps
print "_____ANALYZING MINI STEPS protocols..."

Make/O/N=12 CP_MS_RI
Make/O/N=12 CP_MS_TAU
Make/O/N=6 CP_MS_TAUd

Make/O/N=9 CP_MS_STIM = {-30,-30,0,0,30,30,-40,-20,-10,10,20,40}

for(index=27;index<33;index+=1)

	CurrWave = "RecordA"+num2str(index)
	WAVE local = $CurrWave

	WaveStats /Q/R = (0,0.2) local
	baseline = V_avg

	WaveStats /Q/R = (0.269,0.274) local
	CP_MS_RI[index-27] = V_avg-baseline
	CurveFit/N/Q/W=0 exp  local(0.225,0.275) /D 
	WAVE W_coef
	CP_MS_TAU[index-27] = 1 / W_coef[2]
	
	WaveStats /Q/R = (0.319,0.324) local
	CP_MS_RI[index-27+6] = V_avg-baseline
	CurveFit/N/Q/W=0 exp  local(0.275,0.325) /D 
	WAVE W_coef
	CP_MS_TAU[index-27+6] = 1 / W_coef[2]
	
	CurveFit/N/Q/W=0 exp  local(0.375,0.425) /D 
	WAVE W_coef
	CP_MS_TAUd[index-27] = 1 / W_coef[2]
		
endfor

CurveFit/Q/NTHR=0 line  CP_MS_RI /X=CP_MS_STIM /D 
WAVE W_coef = W_coef
variable/G MINI_slope = W_coef[1]*1000
variable/G MINI_tauN = (CP_MS_TAU[0]+CP_MS_TAU[1])/0.1
variable/G MINI_tauP = (CP_MS_TAU[4]+CP_MS_TAU[5])/0.1

// SPIKE PROPS
// difference in i vs. v slopes for negative and positive steps
print "_____ANALYZING PROPERTIES OF INIDVIDUAL SPIKES..."
string spikeWave="", newWave="", stimWaveName=""
variable jindex=0,winL=0.001, winR=0.002, staL=0.06, staR=0, count=0,rSpkLoc=0

for(index=0;index<10;index+=1)
	CurrWave = "RecordA"+num2str(index)
	WAVE rawData = $CurrWave
	stimWaveName = "root:DAQ:Protocols:CustomProtocol:seg_"+num2str(index)+"_0"
	WAVE stimWave = $stimWaveName
	CORD_SpikeDetectorSimple(CurrWave,0.002)
	spikeWave = "SPLOC_RecordA"+num2str(index)
	WAVE spkData = $spikeWave
	
	for(jindex=0;jindex<numpnts(spkData);jindex+=1)
		newWave = "SPK_"+num2str(count)
		rSpkLoc = spkData[jindex]
		Duplicate/O/R=(rSpkLoc-winL,rSpkLoc+winR) rawData, $newWave
		WAVE spkLocal = $newWave
		SetScale /P x, -winL, 3.33e-5, "s", spkLocal
		newWave = "STA_"+num2str(count)
		Duplicate/O/R=(rSpkLoc-staL,rSpkLoc) stimWave, $newWave
		WAVE staLocal = $newWave
		SetScale /P x, -staL, 3.33e-5, "s", staLocal
		staLocal*=400
		if(count==0)
			Duplicate/O spkLocal, SPK_Mean
			WAVE SPK_Mean = SPK_Mean
			Duplicate/O staLocal, STA_Mean
			WAVE STA_Mean = STA_Mean
		else
			SPK_Mean+=spkLocal
			STA_Mean+=staLocal
		endif
		count+=1
	endfor
endfor

print count
SPK_Mean/=count
STA_Mean/=count

WaveStats/Q SPK_Mean
variable halfThresh = ((V_max-SPK_Mean[0])/4)+SPK_Mean[0]
FindLevels /EDGE=0 /N=2 /D=spkLevels /Q SPK_Mean, halfThresh
variable/G SPK_width = (spkLevels[1]-spkLevels[0])*1000
variable riseTime = V_maxloc-spkLevels[0]
variable fallTime = spkLevels[1]-V_maxloc
variable/G SPK_asymIndex = (fallTime-riseTime) / (riseTime+fallTime)

CurveFit/Q/NTHR=0 Sigmoid  STA_Mean /D 
WAVE sigProps = W_coef
variable/G STA_half = abs(W_coef[2]/staL) // xhalf fraction
variable/G STA_amp = abs(W_coef[1]/W_coef[0]) // xhalf fraction


///////// FOR CLUSTERING...
string clustVectName = "CLW_"+GetDataFolder(0)
Make/O/N=(25) $clustVectName
WAVE clustLocal = $clustVectName
clustLocal[] = 0
clustLocal[0] = SlowFracReliable
clustLocal[1] = MedFracReliable
clustLocal[2] = FastFracReliable
clustLocal[3] = RAMP_Slo_SpkIndex
clustLocal[4] = RAMP_Med_SpkIndex
clustLocal[5] = RAMP_Fast_SpkIndex
clustLocal[6] = RAMP_Hs_AIndex
clustLocal[7] = RAMP_Hm_AIndex
clustLocal[8] = RAMP_Hf_AIndex
clustLocal[9] = RAMP_rheoBaseF[0]
clustLocal[10] = RAMP_rheoBaseF[1]
clustLocal[11] = RAMP_rheoBaseF[2]
clustLocal[12] = RAMP_rheoBaseFL[0]
clustLocal[13] = RAMP_rheoBaseFL[1]
clustLocal[14] = RAMP_rheoBaseFL[2]
clustLocal[15] = FLUC_s_under
clustLocal[16] = MINI_tauN
clustLocal[17] = MINI_tauP
clustLocal[18] = MINI_slope
clustLocal[19] = AHP_s_slope
clustLocal[20] = AHP_m_slope
clustLocal[21] = AHP_f_slope
clustLocal[22] = AHP_min_fracThresh
clustLocal[23] = SPK_asymIndex
clustLocal[24] = STA_amp
clustLocal[25] = STA_half

AppendToTable clustLocal

//// write out the array for clustering in hdf5 with unique cell ids (recoverable post matlab analysis)
//string fileNameStr = "CLW_"+GetDataFolder(0)+".h5"
//variable fileID=0, groupID=0
//HDF5CreateFile /O/P=DataBasePath fileID  as fileNameStr
//HDF5SaveData /O /Z clustLocal, fileID
//HDF5CloseFile fileID

End


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_SpikeDetectorSimple(spikeWaveName,refractory)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	string spikeWaveName
	variable refractory // in number of samples
	
	WAVE local = $spikeWaveName
	Differentiate local/D=derivative
	WaveStats/Q derivative
	variable level = V_max*0.25
	
	FindLevels /EDGE=1 /D=foundLevels /M=(refractory) /Q derivative, level		
	variable numSpikes = V_LevelsFound	
	//print "Spikes found: "+num2str(numSpikes)
	
	string newName = "SPLOC_"+spikeWaveName
	Duplicate/O foundLevels, $newName
	WAVE local2 = $newName
	newName = "SPLEV_"+spikeWaveName
	foundLevels[] = local(local2[p])
	Duplicate/O foundLevels, $newName	

	KillWaves derivative, foundLevels
	
end


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_MergeRepeats(channel)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// This function assumes that multiple repetitions of the same protocol have been gathered together inside a single directory. Corduroy analysis functions
// do not like this, so I wrote a function to pull them into a single directory suitable for analysis
string channel

string topLevDF = GetDataFolder(1), currDF="", newName="", listOfWaves="", currWave=""
string forMatch = "Record"+channel+"*"

// list all of the data folders contained in current df
variable numDFs = CountObjects(":",4), index=0, totalWaves = 0, j=0

// nav into each data folder and pull out each channel of recording
for(index=0;index<numDFs;index+=1)

	currDF = GetIndexedObjName(":", 4, index)
	SetDataFolder $currDF
	listOfWaves = WaveList(forMatch,";","")	

	for(j=0;j<ItemsInList(listOfWaves);j+=1)
		currWave = StringFromList(j, listOfWaves)
		WAVE local = $currWave
		if(index>0)
			newName = topLevDF+"Record"+channel+num2str(totalWaves)
		else
			newName = topLevDF+currWave		
		endif
		Duplicate/O local, $newName
		totalWaves+=1
	endfor

	SetDataFolder $topLevDF
	
endfor

end

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_MakePSTH(duration,resolution)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	variable duration // in seconds
	variable resolution // in milliseconds

	string rastXlist = WaveList("*r_x",";","")
	string rastXname = StringFromList(0,rastXlist)
	WAVE rasterX = $rastXname

	string rastYlist = WaveList("*r_y",";","")
	string rastYname = StringFromList(0,rastYlist)
	WAVE rasterY = $rastYname
	
	Make/O/N=(duration/resolution*1000) psth	
	psth[] = 0
	
	variable/G totalSpks = numpnts(rasterX)
	WaveStats/Q rasterY
	variable/G numTrials = V_max
	variable index=0, currSpkIndex=0
	
	for(index=0;index<totalSpks;index+=1)
	
		currSpkIndex = round(1000*rasterX[index])
		psth[currSpkIndex] += 1
		
	endfor
	
	psth /= numTrials
	
	CORD_CreateKernel(10)
	Duplicate/O psth,psth_conv;DelayUpdate
	Convolve/A kernel, psth_conv

end


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_CalcPSTHRecovery()
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	
	WAVE psth_conv = W_WaveAverage
	
	WaveStats/Q/R=(0,2.5) psth_conv
	variable/G baselineRate = V_avg
	 
	WaveStats/Q/R=(2.9,4) psth_conv
	variable/G ampSupp = V_min
	variable ampSuppMinLoc = V_minLoc
	
	variable halfMax = baselineRate - ( abs(baselineRate-ampSupp)/2 )
	print halfMax
	
	FindLevel /EDGE=2/Q/R=(2.98,ampSuppMinLoc) psth_conv, halfMax
	variable/G fallEdge = V_LevelX
	
	FindLevel /EDGE=1/Q/R=(ampSuppMinLoc,) psth_conv, halfMax
	variable/G riseEdge = V_LevelX
	
	variable/G fwhm = riseEdge-fallEdge
	
	Make/O/N=2 fwhmWaveX
	Make/O/N=2 fwhmWaveY
	
	fwhmWaveX[0] = fallEdge
	fwhmWaveX[1] = riseEdge
	fwhmWaveY[0] = halfMax
	fwhmWaveY[1] = halfMax
	
	Display psth_conv
	AppendToGraph fwhmWaveY vs fwhmWaveX
	ModifyGraph mode(fwhmWaveY)=4,marker(fwhmWaveY)=8,msize(fwhmWaveY)=3;DelayUpdate
	ModifyGraph mrkThick(fwhmWaveY)=1,opaque(fwhmWaveY)=1,rgb(fwhmWaveY)=(0,0,0)

	print "FWHM: "+num2str(fwhm)+" | MIN: "+num2str(baselineRate-ampSupp)

end

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_CreateKernel(std)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// create a gaussian function of a fixed height = 1 and a width defined as 10*std
	variable std
	
	variable totalLength = 10*std*2
	variable avg = 10*std
	
	Make/O/N=(totalLength) kernel
	
	kernel[] = (1/(std*sqrt(2*pi))) * exp( -(p-avg)^2 / (2*std)^2 )

end


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_CalcPause()
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	string rastXlist = WaveList("*r_x",";","")
	string rastXname = StringFromList(0,rastXlist)
	WAVE rasterX = $rastXname

	string rastYlist = WaveList("*r_y",";","")
	string rastYname = StringFromList(0,rastYlist)
	WAVE rasterY = $rastYname

	variable maxTrials = rasterY[numpnts(rasterY)]
	variable index=0, j=0, completed=0, checked=0, isi=0
	variable numSpks = numpnts(rasterX)
	
	Make/O/N=(maxTrials) firstSpk
	firstSpk[] = 0
	Make/O/N=(maxTrials) avgISI
	avgISI[] = 0
	
	for(index=0;index<maxTrials;index+=1)
		for(j=1;j<numSpks;j+=1)
			if(completed==0)
				if(rasterY[j]==index)
					if(rasterY[j-1]==index)
						isi+=(rasterX[j] -rasterX[j-1])
						checked+=1 
					endif
					if(rasterX[j] > 3)
						firstSpk[index] = rasterX[j]-2.98
						completed = 1
					endif
				endif
			endif
		endfor
		avgISI[index] = isi/checked
		completed = 0
		checked = 0
		isi = 0
	endfor
	
	WaveStats/Q firstSpk
	variable/G pauseDuration = V_avg

	WaveStats/Q avgISI
	variable/G averageISI = V_avg
	
	print num2str(pauseDuration) + "  |  " + num2str(averageISI)
	
end


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_MakeColorTable()
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	variable index=0
	variable lowRange = 150
	variable hiRange = 150
	Make/O/N=(lowRange+hiRange+1,3) colorsUsed
		
	variable colorIncremeter = 65535/(lowRange-1)
	variable blueIncrementer = (65535-43690)/(lowRange-1)
	variable whiteIncrementer = 65535/(HiRange)

	for(index=0;index<lowRange;index+=1)
		
		colorsUsed[index][0] = colorIncremeter*(index)
		colorsUsed[index][1] = 43690 + (blueIncrementer*(index))
		colorsUsed[index][2] = 65535

	endfor

	for(index=0;index<=hiRange;index+=1)

		colorsUsed[index+lowRange][0] = 65535
		colorsUsed[index+lowRange][1] = 65535-(whiteIncrementer*(index))
		colorsUsed[index+lowRange][2] = 65535-(whiteIncrementer*(index))


	endfor
	
	SetScale/P x -15,0.1,"", colorsUsed
	
End

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_MakeColorTableBLK()
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	variable index=0
	variable lowRange = 150
	variable hiRange = 150
	Make/O/N=(lowRange+hiRange+1,3) colorsUsed
		
	variable colorIncremeter = 65535/(lowRange-1)
	variable blueIncrementer = (43690)/(lowRange-1)
	variable whiteIncrementer = 65535/(HiRange)

	for(index=0;index<lowRange;index+=1)
		
		colorsUsed[index][0] = 0 
		colorsUsed[index][1] = 43690 - (blueIncrementer*(index))
		colorsUsed[index][2] = 65535 - (colorIncremeter*index)

	endfor

	for(index=0;index<=hiRange;index+=1)

		colorsUsed[index+lowRange][0] = (whiteIncrementer*(index))
		colorsUsed[index+lowRange][1] = 0
		colorsUsed[index+lowRange][2] = 0


	endfor
	
	SetScale/P x -15,0.1,"", colorsUsed
	
End

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// OLD SHIT
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Function CORD_PulseASCIILoader()
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	SetDataFolder root:

// Set a symbolic path to locate data directories
	PathInfo AnalysisDir
	if (V_flag == 0)
		NewPath AnalysisDir
	else
		Print "Path exists as  "+S_path
	endif

// Skip the time column //// Eventually should get scaling from here //// 
	string columnInfoStr= "N=time;N=RecordA;N=RecordB;"
// Load waves from ASCII file
	LoadWave /A/B="N=time;N=RecordA;N=RecordB;"/G/P=AnalysisDir
// Parse filename to remove unwanted characters	
	string fileload = StringFromList(0,S_fileName,".")
// IGOR does not like names that begin with numbers so...
	S_fileName = "f"+fileload
// Make a new directory with the name of the loaded file
	NewDataFolder/O/S root:$S_fileName
	String loadedDF = GetDataFolder(1)
	SetDataFolder root:
// Get the x scaling from the time wave
	Wave time1 = time1
	variable period = (time1[1] - time1[0]) * 1000
	MoveWave time1, $loadedDF
// Give units scale for the selected wave
	string units = "time (ms)"
// Setup variables and strings to move waves into appropriate df
	string LoadedWaves = "", timeWaves=""
	LoadedWaves = WaveList("Record*",";","")
	timeWaves = WaveList("time*",";","")
	String theWave, temp, thisWaveName
	variable index = 0
 // Kill remaining time waves
	do
		theWave = StringFromList(index, timeWaves)
		if (strlen(theWave) == 0)
			break		// Ran out of waves
		endif
		KillWaves/Z $theWave
		index+=1
	while(1)
// Step through loaded waves, move to directory, rescale in x and y
	index=0
	do
		theWave = StringFromList(index, LoadedWaves)
		Wave local = $theWave
		if (strlen(theWave) == 0)
			break		// Ran out of waves
		endif
		SetScale/P x, 0,  period, units, local
//** There is a factor ten offset in PULSE with a 2A amp **//
//** 		Remove this line for other amplifiers 			**//
	if(stringmatch(theWave,"RecordA*"))
		local = local / 10 
	endif
		MoveWave local, $loadedDF
		index+=1
	while(1)
// Move to new data folder
	SetDataFolder loadedDF
	MoveWave RecordA,RecordA0
	variable/G root:Analysis:SynapticPanel:traceCount = 1
	if(WaveExists(RecordB)==1)
		MoveWave RecordB,RecordB0
	//	root:Analysis:SynapticPanel:traceCount = 2 // only relevant if two fields are acquired
	endif
// Plot the loaded waves
	string ChanA = WaveList("RecordA*",";","")
	string ChanB = WaveList("RecordB*",";","")
	DoWindow/K ChannelA
	DoWindow/K ChannelB
	DisplayWaveListOneChannel(ChanA,1)
	if(ItemsInList(ChanB)!=0)
		DisplayWaveListOneChannel(ChanB,2)
	endif
// Update Utility Panel
	CORD_ListDataFolders_Util()
// Update slider and globals to represent largest range of waves in any df
	NVAR NumTrace = root:Analysis:UtilityPanel:NumTrace
	variable currNumTrace = ItemsInList(ChanA) + ItemsInList(ChanB)
	if(currNumTrace > NumTrace)
		NumTrace = currNumTrace
	endif
	Slider GraphSlider1 limits={0,NumTrace,1},win=CORD_UtilitiesControlPanel
// Move to new df and update popup
	SetDataFolder loadedDF
//	SVAR FileList = root:Analysis:UtilityPanel:FileList
//	variable newpop = WhichListItem(loadedDF,FileList)
//	PopupMenu Graphpopup1 popvalue=num2str(newpop)

end // PulseASCIILoader