rng_influence_geiger.py

# This uses geiger-generated numbers only
# It obtains two sets of pre-run numbers, one which is observed and the other unobserved..
# ..and plays them back in parallel with a third set of real-time numbers.
# All results are combined into a single probability.
# That probability controls a line chart and also the pitch of an audio tone, giving real-time feedback.



# Everything is under this block in order to make multi-processing work 
if __name__ == '__main__': 
	import serial
	import tkinter
	from tkinter import *
	from PIL import Image, ImageTk
	import matplotlib.pyplot as plt
	import os
	import time
	import requests
	import threading
	import json
	from datetime import datetime
	from scipy.stats import binomtest
	import sqlite3
	import numpy as np
	from playsound import playsound
	import sqlite3
	import time
	import matplotlib.animation as animation
	import multiprocessing



	def prerun_observed(number_minutes):

		#ls -l /dev/cu.usb
		ser = serial.Serial('/dev/cu.usbserial-A10K714O', 9600)

		is_observed = True
		is_prerun = True

		# Define connection to database
		conn1 = sqlite3.connect('db/database.db', check_same_thread=False )
		cursor = conn1.cursor()

		# Time dif
		start = datetime.now()
		end = datetime.now()
		diff = end - start
		diff_sec = diff.total_seconds() 

		trial_number = 0


		### Create database tables

		# Basic info about the trial. A trial is composed of multiple runs. Each run has four sets of numbers.
		cursor.execute('''CREATE TABLE IF NOT EXISTS trial(
			trial_number integer NOT NULL,
			datetime_initiated datetime NOT NULL,
			number_minutes integer
			)''')

		# Stores information for each run 
		cursor.execute('''CREATE TABLE IF NOT EXISTS run(
			is_prerun boolean,
			is_observed boolean,
			run_number integer,
			trial_number integer NOT NULL,
			sec_elapsed decimal,
			geiger_more_even boolean,
			geiger_hit_percent text,
			geiger_p_val text,
			FOREIGN KEY (trial_number) REFERENCES trial(trial_number)
			)''')

		# Stores information for each run 
		cursor.execute('''CREATE TABLE IF NOT EXISTS result(
			trial_number integer,
			sec_elapsed decimal,
			prob_all int,
			prob_obs int,
			prob_unobs int,
			prob_real int
			)''')

		# Retreive max trial number and set new trial number
		cursor.execute("select max(trial_number) from trial")

		max_trial = cursor.fetchone()

		if str(max_trial)=='(None,)':
			trial_number = 1
		else:
			trial_number = int(str(max_trial)[1:len(max_trial)-3]) + 1

		## Populate basic info of trial
		cursor.execute("INSERT INTO trial(trial_number,datetime_initiated,number_minutes)VALUES(?,?,?)",(trial_number,str(start),number_minutes))
		conn1.commit()

		run_number = 0
		geiger_more_even = False
		geiger_hits = 0

		# This creates a loop that listens for input from the geiger rng
		while True:

			while float(diff_sec) <= float(number_minutes*60):

				geiger_read = ser.read()
				geiger_more_even = False
				run_start = datetime.now()

				if str(geiger_read)[3:6] == 'x01': #1
					run_number = run_number + 1

				if str(geiger_read)[3:6] == 'x02': #2
					run_number = run_number + 1
					geiger_hits = geiger_hits + 1
					geiger_more_even = True

				prob_geiger=binomtest(int(geiger_hits), int(run_number), 0.5, alternative='greater')
				
				# update the end time for this run and get elapsed
				end = datetime.now()
				diff = end - start
				diff_sec = diff.total_seconds() 

				# store resuls for geiger run
				cursor.execute("INSERT INTO run(run_number,trial_number, geiger_more_even, geiger_hit_percent, geiger_p_val, sec_elapsed, is_observed, is_prerun)VALUES(?,?,?,?,?,?,?,?)",(str(run_number),str(trial_number),geiger_more_even, str(int(geiger_hits)/int(run_number)), str(1-prob_geiger.pvalue), diff_sec, is_observed, is_prerun))
				conn1.commit()
				
				# code will show the database row for each run
				#cursor.execute("select * from run where run_number=? and trial_number=?", (str(run_number), str(trial_number)))
				#temp = cursor.fetchone()
				#print(f'DB for run: {temp}')

			print(f'Group #1 complete: Results {geiger_hits}/{run_number}, p={str(1-prob_geiger.pvalue)[0:4]}')

			playsound('mp3/group_complete.mp3')

			break

		conn1.close

		print(f'')
		print(f'')

		return trial_number

	def prerun_unobserved(trial_number, number_minutes):

		#ls -l /dev/cu.usb
		ser = serial.Serial('/dev/cu.usbserial-A10K714O', 9600)

		is_observed = False
		is_prerun = True
		run_number = 0
		geiger_more_even = False
		geiger_hits = 0

		# Time dif
		start = datetime.now()
		end = datetime.now()
		diff = end - start
		diff_sec = diff.total_seconds() 

		# This creates a loop that listens for input from the geiger rng
		while True:

			while float(diff_sec) <= float(number_minutes*60):

				geiger_read = ser.read()
				geiger_more_even = False

				run_start = datetime.now()

				if str(geiger_read)[3:6] == 'x01': #1
					run_number = run_number + 1

				if str(geiger_read)[3:6] == 'x02': #2
					run_number = run_number + 1
					geiger_hits = geiger_hits + 1
					geiger_more_even = True

				# update the end time for this run and get elapsed
				end = datetime.now()
				diff = end - start
				diff_sec = diff.total_seconds() 

				if str(geiger_read)[3:6] == 'x01' or str(geiger_read)[3:6] == 'x02':
					### Create new database for each generated number and store results
					
					db_name = 'db/Trial-' + str(trial_number) + '_Run-' + str(run_number) + '.db'
					conn1 = sqlite3.connect(db_name, check_same_thread=False)
					cursor_unobserved = conn1.cursor()

					# Stores information for each run 
					cursor_unobserved.execute('''CREATE TABLE IF NOT EXISTS run(
						is_prerun boolean,
						is_observed boolean,
						run_number integer,
						trial_number integer NOT NULL,
						sec_elapsed decimal,
						geiger_more_even boolean,
						FOREIGN KEY (trial_number) REFERENCES trial(trial_number)
						)''')

					cursor_unobserved.execute("INSERT INTO run(run_number,trial_number,geiger_more_even, sec_elapsed, is_observed, is_prerun)VALUES(?,?,?,?,?,?)",(str(run_number),str(trial_number),geiger_more_even, diff_sec, is_observed, is_prerun))
					conn1.commit()

			break

		#print(f'Unobserved Results: {geiger_hits}/{run_number}')
		print(f'Group #2 complete. Results hidden.')

		playsound('mp3/group_complete.mp3')

		conn1.close

		print(f'')
		print(f'')

		return run_number


	def realtime(trial_number, number_minutes):

		global start

		#ls -l /dev/cu.usb
		ser = serial.Serial('/dev/cu.usbserial-A10K714O', 9600)

		is_observed = True
		is_prerun = False

		# Define connection to database
		conn1 = sqlite3.connect('db/database.db', check_same_thread=False )
		cursor = conn1.cursor()

		# Time dif
		end = datetime.now()
		diff = end - start
		diff_sec = diff.total_seconds() 

		run_number = 0
		geiger_more_even = False
		geiger_hits = 0

		# This creates a loop that listens for input from the geiger rng
		while True:

			while float(diff_sec) <= float(number_minutes*60):

				geiger_read = ser.read()
				geiger_more_even = False
				run_start = datetime.now()

				if str(geiger_read)[3:6] == 'x01': #1
					run_number = run_number + 1

				if str(geiger_read)[3:6] == 'x02': #2
					run_number = run_number + 1
					geiger_hits = geiger_hits + 1
					geiger_more_even = True

				prob_geiger=binomtest(int(geiger_hits), int(run_number), 0.5, alternative='greater')
				
				# update the end time for this run and get elapsed
				end = datetime.now()
				diff = end - start
				diff_sec = diff.total_seconds()

				# store resuls for geiger run
				cursor.execute("INSERT INTO run(run_number,trial_number, geiger_more_even, geiger_hit_percent, geiger_p_val, sec_elapsed, is_observed, is_prerun)VALUES(?,?,?,?,?,?,?,?)",(str(run_number),str(trial_number),geiger_more_even, str(int(geiger_hits)/int(run_number)), str(1-prob_geiger.pvalue), diff_sec, is_observed, is_prerun))
				conn1.commit()

				# code will show the database row for each run
				#cursor.execute("select * from run where run_number=? and trial_number=?", (str(run_number), str(trial_number)))
				#temp = cursor.fetchone()
				#print(f'DB for run: {temp}')

			break

		conn1.close

		# print(f'Real-time Results: {geiger_hits}/{run_number}, p={str(1-prob_geiger.pvalue)[0:4]}')

		#print(f'Thread 1 complete')

		return run_number


	def read_unobserved(trial_number_formatted, unobserved_run_count):

		global start

		loop_count = 1
		run_number = 1 
		sec_elapsed = 0 
		geiger_more_even = False
		trial_number='(' + str(trial_number_formatted) + ',) ' #to replicate DB read format

		# Time dif
		end = datetime.now()
		diff = end - start
		diff_sec = diff.total_seconds() 

		while loop_count <= unobserved_run_count:
			conn1 = sqlite3.connect('db/database.db', check_same_thread=False)
			cursor = conn1.cursor()

			db_name = 'db/Trial-' + str(trial_number)[1:len(trial_number)-3] + '_Run-' + str(loop_count) + '.db'
			
			conn2 = sqlite3.connect(db_name, check_same_thread=False)
			cursor_unobserved = conn2.cursor()

			cursor_unobserved.execute("select run_number from run")
			run_number = cursor_unobserved.fetchone()

			cursor_unobserved.execute("select trial_number from run")
			trial_number = cursor_unobserved.fetchone()

			cursor_unobserved.execute("select sec_elapsed from run")
			sec_elapsed = cursor_unobserved.fetchone()

			cursor_unobserved.execute("select geiger_more_even from run")
			geiger_more_even = cursor_unobserved.fetchone()

			while float(diff_sec) < float(str(sec_elapsed)[1:len(str(sec_elapsed))-3]):
			
				# update elapsed time
				end = datetime.now()
				diff = end - start
				diff_sec = diff.total_seconds()

			cursor.execute("INSERT INTO run(is_prerun,is_observed,run_number,trial_number,geiger_more_even,sec_elapsed)VALUES(?,?,?,?,?,?)",(1, 0, str(run_number)[1:len(run_number)-3],str(trial_number)[1:len(trial_number)-3],str(geiger_more_even)[1:len(geiger_more_even)-3], str(diff_sec)[1:len(str(diff_sec))-3]))
			conn1.commit()

			loop_count = loop_count + 1

		conn1.close
		conn2.close

		#print(f'Thread 2 complete')

	def results():
		global start, run_count_all, hit_count_all, run_count_obs, hit_count_obs, run_count_unobs, hit_count_unobs 
		global run_count_real, hit_count_real, prob_all, prob_obs, prob_unobs, prob_real

		end = datetime.now()
		diff = end - start
		diff_sec = diff.total_seconds()

		while float(diff_sec) <= float(number_minutes*60+20):
			end = datetime.now()
			diff = end - start
			diff_sec = diff.total_seconds()

		# Define connection to database
		conn1 = sqlite3.connect('db/database.db', check_same_thread=False)
		cursor = conn1.cursor()

		playsound('mp3/trial_complete.mp3')


		print(f'')
		print(f'')
		print(f'Overall: {str(hit_count_all)[1:len(hit_count_all)-3]}/{str(run_count_all)[1:len(run_count_all)-3]}, p={str(prob_all)[1:6]}') 
		print(f'Observed: {str(hit_count_obs)[1:len(hit_count_obs)-3]}/{str(run_count_obs)[1:len(run_count_obs)-3]}, p={str(prob_obs)[1:6]}') 
		print(f'Unbserved: {str(hit_count_unobs)[1:len(hit_count_unobs)-3]}/{str(run_count_unobs)[1:len(run_count_unobs)-3]}, p={str(prob_unobs)[1:6]}') 
		print(f'Real-time: {str(hit_count_real)[1:len(hit_count_real)-3]}/{str(run_count_real)[1:len(run_count_real)-3]}, p={str(prob_real)[1:6]}') 
		print(f'')
		print(f'Trial complete. Please close the graph window.')
		print(f'')

		#print(f'Thread 3 complete')

	def animate(i):

		global xvar, yvar, prob_last, start, trial_number,run_count_all, hit_count_all, run_count_obs, hit_count_obs
		global run_count_unobs, hit_count_unobs, run_count_real, hit_count_real, freq_file, p1, p2
		global prob_all, prob_obs, prob_unobs, prob_real, freq_last_set, thread_killer_1, thread_killer_2

		end = datetime.now()
		diff = end - start
		diff_sec = diff.total_seconds()

		# Define connection to database
		conn1 = sqlite3.connect('db/database.db', check_same_thread=False)
		cursor = conn1.cursor()

		cursor.execute("select count(*) from run where trial_number=?1 and sec_elapsed<?2", [trial_number, diff_sec])
		run_count_all = cursor.fetchone()

		cursor.execute("select count(*) from run where trial_number=?1 and sec_elapsed<?2 and geiger_more_even=True", [trial_number, diff_sec])
		hit_count_all = cursor.fetchone()

		cursor.execute("select count(*) from run where trial_number=?1 and sec_elapsed<?2 and is_prerun=True and is_observed=True", [trial_number, diff_sec])
		run_count_obs = cursor.fetchone()

		cursor.execute("select count(*) from run where trial_number=?1 and sec_elapsed<?2 and geiger_more_even=True and is_prerun=True and is_observed=True", [trial_number, diff_sec])
		hit_count_obs = cursor.fetchone()

		cursor.execute("select count(*) from run where trial_number=?1 and sec_elapsed<?2 and is_prerun=True and is_observed=False", [trial_number, diff_sec])
		run_count_unobs = cursor.fetchone()

		cursor.execute("select count(*) from run where trial_number=?1 and sec_elapsed<?2 and geiger_more_even=True and is_prerun=True and is_observed=False", [trial_number, diff_sec])
		hit_count_unobs = cursor.fetchone()

		cursor.execute("select count(*) from run where trial_number=?1 and sec_elapsed<?2 and is_prerun=False and is_observed=True", [trial_number, diff_sec])
		run_count_real = cursor.fetchone()

		cursor.execute("select count(*) from run where trial_number=?1 and sec_elapsed<?2 and geiger_more_even=True and is_prerun=False and is_observed=True", [trial_number, diff_sec])
		hit_count_real = cursor.fetchone()

		# calculate p-values
		if int(str(hit_count_all)[1:len(hit_count_all)-3]) > 0:
			prob_all_raw=binomtest(int(str(hit_count_all)[1:len(hit_count_all)-3]), int(str(run_count_all)[1:len(run_count_all)-3]), 0.5, alternative='greater')
			prob_all = 1-prob_all_raw.pvalue
		else:
			prob_all = 0

		if int(str(hit_count_obs)[1:len(hit_count_obs)-3]) > 0:
			prob_obs_raw=binomtest(int(str(hit_count_obs)[1:len(hit_count_obs)-3]), int(str(run_count_obs)[1:len(run_count_obs)-3]), 0.5, alternative='greater')		
			prob_obs = 1-prob_obs_raw.pvalue
		else:
			prob_obs = 0

		if int(str(hit_count_unobs)[1:len(hit_count_unobs)-3]) > 0:
			prob_unobs_raw=binomtest(int(str(hit_count_unobs)[1:len(hit_count_unobs)-3]), int(str(run_count_unobs)[1:len(run_count_unobs)-3]), 0.5, alternative='greater')		
			prob_unobs = 1-prob_unobs_raw.pvalue
		else:
			prob_unobs = 0	

		if int(str(hit_count_real)[1:len(hit_count_real)-3]) > 0:
			prob_real_raw=binomtest(int(str(hit_count_real)[1:len(hit_count_real)-3]), int(str(run_count_real)[1:len(run_count_real)-3]), 0.5, alternative='greater')		
			prob_real = 1-prob_real_raw.pvalue
		else:
			prob_real = 0

		end = datetime.now()
		diff = end - start
		diff_sec = diff.total_seconds()

		if float(prob_last) != float(prob_all):
			# print(f'Sec:{diff_sec}, Prob:{prob_all}')
			xvar.append(diff_sec)
			yvar.append(prob_all)
			ax1.clear()
			ax1.plot(xvar,yvar)
		
			# Insert overall results into result table
			cursor.execute("INSERT INTO result(trial_number,sec_elapsed,prob_all,prob_obs,prob_unobs,prob_real )VALUES(?,?,?,?,?,?)",(trial_number,diff_sec,prob_all,prob_obs,prob_unobs,prob_real))
			conn1.commit()


			# Play sound corresponding to overall probability
			  
			if prob_all > 0 and len(str(round((prob_all) * 100)))==2:
				freq_file = 'mp3/1' + str(round((prob_all) * 100)) + 'Hz.mp3'
			elif prob_all > 0 and len(str(round((prob_all) * 100)))==1:
				freq_file = 'mp3/10' + str(round((prob_all) * 100)) + 'Hz.mp3'
			else: 
				freq_file = 'mp3/100Hz.mp3'

			# First run
			if freq_last_set == 0:

				p1 = multiprocessing.Process(target=playsound, args=(freq_file,))
				p1.start()
				freq_last_set = 1

			elif freq_last_set == 1:

				p2 = multiprocessing.Process(target=playsound, args=(freq_file,))
				p2.start()
				time.sleep(.5)
				p1.terminate()

				freq_last_set = 2
				
			# else it equals 2
			else:

				p1 = multiprocessing.Process(target=playsound, args=(freq_file,))
				p1.start()
				time.sleep(.5)
				p2.terminate()

				freq_last_set = 1


		prob_last = prob_all

		conn1.close


	# Set defaults, mostly for global variables
	number_minutes = .5
	trial_number = 0 
	unobserved_run_count = 0
	prob_last = 0.0
	run_count_all = 0
	hit_count_all = 0
	run_count_obs = 0
	hit_count_obs = 0
	run_count_unobs = 0
	hit_count_unobs = 0
	run_count_real = 0
	hit_count_real = 0
	prob_all = 0.0
	prob_obs = 0.0
	prob_unobs = 0.0
	prob_real = 0.0
	freq_last_set = 0
	sound_number = 0
	p1 = multiprocessing.Process(target=playsound, args=('mp3/100Hz.mp3',))
	p2 = multiprocessing.Process(target=playsound, args=('mp3/100Hz.mp3',))


	print(f'')
	print(f'There will be three groups of numbers:')
	print(f'#1 - Pre-run, results must be observed.')
	print(f'#2 - Pre-run, results must NOT be observed.')
	print(f'#3 - Replays results from the first two groups and combines with new real-time results.')
	print(f'')
	print(f'Each group will last a little over {number_minutes} minutes.')
	print(f'')
	print(f'Your task is to increase the height of the line and/or the pitch of the sound of the third group.')
	print(f'')


	try:
		input("Press enter to kick off group #1 [Pre-run observed]")

	except SyntaxError:
		pass
	print(f'Group #1 running...')
	print(f'')

	trial_number = prerun_observed(number_minutes,)

	try:
		input("Press enter to kick off group #2 [Pre-run unobserved]")

	except SyntaxError:
		pass
	print(f'Group #2 running...')
	print(f'')

	unobserved_run_count = prerun_unobserved(trial_number, number_minutes)

	try:
		input("Press enter to kick off the final combined group")

	except SyntaxError:
		pass
	print(f'Group #3 running...')
	print(f'')

	# Set start time
	start = datetime.now()

	# Thread 1:
	t1 = threading.Thread(target=realtime, args=(trial_number, number_minutes,))
	t1.start()

	# Thread 2:
	t2 = threading.Thread(target=read_unobserved, args=(trial_number, unobserved_run_count, ))
	t2.start()

	# Thread 3:
	t3 = threading.Thread(target=results, args=( ))
	t3.start()


	# Initiate graph
	fig = plt.figure()			
	plt.title('Group results combined - Seconds vs. Probability (0-1)')

	# Need to hide these, otherwise the animation duplicates
	plt.xticks([])
	plt.yticks([])

	ax1 = fig.add_subplot(111)

	xvar = []
	yvar = []

	# This will loop the animate function -> interval * frames
	ani = animation.FuncAnimation(fig, animate, interval=100,frames = int(number_minutes*600), repeat = False)
	plt.show()

	p1.terminate()
	p2.terminate()