Refs #8494. Bin value correction.

mantidproject · Dec 12, 2013 · 7810548 · 7810548
1 parent 4f29091
commit 7810548
Show file tree

Hide file tree

Showing 3 changed files with 134 additions and 1 deletion.
diff --git a/Code/Mantid/Framework/WorkflowAlgorithms/inc/MantidWorkflowAlgorithms/MuonLoad.h b/Code/Mantid/Framework/WorkflowAlgorithms/inc/MantidWorkflowAlgorithms/MuonLoad.h
@@ -56,6 +56,9 @@ namespace WorkflowAlgorithms
 
     /// Groups specified workspace according to specified DetectorGroupingTable.
     MatrixWorkspace_sptr groupWorkspace(MatrixWorkspace_sptr ws);
+
+    /// Applies offset, crops and rebin the workspace according to specified params 
+    MatrixWorkspace_sptr correctWorkspace(MatrixWorkspace_sptr ws, double loadedTimeZero);
   };
 
 

diff --git a/Code/Mantid/Framework/WorkflowAlgorithms/src/MuonLoad.cpp b/Code/Mantid/Framework/WorkflowAlgorithms/src/MuonLoad.cpp
@@ -153,7 +153,13 @@ namespace WorkflowAlgorithms
     if ( secondPeriodWS )
       secondPeriodWS = groupWorkspace(secondPeriodWS);
 
-    // TODO: offsetting, cropping, rebinning
+    // Correct bin values
+    double loadedTimeZero = load->getProperty("TimeZero");
+
+    firstPeriodWS = correctWorkspace(firstPeriodWS, loadedTimeZero);
+
+    if ( secondPeriodWS )
+      secondPeriodWS = correctWorkspace(secondPeriodWS, loadedTimeZero);
 
     IAlgorithm_sptr calcAssym = createChildAlgorithm("MuonCalculateAsymmetry");
 
@@ -248,5 +254,78 @@ namespace WorkflowAlgorithms
     return group->getProperty("OutputWorkspace");
   }
 
+  /**
+   * Applies offset, crops and rebin the workspace according to specified params.
+   * @param ws :: Workspace to correct
+   * @param loadedTimeZero :: Time zero of the data, so we can calculate the offset
+   * @return Corrected workspace
+   */
+  MatrixWorkspace_sptr MuonLoad::correctWorkspace(MatrixWorkspace_sptr ws, double loadedTimeZero)
+  {
+    // Offset workspace, if need to
+    double timeZero = getProperty("TimeZero");
+    if ( timeZero != EMPTY_DBL() )
+    {
+      double offset = loadedTimeZero - timeZero;
+
+      IAlgorithm_sptr changeOffset = createChildAlgorithm("ChangeBinOffset");
+      changeOffset->setProperty("InputWorkspace", ws);
+      changeOffset->setProperty("Offset", offset);
+      changeOffset->execute();
+
+      ws = changeOffset->getProperty("OutputWorkspace");
+    }
+
+    // Crop workspace, if need to
+    double Xmin = getProperty("Xmin");
+    double Xmax = getProperty("Xmax");
+    if ( Xmin != EMPTY_DBL() || Xmax != EMPTY_DBL() )
+    {
+      IAlgorithm_sptr crop = createChildAlgorithm("CropWorkspace");
+      crop->setProperty("InputWorkspace", ws);
+
+      if ( Xmin != EMPTY_DBL() )
+        crop->setProperty("Xmin", Xmin);
+
+      if ( Xmax != EMPTY_DBL() )
+        crop->setProperty("Xmax", Xmax);
+
+      crop->execute();
+
+      ws = crop->getProperty("OutputWorkspace");
+    }
+
+    // Rebin workspace if need to
+    std::vector<double> rebinParams = getProperty("RebinParams");
+    if ( ! rebinParams.empty() )
+    {
+      IAlgorithm_sptr rebin = createChildAlgorithm("Rebin");
+      rebin->setProperty("InputWorkspace", ws);
+      rebin->setProperty("Params", rebinParams);
+      rebin->execute();
+
+      ws = rebin->getProperty("OutputWorkspace");
+
+      // TODO: following should be removed when FullBinsOnly function is added to Rebin algorithm
+
+      // Muon group don't want last bin if shorter than previous bins
+      double binSize = ws->dataX(0)[1] - ws->dataX(0)[0]; 
+      size_t numBins = ws->dataX(0).size();
+
+      if ( (ws->dataX(0)[numBins-1] - ws->dataX(0)[numBins-2]) != binSize )
+      {
+        IAlgorithm_sptr crop2 = createChildAlgorithm("CropWorkspace");
+        crop2->setProperty("InputWorkspace", ws);
+        crop2->setProperty("Xmax", ws->dataX(0)[numBins-2]);
+        crop2->execute();
+
+        ws = crop2->getProperty("OutputWorkspace");
+      }
+    }
+
+
+    return ws;
+  }
+
 } // namespace WorkflowAlgorithms
 } // namespace Mantid
