DataObjects::TableWorkspace_sptr ConvertToMDParent::runPreprocessDetectorsToMDChildUpdatingMasks(Mantid::API::MatrixWorkspace_const_sptr InWS2D,
const std::string &OutWSName,const std::string &dEModeRequested,Kernel::DeltaEMode::Type &Emode)
{
// prospective result
DataObjects::TableWorkspace_sptr TargTableWS;
// if input workspace does not exist in analysis data service, we have to add it there to work with the Child Algorithm
std::string InWSName = InWS2D->getName();
if(!API::AnalysisDataService::Instance().doesExist(InWSName))
{
throw std::runtime_error("Can not retrieve input matrix workspace "+InWSName+" from the analysis data service");
}
Mantid::API::Algorithm_sptr childAlg = createChildAlgorithm("PreprocessDetectorsToMD",0.,1.);
if(!childAlg)throw(std::runtime_error("Can not create child ChildAlgorithm to preprocess detectors"));
childAlg->setProperty("InputWorkspace",InWSName);
childAlg->setProperty("OutputWorkspace",OutWSName);
childAlg->setProperty("GetMaskState",true);
childAlg->setProperty("UpdateMasksInfo",true);
childAlg->setProperty("OutputWorkspace",OutWSName);
// check and get energy conversion mode to define additional ChildAlgorithm parameters
Emode = Kernel::DeltaEMode().fromString(dEModeRequested);
if(Emode == Kernel::DeltaEMode::Indirect)
childAlg->setProperty("GetEFixed",true);
childAlg->execute();
if(!childAlg->isExecuted())throw(std::runtime_error("Can not properly execute child algorithm PreprocessDetectorsToMD"));
TargTableWS = childAlg->getProperty("OutputWorkspace");
if(!TargTableWS)throw(std::runtime_error("Can not retrieve results of child algorithm PreprocessDetectorsToMD"));
return TargTableWS;
}
DataObjects::TableWorkspace_sptr
ConvertToMDParent::runPreprocessDetectorsToMDChildUpdatingMasks(
const Mantid::API::MatrixWorkspace_const_sptr &InWS2D,
const std::string &OutWSName, const std::string &dEModeRequested,
Kernel::DeltaEMode::Type &Emode) {
// prospective result
DataObjects::TableWorkspace_sptr TargTableWS;
Mantid::API::Algorithm_sptr childAlg =
createChildAlgorithm("PreprocessDetectorsToMD", 0., 1.);
if (!childAlg)
throw(std::runtime_error(
"Can not create child ChildAlgorithm to preprocess detectors"));
auto pTargWSProp = dynamic_cast<WorkspaceProperty<MatrixWorkspace> *>(
childAlg->getPointerToProperty("InputWorkspace"));
if (!pTargWSProp) {
throw std::runtime_error("Bad program logic: an algorithm workspace "
"property is not castable to a matrix workspace");
}
// TODO: bad unnecessary const_cast but WorkspaceProperty is missing const
// assignment operators and I am not sure if ADS guarantees workspaces
// const-ness
// so, const cast is localized here despite input workspace is and should be
// const in this case.
*pTargWSProp = boost::const_pointer_cast<MatrixWorkspace>(InWS2D);
childAlg->setProperty("OutputWorkspace", OutWSName);
childAlg->setProperty("GetMaskState", true);
childAlg->setProperty("UpdateMasksInfo", true);
childAlg->setProperty("OutputWorkspace", OutWSName);
// check and get energy conversion mode to define additional ChildAlgorithm
// parameters
Emode = Kernel::DeltaEMode::fromString(dEModeRequested);
if (Emode == Kernel::DeltaEMode::Indirect)
childAlg->setProperty("GetEFixed", true);
childAlg->execute();
if (!childAlg->isExecuted())
throw(std::runtime_error(
"Can not properly execute child algorithm PreprocessDetectorsToMD"));
TargTableWS = childAlg->getProperty("OutputWorkspace");
if (!TargTableWS)
throw(std::runtime_error(
"Can not retrieve results of child algorithm PreprocessDetectorsToMD"));
return TargTableWS;
}
/**
* @brief IntegrateEllipsoids::initTargetWSDescr Initialize the output
* information for the MD conversion framework.
*
* @param wksp The workspace to get information from.
*/
void IntegrateEllipsoids::initTargetWSDescr(EventWorkspace_sptr wksp)
{
m_targWSDescr.setMinMax( std::vector<double>(3, -2000.),
std::vector<double>(3, 2000.));
m_targWSDescr.buildFromMatrixWS(wksp, Q3D, ELASTIC);
m_targWSDescr.setLorentsCorr(false);
// generate the detectors table
Mantid::API::Algorithm_sptr childAlg = createChildAlgorithm("PreprocessDetectorsToMD",0.,.5);
childAlg->setProperty("InputWorkspace",wksp);
childAlg->executeAsChildAlg();
DataObjects::TableWorkspace_sptr table = childAlg->getProperty("OutputWorkspace");
if(!table)
throw(std::runtime_error("Can not retrieve results of \"PreprocessDetectorsToMD\""));
else
m_targWSDescr.m_PreprDetTable = table;
}
/** Method takes min-max values from algorithm parameters if they are present or calculates default min-max values if these values
* were not supplied to the method or the supplied value is incorrect.
*
*@param inWS -- the shared pointer to the source workspace
*@param QMode -- the string which defines algorithms Q-conversion mode
*@param dEMode -- the string describes the algorithms energy conversion mode
*@param QFrame -- in Q3D case this describes target coordinate system and is ignored in any other caste
*@param ConvertTo -- The parameter describing Q-scaling transformations
*@param otherDim -- the vector of other dimension names (if any)
* Input-output values:
*@param minVal -- the vector with min values for the algorithm
*@param maxVal -- the vector with max values for the algorithm
*
*
*/
void ConvertToMD::findMinMax(const Mantid::API::MatrixWorkspace_sptr &inWS,const std::string &QMode, const std::string &dEMode,
const std::string &QFrame,const std::string &ConvertTo,const std::vector<std::string> &otherDim,
std::vector<double> &minVal,std::vector<double> &maxVal)
{
// get raw pointer to Q-transformation (do not delete this pointer, it hold by MDTransfFatctory!)
MDTransfInterface* pQtransf = MDTransfFactory::Instance().create(QMode).get();
// get number of dimensions this Q transformation generates from the workspace.
auto iEmode = Kernel::DeltaEMode().fromString(dEMode);
// get total number of dimensions the workspace would have.
unsigned int nMatrixDim = pQtransf->getNMatrixDimensions(iEmode,inWS);
// total number of dimensions
size_t nDim =nMatrixDim+otherDim.size();
// probably already have well defined min-max values, so no point of pre-calculating them
bool wellDefined(true);
if((nDim == minVal.size()) && (minVal.size()==maxVal.size()))
{
// are they indeed well defined?
for(size_t i=0;i<minVal.size();i++)
{
if(minVal[i]>=maxVal[i]) // no it is ill defined
{
g_log.information()<<" Min Value: "<<minVal[i]<<" for dimension N: "<<i<<" equal or exceeds max value:"<<maxVal[i]<<std::endl;
wellDefined = false;
break;
}
}
if (wellDefined)return;
}
// we need to identify min-max values by themselves
Mantid::API::Algorithm_sptr childAlg = createChildAlgorithm("ConvertToMDMinMaxLocal");
if(!childAlg)throw(std::runtime_error("Can not create child ChildAlgorithm to found min/max values"));
childAlg->setPropertyValue("InputWorkspace", inWS->getName());
childAlg->setPropertyValue("QDimensions",QMode);
childAlg->setPropertyValue("dEAnalysisMode",dEMode);
childAlg->setPropertyValue("Q3DFrames",QFrame);
childAlg->setProperty("OtherDimensions",otherDim);
childAlg->setProperty("QConversionScales",ConvertTo);
childAlg->setProperty("PreprocDetectorsWS",std::string(getProperty("PreprocDetectorsWS")));
childAlg->execute();
if(!childAlg->isExecuted())throw(std::runtime_error("Can not properly execute child algorithm to find min/max workspace values"));
minVal = childAlg->getProperty("MinValues");
maxVal = childAlg->getProperty("MaxValues");
// if some min-max values for dimensions produce ws with 0 width in this direction, change it to have some width;
for(unsigned int i=0;i<nDim;i++)
{
if(minVal[i]>=maxVal[i])
{
g_log.debug()<<"identified min-max values for dimension N: "<<i<<" are equal. Modifying min-max value to produce dimension with 0.2*dimValue width\n";
if(minVal[i]>0)
{
minVal[i]*=0.9;
maxVal[i]*=1.1;
}
else if(minVal[i]==0)
{
minVal[i]=-0.1;
maxVal[i]=0.1;
}
else
{
minVal[i]*=1.1;
maxVal[i]*=0.9;
}
}
else // expand min-max values a bit to avoid cutting data on the edges
{
if (std::fabs(minVal[i])>FLT_EPSILON)
minVal[i]*=(1+2*FLT_EPSILON);
else
minVal[i]-=2*FLT_EPSILON;
if (std::fabs(minVal[i])>FLT_EPSILON)
maxVal[i]*=(1+2*FLT_EPSILON);
else
minVal[i]+=2*FLT_EPSILON;
}
}
if(!wellDefined) return;
// if only min or only max limits are defined and are well defined workspace, the algorithm will use these limits
std::vector<double> minAlgValues = this->getProperty("MinValues");
std::vector<double> maxAlgValues = this->getProperty("MaxValues");
bool allMinDefined = (minAlgValues.size()==nDim);
bool allMaxDefined = (maxAlgValues.size()==nDim);
if(allMinDefined || allMaxDefined)
{
for(size_t i=0;i<nDim;i++)
{
if (allMinDefined) minVal[i] = minAlgValues[i];
if (allMaxDefined) maxVal[i] = maxAlgValues[i];
}
}
}
void C2ETab::runAlgorithm(const Mantid::API::Algorithm_sptr algorithm)
{
algorithm->setRethrows(true);
m_algRunner->startAlgorithm(algorithm);
}
/** Execute the algorithm. */
void ConvertToDiffractionMDWorkspace2::exec()
{
Mantid::API::Algorithm_sptr Convert = createChildAlgorithm("ConvertToMD",0.,1.);
Convert->initialize();
Convert->setRethrows(true);
Convert->initialize();
Convert->setProperty<MatrixWorkspace_sptr>("InputWorkspace",this->getProperty("InputWorkspace"));
Convert->setProperty("OutputWorkspace",this->getPropertyValue("OutputWorkspace"));
Convert->setProperty("OverwriteExisting",!this->getProperty("Append"));
if(!MDEvents::MDTransfFactory::Instance().exists("Q3D"))
{
throw std::runtime_error(" ConvertToMD Q3D plugin used to transform into DiffractionWorkspaced has not been registered with the MDTransformation factory");
}
Convert->setPropertyValue("QDimensions","Q3D");
std::vector<std::string> dE_modes = Kernel::DeltaEMode().availableTypes();
Convert->setPropertyValue("dEAnalysisMode",dE_modes[Kernel::DeltaEMode::Elastic]);
std::string TargetFrame,Scaling;
this->convertFramePropertyNames(this->getPropertyValue("OutputDimensions"),TargetFrame,Scaling);
Convert->setProperty("Q3DFrames",TargetFrame);
Convert->setProperty("QConversionScales",Scaling);
Convert->setProperty("OtherDimensions","");
Convert->setProperty("PreprocDetectorsWS","-");
bool lorCorr = this->getProperty("LorentzCorrection");
Convert->setProperty("LorentzCorrection",lorCorr);
bool ignoreZeros = !this->getProperty("OneEventPerBin");
Convert->setProperty("IgnoreZeroSignals",ignoreZeros);
//set extents
std::vector<double> extents = this->getProperty("Extents");
std::vector<double> minVal,maxVal;
convertExtents(extents,minVal,maxVal);
Convert->setProperty("MinValues",minVal);
Convert->setProperty("MaxValues",maxVal);
// Box controller properties. Has defaults
Convert->setProperty("SplitInto",this->getPropertyValue("SplitInto"));
Convert->setProperty("SplitThreshold",this->getPropertyValue("SplitThreshold"));
Convert->setProperty("MaxRecursionDepth",this->getPropertyValue("MaxRecursionDepth"));
std::string depth = this->getPropertyValue("MinRecursionDepth");
if(depth == "0") depth = "1"; // ConvertToMD does not understand 0 depth
Convert->setProperty("MinRecursionDepth",depth);
Convert->executeAsChildAlg();
IMDEventWorkspace_sptr iOut = Convert->getProperty("OutputWorkspace");
this->setProperty("OutputWorkspace",iOut);
}