CompareWorkspaces.cpp

        "compareEventsListInDetails only work on 2 event lists with same "
        "number of events.");

  switch (el1.getEventType()) {
  case EventType::TOF:
    return compareEventLists<Types::Event::TofEvent>(
        g_log, el1, el2, tolTof, tolWeight, tolPulse, printdetails,
        numdiffpulse, numdifftof, numdiffboth, numdiffweight);
  case EventType::WEIGHTED:
    return compareEventLists<DataObjects::WeightedEvent>(
        g_log, el1, el2, tolTof, tolWeight, tolPulse, printdetails,
        numdiffpulse, numdifftof, numdiffboth, numdiffweight);
  case EventType::WEIGHTED_NOTIME:
    return compareEventLists<DataObjects::WeightedEventNoTime>(
        g_log, el1, el2, tolTof, tolWeight, tolPulse, printdetails,
        numdiffpulse, numdifftof, numdiffboth, numdiffweight);
  default:
    throw std::runtime_error("Cannot compare event lists: unknown event type.");
  }
}

//------------------------------------------------------------------------------------------------
void CompareWorkspaces::doPeaksComparison(PeaksWorkspace_sptr tws1,
                                          PeaksWorkspace_sptr tws2) {
  // Check some table-based stuff
  if (tws1->getNumberPeaks() != tws2->getNumberPeaks()) {
    recordMismatch("Mismatched number of rows.");
    return;
  }
  if (tws1->columnCount() != tws2->columnCount()) {
    recordMismatch("Mismatched number of columns.");
    return;
  }

  // sort the workspaces before comparing
  {
    auto sortPeaks = createChildAlgorithm("SortPeaksWorkspace");
    sortPeaks->setProperty("InputWorkspace", tws1);
    sortPeaks->setProperty("ColumnNameToSortBy", "DSpacing");
    sortPeaks->setProperty("SortAscending", true);
    sortPeaks->executeAsChildAlg();
    tws1 = sortPeaks->getProperty("OutputWorkspace");

    sortPeaks = createChildAlgorithm("SortPeaksWorkspace");
    sortPeaks->setProperty("InputWorkspace", tws2);
    sortPeaks->setProperty("ColumnNameToSortBy", "DSpacing");
    sortPeaks->setProperty("SortAscending", true);
    sortPeaks->executeAsChildAlg();
    tws2 = sortPeaks->getProperty("OutputWorkspace");
  }

  const double tolerance = getProperty("Tolerance");
  for (int i = 0; i < tws1->getNumberPeaks(); i++) {
    const IPeak &peak1 = tws1->getPeak(i);
    const IPeak &peak2 = tws2->getPeak(i);
    for (size_t j = 0; j < tws1->columnCount(); j++) {
      boost::shared_ptr<const API::Column> col = tws1->getColumn(j);
      std::string name = col->name();
      double s1 = 0.0;
      double s2 = 0.0;
      if (name == "runnumber") {
        s1 = double(peak1.getRunNumber());
        s2 = double(peak2.getRunNumber());
      } else if (name == "detid") {
        s1 = double(peak1.getDetectorID());
        s2 = double(peak2.getDetectorID());
      } else if (name == "h") {
        s1 = peak1.getH();
        s2 = peak2.getH();
      } else if (name == "k") {
        s1 = peak1.getK();
        s2 = peak2.getK();
      } else if (name == "l") {
        s1 = peak1.getL();
        s2 = peak2.getL();
      } else if (name == "wavelength") {
        s1 = peak1.getWavelength();
        s2 = peak2.getWavelength();
      } else if (name == "energy") {
        s1 = peak1.getInitialEnergy();
        s2 = peak2.getInitialEnergy();
      } else if (name == "tof") {
        s1 = peak1.getTOF();
        s2 = peak2.getTOF();
      } else if (name == "dspacing") {
        s1 = peak1.getDSpacing();
        s2 = peak2.getDSpacing();
      } else if (name == "intens") {
        s1 = peak1.getIntensity();
        s2 = peak2.getIntensity();
      } else if (name == "sigint") {
        s1 = peak1.getSigmaIntensity();
        s2 = peak2.getSigmaIntensity();
      } else if (name == "bincount") {
        s1 = peak1.getBinCount();
        s2 = peak2.getBinCount();
      } else if (name == "row") {
        s1 = peak1.getRow();
        s2 = peak2.getRow();
      } else if (name == "col") {
        s1 = peak1.getCol();
        s2 = peak2.getCol();
      }
      if (std::fabs(s1 - s2) > tolerance) {
        g_log.debug() << "Data mismatch at cell (row#,col#): (" << i << "," << j
                      << ")\n";
        recordMismatch("Data mismatch");
        return;
      }
    }
  }
}

