MDHistoWorkspace_sptr doTest(std::string algoName, std::string inName, std::string outName,
bool succeeds, std::string otherProp, std::string otherPropValue)
{
MDHistoWorkspace_sptr histo = MDEventsTestHelper::makeFakeMDHistoWorkspace(2.0, 2, 5, 10.0, 2.0);
IMDEventWorkspace_sptr event = MDEventsTestHelper::makeMDEW<2>(3, 0.0, 10.0, 1);
WorkspaceSingleValue_sptr scalar = WorkspaceCreationHelper::CreateWorkspaceSingleValue(2.5);
AnalysisDataService::Instance().addOrReplace("histo", histo);
AnalysisDataService::Instance().addOrReplace("event", event);
AnalysisDataService::Instance().addOrReplace("scalar", scalar);
IAlgorithm* alg = FrameworkManager::Instance().createAlgorithm(algoName);
alg->initialize();
alg->setPropertyValue("InputWorkspace", inName );
alg->setPropertyValue("OutputWorkspace", outName );
if (!otherProp.empty())
alg->setPropertyValue(otherProp, otherPropValue);
alg->execute();
if (succeeds)
{
if (!alg->isExecuted())
throw std::runtime_error("Algorithm " + algoName + " did not succeed.");
IMDWorkspace_sptr out = boost::dynamic_pointer_cast<IMDWorkspace>( AnalysisDataService::Instance().retrieve(outName));
if (!out)
throw std::runtime_error("Algorithm " + algoName + " did not create the output workspace.");
return boost::dynamic_pointer_cast<MDHistoWorkspace>(out);
}
else
{
if (alg->isExecuted())
throw std::runtime_error("Algorithm " + algoName + " did not fail as expected.");
return (MDHistoWorkspace_sptr());
}
}
/// Run a binary algorithm.
MDHistoWorkspace_sptr doTest(std::string algoName, std::string lhs, std::string rhs, std::string outName,
bool succeeds, std::string otherProp, std::string otherPropValue)
{
setUpBinaryOperationMDTestHelper();
IAlgorithm* alg = FrameworkManager::Instance().createAlgorithm(algoName);
alg->initialize();
alg->setPropertyValue("LHSWorkspace", lhs );
alg->setPropertyValue("RHSWorkspace", rhs );
alg->setPropertyValue("OutputWorkspace", outName );
if (!otherProp.empty())
alg->setPropertyValue(otherProp, otherPropValue);
alg->execute();
if (succeeds)
{
if (!alg->isExecuted())
throw std::runtime_error("Algorithm " + algoName + " did not succeed.");
IMDWorkspace_sptr out = boost::dynamic_pointer_cast<IMDWorkspace>( AnalysisDataService::Instance().retrieve(outName));
if (!out)
throw std::runtime_error("Algorithm " + algoName + " did not create the output workspace.");
return boost::dynamic_pointer_cast<MDHistoWorkspace>(out);
}
else
{
if (alg->isExecuted())
throw std::runtime_error("Algorithm " + algoName + " did not fail as expected.");
return (MDHistoWorkspace_sptr());
}
}
/** Creates an instance of an algorithm, sets the properties provided and
* then executes it.
*
* @param algName :: The name of the algorithm required
* @param propertiesArray :: A single string containing properties in the
* form "Property1=Value1;Property2=Value2;..."
* @param version :: The version of the algorithm
* @return A pointer to the executed algorithm
* WARNING! DO NOT DELETE THIS POINTER, because it is owned
* by a shared pointer in the AlgorithmManager.
*
* @throw NotFoundError Thrown if algorithm requested is not registered
* @throw std::invalid_argument Thrown if properties string is ill-formed
* @throw runtime_error Thrown if algorithm cannot be executed
*/
IAlgorithm* FrameworkManagerImpl::exec(const std::string& algName, const std::string& propertiesArray, const int& version)
{
// Make use of the previous method for algorithm creation and property setting
IAlgorithm *alg = createAlgorithm(algName, propertiesArray,version);
// Now execute the algorithm
alg->execute();
return alg;
}
/**
* Execute an algorithm
* @param nlhs :: The number of parameters on the left-hand side of the equals
* @param plhs :: The data on the left-hand side of the equals
* @param nrhs :: The number of parameters in the Matlab function call
* @param prhs :: The data from the Matlab function call
* @returns An integer indicating success/failure
*/
int RunAlgorithm(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
try {
char buffer[256];
uint64_t *data = (uint64_t *)mxGetData(prhs[0]);
IAlgorithm *alg = (IAlgorithm *)data[0];
mxGetString(prhs[1], buffer, sizeof(buffer));
alg->setProperties(buffer);
alg->execute();
plhs[0] = mxCreateString("");
return 0;
} catch (std::exception &e) {
mexErrMsgTxt(e.what());
return 1;
}
}
/**
* Execute an algorithm with a property list
* @param nlhs :: The number of parameters on the left-hand side of the equals
* @param plhs :: The data on the left-hand side of the equals
* @param nrhs :: The number of parameters in the Matlab function call
* @param prhs :: The data from the Matlab function call
* @returns An integer indicating success/failure
*/
int RunAlgorithmPV(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
try {
mxArray *marray;
char buffer[256];
std::string property_name;
uint64_t *data = (uint64_t *)mxGetData(prhs[0]);
IAlgorithm *alg = (IAlgorithm *)data[0];
int i = 1;
while (i < nrhs) {
if (mxGetClassID(prhs[i]) != mxCHAR_CLASS) {
mexErrMsgTxt("Algorithm property name must be a string");
}
mxGetString(prhs[i], buffer, sizeof(buffer));
property_name = buffer;
i++;
strcpy(buffer, mxGetClassName(prhs[i]));
if (!strcmp(buffer, "char")) {
mxGetString(prhs[i], buffer, sizeof(buffer));
alg->setPropertyValue(property_name, buffer);
} else if (!strcmp(buffer, "MantidWorkspace")) {
marray = mxGetField(prhs[i], 0, "name");
mxGetString(marray, buffer, sizeof(buffer));
alg->setPropertyValue(property_name, buffer);
} else {
mexErrMsgTxt("Algorithm property value must be a string");
}
i++;
}
alg->execute();
plhs[0] = mxCreateString("");
return 0;
} catch (std::exception &e) {
mexErrMsgTxt(e.what());
return 1;
}
}