simplereactionhandler.cpp

Go to the documentation of this file.

// PTF - Psychological Test Framework
// http://ptf.sourceforge.net
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Library General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

#include <ptf/core/simplereactionhandler.hpp>
#include <ptf/core/ptfcore.hpp>
#include <iostream>

// bring stuff into scope
using std::cout;
using std::endl;

SimpleReactionHandler::SimpleReactionHandler() {
    lastRRec = 0;
}

SimpleReactionHandler::~SimpleReactionHandler() {
    // nothing to do here
}

void SimpleReactionHandler::handle() {
    // get refernce to PtfCore
    PtfCore& ptf = PtfCore::getSingleton();
    // get latest task record
    TaskRecord* taskRec = ptf.getTaskRecords().back();
    // get buttons
    const vector<bool> buttonsSuccess = ptf.getTasks()[taskRec->getId()]->getSuccessfulReaction();
    // calculate window in which reaction has to happen
    timespec executeStart, executeEnd, taskStart, taskEnd, dummy, reactionWindowStart, reactionWindowEnd;
    taskRec->getTimestampE().getInterval(executeStart, executeEnd);
    ptf.getTasks()[taskRec->getId()]->getReactionWindow().getInterval(reactionWindowStart, reactionWindowEnd);
    timespec windowStart = TimeInterval::addTimespecs(executeEnd, reactionWindowStart);
    timespec windowEnd = TimeInterval::addTimespecs(executeEnd, reactionWindowEnd);
    // get timespec of task start/end
    taskRec->getTimestampP().getInterval(taskStart, dummy);
    taskRec->getTimestampF().getInterval(dummy, taskEnd);
    // enter reaction record queue mutex while handling
    ptf.getReactionRecordsMutex().enterMutex();
    // check for reactions
    if (lastRRec == (int)ptf.getReactionRecords().size()) {
        // no reactions
        if ((int)buttonsSuccess.size() == 0) {
            // no reaction is right reaction
            ptf.getHandlerLog() << "Reaction handler:\n"
                << "\tNo reactions. Correct.\n";
            // machine log
            ptf.getMachineLog() << lastRRec << " "  
                << (int)ptf.getTaskRecords().size() << " " << taskRec->getId() << " "
                << taskStart << " " << taskEnd << " " 
                << windowStart << " "<< windowEnd
                << " 0 " << boolVectorToString(buttonsSuccess) << " 7 -1 -1 -1 -1\n";  
        }
        else {
            // no reaction is wrong reaction
            ptf.getHandlerLog() << "Reaction handler:\n"
                << "\tNo reactions. Incorrect.\n";
            // machine log
            ptf.getMachineLog() << lastRRec << " "  
                << (int)ptf.getTaskRecords().size() << " " << taskRec->getId() << " "
                << taskStart << " " << taskEnd << " " 
                << windowStart << " "<< windowEnd
                << " 0 " << boolVectorToString(buttonsSuccess) << " 8 -1 -1 -1 -1\n"; 
        }            
    }
    else {
        // handle available reactions
        while (lastRRec < (int)ptf.getReactionRecords().size()) {
            // get latest unhandled reaction record
            ReactionRecord* reactRec = ptf.getReactionRecords()[lastRRec++];
            // leave mutex during handling
            ptf.getReactionRecordsMutex().leaveMutex();
            // get pressed buttons
            const vector<bool>& buttonsPressed = reactRec->getButtonStates();
            // get relevant timespec (later timestamp of interval)
            timespec reactionTime;
            reactRec->getTimestamp().getInterval(dummy, reactionTime);
            // get delta of end of reaction interval to begin of reaction window
            timespec delta;
            delta = TimeInterval::subTimespecs(reactionTime, windowStart);
            // check timing
            if (TimeInterval::compareTimespecs(reactionTime, taskStart) == -1) {
                // reaction does not belong to task - too early
                ptf.getHandlerLog() << "Reaction handler:\n"
                    << "\tReaction at " << reactRec->getTimestamp().toString() << "\n"
                    << "\tTask at     [" << taskStart << " | " << taskEnd << "]\n"
                    << "\tWindow at   [" << windowStart << " | " << windowEnd << "]\n"
                    << "\tDelta to start of reaction window: " << delta << "\n"
                    << "\tReaction was before start of task.\n";   
                // check buttons
                if (buttonsPressed == buttonsSuccess) {
                    ptf.getHandlerLog() << "\tReaction was with right input.\n";
                    // machine log
                    timespec a, b;
                    reactRec->getTimestamp().getInterval(a, b);
                    ptf.getMachineLog() << lastRRec << " " 
                        << (int)ptf.getTaskRecords().size() << " " << taskRec->getId() << " "
                        << taskStart << " " << taskEnd << " "
                        << windowStart << " " << windowEnd << " " 
                        << boolVectorToString(buttonsPressed) << " " 
                        << boolVectorToString(buttonsSuccess) <<  " 9 "  
                        << a << " " << b << "\n";    
                }
                else {
                    ptf.getHandlerLog() << "\tReaction was with wrong input.\n";
                    // machine log
                    timespec a, b;
                    reactRec->getTimestamp().getInterval(a, b);
                    ptf.getMachineLog() << lastRRec << " " 
                        << (int)ptf.getTaskRecords().size() << " " << taskRec->getId() << " "
                        << taskStart << " " << taskEnd << " "
                        << windowStart << " " << windowEnd << " " 
                        << boolVectorToString(buttonsPressed) << " " 
                        << boolVectorToString(buttonsSuccess) <<  " 10 "  
                        << a << " " << b << "\n";    
                }
                // re-enter mutex for next fetch
                ptf.getReactionRecordsMutex().enterMutex();
                continue;
            }
            if (TimeInterval::compareTimespecs(reactionTime, taskEnd) == 1) {
                // reaction does not belong to task - too late
                ptf.getHandlerLog() << "Reaction handler:\n"
                    << "\tReaction at " << reactRec->getTimestamp().toString() << "\n"
                    << "\tTask at     [" << taskStart << " | " << taskEnd << "]\n"
                    << "\tWindow at   [" << windowStart << " | " << windowEnd << "]\n"
                    << "\tDelta to start of reaction window: " << delta << "\n"
                    << "\tReaction was after end of task.\n";
                // check buttons
                if (buttonsPressed == buttonsSuccess) {
                    ptf.getHandlerLog() << "\tReaction was with right input.\n";
                    // machine log
                    timespec a, b;
                    reactRec->getTimestamp().getInterval(a, b);
                    ptf.getMachineLog() << lastRRec << " " 
                        << (int)ptf.getTaskRecords().size() << " " << taskRec->getId() << " "
                        << taskStart << " " << taskEnd << " "
                        << windowStart << " " << windowEnd << " " 
                        << boolVectorToString(buttonsPressed) << " " 
                        << boolVectorToString(buttonsSuccess) <<  " 11 "  
                        << a << " " << b << "\n";    
                }
                else {
                    ptf.getHandlerLog() << "\tReaction was with wrong input.\n";
                    // machine log
                    timespec a, b;
                    reactRec->getTimestamp().getInterval(a, b);
                    ptf.getMachineLog() << lastRRec << " " 
                        << (int)ptf.getTaskRecords().size() << " " << taskRec->getId() << " "
                        << taskStart << " " << taskEnd << " "
                        << windowStart << " " << windowEnd << " " 
                        << boolVectorToString(buttonsPressed) << " " 
                        << boolVectorToString(buttonsSuccess) <<  " 12 "  
                        << a << " " << b << "\n";      
                }
                // re-enter mutex for next fetch
                ptf.getReactionRecordsMutex().enterMutex();
                continue;    
            }
            if (TimeInterval::compareTimespecs(reactionTime, windowStart) == -1) {
                // reaction does belong to task, but out of reaction window - too early
                ptf.getHandlerLog() << "Reaction handler:\n"
                    << "\tReaction at " << reactRec->getTimestamp().toString() << "\n"
                    << "\tTask at     [" << taskStart << " | " << taskEnd << "]\n"
                    << "\tWindow at   [" << windowStart << " | " << windowEnd << "]\n"
                    << "\tDelta to start of reaction window: " << delta << "\n"
                    << "\tReaction was before start of reaction window.\n";
                // check buttons
                if (buttonsPressed == buttonsSuccess) {
                    ptf.getHandlerLog() << "\tReaction was with right input.\n";
                    // machine log
                    timespec a, b;
                    reactRec->getTimestamp().getInterval(a, b);
                    ptf.getMachineLog() << lastRRec << " " 
                        << (int)ptf.getTaskRecords().size() << " " << taskRec->getId() << " "
                        << taskStart << " " << taskEnd << " "
                        << windowStart << " " << windowEnd << " " 
                        << boolVectorToString(buttonsPressed) << " " 
                        << boolVectorToString(buttonsSuccess) <<  " 3 "  
                        << a << " " << b << "\n";
                }
                else {
                    ptf.getHandlerLog() << "\tReaction was with wrong input.\n";
                    // machine log
                    timespec a, b;
                    reactRec->getTimestamp().getInterval(a, b);
                    ptf.getMachineLog() << lastRRec << " " 
                        << (int)ptf.getTaskRecords().size() << " " << taskRec->getId() << " "
                        << taskStart << " " << taskEnd << " "
                        << windowStart << " " << windowEnd << " " 
                        << boolVectorToString(buttonsPressed) << " " 
                        << boolVectorToString(buttonsSuccess) <<  " 4 "  
                        << a << " " << b << "\n";                
                }
                // re-enter mutex for next fetch
                ptf.getReactionRecordsMutex().enterMutex();
                continue;    
            }
            if (TimeInterval::compareTimespecs(reactionTime, windowEnd) == 1) {
                // reaction does belong to task, but out of reaction window - too late
                ptf.getHandlerLog() << "Reaction handler:\n"
                    << "\tReaction at " << reactRec->getTimestamp().toString() << "\n"
                    << "\tTask at     [" << taskStart << " | " << taskEnd << "]\n"
                    << "\tWindow at   [" << windowStart << " | " << windowEnd << "]\n"
                    << "\tDelta to start of reaction window: " << delta << "\n"
                    << "\tReaction was after end of reaction window.\n";
                // check buttons
                if (buttonsPressed == buttonsSuccess) {
                    ptf.getHandlerLog() << "\tReaction was with right input.\n";
                    // machine log
                    timespec a, b;
                    reactRec->getTimestamp().getInterval(a, b);
                    ptf.getMachineLog() << lastRRec << " " 
                        << (int)ptf.getTaskRecords().size() << " " << taskRec->getId() << " "
                        << taskStart << " " << taskEnd << " "
                        << windowStart << " " << windowEnd << " " 
                        << boolVectorToString(buttonsPressed) << " " 
                        << boolVectorToString(buttonsSuccess) <<  " 5 "  
                        << a << " " << b << "\n";     
                }
                else {
                    ptf.getHandlerLog() << "\tReaction was with wrong input.\n";
                    // machine log
                    timespec a, b;
                    reactRec->getTimestamp().getInterval(a, b);
                    ptf.getMachineLog() << lastRRec << " " 
                        << (int)ptf.getTaskRecords().size() << " " << taskRec->getId() << " "
                        << taskStart << " " << taskEnd << " "
                        << windowStart << " " << windowEnd << " " 
                        << boolVectorToString(buttonsPressed) << " " 
                        << boolVectorToString(buttonsSuccess) <<  " 6 "  
                        << a << " " << b << "\n";      
                }
                // re-enter mutex for next fetch
                ptf.getReactionRecordsMutex().enterMutex();
                continue;    
            }
            // reaction does belong to task and is in reaction window
             ptf.getHandlerLog() << "Reaction handler:\n"
                    << "\tReaction at " << reactRec->getTimestamp().toString() << "\n"
                    << "\tTask at     [" << taskStart << " | " << taskEnd << "]\n"
                    << "\tWindow at   [" << windowStart << " | " << windowEnd << "]\n"
                    << "\tDelta to start of reaction window: " << delta << "\n"
                    << "\tReaction was in reaction window.\n";
            // check buttons
            if (buttonsPressed == buttonsSuccess) {
                ptf.getHandlerLog() << "\tReaction was with right input.\n";
                // machine log
                timespec a, b;
                reactRec->getTimestamp().getInterval(a, b);
                ptf.getMachineLog() << lastRRec << " " 
                        << (int)ptf.getTaskRecords().size() << " " << taskRec->getId() << " "
                        << taskStart << " " << taskEnd << " "
                        << windowStart << " " << windowEnd << " " 
                        << boolVectorToString(buttonsPressed) << " " 
                        << boolVectorToString(buttonsSuccess) <<  " 1 "  
                        << a << " " << b << "\n";      
            }
            else {
                ptf.getHandlerLog() << "\tReaction was with wrong input.\n";
                // machine log
                timespec a, b;
                reactRec->getTimestamp().getInterval(a, b);
                ptf.getMachineLog() << lastRRec << " " 
                        << (int)ptf.getTaskRecords().size() << " " << taskRec->getId() << " "
                        << taskStart << " " << taskEnd << " "
                        << windowStart << " " << windowEnd << " " 
                        << boolVectorToString(buttonsPressed) << " " 
                        << boolVectorToString(buttonsSuccess) <<  " 2 "  
                        << a << " " << b << "\n";      
            }       
            // re-enter mutex for next fetch
            ptf.getReactionRecordsMutex().enterMutex();
        }
    }
    // finally leave mutex
    ptf.getReactionRecordsMutex().leaveMutex();
}

string SimpleReactionHandler::boolVectorToString(const vector<bool>& in) {
    string result = "";
    if ((int)in.size() == 0) {
        result = "0";
        return result;
    }
    for (int i = 0; i < (int)in.size(); i++) {
        in[i] ? result += "1" : result += "0";
    }    
    return result;
}

---