void StartLiveDataDialog::accept()
{
// Now manually set the StartTime property as there's a computation needed
DateAndTime startTime = DateAndTime::getCurrentTime() - ui.dateTimeEdit->value()*60.0;
m_algorithm->setPropertyValue("StartTime",startTime.toISO8601String());
AlgorithmDialog::accept(); // accept executes the algorithm
}
/** Process any HTTP errors states.
@param res : The http response
@param rs : The iutput stream from the response
@param url : The url originally called
@exception Mantid::Kernel::Exception::InternetError : Coded for the failure
state.
*/
int InternetHelper::processErrorStates(const Poco::Net::HTTPResponse &res,
std::istream &rs,
const std::string &url) {
int retStatus = res.getStatus();
g_log.debug() << "Answer from web: " << res.getStatus() << " "
<< res.getReason() << std::endl;
// get github api rate limit information if available;
int rateLimitRemaining;
DateAndTime rateLimitReset;
try {
rateLimitRemaining =
boost::lexical_cast<int>(res.get("X-RateLimit-Remaining", "-1"));
rateLimitReset.set_from_time_t(
boost::lexical_cast<int>(res.get("X-RateLimit-Reset", "0")));
} catch (boost::bad_lexical_cast const &) {
rateLimitRemaining = -1;
}
if (retStatus == HTTP_OK) {
throw Exception::InternetError("Response was ok, processing should never "
"have entered processErrorStates",
retStatus);
} else if (retStatus == HTTP_FOUND) {
throw Exception::InternetError("Response was HTTP_FOUND, processing should "
"never have entered processErrorStates",
retStatus);
} else if (retStatus == HTTP_MOVED_PERMANENTLY) {
throw Exception::InternetError("Response was HTTP_MOVED_PERMANENTLY, "
"processing should never have entered "
"processErrorStates",
retStatus);
} else if (retStatus == HTTP_NOT_MODIFIED) {
throw Exception::InternetError("Not modified since provided date" +
rateLimitReset.toSimpleString(),
retStatus);
} else if ((retStatus == HTTP_FORBIDDEN) && (rateLimitRemaining == 0)) {
throw Exception::InternetError(
"The Github API rate limit has been reached, try again after " +
rateLimitReset.toSimpleString(),
retStatus);
} else {
std::stringstream info;
std::stringstream ss;
Poco::StreamCopier::copyStream(rs, ss);
if (retStatus == HTTP_NOT_FOUND)
info << "Failed to download " << url << " with the link "
<< "<a href=\"" << url << "\">.\n"
<< "Hint. Check that link is correct</a>";
else {
// show the error
info << res.getReason();
info << ss.str();
g_log.debug() << ss.str();
}
throw Exception::InternetError(info.str() + ss.str(), retStatus);
}
}
/**
* Shift the times in a log of a string property
* @param logEntry :: the string property
* @param timeShift :: the time shift.
*/
void ChangeTimeZero::shiftTimeOfLogForStringProperty(
PropertyWithValue<std::string> *logEntry, double timeShift) const {
// Parse the log entry and replace all ISO8601 strings with an adjusted value
auto value = logEntry->value();
if (checkForDateTime(value)) {
DateAndTime dateTime(value);
DateAndTime shiftedTime = dateTime + timeShift;
logEntry->setValue(shiftedTime.toISO8601String());
}
}
void saveTimeVector(::NeXus::File * file, TimeSeriesProperty<NumT> * prop)
{
std::vector<DateAndTime> times = prop->timesAsVector();
DateAndTime start = times[0];
std::vector<double> timeSec(times.size());
for (size_t i=0; i<times.size(); i++)
timeSec[i] = double(times[i].totalNanoseconds() - start.totalNanoseconds()) * 1e-9;
file->writeData("time", timeSec);
file->openData("time");
file->putAttr("start", start.toISO8601String() );
file->closeData();
}
void PolicyEnforcementEngine::run()
{
PolicyEnforcement* aPolicyEnforcement;
PolicyEnforcementContainerIterator iter;
DateAndTime currentTime;
int waitingSleepTime = 1;
int sleepTimeSeconds = 1;
while (1)
{
if(policyEnforcements.size() != 0)
{
currentTime.update();
{
boost::mutex::scoped_lock lock(mtx);
iter = policyEnforcements.begin();
}
std::cout << "PolicyEnforcementEngine::run() - First element: '" << (*iter)->getName() << "' has start time = " << (*iter)->getStart() << endl;
std::cout << "PolicyEnforcementEngine::run() - Current time: '" << currentTime << endl;
if (currentTime == (*iter)->getStart() )
{
std::cout << "PolicyEnforcementEngine::run() - Removing and running top element in PolicyEnforcement Container ..." << endl;
aPolicyEnforcement = popContainer();
aPolicyEnforcement->run();
}
else
{
std::cout << "PolicyEnforcementEngine::run() - Waiting to run next PolicyEnforcement ..." << endl;
sleep(waitingSleepTime);
}
}
else
{
std::cout << "PolicyEnforcementEngine::run() - Waiting for new PolicyEnforcements ..." << endl;
sleep(waitingSleepTime);
}
}
}
void GitHubApiHelper::processResponseHeaders(
const Poco::Net::HTTPResponse &res) {
// get github api rate limit information if available;
int rateLimitRemaining = 0;
int rateLimitLimit;
DateAndTime rateLimitReset;
try {
rateLimitLimit =
boost::lexical_cast<int>(res.get("X-RateLimit-Limit", "-1"));
rateLimitRemaining =
boost::lexical_cast<int>(res.get("X-RateLimit-Remaining", "-1"));
rateLimitReset.set_from_time_t(
boost::lexical_cast<int>(res.get("X-RateLimit-Reset", "0")));
} catch (boost::bad_lexical_cast const &) {
rateLimitLimit = -1;
}
if (rateLimitLimit > -1) {
g_log.debug() << "GitHub API " << rateLimitRemaining << " of "
<< rateLimitLimit << " calls left. Resets at "
<< rateLimitReset.toSimpleString() << " GMT\n";
}
}
/** Execute the algorithm.
*/
void LoadLiveData::exec() {
// The full, post-processed output workspace
m_outputWS = this->getProperty("OutputWorkspace");
// Validate inputs
if (this->hasPostProcessing()) {
if (this->getPropertyValue("AccumulationWorkspace").empty())
throw std::invalid_argument("Must specify the AccumulationWorkspace "
"parameter if using PostProcessing.");
// The accumulated but not post-processed output workspace
m_accumWS = this->getProperty("AccumulationWorkspace");
} else {
// No post-processing, so the accumulation and output are the same
m_accumWS = m_outputWS;
}
// Get or create the live listener
ILiveListener_sptr listener = this->getLiveListener();
// Do we need to reset the data?
bool dataReset = listener->dataReset();
// The listener returns a MatrixWorkspace containing the chunk of live data.
Workspace_sptr chunkWS;
bool dataNotYetGiven = true;
while (dataNotYetGiven) {
try {
chunkWS = listener->extractData();
dataNotYetGiven = false;
} catch (Exception::NotYet &ex) {
g_log.warning() << "The " << listener->name()
<< " is not ready to return data: " << ex.what() << "\n";
g_log.warning()
<< "Trying again in 10 seconds - cancel the algorithm to stop.\n";
const int tenSeconds = 40;
for (int i = 0; i < tenSeconds; ++i) {
Poco::Thread::sleep(10000 / tenSeconds); // 250 ms
this->interruption_point();
}
}
}
// TODO: Have the ILiveListener tell me exactly the time stamp
DateAndTime lastTimeStamp = DateAndTime::getCurrentTime();
this->setPropertyValue("LastTimeStamp", lastTimeStamp.toISO8601String());
// Now we process the chunk
Workspace_sptr processed = this->processChunk(chunkWS);
bool PreserveEvents = this->getProperty("PreserveEvents");
EventWorkspace_sptr processedEvent =
boost::dynamic_pointer_cast<EventWorkspace>(processed);
if (!PreserveEvents && processedEvent) {
// Convert the monitor workspace, if there is one and it's necessary
MatrixWorkspace_sptr monitorWS = processedEvent->monitorWorkspace();
auto monitorEventWS =
boost::dynamic_pointer_cast<EventWorkspace>(monitorWS);
if (monitorEventWS) {
auto monAlg = this->createChildAlgorithm("ConvertToMatrixWorkspace");
monAlg->setProperty("InputWorkspace", monitorEventWS);
monAlg->executeAsChildAlg();
if (!monAlg->isExecuted())
g_log.error(
"Failed to convert monitors from events to histogram form.");
monitorWS = monAlg->getProperty("OutputWorkspace");
}
// Now do the main workspace
Algorithm_sptr alg = this->createChildAlgorithm("ConvertToMatrixWorkspace");
alg->setProperty("InputWorkspace", processedEvent);
std::string outputName = "__anonymous_livedata_convert_" +
this->getPropertyValue("OutputWorkspace");
alg->setPropertyValue("OutputWorkspace", outputName);
alg->execute();
if (!alg->isExecuted())
throw std::runtime_error("Error when calling ConvertToMatrixWorkspace "
"(since PreserveEvents=False). See log.");
// Replace the "processed" workspace with the converted one.
MatrixWorkspace_sptr temp = alg->getProperty("OutputWorkspace");
if (monitorWS)
temp->setMonitorWorkspace(monitorWS); // Set back the monitor workspace
processed = temp;
}
// How do we accumulate the data?
std::string accum = this->getPropertyValue("AccumulationMethod");
// If the AccumulationWorkspace does not exist, we always replace the
// AccumulationWorkspace.
// Also, if the listener said we are resetting the data, then we clear out the
// old.
if (!m_accumWS || dataReset)
accum = "Replace";
g_log.notice() << "Performing the " << accum << " operation.\n";
// Perform the accumulation and set the AccumulationWorkspace workspace
if (accum == "Replace")
this->replaceChunk(processed);
else if (accum == "Append")
this->appendChunk(processed);
else
// Default to Add.
this->addChunk(processed);
// At this point, m_accumWS is set.
if (this->hasPostProcessing()) {
// ----------- Run post-processing -------------
this->runPostProcessing();
// Set both output workspaces
this->setProperty("AccumulationWorkspace", m_accumWS);
this->setProperty("OutputWorkspace", m_outputWS);
doSortEvents(m_outputWS);
} else {
// ----------- No post-processing -------------
m_outputWS = m_accumWS;
// We DO NOT set AccumulationWorkspace.
this->setProperty("OutputWorkspace", m_outputWS);
}
// Output group requires some additional handling
WorkspaceGroup_sptr out_gws =
boost::dynamic_pointer_cast<WorkspaceGroup>(m_outputWS);
if (out_gws) {
size_t n = static_cast<size_t>(out_gws->getNumberOfEntries());
for (size_t i = 0; i < n; ++i) {
auto ws = out_gws->getItem(i);
std::string itemName = ws->name();
std::string wsName =
getPropertyValue("OutputWorkspace") + "_" + std::to_string(i + 1);
if (wsName != itemName) {
if (AnalysisDataService::Instance().doesExist(itemName)) {
// replace the temporary name with the proper one
AnalysisDataService::Instance().rename(itemName, wsName);
}
} else {
// touch the workspace in the ADS to issue a notification to update the
// GUI
AnalysisDataService::Instance().addOrReplace(itemName, ws);
}
}
}
}
/** Set a value for a widget.
*
* The function needs to know about the types of widgets
* that are being used. Currently it knows about QComboBox, QLineEdit and
* QCheckBox
* @param widget :: A pointer to the widget
* @param propName :: The property name
*/
void AlgorithmDialog::setPreviousValue(QWidget *widget,
const QString &propName) {
// If is called from a script, check if we have such property
if (isForScript() && !getAlgorithmProperty(propName))
return;
QString value = getPreviousValue(propName);
Mantid::Kernel::Property *property = getAlgorithmProperty(propName);
// Do the right thing for the widget type
if (QComboBox *opts = qobject_cast<QComboBox *>(widget)) {
if (property && value.isEmpty()) {
value = QString::fromStdString(property->value());
}
int index = opts->findText(value);
if (index >= 0) {
opts->setCurrentIndex(index);
}
return;
}
if (QAbstractButton *checker = qobject_cast<QAbstractButton *>(widget)) {
if (value.isEmpty() &&
dynamic_cast<Mantid::Kernel::PropertyWithValue<bool> *>(property))
value = QString::fromStdString(property->value());
checker->setChecked(value != "0");
return;
}
if (QDateTimeEdit *dateEdit = qobject_cast<QDateTimeEdit *>(widget)) {
// String in ISO8601 format
DateAndTime t = DateAndTime::getCurrentTime();
try {
t.setFromISO8601(verifyAndSanitizeISO8601(value.toStdString()));
} catch (std::exception &) {
}
dateEdit->setDate(QDate(t.year(), t.month(), t.day()));
dateEdit->setTime(QTime(t.hour(), t.minute(), t.second(), 0));
return;
}
QLineEdit *textfield = qobject_cast<QLineEdit *>(widget);
MantidWidget *mtdwidget = qobject_cast<MantidWidget *>(widget);
if (textfield || mtdwidget) {
if (!isForScript()) {
if (textfield)
textfield->setText(value);
else
mtdwidget->setUserInput(value);
} else {
// Need to check if this is the default value as we don't fill them in if
// they are
if (m_python_arguments.contains(propName) || !property->isDefault()) {
if (textfield)
textfield->setText(value);
else
mtdwidget->setUserInput(value);
}
}
return;
}
PropertyWidget *propWidget = qobject_cast<PropertyWidget *>(widget);
if (propWidget) {
propWidget->setPreviousValue(value);
return;
}
// Reaching here means we have a widget type we don't understand. Tell the
// developer
QMessageBox::warning(
this, windowTitle(),
QString("Cannot set value for ") + widget->metaObject()->className() +
". Update AlgorithmDialog::setValue() to cope with this widget.");
}
/** Circumvent a bug in IPython 1.1, which chokes on nanosecond precision
* datetimes.
* Adding a space to the string returned by the C++ method avoids it being
* given
* the special treatment that leads to the problem.
*/
std::string ISO8601StringPlusSpace(DateAndTime &self) {
return self.toISO8601String() + " ";
}
/** Subtract two times.
* @param rhs object on right of operation
* @return a time_duration
*/
time_duration DateAndTime::operator-(const DateAndTime& rhs) const
{
return this->to_ptime() - rhs.to_ptime();
}
/** Execute the algorithm.
*/
void MonitorLiveData::exec() {
double UpdateEvery = getProperty("UpdateEvery");
if (UpdateEvery <= 0)
throw std::runtime_error("UpdateEvery must be > 0");
// Get the listener (and start listening) as early as possible
ILiveListener_sptr listener = this->getLiveListener();
// Grab ownership of the pointer in the LOCAL listener variable.
// This will make the listener destruct if the algorithm throws,
// but the Algorithm is still in the list of "Managed" algorithms.
m_listener.reset();
// The last time we called LoadLiveData.
// Since StartLiveData _just_ called it, use the current time.
DateAndTime lastTime = DateAndTime::getCurrentTime();
m_chunkNumber = 0;
int runNumber = 0;
int prevRunNumber = 0;
std::string AccumulationWorkspace =
this->getPropertyValue("AccumulationWorkspace");
std::string OutputWorkspace = this->getPropertyValue("OutputWorkspace");
std::string NextAccumulationMethod =
this->getPropertyValue("AccumulationMethod");
// Keep going until you get cancelled
while (true) {
// Exit if the user presses cancel
this->interruption_point();
// Sleep for 50 msec
Poco::Thread::sleep(50);
DateAndTime now = DateAndTime::getCurrentTime();
double seconds = DateAndTime::secondsFromDuration(now - lastTime);
if (seconds > UpdateEvery) {
lastTime = now;
g_log.notice() << "Loading live data chunk " << m_chunkNumber << " at "
<< now.toFormattedString("%H:%M:%S") << '\n';
// Time to run LoadLiveData again
Algorithm_sptr alg = createChildAlgorithm("LoadLiveData");
LoadLiveData *loadAlg = dynamic_cast<LoadLiveData *>(alg.get());
if (!loadAlg)
throw std::runtime_error("Error creating LoadLiveData Child Algorithm");
loadAlg->setChild(true);
// So the output gets put into the ADS
loadAlg->setAlwaysStoreInADS(true);
// Too much logging
loadAlg->setLogging(false);
loadAlg->initialize();
// Copy settings from THIS to LoadAlg
loadAlg->copyPropertyValuesFrom(*this);
// Give the listener directly to LoadLiveData (don't re-create it)
loadAlg->setLiveListener(listener);
// Override the AccumulationMethod when a run ends.
loadAlg->setPropertyValue("AccumulationMethod", NextAccumulationMethod);
// Run the LoadLiveData
loadAlg->executeAsChildAlg();
NextAccumulationMethod = this->getPropertyValue("AccumulationMethod");
if (runNumber == 0) {
runNumber = listener->runNumber();
g_log.debug() << "Run number set to " << runNumber << '\n';
}
// Did we just hit a run transition?
ILiveListener::RunStatus runStatus = listener->runStatus();
if (runStatus == ILiveListener::EndRun) {
// Need to keep track of what the run number *was* so we
// can properly rename workspaces
prevRunNumber = runNumber;
}
if ((runStatus == ILiveListener::BeginRun) ||
(runStatus == ILiveListener::EndRun)) {
std::stringstream message;
message << "Run";
if (runNumber != 0)
message << " #" << runNumber;
message << " ended. ";
std::string RunTransitionBehavior =
this->getPropertyValue("RunTransitionBehavior");
if (RunTransitionBehavior == "Stop") {
g_log.notice() << message.str() << "Stopping live data monitoring.\n";
break;
} else if (RunTransitionBehavior == "Restart") {
g_log.notice() << message.str() << "Clearing existing workspace.\n";
NextAccumulationMethod = "Replace";
} else if (RunTransitionBehavior == "Rename") {
g_log.notice() << message.str() << "Renaming existing workspace.\n";
NextAccumulationMethod = "Replace";
// Now we clone the existing workspaces
std::string postFix;
if (runStatus == ILiveListener::EndRun) {
postFix = "_" + Strings::toString(runNumber);
} else {
// indicate that this is data that arrived *after* the run ended
postFix = "_";
if (prevRunNumber != 0)
postFix += Strings::toString(prevRunNumber);
postFix += "_post";
}
doClone(OutputWorkspace, OutputWorkspace + postFix);
}
runNumber = 0;
}
m_chunkNumber++;
progress(0.0, "Live Data " + Strings::toString(m_chunkNumber));
}
// This is the time to process a single chunk. Is it too long?
seconds = DateAndTime::secondsFromDuration(now - lastTime);
if (seconds > UpdateEvery)
g_log.warning() << "Cannot process live data as quickly as requested: "
"requested every " << UpdateEvery
<< " seconds but it takes " << seconds << " seconds!\n";
} // loop until aborted
// Set the outputs (only applicable when RunTransitionBehavior is "Stop")
Workspace_sptr OutputWS =
AnalysisDataService::Instance().retrieveWS<Workspace>(OutputWorkspace);
this->setProperty("OutputWorkspace", OutputWS);
if (!AccumulationWorkspace.empty()) {
Workspace_sptr AccumulationWS =
AnalysisDataService::Instance().retrieveWS<Workspace>(
AccumulationWorkspace);
this->setProperty("AccumulationWorkspace", AccumulationWS);
}
} // exec()
/**
* Execute the algorithm.
*/
void RebinByTimeBase::exec() {
using Mantid::DataObjects::EventWorkspace;
IEventWorkspace_sptr inWS = getProperty("InputWorkspace");
if (!boost::dynamic_pointer_cast<EventWorkspace>(inWS)) {
const std::string algName = this->name();
throw std::invalid_argument(
algName + " Algorithm requires an EventWorkspace as an input.");
}
MatrixWorkspace_sptr outputWS = getProperty("OutputWorkspace");
// retrieve the properties
const std::vector<double> inParams = getProperty("Params");
std::vector<double> rebinningParams;
// workspace independent determination of length
const int histnumber = static_cast<int>(inWS->getNumberHistograms());
const uint64_t nanoSecondsInASecond = static_cast<uint64_t>(1e9);
const DateAndTime runStartTime = inWS->run().startTime();
// The validator only passes parameters with size 1, or 3xn.
double tStep = 0;
if (inParams.size() >= 3) {
// Use the start of the run to offset the times provided by the user. pulse
// time of the events are absolute.
const DateAndTime startTime = runStartTime + inParams[0];
const DateAndTime endTime = runStartTime + inParams[2];
// Rebinning params in nanoseconds.
rebinningParams.push_back(
static_cast<double>(startTime.totalNanoseconds()));
tStep = inParams[1] * nanoSecondsInASecond;
rebinningParams.push_back(tStep);
rebinningParams.push_back(static_cast<double>(endTime.totalNanoseconds()));
} else if (inParams.size() == 1) {
const uint64_t xmin = getMinX(inWS);
const uint64_t xmax = getMaxX(inWS);
rebinningParams.push_back(static_cast<double>(xmin));
tStep = inParams[0] * nanoSecondsInASecond;
rebinningParams.push_back(tStep);
rebinningParams.push_back(static_cast<double>(xmax));
}
// Validate the timestep.
if (tStep <= 0) {
throw std::invalid_argument(
"Cannot have a timestep less than or equal to zero.");
}
// Initialize progress reporting.
Progress prog(this, 0.0, 1.0, histnumber);
MantidVecPtr XValues_new;
// create new X axis, with absolute times in seconds.
const int ntcnew = VectorHelper::createAxisFromRebinParams(
rebinningParams, XValues_new.access());
ConvertToRelativeTime transformToRelativeT(runStartTime);
// Transform the output into relative times in seconds.
MantidVec OutXValues_scaled(XValues_new->size());
std::transform(XValues_new->begin(), XValues_new->end(),
OutXValues_scaled.begin(), transformToRelativeT);
outputWS = WorkspaceFactory::Instance().create("Workspace2D", histnumber,
ntcnew, ntcnew - 1);
WorkspaceFactory::Instance().initializeFromParent(inWS, outputWS, true);
// Copy all the axes
for (int i = 1; i < inWS->axes(); i++) {
outputWS->replaceAxis(i, inWS->getAxis(i)->clone(outputWS.get()));
outputWS->getAxis(i)->unit() = inWS->getAxis(i)->unit();
}
// X-unit is relative time since the start of the run.
outputWS->getAxis(0)->unit() = boost::make_shared<Units::Time>();
// Copy the units over too.
for (int i = 1; i < outputWS->axes(); ++i) {
outputWS->getAxis(i)->unit() = inWS->getAxis(i)->unit();
}
outputWS->setYUnit(inWS->YUnit());
outputWS->setYUnitLabel(inWS->YUnitLabel());
// Assign it to the output workspace property
setProperty("OutputWorkspace", outputWS);
// Go through all the histograms and set the data
doHistogramming(inWS, outputWS, XValues_new, OutXValues_scaled, prog);
}
explicit ConvertToRelativeTime(const DateAndTime &offSet)
: m_offSet(static_cast<double>(offSet.totalNanoseconds()) * 1e-9) {}
