/** @module data */
/**
* Trial Handler
*
* @author Alain Pitiot
* @author Hiroyuki Sogo & Sotiri Bakagiannis - better support for BOM and accented characters
* @version 2022.2.3
* @copyright (c) 2017-2020 Ilixa Ltd. (http://ilixa.com) (c) 2020-2022 Open Science Tools Ltd. (https://opensciencetools.org)
* @license Distributed under the terms of the MIT License
*/
import seedrandom from "seedrandom";
import * as XLSX from "xlsx";
import { PsychObject } from "../util/PsychObject.js";
import * as util from "../util/Util.js";
/**
* <p>A Trial Handler handles the importing and sequencing of conditions.</p>
*
* @extends PsychObject
*/
export class TrialHandler extends PsychObject
{
/**
* Getter for experimentHandler.
*/
get experimentHandler()
{
return this._experimentHandler;
}
/**
* Setter for experimentHandler.
*/
set experimentHandler(exp)
{
this._experimentHandler = exp;
}
/**
* @param {Object} options - the handler options
* @param {module:core.PsychoJS} options.psychoJS - the PsychoJS instance
* @param {Array.<Object> | String} [options.trialList= [undefined] ] - if it is a string, we treat it as the name of a condition resource
* @param {number} options.nReps - number of repetitions
* @param {module:data.TrialHandler.Method} options.method - the trial method
* @param {Object} options.extraInfo - additional information to be stored alongside the trial data, e.g. session ID, participant ID, etc.
* @param {number} options.seed - seed for the random number generator
* @param {boolean} [options.autoLog= false] - whether or not to log
*
* @todo extraInfo is not taken into account, we use the expInfo of the ExperimentHandler instead
*/
constructor({
psychoJS,
trialList = [undefined],
nReps,
method = TrialHandler.Method.RANDOM,
extraInfo = [],
seed,
name,
autoLog = true,
} = {})
{
super(psychoJS);
this._addAttribute("trialList", trialList);
this._addAttribute("nReps", nReps);
this._addAttribute("method", method);
this._addAttribute("extraInfo", extraInfo);
this._addAttribute("name", name);
this._addAttribute("autoLog", autoLog);
this._addAttribute("seed", seed);
this._prepareTrialList();
// number of stimuli
this.nStim = this.trialList.length;
// the total number of trials that will be run:
this.nTotal = this.nReps * this.nStim;
// the total number of trial remaining
this.nRemaining = this.nTotal;
// the current repeat:
this.thisRepN = 0;
// the current trial number within the current repeat:
this.thisTrialN = -1;
// total number of trials completed so far:
this.thisN = -1;
// the index of the current trial in the conditions list
this.thisIndex = 0;
this.ran = 0;
this.order = -1;
// array of current snapshots:
this._snapshots = [];
// setup the trial sequence:
this._prepareSequence();
this._experimentHandler = null;
this.thisTrial = null;
this._finished = false;
}
/**
* Helps go through each trial in the sequence one by one, mirrors PsychoPy.
*/
next()
{
const trialIterator = this[Symbol.iterator]();
const { value } = trialIterator.next();
return value;
}
/**
* Iterator over the trial sequence.
*
* <p>This makes it possible to iterate over all trials.</p>
* @example
* let handler = new TrialHandler({nReps: 5});
* for (const thisTrial of handler) { console.log(thisTrial); }
*/
[Symbol.iterator]()
{
return {
next: () =>
{
this.thisTrialN++;
this.thisN++;
this.nRemaining--;
// check for the last trial:
if (this.nRemaining === 0)
{
// this only indicated that the scheduling is done, not that the loop is finished
// this.finished = true;
}
// start a new repetition:
if (this.thisTrialN === this.nStim)
{
this.thisTrialN = 0;
this.thisRepN++;
}
// check if we have completed the sequence:
if (this.thisRepN >= this.nReps)
{
this.thisTrial = null;
return { done: true };
}
this.thisIndex = this._trialSequence[this.thisRepN][this.thisTrialN];
this.thisTrial = this.trialList[this.thisIndex];
this.ran = 1;
this.order = this.thisN;
/*
if self.autoLog:
msg = 'New trial (rep=%i, index=%i): %s'
vals = (self.thisRepN, self.thisTrialN, self.thisTrial)
logging.exp(msg % vals, obj=self.thisTrial)*/
return { value: this.thisTrial, done: false };
},
};
}
/**
* Execute the callback for each trial in the sequence.
*
* @param callback
*/
forEach(callback)
{
const trialIterator = this[Symbol.iterator]();
while (true)
{
const result = trialIterator.next();
if (result.done)
{
break;
}
callback(result.value);
}
}
/**
* @typedef {Object} Snapshot
* @property {TrialHandler} handler - the trialHandler
* @property {string} name - the trialHandler name
* @property {number} nStim - the number of stimuli
* @property {number} nTotal - the total number of trials that will be run
* @property {number} nRemaining - the total number of trial remaining
* @property {number} thisRepN - the current repeat
* @property {number} thisTrialN - the current trial number within the current repeat
* @property {number} thisN - the total number of trials completed so far
* @property {number} thisIndex - the index of the current trial in the conditions list
* @property {number} ran - whether or not the trial ran
* @property {number} finished - whether or not the trials finished
* @property {Object} trialAttributes - a list of trial attributes
*/
/**
* Get a snapshot of the current internal state of the trial handler (e.g. current trial number,
* number of trial remaining).
*
* <p>This is typically used in the LoopBegin function, in order to capture the current state of a TrialHandler</p>
*
* @return {Snapshot} - a snapshot of the current internal state.
*/
getSnapshot()
{
const currentIndex = this.thisIndex;
const snapshot = {
handler: this,
name: this.name,
nStim: this.nStim,
nTotal: this.nTotal,
nRemaining: this.nRemaining,
thisRepN: this.thisRepN,
thisTrialN: this.thisTrialN,
thisN: this.thisN,
thisIndex: this.thisIndex,
ran: this.ran,
finished: this._finished,
getCurrentTrial: () => this.getTrial(currentIndex),
getTrial: (index = 0) => this.getTrial(index),
addData: (key, value) => this.addData(key, value),
};
// add to the snapshots the current trial's attributes:
const currentTrial = this.getCurrentTrial();
const excludedAttributes = ["handler", "name", "nStim", "nRemaining", "thisRepN", "thisTrialN", "thisN", "thisIndex", "ran", "finished"];
const trialAttributes = [];
for (const attribute in currentTrial)
{
if (!(attribute in excludedAttributes))
{
snapshot[attribute] = currentTrial[attribute];
trialAttributes.push(attribute);
}
else
{
this._psychoJS.logger.warn(`attempt to replace the value of protected TrialHandler variable: ${attribute}`);
}
}
snapshot.trialAttributes = trialAttributes;
// add the snapshot to the list:
this._snapshots.push(snapshot);
return snapshot;
}
/**
* Setter for the seed attribute.
*
* @param {boolean} seed - the seed value
* @param {boolean} log - whether or not to log the change of seed
*/
setSeed(seed, log)
{
this._setAttribute("seed", seed, log);
if (typeof seed !== "undefined")
{
this._randomNumberGenerator = seedrandom(seed);
}
else
{
this._randomNumberGenerator = seedrandom();
}
}
/**
* Set the internal state of the snapshot's trial handler from the snapshot.
*
* @param {Snapshot} snapshot - the snapshot from which to update the current internal state of the
* snapshot's trial handler
*/
static fromSnapshot(snapshot)
{
// if snapshot is undefined, do nothing:
if (typeof snapshot === "undefined")
{
return;
}
snapshot.handler.nStim = snapshot.nStim;
snapshot.handler.nTotal = snapshot.nTotal;
snapshot.handler.nRemaining = snapshot.nRemaining;
snapshot.handler.thisRepN = snapshot.thisRepN;
snapshot.handler.thisTrialN = snapshot.thisTrialN;
snapshot.handler.thisN = snapshot.thisN;
snapshot.handler.thisIndex = snapshot.thisIndex;
snapshot.handler.ran = snapshot.ran;
snapshot.handler._finished = snapshot._finished;
snapshot.handler.thisTrial = snapshot.handler.getCurrentTrial();
// add the snapshot's trial attributes to a global variable, whose name is derived from
// that of the handler: loops -> thisLoop (note the dropped s):
let name = snapshot.name;
if (name[name.length - 1] === "s")
{
name = name.substr(0, name.length - 1);
}
name = `this${name[0].toUpperCase()}${name.substr(1)}`;
const value = {};
for (const attribute of snapshot.trialAttributes)
{
value[attribute] = snapshot[attribute];
}
window[name] = value;
}
/**
* Getter for the finished attribute.
*
* @returns {boolean} whether or not the trial has finished.
*/
get finished()
{
return this._finished;
}
/**
* Setter for the finished attribute.
*
* @param {boolean} isFinished - whether or not the loop is finished.
*/
set finished(isFinished)
{
this._finished = isFinished;
this._snapshots.forEach((snapshot) =>
{
snapshot.finished = isFinished;
});
}
/**
* Get the trial index.
*
* @return {number} the current trial index
*/
getTrialIndex()
{
return this.thisIndex;
}
/**
* Set the trial index.
*
* @param {number} index - the new trial index
*/
setTrialIndex(index)
{
this.thisIndex = index;
}
/**
* Get the attributes of the trials.
*
* <p>Note: we assume that all trials in the trialList share the same attributes
* and consequently consider only the attributes of the first trial.</p>
*
* @return {Array.string} the attributes
*/
getAttributes()
{
if (!Array.isArray(this.trialList) || this.nStim === 0)
{
return [];
}
const firstTrial = this.trialList[0];
if (!firstTrial)
{
return [];
}
return Object.keys(this.trialList[0]);
}
/**
* Get the current trial.
*
* @return {Object} the current trial
*/
getCurrentTrial()
{
return this.trialList[this.thisIndex];
}
/**
* Get the nth trial.
*
* @param {number} index - the trial index
* @return {Object|undefined} the requested trial or undefined if attempting to go beyond the last trial.
*/
getTrial(index = 0)
{
if (index < 0 || index > this.nTotal)
{
return undefined;
}
return this.trialList[index];
}
/**
* Get the nth future or past trial, without advancing through the trial list.
*
* @param {number} [n = 1] - increment
* @return {Object|undefined} the future trial (if n is positive) or past trial (if n is negative)
* or undefined if attempting to go beyond the last trial.
*/
getFutureTrial(n = 1)
{
if (this.thisIndex + n < 0 || n > this.nRemaining)
{
return undefined;
}
return this.trialList[this.thisIndex + n];
}
/**
* Get the nth previous trial.
* <p> Note: this is useful for comparisons in n-back tasks.</p>
*
* @param {number} [n = -1] - increment
* @return {Object|undefined} the past trial or undefined if attempting to go prior to the first trial.
*/
getEarlierTrial(n = -1)
{
return getFutureTrial(-abs(n));
}
/**
* Add a key/value pair to data about the current trial held by the experiment handler
*
* @param {Object} key - the key
* @param {Object} value - the value
*/
addData(key, value)
{
if (this._experimentHandler)
{
this._experimentHandler.addData(key, value);
}
}
/**
* Import a list of conditions from a .xls, .xlsx, .odp, or .csv resource.
*
* <p>The output is suitable as an input to 'TrialHandler', 'trialTypes' or
* 'MultiStairHandler' as a 'conditions' list.</p>
*
* <p>The resource should contain one row per type of trial needed and one column
* for each parameter that defines the trial type. The first row should give
* parameter names, which should:
* <ul>
* <li>be unique</li>
* <li>begin with a letter (upper or lower case)</li>
* <li>contain no spaces or other punctuation (underscores are permitted)</li>
* </ul></p>
*
* <p>Note that we only consider the first worksheet for .xls, .xlsx and .odp resource.</p>
*
*
* <p> 'selection' is used to select a subset of condition indices to be used
* It can be a single integer, an array of indices, or a string to be parsed, e.g.:
* 5
* [1,2,3,10]
* '1,5,10'
* '1:2:5'
* '5:'
* '-5:-2, 9, 11:5:22'
*
* @param {module:core.ServerManager} serverManager - the server manager
* @param {String} resourceName - the name of the resource containing the list of conditions, which must have been registered with the server manager.
* @param {Object} [selection = null] - the selection
* @return {Object} the parsed conditions as an array of 'object as map'
* @throws {Object} Throws an exception if importing the conditions failed.
*/
static importConditions(serverManager, resourceName, selection = null)
{
try
{
const resourceExtension = resourceName.split(".").pop();
if (["csv", "odp", "xls", "xlsx"].indexOf(resourceExtension) > -1)
{
// (*) read conditions from resource:
const resourceValue = serverManager.getResource(resourceName, true);
// Conditionally use a `TextDecoder` to reprocess .csv type input,
// which is then read in as a string
const decodedResourceMaybe = new Uint8Array(resourceValue);
// Could be set to 'buffer' for ASCII .csv
const type = resourceExtension === "csv" ? "string" : "array";
const decodedResource = type === "string" ? (new TextDecoder()).decode(decodedResourceMaybe) : decodedResourceMaybe;
const workbook = XLSX.read(decodedResource, { type });
// we consider only the first worksheet:
if (workbook.SheetNames.length === 0)
{
throw "workbook should contain at least one worksheet";
}
const sheetName = workbook.SheetNames[0];
const worksheet = workbook.Sheets[sheetName];
// worksheet to array of arrays (the first array contains the fields):
const sheet = XLSX.utils.sheet_to_json(worksheet, { header: 1, blankrows: false });
const fields = sheet.shift();
// (*) select conditions:
const selectedRows = (selection === null) ? sheet : util.selectFromArray(sheet, selection);
// (*) return the selected conditions as an array of 'object as map':
// [
// {field0: value0-0, field1: value0-1, ...}
// {field0: value1-0, field1: value1-1, ...}
// ...
// ]
let trialList = new Array(selectedRows.length - 1);
for (let r = 0; r < selectedRows.length; ++r)
{
let row = selectedRows[r];
let trial = {};
for (let l = 0; l < fields.length; ++l)
{
let value = row[l];
// Look for string encoded arrays in the form of '[1, 2]'
const arrayMaybe = util.turnSquareBracketsIntoArrays(value);
if (Array.isArray(arrayMaybe))
{
// Keep the first match if more than one are found. If the
// input string looked like '[1, 2][3, 4]' for example,
// the resulting `value` would be [1, 2]. When `arrayMaybe` is
// empty, `value` turns `undefined`.
value = arrayMaybe;
}
if (typeof value === "string")
{
const numberMaybe = Number.parseFloat(value);
// if value is a numerical string, convert it to a number:
if (!isNaN(numberMaybe) && numberMaybe.toString().length === value.length)
{
value = numberMaybe;
}
else
{
// Parse doubly escaped line feeds
value = value.replace(/(\n)/g, "\n");
}
}
trial[fields[l]] = value;
}
trialList[r] = trial;
}
return trialList;
}
else
{
throw "extension: " + resourceExtension + " currently not supported.";
}
}
catch (error)
{
throw {
origin: "TrialHandler.importConditions",
context: `when importing condition: ${resourceName}`,
error,
};
}
}
/**
* Prepare the trial list.
*
* @protected
* @returns {void}
*/
_prepareTrialList()
{
const response = {
origin: "TrialHandler._prepareTrialList",
context: "when preparing the trial list",
};
// we treat undefined trialList as a list with a single empty entry:
if (typeof this._trialList === "undefined")
{
this.trialList = [undefined];
}
// if trialList is an array, we make sure it is not empty:
else if (Array.isArray(this._trialList))
{
if (this._trialList.length === 0)
{
this.trialList = [undefined];
}
}
// if trialList is a string, we treat it as the name of the condition resource:
else if (typeof this._trialList === "string")
{
this.trialList = TrialHandler.importConditions(this.psychoJS.serverManager, this._trialList);
}
// unknown type:
else
{
throw Object.assign(response, {
error: `unable to prepare trial list: unknown type: ${(typeof this._trialList)}`
});
}
}
/**
* Prepare the sequence of trials.
*
* <p>The returned sequence is a matrix (an array of arrays) of trial indices
* with nStim columns and nReps rows. Note that this is the transpose of the
* matrix return by PsychoPY.
*
* Example: with 3 trial and 5 repetitions, we get:
* - sequential:
* [[0 1 2]
* [0 1 2]
* [0 1 2]
* [0 1 2]
* [0 1 2]]
*
* These 3*5 = 15 trials will be returned by the TrialHandler generator
* - with method = 'sequential' in the order:
* 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2
* - with method = 'random' in the order (amongst others):
* 2, 1, 0, 0, 2, 1, 0, 1, 2, 0, 1, 2, 1, 2, 0
* - with method = 'fullRandom' in the order (amongst others):
* 2, 0, 0, 1, 0, 2, 1, 2, 0, 1, 1, 1, 2, 0, 2
* </p>
*
* @protected
**/
_prepareSequence()
{
const response = {
origin: "TrialHandler._prepareSequence",
context: "when preparing a sequence of trials",
};
// get an array of the indices of the elements of trialList:
const indices = Array.from(this.trialList.keys());
if (this._method === TrialHandler.Method.SEQUENTIAL)
{
this._trialSequence = Array(this.nReps).fill(indices);
// transposed version:
// this._trialSequence = indices.reduce( (seq, e) => { seq.push( Array(this.nReps).fill(e) ); return seq; }, [] );
}
else if (this._method === TrialHandler.Method.RANDOM)
{
this._trialSequence = [];
for (let i = 0; i < this.nReps; ++i)
{
this._trialSequence.push(util.shuffle(indices.slice(), this._randomNumberGenerator));
}
}
else if (this._method === TrialHandler.Method.FULL_RANDOM)
{
// create a flat sequence with nReps repeats of indices:
const flatSequence = [];
for (let i = 0; i < this.nReps; ++i)
{
flatSequence.push.apply(flatSequence, indices);
}
// shuffle the sequence:
util.shuffle(flatSequence, this._randomNumberGenerator);
// reshape it into the trialSequence:
this._trialSequence = [];
for (let i = 0; i < this.nReps; i++)
{
this._trialSequence.push(flatSequence.slice(i * this.nStim, (i + 1) * this.nStim));
}
}
else
{
throw Object.assign(response, { error: "unknown method" });
}
return this._trialSequence;
}
}
/**
* TrialHandler method
*
* @enum {Symbol}
* @readonly
*/
TrialHandler.Method = {
/**
* Conditions are presented in the order they are given.
*/
SEQUENTIAL: Symbol.for("SEQUENTIAL"),
/**
* Conditions are shuffled within each repeat.
*/
RANDOM: Symbol.for("RANDOM"),
/**
* Conditions are fully randomised across all repeats.
*/
FULL_RANDOM: Symbol.for("FULL_RANDOM"),
/**
* Same as above, but named to reflect PsychoPy boileplate.
*/
FULLRANDOM: Symbol.for("FULL_RANDOM"),
};