diff --git a/Code/Mantid/Framework/WorkflowAlgorithms/test/MuonLoadTest.h b/Code/Mantid/Framework/WorkflowAlgorithms/test/MuonLoadTest.h
@@ -128,6 +128,57 @@ class MuonLoadTest : public CxxTest::TestSuite
     }
   }
 
+  void test_binCorrectionParams()
+  {
+    ScopedWorkspace output;
+
+    std::vector<int> group1, group2;
+
+    for ( int i = 1; i <= 16; ++i )
+      group1.push_back(i);
+    for ( int i = 17; i <= 32; ++i )
+      group2.push_back(i);
+
+    TableWorkspace_sptr grouping = createGroupingTable(group1, group2);
+
+    MuonLoad alg;
+    TS_ASSERT_THROWS_NOTHING( alg.initialize() )
+    TS_ASSERT( alg.isInitialized() )
+    TS_ASSERT_THROWS_NOTHING( alg.setPropertyValue("Filename", "emu00006473.nxs") );
+    TS_ASSERT_THROWS_NOTHING( alg.setProperty("DetectorGroupingTable", grouping) );
+    TS_ASSERT_THROWS_NOTHING( alg.setProperty("OutputType", "GroupCounts") );
+    TS_ASSERT_THROWS_NOTHING( alg.setProperty("GroupIndex", 0) );
+    TS_ASSERT_THROWS_NOTHING( alg.setProperty("TimeZero", 0.5) );
+    TS_ASSERT_THROWS_NOTHING( alg.setProperty("Xmin", 0.1) );
+    TS_ASSERT_THROWS_NOTHING( alg.setProperty("Xmax", 16.0) );
+    TS_ASSERT_THROWS_NOTHING( alg.setProperty("RebinParams", "0.08") );
+    TS_ASSERT_THROWS_NOTHING( alg.setPropertyValue("OutputWorkspace", output.name()) );
+    TS_ASSERT_THROWS_NOTHING( alg.execute(); );
+    TS_ASSERT( alg.isExecuted() );
+
+    // Retrieve the workspace from data service.
+    MatrixWorkspace_sptr ws = boost::dynamic_pointer_cast<MatrixWorkspace>( output.retrieve() );
+
+    TS_ASSERT(ws);
+    if (ws)
+    {
+      TS_ASSERT_EQUALS( ws->getNumberHistograms(), 1 );
+      TS_ASSERT_EQUALS( ws->blocksize(), 198 );
+
+      TS_ASSERT_DELTA( ws->readX(0)[0], 0.102, 0.001 ); 
+      TS_ASSERT_DELTA( ws->readX(0)[100], 8.102, 0.001 ); 
+      TS_ASSERT_DELTA( ws->readX(0)[198], 15.942, 0.001 ); 
+
+      TS_ASSERT_DELTA( ws->readY(0)[0], 1024372.2, 0.1); 
+      TS_ASSERT_DELTA( ws->readY(0)[100], 24589.0, 0.1); 
+      TS_ASSERT_DELTA( ws->readY(0)[197], 730.0, 0.1); 
+
+      TS_ASSERT_DELTA( ws->readE(0)[0], 1012.113, 0.001 ); 
+      TS_ASSERT_DELTA( ws->readE(0)[100], 156.809, 0.001 ); 
+      TS_ASSERT_DELTA( ws->readE(0)[197], 27.019, 0.001 ); 
+    }
+  }
+
   TableWorkspace_sptr createGroupingTable(const std::vector<int>& group1, const std::vector<int>& group2)
   {
     auto t = boost::make_shared<TableWorkspace>();