LogParser.cpp

//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidKernel/LogParser.h"
#include "MantidKernel/Strings.h"
#include "MantidKernel/Logger.h"
#include "MantidKernel/PropertyWithValue.h"
#include "MantidKernel/TimeSeriesProperty.h"

#include <fstream>

// constants for the new style icp event commands
const char *START_COLLECTION = "START_COLLECTION";
const char *STOP_COLLECTION = "STOP_COLLECTION";

using std::size_t;

namespace Mantid {
namespace Kernel {
namespace {
/// static logger
Logger g_log("LogParser");
}

/// @returns the name of the log created that defines the status during a run
const std::string LogParser::statusLogName() { return std::string("running"); }

/// @returns the name of the log that contains all of the periods
const std::string LogParser::periodsLogName() { return std::string("periods"); }

/**  Reads in log data from a log file and stores them in a TimeSeriesProperty.
@param logFName :: The name of the log file
@param name :: The name of the property
@return A pointer to the created property.
*/
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 0;
  }

  // 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 =
            "Cannot parse log file " + logFName + ". Line:" + 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.insert(std::make_pair(stime, sdata));
  }

  if (change_times.empty())
    return 0;

  if (isNumeric) {
    Kernel::TimeSeriesProperty<double> *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 {
    Kernel::TimeSeriesProperty<std::string> *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 0;
}

/**
 * Destructor
 */
LogParser::~LogParser() {}

/**
Common creational method for generating a command map.
Better ensures that the same command mapping is available for any constructor.
@param newStyle Command style selector.
@return fully constructed command map.
*/
LogParser::CommandMap LogParser::createCommandMap(bool newStyle) const {
  CommandMap command_map;

  if (newStyle) {
    command_map["START_COLLECTION"] = BEGIN;
    command_map["STOP_COLLECTION"] = END;
    command_map["CHANGE"] = CHANGE_PERIOD;
    command_map["CHANGE_PERIOD"] = CHANGE_PERIOD;
  } else {
    command_map["BEGIN"] = BEGIN;
    command_map["RESUME"] = BEGIN;
    command_map["END_SE_WAIT"] = BEGIN;
    command_map["PAUSE"] = END;
    command_map["END"] = END;
    command_map["ABORT"] = END;
    command_map["UPDATE"] = END;
    command_map["START_SE_WAIT"] = END;
    command_map["CHANGE"] = CHANGE_PERIOD;
    command_map["CHANGE_PERIOD"] = CHANGE_PERIOD;
  }
  return command_map;
}

/**
Try to pass the periods
@param scom : The command corresponding to a change in period.
@param time : The time
@param idata : stream of input data
@param periods : periods data to update
*/
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);
  }
}

/** Create given the icpevent log property.
*  @param log :: A pointer to the property
*/
LogParser::LogParser(const Kernel::Property *log) : m_nOfPeriods(1) {
  Kernel::TimeSeriesProperty<int> *periods =
      new Kernel::TimeSeriesProperty<int>(periodsLogName());
  Kernel::TimeSeriesProperty<bool> *status =
      new Kernel::TimeSeriesProperty<bool>(statusLogName());
  m_periods.reset(periods);
  m_status.reset(status);

  const Kernel::TimeSeriesProperty<std::string> *icpLog =
      dynamic_cast<const Kernel::TimeSeriesProperty<std::string> *>(log);
  if (!icpLog || icpLog->size() == 0) {
    periods->addValue(Kernel::DateAndTime(), 1);
    status->addValue(Kernel::DateAndTime(), true);
    g_log.warning()
        << "Cannot process ICPevent log. Period 1 assumed for all data.\n";
    return;
  }

  std::multimap<Kernel::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 == CHANGE_PERIOD) {
      tryParsePeriod(scom, it->first, idata, periods);
    } else if (com == BEGIN) {
      status->addValue(it->first, true);
    } else if (com == END) {
      status->addValue(it->first, false);
    }
  };

  if (periods->size() == 0)
    periods->addValue(icpLog->firstTime(), 1);
  if (status->size() == 0)
    status->addValue(icpLog->firstTime(), true);
}

