DCSConfigEditorDisplay.cpp

Go to the documentation of this file.

#include <DatabaseUtils/GUI/DCSConfigEditorDisplay.h>
#include <DatabaseUtils/DAQConfig/GlobalNameSpec.h>
#include <DatabaseUtils/DAQConfig/NamedConfigUtils.h>
#include <NovaDAQUtilities/EnvVarCache.h>
#include <boost/shared_ptr.hpp>
#include <QtCore/QCoreApplication>
#include <QtCore/QProcess>
#include <QtGui/QVBoxLayout>
#include <QtGui/QInputDialog>
#include <QtGui/QMenu>
#include <QtGui/QMenuBar>
#include <QtGui/QMessageBox>
#include <QtGui/QProgressDialog>
#include <QtGui/QPushButton>
#include <QtGui/QFileDialog>
#include <boost/assign/std/vector.hpp>  // for 'operator+=()'
#include <boost/filesystem.hpp>

using namespace boost::assign;  // bring 'operator+=()' into scope
using namespace dbutils::daqconfig;

namespace BFS = boost::filesystem;

namespace dbutils {
namespace gui {

DCSConfigEditorDisplay::
DCSConfigEditorDisplay(QWidget *parent) : BasicEditorDisplay(parent)
{
    std::string detectorString =
        novadaq::EnvVarCache::getInstance().getEnvVar("NOVADAQ_ENVIRONMENT");
    if (detectorString.length() == 0) {
        detectorString = "NOVADAQ_ENVIRONMENT_EnvVar_NeedsToBeSet";
    }

    _pvScriptOutputDir = "/nova/config/" + detectorString + "/DCS";

    // (hopefully) temporary menu option to call the script that
    // converts the DB entries into PV settings
    QMenu* actionMenu = menuBar()->addMenu(tr("&Action"));
    QAction* genScriptAction =
        actionMenu->addAction(tr("&Generate Recipe Scripts"));
    QObject::connect(genScriptAction, SIGNAL(triggered()),
                     this, SLOT(generateRecipeScripts()));

    QAction* loadHVAndTempsAction =
        actionMenu->addAction(tr("&Load HV and Temperatures"));
    QObject::connect(loadHVAndTempsAction, SIGNAL(triggered()),
                     this, SLOT(loadHVAndTemps()));

    _addHelpMenu();

    std::vector<std::string> tableDefinitions;
    tableDefinitions +=
        "NovaDatabase/tables/DCS/DCSFEBEnableMasks.xml",
        "NovaDatabase/tables/DCS/APDTemperatureSettings.xml",
        "NovaDatabase/tables/DCS/APDHighVoltages.xml",
        "NovaDatabase/tables/DCS/FEBDryAirChannels.xml",
        "NovaDatabase/tables/DCS/EPICSAlarmThresholds.xml";

    _globalNameSpecPtr.
        reset(new GlobalNameSpec("ColdDetectorSettings", "DCS",
                                 detectorString));
    _globalNameSpecPtr->isSlowControlsConfiguration(true);
    _currentGlobalConfigId = -1;
    if (! NamedConfigUtils::getGlobalConfigId((*_globalNameSpecPtr),
                                              _currentGlobalConfigId)) {
        std::cerr << "Error fetching globalConfigId." << std::endl;
    }
    IDSpec idSpec(_currentGlobalConfigId, IDSpec::GLOBAL,
                  (_globalNameSpecPtr->isSlowControlsConfiguration() ?
                   IDSpec::SLOWCONTROLS : IDSpec::DAQ));

    _editorSet = new TabbedSetOfTreeEditors("APDHardware", "slowcontrols",
                                            tableDefinitions,this);
    _editorSet->isTopLevel(true);
    _editorSet->loadData(idSpec);
    connect(_editorSet, SIGNAL(aChangeWasMade()),
            this, SLOT(reactToDataChange()));
    connect(_editorSet, SIGNAL(dataWasSaved()),
            this, SLOT(reactToDataSave()));

    _settingsDisplay = new SettingsDisplay();
    _settingsDisplay->updateNamedConfiguration(*_globalNameSpecPtr);

    QVBoxLayout* thisDisplayLayout = new QVBoxLayout;
    thisDisplayLayout->addWidget(_editorSet);
    thisDisplayLayout->addWidget(_settingsDisplay);
    QWidget* tmpWidget = new QWidget();
    tmpWidget->setContentsMargins(0,5,0,0);
    tmpWidget->setLayout(thisDisplayLayout);

    setCentralWidget(tmpWidget);
}

bool DCSConfigEditorDisplay::hasChanges() const
{
    return _editorSet->hasChanges();
}

void DCSConfigEditorDisplay::generateRecipeScripts()
{
    // check that the user really wants to do this
    std::string dbString =
        novadaq::EnvVarCache::getInstance().getEnvVar("NOVADBNAME");
    QMessageBox confirmBox(this);

    std::string msgText = "You are about to update PV scripts on ";
    msgText.append("disk based on data in the \"");
    msgText.append(dbString);
    msgText.append("\" database.");
    confirmBox.setText(msgText.c_str());

    msgText = "Are you sure that you want to re-generate ";
    msgText.append("the PV settings scripts?");
    confirmBox.setInformativeText(msgText.c_str());

    confirmBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
    confirmBox.setDefaultButton(QMessageBox::No);
    int retCode = confirmBox.exec();

    if (retCode != QMessageBox::Yes) {return;}

    // determine the output directory to use
    bool status;
    QString responseText =
        QInputDialog::getText(this, tr("Output directory"),
                              tr("Enter the output directory for the generated PV scripts:"),
                              QLineEdit::Normal,
                              _pvScriptOutputDir.c_str(), &status);
    if (! status) {return;}
    _pvScriptOutputDir = responseText.toStdString();

    // verify that the specified output directory is valid
    if (! BFS::exists(_pvScriptOutputDir)) {
        std::string msgText = "Output directory ";
        msgText.append(_pvScriptOutputDir);
        msgText.append(" does not exist. Aborting script generation...");
        QMessageBox::critical(this, "Invalid Output Directory", msgText.c_str());
        return;
    }

    // generate the scripts
    QProgressDialog progressBar("Generating scripts... Timeout at 100%", "Close", 0, 10, this);
    progressBar.setWindowModality(Qt::WindowModal);
    progressBar.setMinimumDuration(0);
    progressBar.setValue(0);
    QCoreApplication::processEvents(QEventLoop::AllEvents, 500);

    std::string cmd = "GenerateDCSRecipeScripts.sh ";
    cmd.append(_pvScriptOutputDir);
    boost::shared_ptr<QProcess> processPtr(new QProcess(this));
    processPtr->start(cmd.c_str());

    bool finished = false;
    QCoreApplication::processEvents(QEventLoop::AllEvents, 500);
    if (processPtr->waitForStarted(8000)) {
        progressBar.setValue(1);
        QCoreApplication::processEvents(QEventLoop::AllEvents, 500);
        for (int idx = 2; idx < 15; ++idx) {
            if (processPtr->waitForFinished(8000)) {
                finished = true;
                break;
            }
            progressBar.setValue(idx < 9 ? idx : 9);
            QCoreApplication::processEvents(QEventLoop::AllEvents, 500);
        }
    }
    progressBar.setValue(10);
    QCoreApplication::processEvents(QEventLoop::AllEvents, 500);

    if (! finished) {
        processPtr->kill();
        processPtr->waitForFinished(5000);
    }

    std::string stdoutString(processPtr->readAllStandardOutput());
    std::string stderrString(processPtr->readAllStandardError());

    if (finished) {
        std::string msgText = "The job to generated the PV ";
        msgText.append("settings scripts completed ");
        msgText.append("Press \"Show Details...\" to see output.");
        std::string outText = stdoutString;
        outText.append("\n");
        outText.append(stderrString);
        QMessageBox resultBox(this);
        resultBox.setIcon(QMessageBox::Information);
        resultBox.setWindowTitle("PV Script Result");
        resultBox.setText(msgText.c_str());
        resultBox.setDetailedText(outText.c_str());
        resultBox.exec();
        //QMessageBox::information(this, "PV Script Result", msgText.c_str());
    }
    else {
        std::string msgText = "The job to generated the PV ";
        msgText.append("settings scripts timed out. ");
        msgText.append("Press \"Show Details...\" to see output.");
        
        std::string outText = stdoutString;
        outText.append("\n");
        outText.append(stderrString);
        QMessageBox resultBox(this);
        resultBox.setIcon(QMessageBox::Warning);
        resultBox.setWindowTitle("PV Script Result");
        resultBox.setText(msgText.c_str());
        resultBox.setDetailedText(outText.c_str());
        resultBox.exec();
        //QMessageBox::warning(this, "PV Script Result", msgText.c_str());
    }
}

bool DCSConfigEditorDisplay::
_doReloadCurrentDataset(const dbutils::daqconfig::IDSpec& idSpec)
{
    return _editorSet->loadData(idSpec);
}

bool DCSConfigEditorDisplay::
_doLoadNewDataset(const dbutils::daqconfig::IDSpec& idSpec)
{
    return _editorSet->loadData(idSpec);
}

bool DCSConfigEditorDisplay::
_doSaveChanges(const dbutils::daqconfig::IDSpec& oldIdSpec,
               const dbutils::daqconfig::IDSpec& newIdSpec,
               const dbutils::daqconfig::GlobalNameSpec& newNameSpec)
{
    return _editorSet->saveChanges(oldIdSpec, newIdSpec, newNameSpec);
}


void DCSConfigEditorDisplay::loadHVAndTemps()
{
  ///////////////////////////////////
  // Prompt for location of the csv
  std::string detName=_globalNameSpecPtr->getDetectorName();
  std::string detDir;
  if(detName=="FarDet")
    detDir = "";
  else if(detName=="NDOS")
    detDir = "";
  else if(detName=="NearDet")
    detDir = "";
  else if(detName=="NDSBTest")
    detDir = "";
  else
    detDir = "";

  QFileDialog peddialog(this);
  peddialog.setViewMode(QFileDialog::Detail);
  QString folderName = peddialog.getExistingDirectory(this, tr("Select HV/Temp Directory."),
                                                         detDir.c_str(),
                                                         QFileDialog::ShowDirsOnly|QFileDialog::DontUseNativeDialog);
  if(folderName==""){return;}

  /////////////////////////////////
  // DB load confirmation box
  QMessageBox confirmBox(this);
  int count;
  std::ostringstream hvfebs;
  std::ostringstream tempfebs;
  
  boost::filesystem::path p(folderName.toUtf8().constData());
  boost::filesystem::path uniquestamp = p.filename();
  
  std::string hvFileName = folderName.toUtf8().constData();
  hvFileName.append("/hv_");
  hvFileName.append(uniquestamp.string());
  hvFileName.append(".csv");
  std::string tempFileName = folderName.toUtf8().constData();
  tempFileName.append("/temp_"); 
  tempFileName.append(uniquestamp.string());
  tempFileName.append(".csv");
  

  std::ifstream hvFile(hvFileName.c_str()); 
  count=std::count(std::istreambuf_iterator<char>(hvFile), 
                  std::istreambuf_iterator<char>(), '\n');
  hvfebs << count;

  std::ifstream tempFile(tempFileName.c_str()); 
  count=std::count(std::istreambuf_iterator<char>(tempFile), 
                  std::istreambuf_iterator<char>(), '\n');
  tempfebs << count;
  
  std::string msgText = "You are about to load voltages and temperatures from  ";
  msgText.append(folderName.toUtf8().constData());
  msgText.append("\n\n Found voltage results from ");
  msgText.append(hvfebs.str());
  msgText.append(" febs, temperature results from ");
  msgText.append(tempfebs.str());
  msgText.append(" febs.");
  confirmBox.setText(msgText.c_str());

  msgText = "Are you sure that you want to load these values? ";
  confirmBox.setInformativeText(msgText.c_str());
  confirmBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
  confirmBox.setDefaultButton(QMessageBox::No);
  int retCode = confirmBox.exec();
  if (retCode != QMessageBox::Yes) {return;}

  //////////
  // Ask if user want to overide all setting in the config or simply append
  // apply proper defualts if they want to override
  QMessageBox loadBox(this);
  msgText = "Do you want to override ALL existing exceptions underneath the defaults or append the results?";
  loadBox.setText(msgText.c_str());
  loadBox.addButton(tr("Override"),QMessageBox::AcceptRole);
  loadBox.addButton(tr("Append"),QMessageBox::NoRole);
  loadBox.addButton(QMessageBox::Cancel);
  loadBox.setDefaultButton(QMessageBox::Cancel);
  retCode = loadBox.exec();
  std::string configName = _globalNameSpecPtr->getConfigName();
  
  std::string systemCommand = "LoadAPDHighVoltagesAndTemps NovaDatabase/tables/DCS ";
  if (retCode == QMessageBox::Cancel){return;}
  else if (retCode == QMessageBox::AcceptRole) {
    std::string tmpstring;
    tmpstring = folderName.toUtf8().constData();
    tmpstring.append("/hvXXXXXX");
    char *hvTmpName = new char[tmpstring.length() + 1]; 
    strcpy(hvTmpName, tmpstring.c_str());  // Get temp name

    tmpstring = folderName.toUtf8().constData();
    tmpstring.append("/tempXXXXXX");  
    char *tempTmpName =  new char[tmpstring.length() + 1];  // Get temp name
    strcpy(tempTmpName, tmpstring.c_str());  // Get temp name

  
    mkstemp(hvTmpName);
    mkstemp(tempTmpName);

    FILE * hvFileTmp = fopen (hvTmpName, "w");
    FILE * tempFileTmp = fopen (tempTmpName, "w");
    
    std::string systemCommandtmp = "";
    
    //defaults
    fputs ("1,default,-1,cold,1533,0,1,2,3,4\n", hvFileTmp);
    fputs ("1,default,-1,warm,2957,0,1,2,3,4\n", hvFileTmp);
    fputs ("1,default,-1,2000,0,1,2,3,4\n",tempFileTmp);
    fclose(hvFileTmp);
    fclose(tempFileTmp);
  
    systemCommandtmp.append(systemCommand);
    systemCommandtmp.append(hvTmpName);
    systemCommandtmp.append(" ");
    systemCommandtmp.append(tempTmpName);
    systemCommandtmp.append(" ");
    systemCommandtmp.append(configName);
    system(systemCommandtmp.c_str());
  
    remove(hvTmpName);
    remove(tempTmpName);
  }

  /////////////////////////////////
  // Prompt user with status ans load into the database
   //#Output the database environment
  //echo
  //echo 'Loading into' $NOVADBNAME 'on' $NOVADBHOST 'at port' $NOVADBPORT '....'

  //#Load the Thesholds and Masks
 
  systemCommand.append(hvFileName);
  systemCommand.append(" ");
  systemCommand.append(tempFileName);
  systemCommand.append(" ");
  systemCommand.append(configName);
  std::cout<<systemCommand.c_str()<<std::endl;
  system(systemCommand.c_str());

  ///////////////////////////////
  //Refresh the editor
  reloadCurrentDataset();
  
} // end of loadHVAndTemps

} // end of namespace gui
} // end of namespace dbutils