MpdEventManagerEditor.cxx

Go to the documentation of this file.

// MpdEventManagerEditor
//
// Specialization of TGedEditor for proper update propagation to TEveManager
 
#include "MpdEventManagerEditor.h"
 
#include "FairRootManager.h"
#include "FairRunAna.h"
#include "TChain.h"
#include "TDatabasePDG.h"
#include "TEveBrowser.h"
#include "TEveElement.h"
#include "TEveGedEditor.h"
#include "TEveManager.h"
#include "TFile.h"
#include "TGFileDialog.h"
#include "TGLayout.h"
#include "TGWindow.h"
#include "TGeoManager.h"
#include "TString.h"
#include "TThread.h"
#include "TVirtualX.h"
 
#include <TGLScenePad.h>
#include <TGLViewer.h>
#include <iostream>
#include <regex>
#include <vector>
 
using namespace std;
 
//______________________________________________________________________________
MpdEventManagerEditor::MpdEventManagerEditor(const TGWindow* p, Int_t width, Int_t height, UInt_t options, Pixel_t back)
    : TGedFrame(p, width, height, options | kVerticalFrame, back)
    , iThreadState(0)
    , iEventCount(-1)
    , isStreamSource(false)
    , fSave(nullptr)
    , fUpdate(nullptr)
    , fCurrentEvent(nullptr)
    , fGeometry(nullptr)
    , fShowMCPoints(nullptr)
    , fShowMCTracks(nullptr)
    , fShowRecoPoints(nullptr)
    , fShowRecoTracks(nullptr)
    ,
 
    fObject(nullptr)
    , fEventManager(MpdEventManager::Instance())
    , fEventTime(nullptr)
    , fCurrentPDGTextEntry(nullptr)
    , fCurrentPDGString("")
    , fVizPri(nullptr)
    , sliderMinEnergy(nullptr)
    , sliderMaxEnergy(nullptr)
    , fGeometryFrame(nullptr)
    , ShowMagnetButton(nullptr)
    , isMagnetFound(false)
{
    fEventManager->SetEventEditor(this);
    Init();
}
 