//------------------------------------------------------------------------------------------------
void CompareWorkspaces::doTableComparison(
    const API::ITableWorkspace_const_sptr &tws1,
    const API::ITableWorkspace_const_sptr &tws2) {
  // First the easy things
  const auto numCols = tws1->columnCount();
  if (numCols != tws2->columnCount()) {
    g_log.debug() << "Number of columns mismatch (" << numCols << " vs "
                  << tws2->columnCount() << ")\n";
    recordMismatch("Number of columns mismatch");
    return;
  }
  const auto numRows = tws1->rowCount();
  if (numRows != tws2->rowCount()) {
    g_log.debug() << "Number of rows mismatch (" << numRows << " vs "
                  << tws2->rowCount() << ")\n";
    recordMismatch("Number of rows mismatch");
    return;
  }

  for (size_t i = 0; i < numCols; ++i) {
    auto c1 = tws1->getColumn(i);
    auto c2 = tws2->getColumn(i);

    if (c1->name() != c2->name()) {
      g_log.debug() << "Column name mismatch at column " << i << " ("
                    << c1->name() << " vs " << c2->name() << ")\n";
      recordMismatch("Column name mismatch");
      return;
    }
    if (c1->type() != c2->type()) {
      g_log.debug() << "Column type mismatch at column " << i << " ("
                    << c1->type() << " vs " << c2->type() << ")\n";
      recordMismatch("Column type mismatch");
      return;
    }
  }

  const bool checkAllData = getProperty("CheckAllData");
  const bool relErr = getProperty("ToleranceRelErr");
  const double tolerance = getProperty("Tolerance");
  bool mismatch = false;
  for (size_t i = 0; i < numCols; ++i) {
    const auto c1 = tws1->getColumn(i);
    const auto c2 = tws2->getColumn(i);

    if (relErr) {
      if (!c1->equalsRelErr(*c2, tolerance)) {
        mismatch = true;
      }
    } else {

      if (!c1->equals(*c2, tolerance)) {
        mismatch = true;
      }
    }
    if (mismatch) {
      g_log.debug() << "Table data mismatch at column " << i << "\n";
      recordMismatch("Table data mismatch");
      mismatch = false;
      if (!checkAllData) {
        return;
      }
    }
  } // loop over columns
}

//------------------------------------------------------------------------------------------------
void CompareWorkspaces::doMDComparison(const Workspace_sptr &w1,
                                       const Workspace_sptr &w2) {
  IMDWorkspace_sptr mdws1, mdws2;
  mdws1 = boost::dynamic_pointer_cast<IMDWorkspace>(w1);
  mdws2 = boost::dynamic_pointer_cast<IMDWorkspace>(w2);

  IAlgorithm_sptr alg = this->createChildAlgorithm("CompareMDWorkspaces");
  alg->setProperty<IMDWorkspace_sptr>("Workspace1", mdws1);
  alg->setProperty<IMDWorkspace_sptr>("Workspace2", mdws2);
  const double tolerance = getProperty("Tolerance");
  alg->setProperty("Tolerance", tolerance);
  alg->executeAsChildAlg();
  bool doesMatch = alg->getProperty("Equals");
  std::string algResult = alg->getProperty("Result");
  if (!doesMatch) {
    recordMismatch(algResult);
  }
}

//------------------------------------------------------------------------------------------------
/**
 * Records a mismatch that has occurred in the output workspace and sets the
 * Result to indicate that the input workspaces did not match.
 *
 * @param msg Mismatch message to be logged in output workspace
 * @param ws1 Name of first workspace being compared
 * @param ws2 Name of second workspace being compared
 */
void CompareWorkspaces::recordMismatch(const std::string &msg, std::string ws1,
                                       std::string ws2) {
  // Workspace names default to the workspaces currently being compared
  if (ws1.empty()) {
    Workspace_const_sptr w1 = getProperty("Workspace1");
    ws1 = w1->getName();
  }
  if (ws2.empty()) {
    Workspace_const_sptr w2 = getProperty("Workspace2");
    ws2 = w2->getName();
  }

  // Add new row and flag this comparison as a mismatch
  TableRow row = m_messages->appendRow();
  row << msg << ws1 << ws2;
  m_result = false;
}

//------------------------------------------------------------------------------------------------
/** Function which calculates relative error between two values and analyses if
this error is within the limits
* requested. When the absolute value of the difference is smaller then the value
of the error requested,
* absolute error is used instead of relative error.

@param x1       -- first value to check difference
@param x2       -- second value to check difference
@param errorVal -- the value of the error, to check against. Should  be large
then 0

@returns true if error or false if the value is within the limits requested
*/
bool CompareWorkspaces::relErr(double x1, double x2, double errorVal) const {
  double num = std::fabs(x1 - x2);
  // how to treat x1<0 and x2 > 0 ?  probably this way
  double den = 0.5 * (std::fabs(x1) + std::fabs(x2));
  if (den < errorVal)
    return (num > errorVal);

  return (num / den > errorVal);
}

Parallel::ExecutionMode CompareWorkspaces::getParallelExecutionMode(
    const std::map<std::string, Parallel::StorageMode> &storageModes) const {
  using namespace Parallel;
  if (storageModes.at("Workspace1") == StorageMode::Cloned) {
    if (storageModes.at("Workspace2") == StorageMode::Cloned)
      return getCorrespondingExecutionMode(StorageMode::Cloned);
    if (storageModes.at("Workspace2") == StorageMode::MasterOnly)
      return getCorrespondingExecutionMode(StorageMode::MasterOnly);
  }
  if (storageModes.at("Workspace1") == StorageMode::MasterOnly) {
    if (storageModes.at("Workspace2") != StorageMode::Distributed)
      return getCorrespondingExecutionMode(StorageMode::MasterOnly);
  }
  return ExecutionMode::Invalid;
}

void CompareWorkspaces::execMasterOnly() {
  if (communicator().rank() == 0)
    exec();
  else
    setProperty("Result", true);
}

} // namespace Algorithms
} // namespace Mantid