/Framework/SINQ/test/ProjectMDTest.h

https://github.com/wdzhou/mantid · C Header · 254 lines · 214 code · 36 blank · 4 comment · 6 complexity · d6a44956fd09f95fd667f7adc7070bd2 MD5 · raw file 

    

  1. #ifndef __PROJECTMDTEST
    2. 

  2. #define __PROJECTMDTEST
    3. 

  3. 

  4. #include <cxxtest/TestSuite.h>
    5. 

  5. #include "MantidSINQ/ProjectMD.h"
    6. 

  6. #include "MantidAPI/AnalysisDataService.h"
    7. 

  7. #include "MantidGeometry/MDGeometry/MDHistoDimension.h"
    8. 

  8. #include "MantidAPI/IMDHistoWorkspace.h"
    9. 

  9. #include "MantidAPI/Run.h"
    10. 

  10. #include "MantidKernel/Property.h"
    11. 

  11. #include "MantidKernel/cow_ptr.h"
    12. 

  12. #include "MantidDataObjects/MDHistoWorkspace.h"
    13. 

  13. 

  14. using namespace Mantid::API;
    15. 

  15. using namespace Mantid::Geometry;
    16. 

  16. using namespace Mantid::Kernel;
    17. 

  17. using namespace Mantid;
    18. 

  18. using namespace Mantid::DataObjects;
    19. 

  19. 

  20. class ProjectMDTest : public CxxTest::TestSuite {
    21. 

  21. public:
    22. 

  22.   void testName() {
    23. 

  23.     ProjectMD loader;
    24. 

  24.     TS_ASSERT_EQUALS(loader.name(), "ProjectMD");
    25. 

  25.   }
    26. 

  26. 

  27.   void testInit() {
    28. 

  28.     ProjectMD loader;
    29. 

  29.     TS_ASSERT_THROWS_NOTHING(loader.initialize());
    30. 

  30.     TS_ASSERT(loader.isInitialized());
    31. 

  31.   }
    32. 

  32. 

  33.   void testProjectZ() {
    34. 

  34.     makeTestMD();
    35. 

  35. 

  36.     ProjectMD pmd;
    37. 

  37.     pmd.initialize();
    38. 

  38.     pmd.setPropertyValue("InputWorkspace", "PMDTest");
    39. 

  39.     pmd.setPropertyValue("ProjectDirection", "Z");
    40. 

  40.     pmd.setPropertyValue("StartIndex", "0");
    41. 

  41.     pmd.setPropertyValue("EndIndex", "20");
    42. 

  42.     std::string outputSpace = "PMD_out";
    43. 

  43.     pmd.setPropertyValue("OutputWorkspace", outputSpace);
    44. 

  44.     TS_ASSERT_THROWS_NOTHING(pmd.execute());
    45. 

  45. 

  46.     IMDHistoWorkspace_sptr data =
    47. 

  47.         AnalysisDataService::Instance().retrieveWS<IMDHistoWorkspace>(
    48. 

  48.             outputSpace);
    49. 

  49.     TS_ASSERT_EQUALS(2, data->getNumDims());
    50. 

  50.     long nBin = static_cast<long>(data->getNPoints());
    51. 

  51.     long sum = 0;
    52. 

  52.     double *sdata = data->getSignalArray();
    53. 

  53.     for (long i = 0; i < nBin; i++) {
    54. 

  54.       sum += (long)sdata[i];
    55. 

  55.     }
    56. 

  56.     TS_ASSERT_EQUALS(sum, 2400);
    57. 

  57. 

  58.     // test dimensions
    59. 

  59.     boost::shared_ptr<const IMDDimension> dimi = data->getDimension(0);
    60. 

  60.     TS_ASSERT_EQUALS(dimi->getNBins(), 10);
    61. 

  61.     TS_ASSERT_DELTA(dimi->getMinimum(), -5., .01);
    62. 

  62.     TS_ASSERT_DELTA(dimi->getMaximum(), 5., .01);
    63. 

  63. 

  64.     dimi = data->getDimension(1);
    65. 

  65.     TS_ASSERT_EQUALS(dimi->getNBins(), 12);
    66. 

  66.     TS_ASSERT_DELTA(dimi->getMinimum(), -6., .01);
    67. 

  67.     TS_ASSERT_DELTA(dimi->getMaximum(), 6., .01);
    68. 

  68. 

  69.     AnalysisDataService::Instance().clear();
    70. 

  70.   }
    71. 

  71. 

  72.   void testProjectHalfZ() {
    73. 

  73.     makeTestMD();
    74. 

  74. 

  75.     ProjectMD pmd;
    76. 

  76.     pmd.initialize();
    77. 

  77.     pmd.setPropertyValue("InputWorkspace", "PMDTest");
    78. 

  78.     pmd.setPropertyValue("ProjectDirection", "Z");
    79. 

  79.     pmd.setPropertyValue("StartIndex", "5");
    80. 

  80.     pmd.setPropertyValue("EndIndex", "15");
    81. 

  81.     std::string outputSpace = "PMD_out";
    82. 

  82.     pmd.setPropertyValue("OutputWorkspace", outputSpace);
    83. 

  83.     TS_ASSERT_THROWS_NOTHING(pmd.execute());
    84. 

  84. 

  85.     IMDHistoWorkspace_sptr data =
    86. 

  86.         AnalysisDataService::Instance().retrieveWS<IMDHistoWorkspace>(
    87. 

  87.             outputSpace);
    88. 

  88.     TS_ASSERT_EQUALS(2, data->getNumDims());
    89. 

  89.     long nBin = static_cast<long>(data->getNPoints());
    90. 

  90.     long sum = 0;
    91. 

  91.     double *sdata = data->getSignalArray();
    92. 

  92.     for (long i = 0; i < nBin; i++) {
    93. 

  93.       sum += (long)sdata[i];
    94. 

  94.     }
    95. 

  95.     TS_ASSERT_EQUALS(sum, 1200);
    96. 

  96. 

  97.     // test dimensions
    98. 

  98.     boost::shared_ptr<const IMDDimension> dimi = data->getDimension(0);
    99. 

  99.     TS_ASSERT_EQUALS(dimi->getNBins(), 10);
    100. 

  100.     TS_ASSERT_DELTA(dimi->getMinimum(), -5., .01);
    101. 

  101.     TS_ASSERT_DELTA(dimi->getMaximum(), 5., .01);
    102. 

  102. 

  103.     dimi = data->getDimension(1);
    104. 

  104.     TS_ASSERT_EQUALS(dimi->getNBins(), 12);
    105. 

  105.     TS_ASSERT_DELTA(dimi->getMinimum(), -6., .01);
    106. 

  106.     TS_ASSERT_DELTA(dimi->getMaximum(), 6., .01);
    107. 

  107. 

  108.     AnalysisDataService::Instance().clear();
    109. 

  109.   }
    110. 

  110. 

  111.   void testProjectX() {
    112. 

  112.     makeTestMD();
    113. 

  113. 

  114.     ProjectMD pmd;
    115. 

  115.     pmd.initialize();
    116. 

  116.     pmd.setPropertyValue("InputWorkspace", "PMDTest");
    117. 

  117.     pmd.setPropertyValue("ProjectDirection", "X");
    118. 

  118.     pmd.setPropertyValue("StartIndex", "0");
    119. 

  119.     pmd.setPropertyValue("EndIndex", "10");
    120. 

  120.     std::string outputSpace = "PMD_out";
    121. 

  121.     pmd.setPropertyValue("OutputWorkspace", outputSpace);
    122. 

  122.     TS_ASSERT_THROWS_NOTHING(pmd.execute());
    123. 

  123. 

  124.     IMDHistoWorkspace_sptr data =
    125. 

  125.         AnalysisDataService::Instance().retrieveWS<IMDHistoWorkspace>(
    126. 

  126.             outputSpace);
    127. 

  127.     TS_ASSERT_EQUALS(2, data->getNumDims());
    128. 

  128.     long nBin = static_cast<long>(data->getNPoints());
    129. 

  129.     long sum = 0;
    130. 

  130.     double *sdata = data->getSignalArray();
    131. 

  131.     for (long i = 0; i < nBin; i++) {
    132. 

  132.       sum += (long)sdata[i];
    133. 

  133.     }
    134. 

  134.     TS_ASSERT_EQUALS(sum, 2400);
    135. 

  135. 

  136.     // test dimensions
    137. 

  137.     boost::shared_ptr<const IMDDimension> dimi = data->getDimension(0);
    138. 

  138.     TS_ASSERT_EQUALS(dimi->getNBins(), 12);
    139. 

  139.     TS_ASSERT_DELTA(dimi->getMinimum(), -6., .01);
    140. 

  140.     TS_ASSERT_DELTA(dimi->getMaximum(), 6., .01);
    141. 

  141. 

  142.     dimi = data->getDimension(1);
    143. 

  143.     TS_ASSERT_EQUALS(dimi->getNBins(), 20);
    144. 

  144.     TS_ASSERT_DELTA(dimi->getMinimum(), -10., .01);
    145. 

  145.     TS_ASSERT_DELTA(dimi->getMaximum(), 10., .01);
    146. 

  146. 

  147.     AnalysisDataService::Instance().clear();
    148. 

  148.   }
    149. 

  149. 

  150.   void testProjectY() {
    151. 

  151.     makeTestMD();
    152. 

  152. 

  153.     ProjectMD pmd;
    154. 

  154.     pmd.initialize();
    155. 

  155.     pmd.setPropertyValue("InputWorkspace", "PMDTest");
    156. 

  156.     pmd.setPropertyValue("ProjectDirection", "Y");
    157. 

  157.     pmd.setPropertyValue("StartIndex", "0");
    158. 

  158.     pmd.setPropertyValue("EndIndex", "12");
    159. 

  159.     std::string outputSpace = "PMD_out";
    160. 

  160.     pmd.setPropertyValue("OutputWorkspace", outputSpace);
    161. 

  161.     TS_ASSERT_THROWS_NOTHING(pmd.execute());
    162. 

  162. 

  163.     IMDHistoWorkspace_sptr data =
    164. 

  164.         AnalysisDataService::Instance().retrieveWS<IMDHistoWorkspace>(
    165. 

  165.             outputSpace);
    166. 

  166.     TS_ASSERT_EQUALS(2, data->getNumDims());
    167. 

  167.     long nBin = static_cast<long>(data->getNPoints());
    168. 

  168.     long sum = 0;
    169. 

  169.     double *sdata = data->getSignalArray();
    170. 

  170.     for (long i = 0; i < nBin; i++) {
    171. 

  171.       sum += (long)sdata[i];
    172. 

  172.     }
    173. 

  173.     TS_ASSERT_EQUALS(sum, 2400);
    174. 

  174. 

  175.     // test dimensions
    176. 

  176.     boost::shared_ptr<const IMDDimension> dimi = data->getDimension(0);
    177. 

  177.     TS_ASSERT_EQUALS(dimi->getNBins(), 10);
    178. 

  178.     TS_ASSERT_DELTA(dimi->getMinimum(), -5., .1);
    179. 

  179.     TS_ASSERT_DELTA(dimi->getMaximum(), 5., .1);
    180. 

  180. 

  181.     dimi = data->getDimension(1);
    182. 

  182.     TS_ASSERT_EQUALS(dimi->getNBins(), 20);
    183. 

  183.     TS_ASSERT_DELTA(dimi->getMinimum(), -10., .1);
    184. 

  184.     TS_ASSERT_DELTA(dimi->getMaximum(), 10., .1);
    185. 

  185. 

  186.     AnalysisDataService::Instance().clear();
    187. 

  187.   }
    188. 

  188. 

  189.   void testMetaDataCopy() {
    190. 

  190.     makeTestMD();
    191. 

  191.     IMDHistoWorkspace_sptr data =
    192. 

  192.         AnalysisDataService::Instance().retrieveWS<IMDHistoWorkspace>(
    193. 

  193.             std::string("PMDTest"));
    194. 

  194.     data->setTitle("Hugo");
    195. 

  195.     if (data->getNumExperimentInfo() == 0) {
    196. 

  196.       data->addExperimentInfo((ExperimentInfo_sptr) new ExperimentInfo());
    197. 

  197.     }
    198. 

  198.     Run &rr = data->getExperimentInfo(0)->mutableRun();
    199. 

  199.     rr.addProperty("Gwendolin", 27.8, true);
    200. 

  200. 

  201.     ProjectMD pmd;
    202. 

  202.     pmd.initialize();
    203. 

  203.     pmd.setPropertyValue("InputWorkspace", "PMDTest");
    204. 

  204.     pmd.setPropertyValue("ProjectDirection", "Y");
    205. 

  205.     pmd.setPropertyValue("StartIndex", "0");
    206. 

  206.     pmd.setPropertyValue("EndIndex", "12");
    207. 

  207.     std::string outputSpace = "PMD_out";
    208. 

  208.     pmd.setPropertyValue("OutputWorkspace", outputSpace);
    209. 

  209.     TS_ASSERT_THROWS_NOTHING(pmd.execute());
    210. 

  210. 

  211.     data = AnalysisDataService::Instance().retrieveWS<IMDHistoWorkspace>(
    212. 

  212.         outputSpace);
    213. 

  213.     std::string tst = data->getTitle();
    214. 

  214.     size_t found = tst.find("Hugo");
    215. 

  215.     TS_ASSERT_DIFFERS(found, std::string::npos);
    216. 

  216. 

  217.     ExperimentInfo_sptr info;
    218. 

  218.     info = data->getExperimentInfo(0);
    219. 

  219.     const Run r = info->run();
    220. 

  220.     Mantid::Kernel::Property *p = r.getProperty("Gwendolin");
    221. 

  221.     std::string cd = p->value();
    222. 

  222.     found = cd.find("27.8");
    223. 

  223.     TS_ASSERT_DIFFERS(found, std::string::npos);
    224. 

  224. 

  225.     AnalysisDataService::Instance().clear();
    226. 

  226.   }
    227. 

  227. 

  228. private:
    229. 

  229.   MDHistoWorkspace_sptr makeTestMD() {
    230. 

  230.     IMDDimension_sptr dim;
    231. 

  231.     Mantid::Geometry::GeneralFrame frame(
    232. 

  232.         Mantid::Geometry::GeneralFrame::GeneralFrameDistance, "mm");
    233. 

  233.     std::vector<IMDDimension_sptr> dimensions;
    234. 

  234.     dim = MDHistoDimension_sptr(
    235. 

  235.         new MDHistoDimension(std::string("x"), std::string("ID0"), frame,
    236. 

  236.                              coord_t(-5), coord_t(5), size_t(10)));
    237. 

  237.     dimensions.push_back(boost::const_pointer_cast<IMDDimension>(dim));
    238. 

  238.     dim = MDHistoDimension_sptr(
    239. 

  239.         new MDHistoDimension(std::string("y"), std::string("ID1"), frame,
    240. 

  240.                              coord_t(-6), coord_t(6), size_t(12)));
    241. 

  241.     dimensions.push_back(boost::const_pointer_cast<IMDDimension>(dim));
    242. 

  242.     dim = MDHistoDimension_sptr(
    243. 

  243.         new MDHistoDimension(std::string("z"), std::string("ID2"), frame,
    244. 

  244.                              coord_t(-10), coord_t(10), size_t(20)));
    245. 

  245.     dimensions.push_back(boost::const_pointer_cast<IMDDimension>(dim));
    246. 

  246. 

  247.     MDHistoWorkspace_sptr outWS(new MDHistoWorkspace(dimensions));
    248. 

  248.     outWS->setTo(1., 1., .0);
    249. 

  249.     AnalysisDataService::Instance().add("PMDTest", outWS);
    250. 

  250.     return outWS;
    251. 

  251.   }
    252. 

  252. };
    253. 

  253. 

  254. #endif
    255.