/** Creates a TimeSeriesProperty<bool> showing times when a particular period was active.
* @param period :: The data period
* @return the times when requested period was active
*/
Kernel::Property* LoadRaw::createPeriodLog(int period)const
{
Kernel::TimeSeriesProperty<int>* periods = dynamic_cast< Kernel::TimeSeriesProperty<int>* >(m_perioids.get());
if(!periods) return 0;
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;
}
void AddSinglePointTimeSeriesProperty(API::LogManager &logManager,
const std::string &time,
const std::string &name,
const TYPE value) {
// create time series property and add single value
Kernel::TimeSeriesProperty<TYPE> *p =
new Kernel::TimeSeriesProperty<TYPE>(name);
p->addValue(time, value);
// add to log manager
logManager.addProperty(p);
}
/// Run the LoadLog Child Algorithm
void LoadMuonNexus1::runLoadLog(DataObjects::Workspace2D_sptr localWorkspace) {
IAlgorithm_sptr loadLog = createChildAlgorithm("LoadMuonLog");
// Pass through the same input filename
loadLog->setPropertyValue("Filename", m_filename);
// Set the workspace property to be the same one filled above
loadLog->setProperty<MatrixWorkspace_sptr>("Workspace", localWorkspace);
// Now execute the Child Algorithm. Catch and log any error, but don't stop.
try {
loadLog->execute();
} catch (std::runtime_error &) {
g_log.error("Unable to successfully run LoadLog Child Algorithm");
} catch (std::logic_error &) {
g_log.error("Unable to successfully run LoadLog Child Algorithm");
}
if (!loadLog->isExecuted())
g_log.error("Unable to successfully run LoadLog Child Algorithm");
NXRoot root(m_filename);
try {
NXChar orientation = root.openNXChar("run/instrument/detector/orientation");
// some files have no data there
orientation.load();
if (orientation[0] == 't') {
Kernel::TimeSeriesProperty<double> *p =
new Kernel::TimeSeriesProperty<double>("fromNexus");
std::string start_time = root.getString("run/start_time");
p->addValue(start_time, -90.0);
localWorkspace->mutableRun().addLogData(p);
setProperty("MainFieldDirection", "Transverse");
} else {
setProperty("MainFieldDirection", "Longitudinal");
}
} catch (...) {
setProperty("MainFieldDirection", "Longitudinal");
}
auto &run = localWorkspace->mutableRun();
int n = static_cast<int>(m_numberOfPeriods);
ISISRunLogs runLogs(run, n);
runLogs.addStatusLog(run);
}
/*
* Merge 2 TimeSeries log together for the third one
* @param ilogname1: name of log 1 to be merged
* @param ilogname2: name of log 2 to be merged
* @param ologname: name of the merged log to be added to workspace
*/
void Merge2WorkspaceLogs::mergeLogs(std::string ilogname1,
std::string ilogname2, std::string ologname,
bool resetlogvalue, double logvalue1,
double logvalue2) {
// 1. Get log
Kernel::TimeSeriesProperty<double> *p1 = getTimeSeriesLog(ilogname1);
Kernel::TimeSeriesProperty<double> *p2 = getTimeSeriesLog(ilogname2);
std::vector<Kernel::DateAndTime> times1 = p1->timesAsVector();
std::vector<Kernel::DateAndTime> times2 = p2->timesAsVector();
Kernel::TimeSeriesProperty<double> *rp =
new Kernel::TimeSeriesProperty<double>(ologname);
// 2. Merge
size_t index1 = 0;
size_t index2 = 0;
bool icont = true;
Kernel::DateAndTime tmptime;
double tmpvalue;
bool launch1 = true;
;
bool nocomparison = false;
std::cout << "Merging!!" << std::endl;
while (icont) {
// std::cout << "index1 = " << index1 << ", index2 = " << index2 << ",
// launch1 = " << launch1 << ", nocomparison = " << nocomparison <<
// std::endl;
// i. Determine which log to work on
if (!nocomparison) {
if (times1[index1] < times2[index2]) {
launch1 = true;
} else {
launch1 = false;
}
}
// ii. Retrieve data from source log
if (launch1) {
// Add log1
tmptime = times1[index1];
if (resetlogvalue) {
tmpvalue = logvalue1;
} else {
tmpvalue = p1->getSingleValue(tmptime);
}
} else {
// Add log 2
tmptime = times2[index2];
if (resetlogvalue) {
tmpvalue = logvalue2;
} else {
tmpvalue = p2->getSingleValue(tmptime);
}
}
// iii. Add log
rp->addValue(tmptime, tmpvalue);
// iv. Increase step
if (launch1) {
index1++;
} else {
index2++;
}
// v. Determine status
if (nocomparison) {
// no comparison case: transition to terminate while
if (launch1 && index1 >= times1.size()) {
icont = false;
} else if (!launch1 && index2 >= times2.size()) {
icont = false;
}
} else {
// still in comparison: transition to no-comparison
if (launch1 && index1 >= times1.size()) {
nocomparison = true;
launch1 = false;
} else if (!launch1 && index2 >= times2.size()) {
nocomparison = true;
launch1 = true;
}
} // ENDIFELSE nocomparison
} // ENDWHILE
// 3. Check and add new log
int newlogsize = rp->size();
if (size_t(newlogsize) != (times1.size() + times2.size())) {
g_log.error()
<< "Resulted log size is not equal to the sum of two source log sizes"
<< std::endl;
throw;
}
matrixWS->mutableRun().addProperty(rp);
return;
}
/**
* reads the .log stream and creates timeseries property and sets that to the run object
* @param logFileStream :: The stream of the log file (data).
* @param logFileName :: The name of the log file to load.
* @param run :: The run information object
*/
void LoadLog::loadThreeColumnLogFile(std::ifstream& logFileStream, std::string logFileName, API::Run& run)
{
std::string str;
std::string propname;
Mantid::Kernel::TimeSeriesProperty<double>* logd = 0;
Mantid::Kernel::TimeSeriesProperty<std::string>* logs = 0;
std::map<std::string,Kernel::TimeSeriesProperty<double>*> dMap;
std::map<std::string,Kernel::TimeSeriesProperty<std::string>*> sMap;
typedef std::pair<std::string,Kernel::TimeSeriesProperty<double>* > dpair;
typedef std::pair<std::string,Kernel::TimeSeriesProperty<std::string>* > spair;
kind l_kind(LoadLog::empty);
bool isNumeric(false);
if (!logFileStream)
{
throw std::invalid_argument("Unable to open file " + m_filename);
}
while(Mantid::Kernel::Strings::extractToEOL(logFileStream,str))
{
if ( !isDateTimeString(str) )
{
throw std::invalid_argument("File" + logFileName + " is not a standard ISIS log file. Expected to be a file starting with DateTime String format.");
}
if (!Kernel::TimeSeriesProperty<double>::isTimeString(str) || (str[0]=='#'))
{ //if the line doesn't start with a time read the next line
continue;
}
std::stringstream line(str);
std::string timecolumn;
line >> timecolumn;
std::string blockcolumn;
line >> blockcolumn;
l_kind = classify(blockcolumn);
if ( LoadLog::string != l_kind )
{
throw std::invalid_argument("ISIS log file contains unrecognised second column entries:" + logFileName);
}
std::string valuecolumn;
line >> valuecolumn;
l_kind = classify(valuecolumn);
if ( LoadLog::string != l_kind && LoadLog::number != l_kind)
{
continue; //no value defined, just skip this entry
}
// column two in .log file is called block column
propname = stringToLower(blockcolumn);
//check if the data is numeric
std::istringstream istr(valuecolumn);
double dvalue;
istr >> dvalue;
isNumeric = !istr.fail();
if (isNumeric)
{
std::map<std::string,Kernel::TimeSeriesProperty<double>*>::iterator ditr = dMap.find(propname);
if(ditr != dMap.end())
{
Kernel::TimeSeriesProperty<double>* prop = ditr->second;
if (prop) prop->addValue(timecolumn,dvalue);
}
else
{
logd = new Kernel::TimeSeriesProperty<double>(propname);
logd->addValue(timecolumn,dvalue);
dMap.insert(dpair(propname,logd));
}
}
else
{
std::map<std::string,Kernel::TimeSeriesProperty<std::string>*>::iterator sitr = sMap.find(propname);
if(sitr != sMap.end())
{
Kernel::TimeSeriesProperty<std::string>* prop = sitr->second;
if (prop) prop->addValue(timecolumn,valuecolumn);
}
else
{
logs = new Kernel::TimeSeriesProperty<std::string>(propname);
logs->addValue(timecolumn,valuecolumn);
sMap.insert(spair(propname,logs));
}
}
}
try
{
std::map<std::string,Kernel::TimeSeriesProperty<double>*>::const_iterator itr = dMap.begin();
for(;itr != dMap.end(); ++itr)
{
run.addLogData(itr->second);
}
std::map<std::string,Kernel::TimeSeriesProperty<std::string>*>::const_iterator sitr = sMap.begin();
for(;sitr!=sMap.end();++sitr)
{
run.addLogData(sitr->second);
}
}
catch(std::invalid_argument &e)
{
g_log.warning() << e.what();
}
catch(Exception::ExistsError&e)
{
g_log.warning() << e.what();
}
}
/*
* Add and check log from processed absolute time stamps
*/
void ProcessDasNexusLog::addLog(API::MatrixWorkspace_sptr ws,
std::vector<Kernel::DateAndTime> timevec,
double unifylogvalue, std::string logname,
std::vector<Kernel::DateAndTime> pulsetimes,
std::vector<double> orderedtofs, bool docheck) {
// 1. Do some static
g_log.notice() << "Vector size = " << timevec.size() << std::endl;
double sum1dtms = 0.0; // sum(dt^2)
double sum2dtms = 0.0; // sum(dt^2)
size_t numinvert = 0;
size_t numsame = 0;
size_t numnormal = 0;
double maxdtms = 0;
double mindtms = 1.0E20;
size_t numdtabove10p = 0;
size_t numdtbelow10p = 0;
double sampledtms = 0.00832646 * 1.0E6;
double dtmsA10p = sampledtms * 1.1;
double dtmsB10p = sampledtms / 1.0;
for (size_t i = 1; i < timevec.size(); i++) {
int64_t dtns =
timevec[i].totalNanoseconds() - timevec[i - 1].totalNanoseconds();
double dtms = static_cast<double>(dtns) * 1.0E-3;
sum1dtms += dtms;
sum2dtms += dtms * dtms;
if (dtns == 0)
numsame++;
else if (dtns < 0)
numinvert++;
else
numnormal++;
if (dtms > maxdtms)
maxdtms = dtms;
if (dtms < mindtms)
mindtms = dtms;
if (dtms > dtmsA10p)
numdtabove10p++;
else if (dtms < dtmsB10p)
numdtbelow10p++;
} // ENDFOR
double dt = sum1dtms / static_cast<double>(timevec.size()) * 1.0E-6;
double stddt =
sqrt(sum2dtms / static_cast<double>(timevec.size()) * 1.0E-12 - dt * dt);
g_log.notice() << "Normal dt = " << numnormal << std::endl;
g_log.notice() << "Zero dt = " << numsame << std::endl;
g_log.notice() << "Negative dt = " << numinvert << std::endl;
g_log.notice() << "Avg d(T) = " << dt << " seconds +/- " << stddt
<< ", Frequency = " << 1.0 / dt << std::endl;
g_log.notice() << "d(T) (unit ms) is in range [" << mindtms << ", " << maxdtms
<< "]" << std::endl;
g_log.notice() << "Number of d(T) 10% larger than average = "
<< numdtabove10p << std::endl;
g_log.notice() << "Number of d(T) 10% smaller than average = "
<< numdtbelow10p << std::endl;
g_log.notice() << "Size of timevec, pulsestimes, orderedtofs = "
<< timevec.size() << ", " << pulsetimes.size() << ", "
<< orderedtofs.size() << std::endl;
if (docheck) {
exportErrorLog(ws, timevec, pulsetimes, orderedtofs, 1 / (0.5 * 240.1));
calDistributions(timevec, 1 / (0.5 * 240.1));
}
// 2. Add log
Kernel::TimeSeriesProperty<double> *newlog =
new Kernel::TimeSeriesProperty<double>(logname);
for (size_t i = 0; i < timevec.size(); i++) {
newlog->addValue(timevec[i], unifylogvalue);
}
ws->mutableRun().addProperty(newlog, true);
return;
}