/** Creates a TimeSeriesProperty<bool> showing times when a particular period
 * was active.
 *  @param period :: The data period
 *  @return times requested period was active
 */
Kernel::TimeSeriesProperty<bool> *LogParser::createPeriodLog(int period) const {
  Kernel::TimeSeriesProperty<int> *periods =
      dynamic_cast<Kernel::TimeSeriesProperty<int> *>(m_periods.get());
  if (!periods) {
    throw std::logic_error("Failed to cast periods to TimeSeriesProperty");
  }
  std::ostringstream ostr;
  ostr << period;
  Kernel::TimeSeriesProperty<bool> *p =
      new Kernel::TimeSeriesProperty<bool>("period " + ostr.str());
  std::map<Kernel::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 p;
}

/**
 * Create a log vale for the current period.
 * @param period: The period number to create the log entry for.
*/
Kernel::Property *LogParser::createCurrentPeriodLog(const int &period) const {
  Kernel::PropertyWithValue<int> *currentPeriodProperty =
      new Kernel::PropertyWithValue<int>("current_period", period);
  return currentPeriodProperty;
}

/// Ctreates a TimeSeriesProperty<int> with all data periods
Kernel::Property *LogParser::createAllPeriodsLog() const {
  return m_periods->clone();
}

/// Creates a TimeSeriesProperty<bool> with running status
Kernel::TimeSeriesProperty<bool> *LogParser::createRunningLog() const {
  return m_status->clone();
}

namespace {
/// Define operator for checking for new-style icp events
struct hasNewStyleCommands {
  bool
  operator()(const std::pair<Mantid::Kernel::DateAndTime, std::string> &p) {
    return p.second.find(START_COLLECTION) != std::string::npos ||
           p.second.find(STOP_COLLECTION) != std::string::npos;
  }
};
}

/**
 * Check if the icp log commands are in the new style. The new style is the one
 * that uses START_COLLECTION and STOP_COLLECTION commands for changing periods
 * and running status.
 * @param logm :: A log map created from a icp-event log.
 */
bool LogParser::isICPEventLogNewStyle(
    const std::multimap<Kernel::DateAndTime, std::string> &logm) {
  hasNewStyleCommands checker;

  return std::find_if(logm.begin(), logm.end(), checker) != logm.end();
}

/**
 * Returns the time-weighted mean value if the property is
 * TimeSeriesProperty<double>.
 *
 * TODO: Make this more efficient.
 *
 * @param p :: Property with the data. Will throw if not
 *             TimeSeriesProperty<double>.
 * @return The mean value over time.
 * @throw runtime_error if the property is not TimeSeriesProperty<double>
*/
double timeMean(const Kernel::Property *p) {
  const Kernel::TimeSeriesProperty<double> *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>.");
  }

  // Special case for only one value - the algorithm
  if (dp->size() == 1) {
    return dp->nthValue(1);
  }
  double res = 0.;
  Kernel::time_duration total(0, 0, 0, 0);
  size_t dp_size = dp->size();
  for (size_t i = 0; i < dp_size; i++) {
    Kernel::TimeInterval t = dp->nthInterval(static_cast<int>(i));
    Kernel::time_duration dt = t.length();
    total += dt;
    res += dp->nthValue(static_cast<int>(i)) *
           Kernel::DateAndTime::secondsFromDuration(dt);
  }

  double total_seconds = Kernel::DateAndTime::secondsFromDuration(total);

  // If all the time stamps were the same, just return the first value.
  if (total_seconds == 0.0)
    res = dp->nthValue(1);

  if (total_seconds > 0)
    res /= total_seconds;

  return res;
}

} // namespace Geometry
} // namespace Mantid