First version of ChangeLogTime. It only works inplace for the moment. Refs #3179.

Code/Mantid/Framework/Algorithms/CMakeLists.txt

@@ -10,6 +10,7 @@ set ( SRC_FILES
 	src/CalculateTransmissionBeamSpreader.cpp
 	src/CaltoDspacemap.cpp
 	src/ChangeBinOffset.cpp
+	src/ChangeLogTime.cpp
 	src/ChangePulsetime.cpp
 	src/CheckWorkspacesMatch.cpp
 	src/ChopData.cpp
@@ -161,6 +162,7 @@ set ( INC_FILES
 	inc/MantidAlgorithms/CalculateTransmissionBeamSpreader.h
 	inc/MantidAlgorithms/CaltoDspacemap.h
 	inc/MantidAlgorithms/ChangeBinOffset.h
+	inc/MantidAlgorithms/ChangeLogTime.h
 	inc/MantidAlgorithms/ChangePulsetime.h
 	inc/MantidAlgorithms/CheckWorkspacesMatch.h
 	inc/MantidAlgorithms/ChopData.h
@@ -312,6 +314,7 @@ set ( TEST_FILES
 	test/CalculateTransmissionTest.h
 	test/ChainedOperatorTest.h
 	test/ChangeBinOffsetTest.h
+	test/ChangeLogTimeTest.h
 	test/ChangePulsetimeTest.h
 	test/CheckWorkspacesMatchTest.h
 	test/ChopDataTest.h

Code/Mantid/Framework/Algorithms/inc/MantidAlgorithms/ChangeLogTime.h

+#ifndef CHANGELOGTIME_H
+#define CHANGELOGTIME_H
+
+#include "MantidAPI/Algorithm.h"
+
+namespace Mantid
+{
+namespace Algorithms
+{
+
+class ChangeLogTime : public API::Algorithm
+{
+public:
+    ChangeLogTime();
+    ~ChangeLogTime();
+
+    const std::string name() const;
+    int version() const;
+    const std::string category() const;
+
+private:
+  /// Sets documentation strings for this algorithm
+  virtual void initDocs();
+  /// Initialise the properties
+  void init();
+  /// Run the algorithm
+  void exec();
+};
+
+} // namespace Mantid
+} // namespace Algorithms
+#endif // CHANGELOGTIME_H

Code/Mantid/Framework/Algorithms/src/ChangeLogTime.cpp

+#include "MantidAlgorithms/ChangeLogTime.h"
+#include "MantidDataObjects/EventWorkspace.h"
+#include "MantidKernel/TimeSeriesProperty.h"
+#include <sstream>
+
+namespace Mantid
+{
+namespace Algorithms
+{
+
+// Register the algorithm into the AlgorithmFactory
+DECLARE_ALGORITHM(ChangeLogTime);
+
+using std::string;
+using std::stringstream;
+using std::vector;
+using namespace Mantid::API;
+using namespace Mantid::DataObjects;
+using namespace Mantid::Kernel;
+
+ChangeLogTime::ChangeLogTime()
+{
+}
+
+ChangeLogTime::~ChangeLogTime()
+{
+}
+
+/// Algorithm's name for identification
+const string ChangeLogTime::name() const
+{
+  return "ChangeLogTime";
+}
+
+/// Algorithm's version for identification
+int ChangeLogTime::version() const
+{
+  return 1;
+}
+
+/// Algorithm's category for identification
+const std::string ChangeLogTime::category() const
+{
+  return "General";
+}
+
+void ChangeLogTime::initDocs()
+{
+
+}
+
+void ChangeLogTime::init()
+{
+  declareProperty( new WorkspaceProperty<API::MatrixWorkspace>("InputWorkspace","",Direction::Input),
+    "A workspace with units of TOF" );
+  declareProperty( new WorkspaceProperty<API::MatrixWorkspace>("OutputWorkspace","",Direction::Output),
+    "The name to use for the output workspace" );
+  this->declareProperty("LogName", "", "Name of the log to add the offset to");
+  this->declareProperty(new PropertyWithValue<double>("TimeOffset",Direction::Input),
+        "Number of seconds (a float) to add to the time of each log value. Required.");
+}
+
+void ChangeLogTime::exec()
+{
+  // check that a log was specified
+  string logname = this->getProperty("LogName");
+  if (logname.empty()) {
+    throw std::runtime_error("Failed to supply a LogName");
+  }
+  // everything will need an offset
+  double offset = this->getProperty("TimeOffset");
+
+  // make sure the log is in the input workspace
+  MatrixWorkspace_sptr inputWS = getProperty("InputWorkspace");
+  Kernel::TimeSeriesProperty<double> * oldlog = dynamic_cast<Kernel::TimeSeriesProperty<double> *>( inputWS->run().getLogData(logname) );
+  if (!oldlog) {
+    stringstream msg;
+    msg << "InputWorkspace \'" << this->getPropertyValue("InputWorkspace")
+        << "\' does not have LogName \'" << logname << "\'";
+    throw std::runtime_error(msg.str());
+  }
+
+  // Create the new log
+  TimeSeriesProperty<double>* newlog = new TimeSeriesProperty<double>(logname);
+  newlog->setUnits(oldlog->units());
+  int size = oldlog->realSize();
+  vector<double> values = oldlog->valuesAsVector();
+  vector<DateAndTime> times = oldlog->timesAsVector();
+  for (int i = 0; i < size; i++) {
+    newlog->addValue(times[i] + offset, values[i]);
+  }
+
+  // Just overwrite if the change is in place
+  API::MatrixWorkspace_sptr outputWS = getProperty("OutputWorkspace");
+  if (outputWS == inputWS) {
+    inputWS->mutableRun().addProperty(newlog, true);
+    return;
+  }
+
+  // see if input workspace is event
+  EventWorkspace_const_sptr eventWS = boost::dynamic_pointer_cast<const EventWorkspace>(inputWS);
+  if (eventWS != NULL)
+  {
+    // TODO
+  }
+  else
+  {
+    // TODO
+  }
+}
+
+} // namespace Mantid
+} // namespace Algorithms

Code/Mantid/Framework/Algorithms/test/ChangeLogTimeTest.h

+#ifndef CHANGELOGTIMETEST_H_
+#define CHANGELOGTIMETEST_H_
+
+#include <cxxtest/TestSuite.h>
+#include "MantidAlgorithms/ChangeLogTime.h"
+#include "MantidDataObjects/Workspace2D.h"
+#include "MantidKernel/TimeSeriesProperty.h"
+
+using std::string;
+using namespace Mantid::Algorithms;
+using namespace Mantid::API;
+using namespace Mantid::DataObjects;
+using namespace Mantid::Kernel;
+
+class ChangeLogTimeTest : public CxxTest::TestSuite
+{
+public:
+  ChangeLogTimeTest()
+  {
+    length = 10;
+    logname = "fakelog";
+    start_str = "2011-07-14T12:00Z";
+  }
+
+  void xtestCopyHist()
+  {
+    this->verify("ChangeLogTime_in", "ChangeLogTime_out");
+  }
+
+  void testInplace() {
+    this->verify("ChangeLogTime", "ChangeLogTime");
+  }
+
+private:
+  std::string logname;
+  int length;
+  std::string start_str;
+
+  void verify(const std::string in_name, const std::string out_name)
+  {
+    DateAndTime start(start_str);
+
+    // create a workspace to mess with
+    Workspace2D_sptr testWorkspace(new Workspace2D);
+    testWorkspace->setTitle("input2D");
+    testWorkspace->initialize(5,2,2);
+    int jj=0;
+    for (int i =0; i < 2; ++i)
+    {
+      for (jj=0; jj<4; ++jj)
+      testWorkspace->dataX(jj)[i] = 1.0*i;
+      testWorkspace->dataY(jj)[i] = 2.0*i;
+    }
+    TimeSeriesProperty<double>* log = new TimeSeriesProperty<double>(logname);
+    log->setUnits("furlongs");
+    for (int i = 0; i < length; i++)
+    {
+      log->addValue(start+static_cast<double>(i), static_cast<double>(i));
+    }
+    testWorkspace->mutableRun().addProperty(log, true);
+    AnalysisDataService::Instance().add(in_name, testWorkspace);
+
+    // set up the algorithm
+    ChangeLogTime alg;
+    TS_ASSERT_THROWS_NOTHING(alg.initialize());
+    TS_ASSERT(alg.isInitialized());
+    alg.setPropertyValue("InputWorkspace", in_name);
+    alg.setPropertyValue("OutputWorkspace", out_name);
+    alg.setPropertyValue("LogName", logname);
+    alg.setPropertyValue("TimeOffset", ".1");
+
+    // run the algorithm
+    TS_ASSERT_THROWS_NOTHING(alg.execute());
+    TS_ASSERT(alg.isExecuted());
+
+    // verify the results
+    Workspace2D_sptr outWorkspace
+      = boost::dynamic_pointer_cast<Workspace2D>(AnalysisDataService::Instance().retrieve(out_name));
+    TimeSeriesProperty<double> *newlog
+      = dynamic_cast<TimeSeriesProperty<double> *>(outWorkspace->run().getLogData(logname));
+    TS_ASSERT(newlog);
+    TS_ASSERT(!newlog->units().empty());
+    TS_ASSERT_EQUALS(length, newlog->size());
+    TS_ASSERT_EQUALS(start+.1 , newlog->firstTime());
+
+    // cleanup
+    AnalysisDataService::Instance().remove(in_name);
+    if (in_name != out_name)
+      AnalysisDataService::Instance().remove(out_name);
+  }
+};
+
+#endif // CHANGELOGTIMETEST_H_