//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidKernel/LogParser.h"
#include "MantidKernel/TimeSeriesProperty.h"
#include "MantidKernel/PropertyWithValue.h"
#include <algorithm>
#include <fstream>
#include <limits>
#include <sstream>
// 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
{
Kernel::Logger& LogParser::g_log = Mantid::Kernel::Logger::get("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::map<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::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);
}
change_times[stime] += std::string(" ") + str;
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;
//if time is repeated and the data aren't numeric append the new string to the old one
if (!isNumeric && change_times[stime].size() > 0)
change_times[stime] += std::string(" ") + sdata;
else
change_times[stime] = sdata;
}
if (change_times.empty()) return 0;
if (isNumeric)
{
Kernel::TimeSeriesProperty<double>* logv = new Kernel::TimeSeriesProperty<double>(name);
std::map<std::string,std::string>::iterator 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);
std::map<std::string,std::string>::iterator 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;
std::map<Kernel::DateAndTime, std::string>::const_iterator 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());
std::ostringstream ostr;
ostr<<period;
Kernel::TimeSeriesProperty<bool>* p = new Kernel::TimeSeriesProperty<bool> ("period " + ostr.str());
std::map<Kernel::DateAndTime, int> pMap = periods->valueAsMap();
std::map<Kernel::DateAndTime, int>::const_iterator 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;
}
/**
* Extract a string until an EOL character is reached. There are 3 scenarios that we need to deal with
* 1) Windows-style - CRLF ('\\r\\n');
* 2) Unix-style - LF ('\\n');
* 3) Old MAC style - CR ('\\r').
* This function will give the string preceding any of these sequences
* @param is :: The input stream to read from
* @param str :: The output string to use to accumulate the line
* @returns A reference to the input stream
*/
std::istream& extractToEOL(std::istream& is, std::string& str)
{
// Empty the string
str = "";
char c('\0');
while( is.get(c) )
{
if( c == '\r' )
{
c = static_cast<char>(is.peek());
if( c == '\n' )
{
//Extract this as well
is.get();
}
break;
}
else if( c == '\n')
{
break;
}
else
{
//Accumulate the string
str += c;
}
}
return is;
}
} // namespace Geometry
} // namespace Mantid