void MpdEventManagerEditor::Init()
{
    FairRootManager* fRootManager = FairRootManager::Instance();
    TChain* chain = fRootManager->GetInChain();
 
    // create tab for event visualization
    MakeTitle("EventManager Editor");
    TGVerticalFrame* fInfoFrame = CreateEditorTabSubFrame("Event Info");
    TGCompositeFrame* title1 =
        new TGCompositeFrame(fInfoFrame, 250, 10, kVerticalFrame | kLHintsExpandX | kFixedWidth | kOwnBackground);
 
    // display file name (or stream name if no input file)
    TString InSource = "File: ";
    TFile* pChainFile = chain->GetFile();
    if (pChainFile == NULL) {
        InSource = "Data Stream";
        isStreamSource = true;
    } else
        InSource += pChainFile->GetName();
    TGLabel* TFName = new TGLabel(title1, InSource.Data());
    title1->AddFrame(TFName);
 
    // textbox for Run ID and time cutting
    TGHorizontalFrame* f2 = new TGHorizontalFrame(title1);
    // Run Id
    UInt_t RunId = FairRunAna::Instance()->getRunId();
    TString run = TString::Format("Run Id: %d. ", RunId);
    TGLabel* TRunId = new TGLabel(f2, run.Data());
    // time cutting
    TGLabel* EventTimeLabel = new TGLabel(f2, " Event Time: ");
    fEventTime = new TGLabel(f2, "");
    f2->AddFrame(TRunId);
    f2->AddFrame(EventTimeLabel);
    f2->AddFrame(fEventTime);
    title1->AddFrame(f2);
    // display event time
    TString time = TString::Format("%.2f ns", FairRootManager::Instance()->GetEventTime());
    fEventTime->SetText(time.Data());
 
    // display event count and count of geometry nodes
    iEventCount = chain->GetEntriesFast();
    Int_t nodes = gGeoManager->GetNNodes();
    TString nevent = TString::Format("No of events: %d. No. of nodes: %d", iEventCount, nodes);
    TGLabel* TEvent = new TGLabel(title1, nevent.Data());
    title1->AddFrame(TEvent);
 
    // setting textbox for event number
    TGHorizontalFrame* f = new TGHorizontalFrame(title1);
    TGLabel* l = new TGLabel(f, "Current Event:");
    f->AddFrame(l, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 1, 2, 1, 1));
    fCurrentEvent = new TGNumberEntry(f, 0., 6, -1, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative,
                                      TGNumberFormat::kNELLimitMinMax, 0, iEventCount - 1);
    f->AddFrame(fCurrentEvent, new TGLayoutHints(kLHintsLeft, 1, 1, 1, 1));
    fCurrentEvent->Connect("ValueSet(Long_t)", "MpdEventManagerEditor", this, "SelectEvent()");
    // if event count is 0 then deactivate the field for event number
    if (iEventCount < 1)
        fCurrentEvent->SetState(kFALSE);
 
    // button for saving the current image (EVE screenshot)
    fSave = new TGPictureButton(f, gClient->GetPicture("save.xpm"), 5);
    f->AddFrame(fSave, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 1, 2, 1, 1));
    fSave->Connect("Clicked()", "MpdEventManagerEditor", this, "SaveImage()");
    title1->AddFrame(f);
 
    // checkbox to display only primary particles in event
    fVizPri = new TGCheckButton(title1, "Primary Only");
    AddFrame(fVizPri, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
    fVizPri->Connect("Toggled(Bool_t)", "MpdEventManagerEditor", this, "DoVizPri()");
    title1->AddFrame(fVizPri);
 
    // textbox to display only particles with given PDG
    TGHorizontalFrame* f1 = new TGHorizontalFrame(title1);
    TGLabel* L1 = new TGLabel(f1, "Select Particles: ");
    f1->AddFrame(L1, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 1, 2, 1, 1));
    fCurrentPDGTextEntry = new TGTextEntry(f1);
    f1->AddFrame(fCurrentPDGTextEntry, new TGLayoutHints(kLHintsLeft, 1, 1, 1, 1));
    fCurrentPDGTextEntry->Connect("TextChanged(char*)", "MpdEventManagerEditor", this, "SelectPDG()");
    title1->AddFrame(f1);
 
    // textbox for min energy cutting
    sliderMinEnergy = new TEveGValuator(title1, "Min Energy:", 90, 0);
    sliderMinEnergy->SetNELength(5);
    sliderMinEnergy->SetLabelWidth(80);
    sliderMinEnergy->Build();
    sliderMinEnergy->SetLimits(fEventManager->GetMinEnergyLimit(), fEventManager->GetMaxEnergyLimit(), 2001,
                               TGNumberFormat::kNESRealOne);
    sliderMinEnergy->SetToolTip("Minimum energy of displayed tracks");
    sliderMinEnergy->SetValue(fEventManager->GetMinEnergyLimit());
    sliderMinEnergy->Connect("ValueSet(Double_t)", "MpdEventManagerEditor", this, "SetMinEnergyCut()");
    title1->AddFrame(sliderMinEnergy, new TGLayoutHints(kLHintsTop, 1, 1, 1, 0));
 
    // textbox with slider for max energy cutting
    sliderMaxEnergy = new TEveGValuator(title1, "Max Energy:", 90, 0);
    sliderMaxEnergy->SetNELength(5);
    sliderMaxEnergy->SetLabelWidth(80);
    sliderMaxEnergy->Build();
    sliderMaxEnergy->SetLimits(fEventManager->GetMinEnergyLimit(), fEventManager->GetMaxEnergyLimit(), 2001,
                               TGNumberFormat::kNESRealOne);
    sliderMaxEnergy->SetToolTip("Maximum energy of displayed tracks");
    sliderMaxEnergy->SetValue(fEventManager->GetMaxEnergyLimit());
    sliderMaxEnergy->Connect("ValueSet(Double_t)", "MpdEventManagerEditor", this, "SetMaxEnergyCut()");
    title1->AddFrame(sliderMaxEnergy, new TGLayoutHints(kLHintsTop, 1, 1, 1, 0));
 
    fGeometryFrame = new TGHorizontalFrame(title1);
    // button: whether show detector geometry or not
    fGeometry = new TGCheckButton(fGeometryFrame, "show geometry");
    fGeometryFrame->AddFrame(fGeometry, new TGLayoutHints(kLHintsLeft | kLHintsExpandX, 5, 5, 1, 1));
    fGeometry->Connect("Toggled(Bool_t)", "MpdEventManagerEditor", this, "ShowGeometry(Bool_t)");
    fGeometry->SetOn();
    // button: whether show magnet or not
    TGeoVolume* magnet = gGeoManager->FindVolumeFast("Magnet");
    if (magnet) {
        isMagnetFound = true;
        ShowMagnetButton = new TGCheckButton(fGeometryFrame, "show magnet");
        fGeometryFrame->AddFrame(ShowMagnetButton, new TGLayoutHints(kLHintsLeft | kLHintsExpandX, 5, 5, 1, 1));
        ShowMagnetButton->Connect("Toggled(Bool_t)", "MpdEventManagerEditor", this, "ShowMagnet(Bool_t)");
        ShowMagnetButton->SetOn();
    }
    title1->AddFrame(fGeometryFrame);
 
    // button for high transparency of detectors' geometry to highlight event objects
    TGCheckButton* fTransparency = new TGCheckButton(title1, "high transparency");
    title1->AddFrame(fTransparency, new TGLayoutHints(kLHintsRight | kLHintsExpandX, 5, 5, 1, 1));
    fTransparency->Connect("Toggled(Bool_t)", "MpdEventManagerEditor", this, "SwitchTransparency(Bool_t)");
 
    // button for switching from black to white background
    TGCheckButton* backgroundButton = new TGCheckButton(title1, "light background");
    title1->AddFrame(backgroundButton, new TGLayoutHints(kLHintsRight | kLHintsExpandX, 5, 5, 1, 1));
    backgroundButton->Connect("Toggled(Bool_t)", "MpdEventManagerEditor", this, "SwitchBackground(Bool_t)");
    if (!fEventManager->isDarkColor) {
        backgroundButton->SetOn();
        gEve->GetViewers()->SwitchColorSet();
    }
 
    // group for displaying simulation and reconstruction data
    TGGroupFrame* groupData = new TGGroupFrame(title1, "Show MC and reco data");
    groupData->SetTitlePos(TGGroupFrame::kCenter);
 
    TGHorizontalFrame* framePointsInfo = new TGHorizontalFrame(groupData);
    // button for show|hide MC points
    fShowMCPoints = new TGCheckButton(framePointsInfo, "MC points");
    framePointsInfo->AddFrame(fShowMCPoints, new TGLayoutHints(kLHintsNormal, 0, 0, 0, 0));
    fShowMCPoints->Connect("Toggled(Bool_t)", "MpdEventManagerEditor", this, "ShowMCPoints(Bool_t)");
    fShowMCPoints->SetDisabledAndSelected(kFALSE);
 
    // button for show|hide reconstructed points
    fShowRecoPoints = new TGCheckButton(framePointsInfo, "Reco points");
    framePointsInfo->AddFrame(fShowRecoPoints, new TGLayoutHints(kLHintsRight, 0, 0, 1, 0));
    fShowRecoPoints->Connect("Toggled(Bool_t)", "MpdEventManagerEditor", this, "ShowRecoPoints(Bool_t)");
    fShowRecoPoints->SetDisabledAndSelected(kFALSE);
    groupData->AddFrame(framePointsInfo, new TGLayoutHints(kLHintsNormal | kLHintsExpandX, 1, 1, 5, 0));
 
    TGHorizontalFrame* frameTracksInfo = new TGHorizontalFrame(groupData);
    // button for show|hide MC tracks
    fShowMCTracks = new TGCheckButton(frameTracksInfo, "MC tracks");
    frameTracksInfo->AddFrame(fShowMCTracks, new TGLayoutHints(kLHintsNormal, 0, 0, 0, 0));
    fShowMCTracks->Connect("Toggled(Bool_t)", "MpdEventManagerEditor", this, "ShowMCTracks(Bool_t)");
    fShowMCTracks->SetDisabledAndSelected(kFALSE);
 
    // button for show|hide reco tracks
    fShowRecoTracks = new TGCheckButton(frameTracksInfo, "Reco tracks");
    frameTracksInfo->AddFrame(fShowRecoTracks, new TGLayoutHints(kLHintsRight, 0, 0, 1, 0));
    fShowRecoTracks->Connect("Toggled(Bool_t)", "MpdEventManagerEditor", this, "ShowRecoTracks(Bool_t)");
    fShowRecoTracks->SetDisabledAndSelected(kFALSE);
 
    groupData->AddFrame(frameTracksInfo, new TGLayoutHints(kLHintsNormal | kLHintsExpandX, 1, 1, 5, 0));
    title1->AddFrame(groupData, new TGLayoutHints(kLHintsRight | kLHintsExpandX, 3, 15, 1, 1));
 
    // button for update of event visualization
    if (fEventManager->isOnline)
        fUpdate = new TGTextButton(title1, "Start online display");
    else
        fUpdate = new TGTextButton(title1, "Update event");
    title1->AddFrame(fUpdate, new TGLayoutHints(kLHintsRight | kLHintsExpandX, 3, 15, 1, 1));
    fUpdate->Connect("Clicked()", "MpdEventManagerEditor", this, "UpdateEvent()");
 
    // add all frame above to "event info" tab
    fInfoFrame->AddFrame(title1, new TGLayoutHints(kLHintsTop, 0, 0, 2, 0));
 
    if ((iEventCount < 1) && (!isStreamSource)) {
        fUpdate->SetEnabled(kFALSE);
        return;
    }
 
    // read first event in Offline mode
    if (!fEventManager->isOnline)
        fEventManager->GotoEvent(0);
 
    // update tab controls
    Update();
}
 
// set flag: show all particles or only primary
void MpdEventManagerEditor::DoVizPri()
{
    if (fVizPri->IsOn())
        fEventManager->SetPriOnly(kTRUE);
    else
        fEventManager->SetPriOnly(kFALSE);
}
 
// select displaying particle by PDG code
void MpdEventManagerEditor::SelectPDG()
{
    fCurrentPDGString = fCurrentPDGTextEntry->GetDisplayText();
}
 
//______________________________________________________________________________
void MpdEventManagerEditor::SetMinEnergyCut()
{
    fEventManager->SetMinEnergyCut(sliderMinEnergy->GetValue());
}
 
//______________________________________________________________________________
void MpdEventManagerEditor::SetMaxEnergyCut()
{
    fEventManager->SetMaxEnergyCut(sliderMaxEnergy->GetValue());
}
 
// show or hide detector geometry
void MpdEventManagerEditor::ShowGeometry(Bool_t is_show)
{
    // set cursor HourClock
    gVirtualX->SetCursor(gEve->GetMainWindow()->GetId(), gVirtualX->CreateCursor(kWatch));
    gVirtualX->SetCursor(gEve->GetLTEFrame()->GetListTree()->GetId(), gVirtualX->CreateCursor(kWatch));
    gVirtualX->SetCursor(gEve->GetLTEFrame()->GetEditor()->GetId(), gVirtualX->CreateCursor(kWatch));
 
    gEve->GetGlobalScene()->SetRnrState(is_show);
    if (!fEventManager->isOnline) {
        fEventManager->GetRPhiScene()->SetRnrState(is_show);
        fEventManager->GetRhoZScene()->SetRnrState(is_show);
    }
 
    // disable "Magnet Show" box after hiding of detector geometry
    if (isMagnetFound) {
        if (!is_show)
            fGeometryFrame->HideFrame(ShowMagnetButton);
        else
            fGeometryFrame->ShowFrame(ShowMagnetButton);
    }
 
    gEve->Redraw3D();
 
    // set cursor Pointer
    gSystem->ProcessEvents();
    gVirtualX->SetCursor(gEve->GetMainWindow()->GetId(), gVirtualX->CreateCursor(kPointer));
    gVirtualX->SetCursor(gEve->GetLTEFrame()->GetListTree()->GetId(), gVirtualX->CreateCursor(kPointer));
    gVirtualX->SetCursor(gEve->GetLTEFrame()->GetEditor()->GetId(), gVirtualX->CreateCursor(kPointer));
}
 
// show or hide magnet
void MpdEventManagerEditor::ShowMagnet(Bool_t is_show)
{
    TGeoVolume* magnet = gGeoManager->FindVolumeFast("Magnet");
    if (!magnet) {
        cout << "ERROR: There is no magnet with given name: Magnet" << endl;
        return;
    }
 
    magnet->SetVisibility(is_show);
    magnet->VisibleDaughters(is_show);
 
    if (gEve->GetGlobalScene()->GetRnrState()) {
        gEve->GetGlobalScene()->SetRnrState(kFALSE);
        gEve->GetGlobalScene()->SetRnrState(kTRUE);
        gEve->Redraw3D();
    }
}
 
// switch between light and dark background
void MpdEventManagerEditor::SwitchBackground(Bool_t is_on)
{
    gEve->GetViewers()->SwitchColorSet();
}
 
// set transparency to high value (80%)
void MpdEventManagerEditor::SwitchTransparency(Bool_t is_on)
{
    fEventManager->SetTransparentGeometry(is_on);
 
    if (gEve->GetGlobalScene()->GetRnrState()) {
        gEve->GetGlobalScene()->SetRnrState(kFALSE);
        gEve->GetGlobalScene()->SetRnrState(kTRUE);
        gEve->Redraw3D();
    }
}
 
// show|hide MC points
void MpdEventManagerEditor::ShowMCPoints(Bool_t is_show)
{
    /*
    TEveElement::List_t matches;
    TPRegexp* regexp = new TPRegexp("(\\w+)Point\\b");
    Int_t numFound = fEventManager->FindChildren(matches, *regexp);
    if (numFound > 0)
    {
        for (TEveElement::List_i p = matches.begin(); p != matches.end(); ++p)
            (*p)->SetRnrState(is_show);
    }
    */
 
    TEveElement* points = fEventManager->FindChild("MC points");
    if (points == NULL) {
        cout << "There is no information about MC points" << endl;
        fShowMCPoints->SetDisabledAndSelected(kFALSE);
        return;
    }
 
    points->SetRnrState(is_show);
 
    if (fEventManager->isZDCModule) {
        if (is_show)
            RedrawZDC(false);
        else
            RedrawZDC(true);
    }
 
    fEventManager->fgShowShowMCPoints = is_show;
    // exec event visualization of selected event
    if (!fEventManager->isOnline && fEventManager->fgRedrawRecoPointsReqired)
        fEventManager->GotoEvent(fCurrentEvent->GetIntNumber());
 
    // redraw points
    gEve->Redraw3D();
}
 
bool MpdEventManagerEditor::RedrawZDC(bool isFull, bool isRedraw)
{
    TGeoVolume* curVolume = gGeoManager->GetVolume("VETO");
    if (!curVolume) {
        cout << "ERROR: There is no volume with given name: VETO" << endl;
        return false;
    } else {
        int i = 0;
        for (; i < 68; i++) {
            TGeoNode* child = curVolume->FindNode(Form("VMDL_%d", i + 1));
            if (child == NULL)
                continue;
            // cout<<"Node: "<<child->GetName()<<". Number is equal "<<i<<endl;
 
            if (isFull) {
                if (fEventManager->isZDCModule[i] == false) {
                    child->SetVisibility(true);
                    child->VisibleDaughters(true);
                }
            } else {
                child->SetVisibility(fEventManager->isZDCModule[i]);
                child->VisibleDaughters(fEventManager->isZDCModule[i]);
            }
        }
 
        for (; i < 104; i++) {
            TGeoNode* child = curVolume->FindNode(Form("UMDL_%d", i + 1 - 68));
            if (child == NULL)
                continue;
            // cout<<"Node: "<<child->GetName()<<". Number is equal "<<i<<endl;
 
            if (isFull) {
                if (fEventManager->isZDCModule[i] == false) {
                    child->SetVisibility(true);
                    child->VisibleDaughters(true);
                }
            } else {
                child->SetVisibility(fEventManager->isZDCModule[i]);
                child->VisibleDaughters(fEventManager->isZDCModule[i]);
            }
        }
 
        if ((isFull || isRedraw) && (gEve->GetGlobalScene()->GetRnrState())) {
            gEve->GetGlobalScene()->SetRnrState(kFALSE);
            gEve->GetGlobalScene()->SetRnrState(kTRUE);
 
            return true;
        }
    }   // else - ZDC detector was found
 
    return false;
}
 
void MpdEventManagerEditor::UpdateEnergySlider()
{
    // display new min and max energy limits given by event energy range
    sliderMinEnergy->SetLimits(fEventManager->GetMinEnergyLimit(), fEventManager->GetMaxEnergyLimit(), 2001);
    sliderMinEnergy->SetValue(fEventManager->GetMinEnergyCut());
    sliderMaxEnergy->SetLimits(fEventManager->GetMinEnergyLimit(), fEventManager->GetMaxEnergyLimit(), 2001);
    sliderMaxEnergy->SetValue(fEventManager->GetMaxEnergyCut());
}
 
//______________________________________________________________________________
void MpdEventManagerEditor::ShowMCTracks(Bool_t is_show)
{
    TEveElement* tracks = fEventManager->FindChild("MC tracks");
    if (tracks == NULL) {
        cout << "There is no information about MC tracks" << endl;
        fShowMCTracks->SetDisabledAndSelected(kFALSE);
        return;
    }
 
    tracks->SetRnrState(is_show);
    gEve->Redraw3D();
}
 
