API

• Core
  • Overview
  • API
  • Scorer
  • Resources
  • Playground
• Tutorials
  • Hello World
    • Playground
  • Slide show
    • step1
    • step2
    • step3
  • Stroop
    • Setup
    • Interactions
    • inheritance
    • Blocks
    • Task
• Examples
  • IAT
  • AMP
  • BIAT
  • GNAT
  • SPF
  • ST-IAT
  • Evaluative priming
  • Evaluative priming 2
• Snippets
  • Inheritance
  • Input
  • Interactions
  • Sequence
  • Settings
  • Stimulus
  • Touch
  • Trial

The Scorer component of the miTime is an implementation of the D-score algorithm for computing IAT scores. The scorer allows creating an appropriate feedback message for the users, as well as logging them to the server. In order to compute the score the trials are divided to parcels, the score for each parcel is computed and then the scores are averaged.

Table of contents

• How to Use
• Settings: compute
  • Parcels
  • errorLatency
• Settings: message
• Posting to the server.
  • dynamicPost
  • postToServer

How to Use

Create instance of the scorer:

var scorer = new Scorer();

Set the settings for the scorer as covered in compute, and messages.

The scorer has two sets of settings; compute, and messages. The first has to do with the way the score is computed, the second allows you to customize the feedback messages that the scorer creates. Each takes an object with an assortment of properties as described below. You can set the different settings using the following commands:

scorer.addSettings('compute',computeObj);
scorer.addSettings('message',messageObj);

Get the score and the message from the scorer (make sure that you do this in a function that is called at the end of the miTime task, after the scores are collected);

var DScoreObj = scorer.computeD();

computeD

The computeD function activates the scorer and returns an object with the score and feedback message.

var DScoreObj = scorer.computeD();

The DscoreObj has the following properties:

Settings: compute

The compute settings affects the way that the final score is computed. In order to use it you set an object into the compute setting. The available properties are described below.

scorer.addSettings('compute',{
    property : value
});

Parcels

First we set up the parcels:

scorer.addSettings('compute',{
        ...
        parcelVar : "parcel",
        parcelValue : ['first','second'],
        ...
});

Then set up the assorted trial parcels.

    {
        data: {parcel:'first' ...},
        ...
    },
    {
        data: {parcel:'second' ...},
        ...
    }

Each parcel will be computed separately, and the final score will be the average of all parcels.

errorLatency

The errorLatency property takes an object with the following properties.

The following examples shows a setting that penalizes mistakes by 600ms, and includes them in variance calculations.

scorer.addSettings('compute',{
        ....
        errorLatency : {use:"penalty", penalty:600, useForSTD:true},
        ....
}

Settings: message

The message setting affects the feedback messages that the scorer produces. In order to use it you set an object into the message setting. The available properties are described below.

scorer.addSettings('message',{
    property : value
});

For example:

    scorer.addSettings('message',{
        manyErrors: "There were too many errors made to determine a result.",
        tooFast: "There were too many fast trials to determine a result.",
        notEnough: "There were not enough trials to determine a result."
        MessageDef: [
            { cut:'-0.65', message:'strong preference left' },
            { cut:'-0.35', message:'moderate preference left' },
            { cut:'-0.15', message:'slight preference left' },
            { cut:'0.15', message:'little to no preference' },
            { cut:'0.35', message:'slight preference right' },
            { cut:'0.65', message:'moderate preference right' },
            { cut:'5', message:'strong preference right' }
        ]
    });

Posting to the server.

The scorer offers two methods for posting scorer data to the server. The preferable method is using the scorer function dynamicPost. We keep the deprecated function postToServer only for backward compatibility.

You can and should set the post settings in the postSettings property of the compute setting. Most notably, that is where you set the target URL.

scorer.addSettings('compute',{
    postSettings : {score:"score",msg:"feedback",url:"/implicit/scorer"}
});

dynamicPost

This function takes an object, jsonifies it, and sends it to the server. It returns a jQuery promise so you can do anything that you like after it finishes.

// Compute score
var DScoreObj = scorer.computeD();
// Post to the server
scorer.dynamicPost({
    score: DScoreObj.DScore,
    feedback: DScoreObj.FBMsg
}).always(function(){ // always run the following code, even if the post failed.
    top.location.href = "/my/next/url/";
});

postToServer

This method is deprecated. Use dynamicPost instead.

If you need to use it anyway, The syntax is like so:

// Compute score
var DScoreObj = scorer.computeD();
var score = DScoreObj.DScore,
var feedback = DScoreObj.FBMsg
var score = 'score';
var msg = 'feedback';

// post to server
scorer.postToServer(score, msg, scoreKey, msgKey);

Where the arguments are as follows: