MGuiDriver.cc

Go to the documentation of this file.

#include "MGuiDriver.hh"
#include "QGDUtils.hh"
#include "QEventAssembler.hh"
#include "QRunData.hh"
#include "QRunDataHandle.hh" 
#include "QRawEvent.hh"
#include <iostream>
#include "TSocket.h"
#include "TMessage.h"
#include "TMap.h"
#include "TObjString.h"
#include <sstream>
 
using namespace Diana;
 
REGISTER_MODULE(MGuiDriver)
 
MGuiDriver::MGuiDriver()
{
    fSocket = 0;
    fEva = new QEventAssembler();
}
 
MGuiDriver::~MGuiDriver()
{
    delete fEva;
    // called once in a sequence
}
 
QDriver::Action MGuiDriver::Init(QEventAssembler& eva)
{
 
    // open network connection to GUI if not already done
    if (fSocket == 0) {
        std::string add = GetString("GuiHost","localhost");
        int port = GetInt("GuiPort",1130);
        fSocket = new TSocket(add.c_str(),port);
    }
    fRunData.Clear();
    // called before event loop
    Action act = Menu(ML_Init);
    fEva->Clear();
    return act;
}
 
QDriver::Action MGuiDriver::Do(QEventAssembler& eva)
{
 
        QEvent& ev = eva.GetEvent();
    // get event number and channel id of this event
 
    const QHeader& hdr = ev.Get<QHeader>("","Header");;
    const QPulseInfo& pi = ev.Get<QPulseInfo>("","PulseInfo");;
    Debug("Current event: %d, Channel %d",hdr.GetEventNumber(), pi.GetChannelId());
    fEva->Assign(ev);
    fDm = &GlobalData();
    if(fRunData.fNumber != hdr.GetRun())
        //fRunData =  GlobalData().Get<QRunData>("","RunData","");
        {
          QRunDataHandle rh(hdr.GetRun());
          GlobalData().Get("DAQ",&rh,"");
          if(rh.IsValid()) fRunData = rh.Get();
        }
 
    Action act = Menu(ML_Do);
    return act;
}
 
QDriver::Action MGuiDriver::Done()
{
    // called at the end of the event loop
    Action act = Menu(ML_Done);
    return act;
}
 
QDriver::Action MGuiDriver::Menu(MenuLevel level) {
    QDriver::Action act;
    act.fActionId = ACT_NONE;
    while(act.fActionId == ACT_NONE) {
        SendCommands(level);
        QGDCommand cmd = GetCommand(level);
        act = HandleCommand(cmd);        
    }
    Debug("Performing action %d",act.fActionId);
    return act;
}
 
 
QDriver::Action MGuiDriver::HandleCommand(QGDCommand cmd) 
{
    QDriver::Action act;
    switch( cmd.fCommandId ) 
    {
        case QGDCommand::CmdNext: 
            act.fActionId = ACT_NEXTEV;
            break;
        case QGDCommand::CmdPrev:
            act.fActionId = ACT_PREVEV;
            break;
        case QGDCommand::CmdJump:
            act.fActionId = ACT_GOTOEV;
            act.fEventNumber = QGDUtils::ParameterToQVdt(cmd.fParameter1).GetInt();
            break;
        case QGDCommand::CmdQuit:
            act.fActionId = ACT_QUIT;
            break;
        case QGDCommand::CmdRerun:
            act.fActionId = ACT_RERUN;
            break;
        case QGDCommand::CmdListMod: 
            ListModules();
            act.fActionId = ACT_NONE;
            break;
        case QGDCommand::CmdListPar: 
            ListModuleParameters(QGDUtils::ParameterToQVdt(cmd.fParameter1).GetInt());
            act.fActionId = ACT_NONE;
            break;
        case QGDCommand::CmdChangePar: 
            ChangeModuleParameter(QGDUtils::ParameterToQVdt(cmd.fParameter1).GetInt(),
                    QGDUtils::ParameterToQVdt(cmd.fParameter2));
            act.fActionId = ACT_NONE;
            break;
        case QGDCommand::CmdSendData: 
            SendData(QGDUtils::ParameterToQVdt(cmd.fParameter1).GetString());
            act.fActionId = ACT_NONE;
            break;
        case QGDCommand::CmdNone:
        default:
            act.fActionId = ACT_NONE;
            break;
    }
    return act;
}
 
QGDCommand MGuiDriver::GetCommand(MenuLevel level) 
{
    QGDCommand cmd;
    if(fSocket && fSocket->IsValid()) {
        TMessage* mess = NULL;
        Debug("Waiting for command");
        fSocket->Recv(mess);
        if(mess) {
            TObject* obj = mess->ReadObject(mess->GetClass());
            if(QGDCommand* myCmd = dynamic_cast<QGDCommand*>(obj)) {
                cmd = *myCmd;
                Debug("Command received: %d",cmd.fCommandId);
                return cmd;
            } else  {
                Warn("Object received is not a QGDCommand, Ignored");
            }
        }
    }
    Panic("Connection error, command not received");
    return cmd;
}
 
 
 
void MGuiDriver::SendCommands(MenuLevel level)
{    
    Debug("Sending avalaible commands");
    QGDCommandList cl;
    cl.fCommands.clear();
    QGDCommand command;
    if(level == ML_Init) {
        cl.fCommands.push_back(QGDCommand::CmdNone);
        cl.fCommands.push_back(QGDCommand::CmdNext);
        cl.fCommands.push_back(QGDCommand::CmdJump);
        cl.fCommands.push_back(QGDCommand::CmdQuit);
        cl.fCommands.push_back(QGDCommand::CmdRerun);
        cl.fCommands.push_back(QGDCommand::CmdListMod);
        cl.fCommands.push_back(QGDCommand::CmdListPar);
        cl.fCommands.push_back(QGDCommand::CmdChangePar);
    } else if(level == ML_Do) {
        cl.fCommands.push_back(QGDCommand::CmdNone);
        cl.fCommands.push_back(QGDCommand::CmdNext);
        cl.fCommands.push_back(QGDCommand::CmdPrev);
        cl.fCommands.push_back(QGDCommand::CmdJump);
        cl.fCommands.push_back(QGDCommand::CmdQuit);
        cl.fCommands.push_back(QGDCommand::CmdRerun);
        cl.fCommands.push_back(QGDCommand::CmdListMod);
        cl.fCommands.push_back(QGDCommand::CmdListPar);
        cl.fCommands.push_back(QGDCommand::CmdChangePar);
        cl.fCommands.push_back(QGDCommand::CmdSendData);
    } else if(level == ML_Done) {
        cl.fCommands.push_back(QGDCommand::CmdNone);
        cl.fCommands.push_back(QGDCommand::CmdRerun);
        cl.fCommands.push_back(QGDCommand::CmdListMod);
        cl.fCommands.push_back(QGDCommand::CmdListPar);
        cl.fCommands.push_back(QGDCommand::CmdChangePar);
    }
    SendTObject(&cl); 
 
}
 
void MGuiDriver::SendTObject(const TObject* obj)
{
    if(fSocket && fSocket->IsValid()) {
        TMessage mess(kMESS_OBJECT);
        mess.WriteObject( obj );
        fSocket->Send( mess );
        Debug("Object sent");
    } else {
        Panic("Connection error, could not send data");
    }
}
 
 
void MGuiDriver::ListModules() 
{
 
    const std::vector<QBaseModule*>& modList = GetModulesList();
    QGDModuleList eModList;
    for(size_t m = 0; m < modList.size(); m++) {
        QBaseModule *mod = modList[m];
        std::string fullPath = mod->GetFullPath();
        eModList.fModules.push_back(fullPath);
    }
    SendTObject(&eModList); 
}
 
void MGuiDriver::ListModuleParameters(int modIndex) 
{
    const std::vector<QBaseModule*>& modList = GetModulesList();
    if(modIndex <= 0 && modIndex > (int)modList.size()-1) {
        Error("Module index (%d) out of range",modIndex);
        return;
    }
    const QBaseModule* thisMod = modList[(size_t)modIndex];
    std::string moduleName = thisMod->GetName();
    int occurrence =  thisMod->GetOccurrence();
    std::map<std::string, QVdt*> params = GetModuleParameters(moduleName, occurrence);
    std::map<std::string, QVdt*>::iterator p1 = params.begin();
    QGDModuleParameterList pList;
    while(p1 != params.end()) {
        QGDParameter qparam;
        qparam = QGDUtils::QVdtToParameter(*(p1->second));
        qparam.fName = p1->first;
        pList.fParameters.push_back(qparam);
        p1++;
    }
    SendTObject(&pList);
}
 
void MGuiDriver::ChangeModuleParameter(int modIndex, const QVdt& newVal)
{
    const std::vector<QBaseModule*>& modList = GetModulesList();
    if(modIndex <= 0 && modIndex > (int)modList.size()-1) {
        Error("Module index (%d) out of range",modIndex);
        return;
    }
    const QBaseModule* thisMod = modList[(size_t)modIndex];
    std::string moduleName = thisMod->GetName();
    int occurrence =  thisMod->GetOccurrence();
    std::map<std::string,QVdt*> parameters = GetModuleParameters(moduleName,occurrence);
    std::string parName = newVal.GetName();
    std::map<std::string,QVdt*>::iterator thisPar = parameters.find(parName);
    if(thisPar == parameters.end()) 
        Warn("Parameter %s not found, setting it anyway",parName.c_str());
    *(parameters[parName]) = newVal;
}
 
void MGuiDriver::SendData(const std::string& type)
{
    if( type == "QRunData") {
        SendTObject(&fRunData);
    } else if (type == "QGlobal") {
        TMap* data = new TMap();
        data->SetName("QGlobal");
        data->SetOwner(1);
        std::vector<QGlobalLabel> labels = fDm->GetWriteLabels();
        for(size_t l = 0; l < labels.size(); l++) {
            QGlobalLabel lab(labels[l]);
            const QObject* obj = fDm->GetByLabel(lab);
            if(obj ) {
                QObject* dobj = obj->Duplicate();
                obj->FullyFill(dobj);
                TObjString* strlab = new TObjString(lab.GetStringLabel().c_str());
                data->Add(strlab, dobj);
            }
        }
        SendTObject(data);
        delete data;
    } else {
        TMap* data = new TMap();
        data->SetName("QEvent");
        data->SetOwner(1);
        std::vector<QEventLabel> labels = fEva->GetWriteLabels();
        for(size_t l = 0; l < labels.size(); l++) {
            QEventLabel lab(labels[l]);
            QObject** obj = fEva->Get(lab.owner.c_str(),lab.name.c_str());
            if(obj && *obj) {
                QObject* dobj = (*obj)->Duplicate();
                (*obj)->FullyFill(dobj);
                TObjString* strlab = new TObjString(lab.GetStringLabel().c_str());
                data->Add(strlab, dobj);
            }
        }
        SendTObject(data);
        delete data;
    }
}