//______________________________________________________________________________
void MpdEventManagerEditor::ShowRecoPoints(Bool_t is_show)
{
    TEveElement* points = fEventManager->FindChild("Reco points");
    if (points == NULL) {
        cout << "There is no information about reconstructed points" << endl;
        fShowRecoPoints->SetDisabledAndSelected(kFALSE);
        return;
    }
 
    fEventManager->fgShowShowRecoPoints = is_show;
    // exec event visualization of selected event
    if (!fEventManager->isOnline && fEventManager->fgRedrawRecoPointsReqired)
        fEventManager->GotoEvent(fCurrentEvent->GetIntNumber());
 
    points->SetRnrState(is_show);
    gEve->Redraw3D();
}
 
//______________________________________________________________________________
void MpdEventManagerEditor::ShowRecoTracks(Bool_t is_show)
{
    TEveElement* tracks = fEventManager->FindChild("Reco tracks");
    if (tracks == NULL) {
        cout << "There is no information about reconstructed tracks" << endl;
        fShowRecoTracks->SetDisabledAndSelected(kFALSE);
        return;
    }
 
    fEventManager->fgShowShowRecoTracks = is_show;
    // exec event visualization of selected event
    if (!fEventManager->isOnline && fEventManager->fgRedrawRecoPointsReqired)
        fEventManager->GotoEvent(fCurrentEvent->GetIntNumber());
 
    tracks->SetRnrState(is_show);
    gEve->Redraw3D();
}
 
void MpdEventManagerEditor::SaveImage()
{
    const char* filetypes[] = {"PNG", "*.png", "JPG", "*.jpg", 0, 0};
    TGFileInfo fi;
    fi.fFileTypes = filetypes;
    fi.fIniDir = StrDup(".");
    new TGFileDialog(gClient->GetRoot(), gEve->GetMainWindow(), kFDSave, &fi);
 
    printf("Saving file: %s (dir: %s)\n", fi.fFilename, fi.fIniDir);
    gEve->GetDefaultGLViewer()->SavePicture(fi.fFilename);
 
    return;
}
 
// update event display when setting event number in textbox
void MpdEventManagerEditor::SelectEvent()
{
    // if OFFLINE mode
    if (!fEventManager->isOnline) {
        int iOldEvent = fEventManager->GetCurrentEvent(), iNewEvent = fCurrentEvent->GetIntNumber();
        // exec event visualization of selected event
        fEventManager->GotoEvent(iNewEvent);
 
        if ((fEventManager->isZDCModule) && (fShowMCPoints->IsOn()))
            RedrawZDC(false);
 
        if (iOldEvent != iNewEvent) {
            // display event time
            TString time = TString::Format("%.2f ns", FairRootManager::Instance()->GetEventTime());
            fEventTime->SetText(time.Data());
 
            UpdateEnergySlider();
        }
 
        // update tab controls
        Update();
 
        return;
    }
 
    /*// update all scenes
    fEventManager->fRPhiView->GetGLViewer()->UpdateScene(kTRUE);
    fEventManager->fRhoZView->GetGLViewer()->UpdateScene(kTRUE);
    fEventManager->fMulti3DView->GetGLViewer()->UpdateScene(kTRUE);
    fEventManager->fMultiRPhiView->GetGLViewer()->UpdateScene(kTRUE);
    fEventManager->fMultiRhoZView->GetGLViewer()->UpdateScene(kTRUE);*/
}
 
