def startLogging(self): """ Start sending synchs and logging. """ # start logging LogTrack.startLogging(self) # check record state, maybe get new file, start recording if self.record_mode == "S": # is scalp, so start recording to new file self.dat_filename = 'eeg0.dat' # make sure we have a file name that doesn't already exist... n = 0 while self.archive.exists(self.dat_filename): n += 1 self.dat_filename = 'eeg%d.dat' % n self.dat_file = self.archive.createFile(self.dat_filename) self.dat_file.close() EEGRecStart(self.dat_file.name) # setup scalp callback self.last_align = timing.now() self.align_interval = 1000 addPollCallback(self.scalpCallback) elif self.record_mode == "P": # is pulse, so setup pulse callback self.last_align = timing.now() self.align_interval = 1000 self.pulseTrain(10, "EXPSTART_") addPollCallback(self.pulseCallback)
def test_all(): """ Runs a number of tests to check whether the python scripts of archive-update perform correctly. The name of the method needs to start with "test_" so that it gets picked up by py.test. """ import timing prepare_archive_data() timing.log('prepare_archive_data done', timing.now()) run_archive_update() timing.log('run_archive_update done', timing.now()) run_archive_reformat() timing.log('run_archive_reformat done', timing.now()) run_archive_split() timing.log('run_archive_split done', timing.now()) run_archive_thinning() timing.log('run_archive_thinning done', timing.now()) run_archive_analysis() timing.log('run_archive_analysis done', timing.now()) run_archive_difference() timing.log('run_archive_difference done', timing.now()) run_extract_extremes() timing.log('run_extract_extremes done', timing.now()) cleanup_archive_data() timing.log('cleanup_archive_data done', timing.now())
def callback(self, change): """ Callback used to communicate with parent Roller. The parent roller passes the amount that it is changeing to the callback. """ thistime = timing.now() elapsed = thistime - self.lasttime if not elapsed: self.accum = self.accum + change return change = change + self.accum self.accum = 0.0 thisvelocity = change / elapsed if self.maxAccel: if abs(thisvelocity - self.lastvelocity) / elapsed > self.maxAccel: if thisvelocity < self.lastvelocity: thisvelocity = self.lastvelocity - self.maxAccel * elapsed else: thisvelocity = self.lastvelocity + self.maxAccel * elapsed if self.maxVel: if thisvelocity > self.maxVel: thisvelocity = self.maxVel elif thisvelocity < -self.maxVel: thisvelocity = -self.maxVel self.lasttime = thistime self.lastvelocity = thisvelocity self.move(thisvelocity * elapsed)
def __init__(self, inc_button, dec_button, speed=1.0, backspeed=None, name=None): """ Create ButtonRoller where inc_button being pressed causes positive movement at speed roller units per millisecond and dec_button being pressed causes negative movement at speed roller units per millisecond. """ if name is None: name = "ButtonRoller from %s and %s" % (inc_button.name, dec_button.name) else: name = name if backspeed is None: backspeed = speed Roller.__init__(self, name) self.inc_button = inc_button self.dec_button = dec_button self.speed = speed self.backspeed = backspeed self.lasttime = timing.now()
def __playCallback__(self, s, ow, ampFactor): """ Timer for appending the remainder of a sound. """ currentTime = timing.now() if self.playing and currentTime >= self.last_play + self.play_interval: # see if stop the time if self.startInd < self.endInd: # determine how much to append actualInd = self.startInd + self.bytes_per_append # make sure it's not beyond the end if actualInd > self.endInd: # just set to the end actualInd = self.endInd # append the sound appended = self.eplsound.append( s[self.startInd:actualInd], len(s[self.startInd:actualInd]) / self.eplsound.FORMAT_SIZE, 0, ampFactor) self.last_play = currentTime # update the startInd if appended > 0: self.startInd += appended * self.eplsound.FORMAT_SIZE else: # no more sound if (self.eplsound.getSamplesPlayed() * self.eplsound.NUM_CHANNELS) >= self.total_samples: self.playStop()
def sendFreq(self, duration, freqhz, duration_is_cycles=False): """ Sends a train of pulses at a given frequency on TTL2 NOTE: MUST CALL configFreq FIRST TO GET ACCURATE RESULTS INPUT ARGS: duration - Duration of the train (defaults to seconds, can override with 3rd argument) freqhz - Frequency at which to stimulate in Hz duration_is_cycles - Whether duration provided is in seconds or number of pulses (default: False) """ if not self.labjack: raise (Exception('CAN ONLY USE THIS FUNCTION ON LABJACK')) # Time at which to send the pulse trainTime = timing.now() (timeInterval, returnValue) = timing.timedCall(\ trainTime,\ self.labjack.pulseTrain,\ duration,\ freqhz,\ duration_is_cycles) if duration_is_cycles: self.logMessage( 'STIM_TRAIN\t%d\t%d' % (int(round(float(duration) / freqhz)), freqhz), timeInterval) else: self.logMessage('STIM_TRAIN\t%d\t%d' % (duration, freqhz), timeInterval) return timeInterval
def process(self): if timing.now() < self.next_process: return 0 log.debug("Beginning Pool processing.") smtp = smtplib.SMTP(config.get('mail', 'server')) for fn in self.pick_files(): if not fn.startswith('m'): # Currently all messages are prefixed with an m. continue fqfn = os.path.join(config.get('paths', 'pool'), fn) f = open(fqfn, 'r') msg = email.message_from_file(f) f.close() log.debug("Pool processing: %s", fn) if not 'To' in msg: log.warn("%s: Malformed pool message. No recipient " "specified.", fn) continue msg["Message-ID"] = Utils.msgid() msg["Date"] = email.Utils.formatdate() msg["From"] = "%s <%s>" % (config.get('general', 'longname'), config.get('mail', 'address')) try: smtp.sendmail(msg["From"], msg["To"], msg.as_string()) log.debug("Email sent to: %s", msg["To"]) except smtplib.SMTPRecipientsRefused, e: log.warn("SMTP failed with: %s", e) self.delete(fqfn)
def date_expired(self, expires): if type(expires) == str: expires = timing.dateobj(expires) try: return expires < timing.now() except ValueError: # If the date is corrupt, assume it's expired return True
def date_prevalid(self, created): if type(created) == str: created = timing.dateobj(created) try: return created > timing.now() except ValueError: # If the date is corrupt, assume it's prevalid return True
def setPosition(self, p, timestamp=None): """ Set the position of this axis between 1.0 and -1.0. """ if p != self.position: if timestamp == None: timestamp = (timing.now(), long(0)) self.position = p for c, args in self.callbacks.items(): c(p, timestamp, *args)
def setPressed(self, p, timestamp=None): """ Set the pressed state of this button (True or False). """ if p != self.pressed: if timestamp == None: timestamp = (timing.now(), long(0)) self.presstime = timestamp self.pressed = p for c, args in self.callbacks.items(): c(p, timestamp, *args)
def prune(self): if timing.now() > self.nextday: log.info("Performing daily prune of partial chunk log.") for messageid in self.pktlog.keys(): if self.pktlog[messageid]['age'] > self.pktexp: log.info("Deleting chunks due to packet expiration. " "A message will be lost but we can't wait " "forever.") self.delete(messageid) else: self.pktlog[messageid]['age'] += 1 self.nextday = timing.future(days=1)
def update(self): """ Update the Roller's movement in a time-consistent manner. """ Roller.update(self) thistime = timing.now() elapsed = thistime - self.lasttime if elapsed: if (self.inc_button.isPressed()): self.move(elapsed * self.speed) if (self.dec_button.isPressed()): self.move(elapsed * -self.backspeed) self.lasttime = thistime
def flush(self): """ Flush the recording buffer. """ currentTime = timing.now() newstuff = self.getBuffData() # Update the last time self.last_rec = currentTime if len(newstuff) > 0: # append the data to the clip self.recClip.append(newstuff, self.eplsound.getRecChans())
def scalpCallback(self): """ Callback to make logs using the real-time scalp interface. """ # is it time to do another alignment? if timing.now() >= self.last_align + self.align_interval: # query for offset (timeInterval, offset) = timing.timedCall(None, EEGGetOffset) # get info for log message self.logMessage("%s\t%s" % (self.dat_filename, offset), timeInterval) # update last_align self.last_align = timeInterval[0]
def update(self): """ Update the change for this roller in a time-consistent manner. """ Roller.update(self) thistime = timing.now() elapsed = thistime - self.lasttime if elapsed: norm = self.axis.getNormalized() if norm > 0: self.move(elapsed * self.speedfactor * norm) else: self.move(elapsed * self.backwardspeedfactor * norm) self.lasttime = thistime
def __recCallback__(self): """ Internal callback function, only for use by pyEpl functions. Thread function for recording, called by startRecording. """ currentTime = timing.now() if self.recording and currentTime >= self.last_rec + self.rec_interval: newstuff = self.getBuffData() # Update the last time self.last_rec = currentTime if len(newstuff) > 0: # append the data to the clip self.recClip.append(newstuff, self.eplsound.getRecChans())
def clientLowNow(self, clk=None): """ Do a non-blocking low on channel 2 """ if self.labjack == None: raise EPLPulseEEGException( "Client pulse methods are only callable with multiple outputs." ) if clk is None: # no clock, so use time clk = timing.now() (timeInterval, returnValue) = timing.timedCall(clk, self.labjack.setChannel2Low) pulsePrefix = "CHANNEL_2_" self.logMessage("%s" % pulsePrefix + "DN", timeInterval)
def pulseCallback(self): """ Callback to manage sending pulses. """ minInterPulsetime = 750 maxInterPulseTime = 1250 pulseLen = 10 #in milliseconds if timing.now() >= self.last_align + self.align_interval: timeInterval = self.timedPulse(pulseLen) # randomize the alignment interval self.align_interval = random.uniform(minInterPulsetime, maxInterPulseTime) # update last_align self.last_align = timeInterval[0]
def __init__(self, axis, maxVel=None, maxAccel=None, name=None): """ """ if name == None: name = "ThrottledAxis from %s" % axis.name else: name = name Axis.__init__(self, name, axis.posmin, axis.posmax) self.axis = axis self.lasttime = timing.now() self.lastpos = axis.getPosition() self.lastspeed = 0.0 self.maxVel = maxVel self.maxAccel = maxAccel self.cb = MethodCallback(self.callback) axis.addCallback(self.cb) self.parents = (axis, )
def logMessage(self, message, timestamp=None): """ Add message to log. INPUT ARGS: message- String to add to log. timestamp- Timestamp for this log entry. If this is None, then the current time used as the timestamp. """ if self.logall: if isinstance(timestamp, exputils.PresentationClock): timestamp = (timestamp.get(), 0L) elif timestamp is None: timestamp = (timing.now(), 0L) elif not isinstance(timestamp, tuple): timestamp = (timestamp, 0L) self.dataFile.seek(0, 2) # seek to end of file self.dataFile.write("%s\t%s\t%s\n" % (timestamp[0], timestamp[1], message))
def prune(self): """Check if a day has passed since the last prune operation. If it has, increment the day counter on each stored packetid. If the count exceeeds the expiry period then delete the id from the log. """ if timing.now() > self.nextday: log.info("Performing daily prune of packetid log.") before = len(self.idlog) deleted = 0 for k in self.idlog.keys(): if self.idlog[k] > self.idexp: del self.idlog[k] deleted += 1 else: self.idlog[k] += 1 self.idlog.sync() self.nextday = timing.future(days=1) after = len(self.idlog) log.info("Packet ID prune complete. Before=%s, Deleted=%s, " "After=%s.", before, deleted, after)
def __init__(self, axis, speedfactor=1.0, backwardspeedfactor=None, name=None): """ Create AxisRoller from axis with specified speedfactor (defaults to 1.0). Speedfactor units are roller units per millisecond per axis unit. """ if name == None: name = "AxisRoller from %s" % axis.name else: name = name if backwardspeedfactor is None: backwardspeedfactor = speedfactor Roller.__init__(self, name) self.axis = axis self.speedfactor = speedfactor self.backwardspeedfactor = backwardspeedfactor self.lasttime = timing.now()
def __playLoopCallback__(self, ow, ampFactor): """ Timer for appending the remainder of a sound. """ currentTime = timing.now() if self.playing and currentTime >= self.last_play + self.play_interval: # see if stop the time if self.startInd < self.endInd: # do the sound s = self.currentClip.snd # determine how much to append toplay = self.eplsound.getBufferUsed() toappend = self.bytes_per_append - toplay if toappend <= 0: return actualInd = self.startInd + toappend # self.bytes_per_append # make sure it's not beyond the end if actualInd > self.endInd: # just set to the end actualInd = self.endInd # append the sound appended = self.eplsound.append( s[self.startInd:actualInd], len(s[self.startInd:actualInd]) / self.eplsound.FORMAT_SIZE, 0, ampFactor) self.last_play = currentTime # update the startInd if appended > 0: self.startInd += appended * self.eplsound.FORMAT_SIZE else: # no more sound, so start again right away self.startInd = 0
def __init__(self, roller, maxAccel=None, maxVel=None, name=None): """ Create a ThrottledRoller with maxAccel roller units per millisecond per millisecond maximum acceleration and maxVel roller units per millisecond maximum velocity. None for either of those values means that the constraint will not be applied. """ if name == None: name = "ThrottledRoller from %s" % roller.name else: name = name Roller.__init__(self, name) self.roller = roller self.parents = [roller] self.maxAccel = maxAccel self.maxVel = maxVel self.accum = 0.0 self.lastvelocity = 0.0 self.lasttime = timing.now() self.cb = MethodCallback(self.callback) roller.addCallback(self.cb)
def record(self, duration, basename=None, t=None, **sfargs): """ Perform a blocked recording for a specified duration (in milliseconds). INPUT ARGS: duration- length of time (in ms.) to record for. basename- filename to save recorded data to. t- optional PresentationClock for timing. sfargs- keyword arguments passed to FileAudioClip constructor OUTPUT ARGS: recClip- The AudioClip object that contains the recorded data. timestamp- time and latency when sound recording began. """ if not t: t = timing.now() elif isinstance(t, exputils.PresentationClock): clk = t t = clk.get() clk.delay(duration) (r, starttime) = self.startRecording(basename, t=t, **sfargs) (r, stoptime) = self.stopRecording(t=t + duration) return (r, starttime)
def configFreq(self, frequency): """ Configures stimulation so that stimulation trains can happen more quickly NOTE: ONLY FUNCTIONS ON TTL2 INPUT ARGS: frequency - the frequency (Hz) at which to configure """ # Log the frequency self.logMessage("CONFIG\t%d" % frequency) # Set the time at which to configure configTime = timing.now() if not self.labjack: raise (Exception('CAN ONLY CONFIGURE FREQUENCY ON LABJACK')) (timeInterval, returnValue)=timing.timedCall(configTime,\ self.labjack.configFreq,\ frequency) return timeInterval
def pulseTrain(self, numPulses, trainName=""): """ Send a train of pulses. INPUT ARGS: numPulses- Number of pulses in train. trainName- Name to use in the log. """ #trainLen denotes the number of pulses in this train pulseLen = 10 #in milliseconds interPulseInterval = 5 self.logMessage(trainName + "TRAIN") # set the desired pulsetime pulseTime = timing.now() for i in range(numPulses): # send a pulse (timeInterval, returnValue) = timing.timedCall(pulseTime, self.timedPulse, pulseLen, 'TRAIN_') # pause for the next pulse pulseTime += interPulseInterval
def timedStim(self, duration, freq, doRelay=False): ''' Start a sync box controlled train of pulses to trigger a stimulator. INPUT ARGS: duration - duration of stimulation (s) freq - frequency to send pulse (Hz) ''' # use the current time clk = timing.now() # only labjack boxes support stimulation if self.labjack: (timeInterval, returnValue) = timing.timedCall(clk, self.labjack.StartStim, duration, freq, doRelay) # log start of stimulation self.logMessage("STIM_ON", timeInterval) return timeInterval else: raise EPLPulseEEGException( "timedStim only functions with labjack autostim boards.")
def trigger(self): return timing.now() >= self.trigger_time
parser = argparse.ArgumentParser() parser.add_argument('-f', '--functions', type=parse_range, default=range(1, 56), help='function numbers to be included in the processing of archives') parser.add_argument('-i', '--instances', type=parse_range, default=range(1, 11), help='instance numbers to be included in the processing of archives') parser.add_argument('-d', '--dimensions', type=parse_range, default=[2, 3, 5], help='dimensions to be included in the processing of archives') parser.add_argument('-l', '--lower_bound', type=float, default=-5.0, help='lower bound of the decision space') parser.add_argument('-u', '--upper_bound', type=float, default=5.0, help='upper bound of the decision space') parser.add_argument('output', help='path to the output folder') parser.add_argument('summary', help='file name for the summary') parser.add_argument('input', help='path to the input folder') args = parser.parse_args() print('Program called with arguments: \ninput folder = {}\noutput folder = {}'.format(args.input, args.output)) print('summary file = {}'.format(args.summary)) print('functions = {} \ninstances = {}\ndimensions = {}'.format(args.functions, args.instances, args.dimensions)) print('lower bound = {} \nupper bound = {}\n'.format(args.lower_bound, args.upper_bound)) # Analyze the archives archive_analysis(args.input, args.output, args.lower_bound, args.upper_bound, args.functions, args.instances, args.dimensions) timing.log('Finished reading data', timing.now()) summary_analysis(args.output, args.summary, args.lower_bound, args.upper_bound, args.functions, args.instances, args.dimensions)
parser.add_argument('input', default=[], nargs='+', help='path(s) to the input folder(s)') args = parser.parse_args() print( 'Program called with arguments: \ninput folders = {}\noutput folder = {}' .format(args.input, args.output)) print('functions = {} \ninstances = {}\ndimensions = {}\n'.format( args.functions, args.instances, args.dimensions)) # Merge the archives new_hypervolumes = merge_archives(args.input, args.output, args.functions, args.instances, args.dimensions, args.crop_variables) timing.log('Finished merging', timing.now()) # Use files with best hypervolume values from the src folder and update them with the new best values if not args.merge_only: base_path = os.path.dirname(__file__) file_names = ['suite_biobj_best_values_hyp.c'] file_names = [ os.path.abspath( os.path.join(base_path, '..', '..', 'code-experiments/src', file_name)) for file_name in file_names ] update_best_hypervolume(file_names, new_hypervolumes, os.path.join(args.output, '..', args.hyp_file))
def mathDistract(clk=None, mathlog=None, problemTimeLimit=None, numVars=2, maxNum=9, minNum=1, maxProbs=50, plusAndMinus=False, minDuration=20000, textSize=None, correctBeepDur=500, correctBeepFreq=400, correctBeepRF=50, correctSndFile=None, incorrectBeepDur=500, incorrectBeepFreq=200, incorrectBeepRF=50, incorrectSndFile=None, tfKeys=None, ansMod=[0, 1, -1, 10, -10], ansProb=[.5, .125, .125, .125, .125], visualFeedback=False): """ Math distractor for specified period of time. Logs to a math_distract.log if no log is passed in. INPUT ARGS: clk - Optional PresentationClock for timing. mathlog - Optional Logtrack for logging. problemTimeLimit - set this param for non-self-paced distractor; buzzer sounds when time's up; you get at least minDuration/problemTimeLimit problems. numVars - Number of variables in the problem. maxNum - Max possible number for each variable. minNum - Min possible number for each varialbe. maxProbs - Max number of problems. plusAndMinus - True will have both plus and minus. minDuration - Minimum duration of distractor. textSize - Vertical height of the text. correctBeepDur - Duration of correct beep. correctBeepFreq - Frequency of correct beep. correctBeepRF - Rise/Fall of correct beep. correctSndFile - Optional Audio clip to use for correct notification. incorrectBeepDur - Duration of incorrect beep. incorrectBeepFreq - Frequency of incorrect beep. incorrectBeepRF - Rise/Fall of incorrect beep incorrectSndFile - Optional AudioClip used for incorrect notification. tfKeys - Tuple of keys for true/false problems. e.g., tfKeys = ('T','F') ansMod - For True/False problems, the possible values to add to correct answer. ansProb - The probability of each modifer on ansMod (must add to 1). visualFeedback - Whether to provide visual feedback to indicate correctness. """ # start the timing start_time = timing.now() # get the tracks v = display.VideoTrack.lastInstance() a = sound.AudioTrack.lastInstance() k = keyboard.KeyTrack.lastInstance() # see if need logtrack if mathlog is None: mathlog = LogTrack('math_distract') # log the start mathlog.logMessage('START') # start timing if clk is None: clk = exputils.PresentationClock() # set the stop time if not minDuration is None: stop_time = start_time + minDuration else: stop_time = None # generate the beeps correctBeep = sound.Beep(correctBeepFreq, correctBeepDur, correctBeepRF) incorrectBeep = sound.Beep(incorrectBeepFreq, incorrectBeepDur, incorrectBeepRF) # clear the screen (now left up to caller of function) #v.clear("black") # generate a bunch of math problems vars = numpy.random.randint(minNum, maxNum + 1, [maxProbs, numVars]) if plusAndMinus: pm = numpy.sign(numpy.random.uniform(-1, 1, [maxProbs, numVars - 1])) else: pm = numpy.ones([maxProbs, numVars - 1]) # see if T/F or numeric answers if isinstance(tfKeys, tuple): # do true/false problems tfProblems = True # check the ansMod and ansProb if len(ansMod) != len(ansProb): # raise error pass if sum(ansProb) != 1.0: # raise error pass ansProb = numpy.cumsum(ansProb) else: # not t/f problems tfProblems = False # set up the answer button if tfProblems: # set up t/f keys ans_but = k.keyChooser(*tfKeys) else: # set up numeric entry ans_but = k.keyChooser('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', 'RETURN', '[0]', '[1]', '[2]', '[3]', '[4]', '[5]', '[6]', '[7]', '[8]', '[9]', '[-]', 'ENTER', 'BACKSPACE') # do equations till the time is up curProb = 0 while not (not stop_time is None and timing.now() >= stop_time) and curProb < maxProbs: # generate the string and result # loop over each variable to generate the problem probtxt = '' for i, x in enumerate(vars[curProb, :]): if i > 0: # add the sign if pm[curProb, i - 1] > 0: probtxt += ' + ' else: probtxt += ' - ' # add the number probtxt += str(x) # calc the correct answer cor_ans = eval(probtxt) # add the equal sign probtxt += ' = ' # do tf or numeric problem if tfProblems: # determine the displayed answer # see which answermod ansInd = numpy.nonzero(ansProb >= numpy.random.uniform(0, 1)) if isinstance(ansInd, tuple): ansInd = ansInd[0] ansInd = min(ansInd) disp_ans = cor_ans + ansMod[ansInd] # see if is True or False if disp_ans == cor_ans: # correct response is true corRsp = tfKeys[0] else: # correct response is false corRsp = tfKeys[1] # set response str rstr = str(disp_ans) else: rstr = '' # display it on the screen pt = v.showProportional(display.Text(probtxt, size=textSize), .4, .5) rt = v.showRelative(display.Text(rstr, size=textSize), display.RIGHT, pt) probstart = v.updateScreen(clk) # wait for input answer = .12345 # not an int hasMinus = False if problemTimeLimit: probStart = timing.now() probEnd = probStart + problemTimeLimit curProbTimeLimit = probEnd - probStart else: curProbTimeLimit = None # wait for keypress kret, timestamp = ans_but.waitWithTime(maxDuration=curProbTimeLimit, clock=clk) # process as T/F or as numeric answer if tfProblems: # check the answer if not kret is None and kret.name == corRsp: isCorrect = 1 else: isCorrect = 0 else: # is part of numeric answer while kret and \ ((kret.name != "RETURN" and kret.name != "ENTER") or \ (hasMinus is True and len(rstr)<=1) or (len(rstr)==0)): # process the response if kret.name == 'BACKSPACE': # remove last char if len(rstr) > 0: rstr = rstr[:-1] if len(rstr) == 0: hasMinus = False elif kret.name == '-' or kret.name == '[-]': if len(rstr) == 0 and plusAndMinus: # append it rstr = '-' hasMinus = True elif kret.name == 'RETURN' or kret.name == 'ENTER': # ignore cause have minus without number pass elif len(rstr) == 0 and (kret.name == '0' or kret.name == '[0]'): # Can't start a number with 0, so pass pass else: # if its a number, just append numstr = kret.name.strip('[]') rstr = rstr + numstr # update the text rt = v.replace(rt, display.Text(rstr, size=textSize)) v.updateScreen(clk) # wait for another response if problemTimeLimit: curProbTimeLimit = probEnd - timing.now() else: curProbTimeLimit = None kret, timestamp = ans_but.waitWithTime( maxDuration=curProbTimeLimit, clock=clk) # check the answer if len(rstr) == 0 or eval(rstr) != cor_ans: isCorrect = 0 else: isCorrect = 1 # give feedback if isCorrect == 1: # play the beep pTime = a.play(correctBeep, t=clk, doDelay=False) #clk.tare(pTime[0]) #correctBeep.present(clk) # see if set color of text if visualFeedback: pt = v.replace( pt, display.Text(probtxt, size=textSize, color='green')) rt = v.replace( rt, display.Text(rstr, size=textSize, color='green')) v.updateScreen(clk) clk.delay(correctBeepDur) else: # play the beep pTime = a.play(incorrectBeep, t=clk, doDelay=False) #clk.tare(pTime[0]) #incorrectBeep.present(clk) # see if set color of text if visualFeedback: pt = v.replace( pt, display.Text(probtxt, size=textSize, color='red')) rt = v.replace(rt, display.Text(rstr, size=textSize, color='red')) v.updateScreen(clk) clk.delay(incorrectBeepDur) # calc the RT as (RT, maxlatency) prob_rt = (timestamp[0] - probstart[0], timestamp[1] + probstart[1]) # log it # probstart, PROB, prob_txt, ans_txt, Correct(1/0), RT mathlog.logMessage( 'PROB\t%r\t%r\t%d\t%ld\t%d' % (probtxt, rstr, isCorrect, prob_rt[0], prob_rt[1]), probstart) # clear the problem v.unshow(pt, rt) v.updateScreen(clk) # increment the curprob curProb += 1 # log the end mathlog.logMessage('STOP', timestamp)
def timedPulse(self, pulseTime, pulsePrefix='', signal='', clk=None, output_channel=0): """ Send a pulse and log it. INPUT ARGS: pulseTime- Duration of pulse. pulsePrefix- Name to log the pulse. """ # see if using clock usingClock = True if clk is None: # no clock, so use time clk = timing.now() usingClock = False if self.awCard: if len(signal) > 0: (timeInterval, returnValue) = timing.timedCall(clk, self.awCard.write, signal) else: (timeInterval, returnValue) = timing.timedCall(clk, self.awCard.allOn) elif self.labjack: (timeInterval, returnValue) = timing.timedCall(clk, self.labjack.setFIOState, output_channel, 0 if output_channel == 4 else 1) pulsePrefix = "CHANNEL_" + str(output_channel) + "_" else: if len(signal) > 0: (timeInterval, returnValue) = timing.timedCall(clk, self.parallel.setSignal, True, signal) else: (timeInterval, returnValue) = timing.timedCall(clk, self.parallel.setState, True) self.logMessage("%s" % pulsePrefix + "UP", timeInterval) # wait for the pulse time if usingClock: clk.delay(pulseTime) else: clk = clk + pulseTime if self.awCard: (timeInterval, returnValue) = timing.timedCall(clk, self.awCard.allOff) elif self.labjack: (timeInterval, returnValue) = timing.timedCall(clk, self.labjack.setFIOState, output_channel, 1 if output_channel == 4 else 0) else: (timeInterval, returnValue) = timing.timedCall(clk, self.parallel.setState, False) self.logMessage("%s" % pulsePrefix + "DN", timeInterval) # I'm not sure when if you want this to be the start or end of the pulse return timeInterval
parser = argparse.ArgumentParser() parser.add_argument('-f', '--functions', type=parse_range, default=range(1, 56), help='function numbers to be included in the processing of archives') parser.add_argument('-i', '--instances', type=parse_range, default=range(1, 11), help='instance numbers to be included in the processing of archives') parser.add_argument('-d', '--dimensions', type=parse_range, default=[2, 3, 5], help='dimensions to be included in the processing of archives') parser.add_argument('-l', '--lower_bound', type=float, default=-5.0, help='lower bound of the decision space') parser.add_argument('-u', '--upper_bound', type=float, default=5.0, help='upper bound of the decision space') parser.add_argument('output', help='path to the output folder') parser.add_argument('summary', help='file name for the summary') parser.add_argument('input', default=[], nargs='+', help='path(s) to the input folder(s)') args = parser.parse_args() print('Program called with arguments: \ninput folders = {}\noutput folder = {}'.format(args.input, args.output)) print('summary file = {}'.format(args.summary)) print('functions = {} \ninstances = {}\ndimensions = {}'.format(args.functions, args.instances, args.dimensions)) print('lower bound = {} \nupper bound = {}\n'.format(args.lower_bound, args.upper_bound)) # Analyze the archives archive_analysis(args.input, args.output, args.lower_bound, args.upper_bound, args.functions, args.instances, args.dimensions) timing.log('Finished reading data', timing.now()) summary_analysis(args.output, args.summary, args.lower_bound, args.upper_bound, args.functions, args.instances, args.dimensions)
parser.add_argument('-i', '--instances', type=parse_range, default=range(1, 16), help='instance numbers to be included in the processing of archives') parser.add_argument('-d', '--dimensions', type=parse_range, default=[2, 3, 5, 10, 20, 40], help='dimensions to be included in the processing of archives') parser.add_argument('--merge-only', action='store_true', help='perform only merging of archives, do not update hypervolume values') parser.add_argument('--crop-variables', action='store_true', help='don\'t include information on the variables in the output archives') parser.add_argument('--hyp-file', default='new_best_values_hyp.c', help='name of the file to store new hypervolume values') parser.add_argument('output', help='path to the output folder') parser.add_argument('input', default=[], nargs='+', help='path(s) to the input folder(s)') args = parser.parse_args() print('Program called with arguments: \ninput folders = {}\noutput folder = {}'.format(args.input, args.output)) print('functions = {} \ninstances = {}\ndimensions = {}\n'.format(args.functions, args.instances, args.dimensions)) # Merge the archives new_hypervolumes = merge_archives(args.input, args.output, args.functions, args.instances, args.dimensions, args.crop_variables) timing.log('Finished merging', timing.now()) # Use files with best hypervolume values from the src folder and update them with the new best values if not args.merge_only: base_path = os.path.dirname(__file__) file_names = ['suite_biobj_best_values_hyp.c'] file_names = [os.path.abspath(os.path.join(base_path, '..', '..', 'code-experiments/src', file_name)) for file_name in file_names] update_best_hypervolume(file_names, new_hypervolumes, os.path.join(args.output, '..', args.hyp_file))
def update(self): """ """ self.callback(self.axis.getPosition(), (timing.now(), long(0)))