LogParser.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidKernel/LogParser.h"
#include "MantidKernel/Logger.h"
#include "MantidKernel/PropertyWithValue.h"
#include "MantidKernel/Strings.h"
#include "MantidKernel/TimeROI.h"
#include "MantidKernel/TimeSeriesProperty.h"
 
#include <fstream>
 
// constants for the new style icp event commands
constexpr const char *START_COLLECTION = "START_COLLECTION";
constexpr const char *STOP_COLLECTION = "STOP_COLLECTION";
 
using std::size_t;
 
namespace Mantid {
 
using Types::Core::DateAndTime;
namespace Kernel {
namespace {
Logger g_log("LogParser");
} // namespace
 
Kernel::Property *LogParser::createLogProperty(const std::string &logFName, const std::string &name) {
  std::ifstream file(logFName.c_str());
  if (!file) {
    g_log.warning() << "Cannot open log file " << logFName << "\n";
    return nullptr;
  }
 
  // Change times and new values read from file
  std::multimap<std::string, std::string> change_times;
 
  // Read in the data and determin if it is numeric
  std::string str, old_data;
  bool isNumeric(false);
  std::string stime, sdata;
  // MG 22/09/09: If the log file was written on a Windows machine and then read
  // on a Linux machine, std::getline will
  // leave CR at the end of the string and this causes problems when reading out
  // the log values. Mantid::extractTOEOL
  // extracts all EOL characters
  while (Mantid::Kernel::Strings::extractToEOL(file, str)) {
    if (str.empty() || str[0] == '#') {
      continue;
    }
 
    if (!Kernel::TimeSeriesProperty<double>::isTimeString(str)) {
      // if the line doesn't start with a time treat it as a continuation of the
      // previous data
      if (change_times.empty() || isNumeric) { // if there are no previous data
        std::string mess = std::string("Cannot parse log file ").append(logFName).append(". Line:").append(str);
        g_log.error(mess);
        throw std::logic_error(mess);
      }
      auto range = change_times.equal_range(stime);
      if (range.first != range.second) {
        auto last = range.first;
        for (auto it = last; it != range.second; ++it) {
          last = it;
        }
        last->second += std::string(" ") + str;
        old_data = last->second;
        continue;
      }
    }
    stime = str.substr(0, 19);
    sdata = str.substr(19);
 
    if (sdata == old_data)
      continue; // looking for a change in the data
 
    // check if the data is numeric
    std::istringstream istr(sdata);
    double tmp;
    istr >> tmp;
    isNumeric = !istr.fail();
    old_data = sdata;
 
    change_times.emplace(stime, sdata);
  }
 
  if (change_times.empty())
    return nullptr;
 
  if (isNumeric) {
    auto logv = new Kernel::TimeSeriesProperty<double>(name);
    auto it = change_times.begin();
    for (; it != change_times.end(); ++it) {
      std::istringstream istr(it->second);
      double d;
      istr >> d;
      logv->addValue(it->first, d);
    }
    return logv;
  } else {
    auto logv = new Kernel::TimeSeriesProperty<std::string>(name);
    auto it = change_times.begin();
    for (; it != change_times.end(); ++it) {
      logv->addValue(it->first, it->second);
    }
    return logv;
  }
  return nullptr;
}
 
LogParser::CommandMap LogParser::createCommandMap(bool newStyle) const {
  CommandMap command_map;
 
  if (newStyle) {
    command_map["START_COLLECTION"] = commands::BEGIN;
    command_map["STOP_COLLECTION"] = commands::END;
    command_map["CHANGE"] = commands::CHANGE_PERIOD;
    command_map["CHANGE_PERIOD"] = commands::CHANGE_PERIOD;
    command_map["ABORT"] = commands::ABORT;
  } else {
    command_map["BEGIN"] = commands::BEGIN;
    command_map["RESUME"] = commands::BEGIN;
    command_map["END_SE_WAIT"] = commands::BEGIN;
    command_map["PAUSE"] = commands::END;
    command_map["END"] = commands::END;
    command_map["ABORT"] = commands::ABORT;
    command_map["UPDATE"] = commands::END;
    command_map["START_SE_WAIT"] = commands::END;
    command_map["CHANGE"] = commands::CHANGE_PERIOD;
    command_map["CHANGE_PERIOD"] = commands::CHANGE_PERIOD;
  }
  return command_map;
}
 
void LogParser::tryParsePeriod(const std::string &scom, const DateAndTime &time, std::istringstream &idata,
                               Kernel::TimeSeriesProperty<int> *const periods) {
  int ip = -1;
  bool shouldAddPeriod = false;
  // Handle the version where log flag is CHANGE PERIOD
  if (scom == "CHANGE") {
    std::string s;
    idata >> s >> ip;
    if (ip > 0 && s == "PERIOD") {
      shouldAddPeriod = true;
    }
  }
  // Handle the version where log flat is CHANGE_PERIOD
  else if (scom == "CHANGE_PERIOD") {
    idata >> ip;
    if (ip > 0) {
      shouldAddPeriod = true;
    }
  }
  // Common for either variant of the log flag.
  if (shouldAddPeriod) {
    if (ip > m_nOfPeriods) {
      m_nOfPeriods = ip;
    }
    periods->addValue(time, ip);
  }
}
 
LogParser::LogParser(const Kernel::Property *log) : m_nOfPeriods(1) {
  m_periods.reset(new Kernel::TimeSeriesProperty<int>(periodsLogName()));
  m_status.reset(new Kernel::TimeSeriesProperty<bool>(statusLogName()));
 
  const auto *icpLog = dynamic_cast<const Kernel::TimeSeriesProperty<std::string> *>(log);
  if (!icpLog || icpLog->size() == 0) {
    m_periods->addValue(Types::Core::DateAndTime(), 1);
    m_status->addValue(Types::Core::DateAndTime(), true);
    g_log.information() << "Cannot process ICPevent log. Period 1 assumed for all data.\n";
    return;
  }
 
  std::multimap<Types::Core::DateAndTime, std::string> logm = icpLog->valueAsMultiMap();
  CommandMap command_map = createCommandMap(LogParser::isICPEventLogNewStyle(logm));
 
  m_nOfPeriods = 1;
 
  auto it = logm.begin();
 
  for (; it != logm.end(); ++it) {
    std::string scom;
    std::istringstream idata(it->second);
    idata >> scom;
    commands com = command_map[scom];
    if (com == commands::CHANGE_PERIOD) {
      tryParsePeriod(scom, it->first, idata, m_periods.get());
    } else if (com == commands::BEGIN) {
      m_status->addValue(it->first, true);
    } else if (com == commands::END) {
      m_status->addValue(it->first, false);
    } else if (com == commands::ABORT) {
      // Set all previous values to false
      const auto &times = m_status->timesAsVector();
      const std::vector<bool> values(times.size(), false);
      m_status->replaceValues(times, values);
      // Add a new value at the present time
      m_status->addValue(it->first, false);
    }
  };
 
  if (m_periods->size() == 0)
    m_periods->addValue(icpLog->firstTime(), 1);
  if (m_status->size() == 0)
    m_status->addValue(icpLog->firstTime(), true);
}
 
Kernel::TimeSeriesProperty<bool> *LogParser::createPeriodLog(int period) const {
  auto const *periods = dynamic_cast<Kernel::TimeSeriesProperty<int> *>(m_periods.get());
  if (!periods) {
    throw std::logic_error("Failed to cast periods to TimeSeriesProperty");
  }
  Kernel::TimeSeriesProperty<bool> *p = new Kernel::TimeSeriesProperty<bool>(LogParser::currentPeriodLogName(period));
  std::map<Types::Core::DateAndTime, int> pMap = periods->valueAsMap();
  auto it = pMap.begin();
  if (it->second != period)
    p->addValue(it->first, false);
  for (; it != pMap.end(); ++it) {
 
    p->addValue(it->first, (it->second == period));
  }
 
  return std::move(p);
}
 
const std::string LogParser::currentPeriodLogName(const int period) {
  std::ostringstream ostr;
  ostr << period;
  return "period " + ostr.str();
}
 
Kernel::Property *LogParser::createCurrentPeriodLog(const int &period) const {
  Kernel::PropertyWithValue<int> *currentPeriodProperty =
      new Kernel::PropertyWithValue<int>(currentPeriodLogName(), period);
  return currentPeriodProperty;
}
 
Kernel::Property *LogParser::createAllPeriodsLog() const { return m_periods->clone(); }
 
Kernel::TimeSeriesProperty<bool> *LogParser::createRunningLog() const { return m_status->clone(); }
 
namespace {
struct hasNewStyleCommands {
  bool operator()(const std::pair<Mantid::Types::Core::DateAndTime, std::string> &p) {
    return p.second.find(START_COLLECTION) != std::string::npos || p.second.find(STOP_COLLECTION) != std::string::npos;
  }
};
} // namespace
 
bool LogParser::isICPEventLogNewStyle(const std::multimap<Types::Core::DateAndTime, std::string> &logm) {
  hasNewStyleCommands checker;
 
  return std::find_if(logm.begin(), logm.end(), checker) != logm.end();
}
 
double timeMean(const Kernel::Property *p, const Kernel::TimeROI *roi) {
  const auto *dp = dynamic_cast<const Kernel::TimeSeriesProperty<double> *>(p);
  if (!dp) {
    throw std::runtime_error("Property of a wrong type. Cannot be cast to a "
                             "TimeSeriesProperty<double>.");
  }
 
  return dp->timeAverageValue(roi);
}
 
} // namespace Kernel
} // namespace Mantid