// clicking 'Update event' button to update event display OR 'Start online display' button to start/stop online event
// display
void MpdEventManagerEditor::UpdateEvent()
{
    if (iThreadState == 1) {
        iThreadState = 0;
        return;
    }
 
    fEventManager->fCurrentPDG.clear();
    istringstream iss(fCurrentPDGString);
    auto databasePDG = TDatabasePDG::Instance();
    regex rgx("[\\s,]+");
    sregex_token_iterator iter(fCurrentPDGString.begin(), fCurrentPDGString.end(), rgx, -1);
    sregex_token_iterator end;
    for (; iter != end; ++iter) {
        string s = (*iter).str();
        if (s != "") {
            auto pdg = atoi(s.c_str());
            if (pdg)
                fEventManager->fCurrentPDG.insert(pdg);
            else {
                auto particle = databasePDG->GetParticle(s.c_str());
                if (particle)
                    fEventManager->fCurrentPDG.insert(particle->PdgCode());
            }
        }
    }
 
    // if OFFLINE mode
    if (!fEventManager->isOnline) {
        int iOldEvent = fEventManager->GetCurrentEvent(), iNewEvent = fCurrentEvent->GetIntNumber();
        // exec event visualization of selected event
        fEventManager->GotoEvent(iNewEvent);
 
        if ((fEventManager->isZDCModule) && (fShowMCPoints->IsOn()))
            RedrawZDC(false);
 
        if (iOldEvent != iNewEvent) {
            // display event time
            TString time = TString::Format("%.2f ns", FairRootManager::Instance()->GetEventTime());
            fEventTime->SetText(time.Data());
 
            UpdateEnergySlider();
        }
 
        // update tab controls
        Update();
 
        return;
    }
    // if ONLINE mode
    else
    {
        // block user interface to exclude sharing of Redraw access
        BlockUI();
 
        // Run separate thread for Online Display
        ThreadParam_OnlineDisplay* par_online_display = new ThreadParam_OnlineDisplay();
        par_online_display->fEventManager = fEventManager;
        par_online_display->fManagerEditor = this;
        par_online_display->fRootManager = FairRootManager::Instance();
        par_online_display->isZDCRedraw = false;
        if ((fEventManager->isZDCModule) && (fShowMCPoints->IsOn()))
            par_online_display->isZDCRedraw = true;
        par_online_display->iCurrentEvent = fCurrentEvent->GetIntNumber();
        par_online_display->isStreamSource = isStreamSource;
 
        TThread* thread_run_online = new TThread(RunOnlineDisplay, (void*)par_online_display);
        iThreadState = 1;
        thread_run_online->Run();
 
        return;
    }
}
 
void MpdEventManagerEditor::BlockUI()
{
    // fCurrentEvent->SetState(kFALSE);
    // fUpdate->SetEnabled(kFALSE);
    fUpdate->SetText("Stop online display");
    // fGeometry->SetEnabled(kFALSE);
}
 
void MpdEventManagerEditor::UnblockUI()
{
    // fCurrentEvent->SetState(kTRUE);
    // fUpdate->SetEnabled(kTRUE);
    fUpdate->SetText("Start online display");
    // fGeometry->SetEnabled(kTRUE);
}
 
// thread function for Online Display
void* RunOnlineDisplay(void* ptr)
{
    ThreadParam_OnlineDisplay* thread_par = (ThreadParam_OnlineDisplay*)ptr;
    MpdEventManager* fEventManager = thread_par->fEventManager;
    MpdEventManagerEditor* fEditor = thread_par->fManagerEditor;
    FairRootManager* fRootManager = thread_par->fRootManager;
    int current_event = thread_par->iCurrentEvent;
    bool stream_source = thread_par->isStreamSource;
    bool isZDCRedraw = thread_par->isZDCRedraw;
 
    // get all tasks from FairRunAna
    FairRunAna* pRun = fEventManager->fRunAna;
    FairTask* pMainTask = pRun->GetMainTask();
    TList* taskList = pMainTask->GetListOfTasks();
 
    for (int i = current_event + 1; ((stream_source) || (i < fEditor->iEventCount)); i++) {
        if (fEditor->iThreadState == 0)
            break;
        do {
            TThread::Sleep(0, 200000000);
        } while ((gEve->GetGlobalScene()->GetGLScene()->IsLocked())
                 || (gEve->GetEventScene()->GetGLScene()->IsLocked()));
 
        fRootManager->ReadEvent(i);
        fEventManager->SetCurrentEvent(i);
 
        // run all tasks
        TObjLink* lnk = taskList->FirstLink();
        while (lnk) {
            FairTask* pCurTask = (FairTask*)lnk->GetObject();
            pCurTask->ExecuteTask("");
            lnk = lnk->Next();
        }
 
        // fEditor->fCurrentEvent->SetIntNumber(i);
 
        // highlight ZDC modules if ZDC present
        if (isZDCRedraw)
            fEditor->RedrawZDC();
 
        // redraw points
        cout << "Redrawing event #" << i << "..." << endl << endl;
        gEve->Redraw3D();
        // TThread::Sleep(1,0);
        // gSystem->ProcessEvents();
    }
 
    fEditor->UnblockUI();
    fEditor->iThreadState = 0;
 
    return NULL;
}