/// Try to extract a V3D from the given string with different separators.
V3D V3DFromHKLColumnExtractor::getHKLFromString(
const std::string &hklString) const {
auto delimiters = boost::is_any_of(" ,[];");
std::string workingCopy = boost::trim_copy_if(hklString, delimiters);
std::vector<std::string> indicesStr;
boost::split(indicesStr, workingCopy, delimiters);
if (indicesStr.size() != 3) {
throw std::invalid_argument("Input string cannot be parsed as HKL.");
}
V3D hkl;
hkl.setX(boost::lexical_cast<double>(indicesStr[0]));
hkl.setY(boost::lexical_cast<double>(indicesStr[1]));
hkl.setZ(boost::lexical_cast<double>(indicesStr[2]));
return hkl;
}
/** Create or adjust "pos" parameter for a component
* Assumed that name either equals "x", "y" or "z" otherwise this
* method will not add or modify "pos" parameter
* @param comp :: Component
* @param name :: name of the parameter
* @param value :: value
* @param pDescription :: a pointer (may be NULL) to a string, containing
* parameter's
* description. If provided, the contents of the string is copied to the
* parameters
* memory
*/
void ParameterMap::addPositionCoordinate(
const IComponent *comp, const std::string &name, const double value,
const std::string *const pDescription) {
Parameter_sptr param = get(comp, pos());
V3D position;
if (param) {
// so "pos" already defined
position = param->value<V3D>();
} else {
// so "pos" is not defined - therefore get position from component
position = comp->getPos();
}
// adjust position
if (name.compare(posx()) == 0)
position.setX(value);
else if (name.compare(posy()) == 0)
position.setY(value);
else if (name.compare(posz()) == 0)
position.setZ(value);
else {
g_log.warning() << "addPositionCoordinate() called with unrecognized "
"coordinate symbol: " << name;
// set description if one is provided
if (pDescription) {
param->setDescription(*pDescription);
}
return;
}
// clear the position cache
clearPositionSensitiveCaches();
// finally add or update "pos" parameter
addV3D(comp, pos(), position, pDescription);
}
void SANSDirectBeamScaling::exec()
{
MatrixWorkspace_const_sptr inputWS = getProperty("InputWorkspace");
const double beamRadius = getProperty("BeamRadius");
const double attTrans = getProperty("AttenuatorTransmission");
const double attTransErr = getProperty("AttenuatorTransmissionError");
// Extract the required spectra into separate workspaces
std::vector<detid_t> udet;
std::vector<size_t> index;
udet.push_back(getProperty("BeamMonitor"));
// Convert UDETs to workspace indices
inputWS->getIndicesFromDetectorIDs(udet,index);
if (index.size() < 1)
{
g_log.debug() << "inputWS->getIndicesFromDetectorIDs() returned empty\n";
throw std::invalid_argument("Could not find the incident beam monitor spectra\n");
}
const int64_t numHists = inputWS->getNumberHistograms();
Progress progress(this,0.0,1.0,numHists);
// Number of X bins
const int64_t xLength = inputWS->readY(0).size();
// Monitor counts
double monitor = 0.0;
const MantidVec& MonIn = inputWS->readY(index[0]);
for (int64_t j = 0; j < xLength; j++)
monitor += MonIn[j];
const V3D sourcePos = inputWS->getInstrument()->getSource()->getPos();
double counts = 0.0;
double error = 0.0;
int nPixels = 0;
// Sample-detector distance for the contributing pixels
double sdd = 0.0;
for (int64_t i = 0; i < int64_t(numHists); ++i)
{
IDetector_const_sptr det;
try {
det = inputWS->getDetector(i);
} catch (Exception::NotFoundError&) {
g_log.warning() << "Spectrum index " << i << " has no detector assigned to it - discarding" << std::endl;
continue;
}
// Skip if we have a monitor or if the detector is masked.
if ( det->isMonitor() || det->isMasked() ) continue;
const MantidVec& YIn = inputWS->readY(i);
const MantidVec& EIn = inputWS->readE(i);
// Sum up all the counts
V3D pos = det->getPos() - V3D(sourcePos.X(), sourcePos.Y(), 0.0);
const double pixelDistance = pos.Z();
pos.setZ(0.0);
if (pos.norm() <= beamRadius) {
// Correct data for all X bins
for (int64_t j = 0; j < xLength; j++)
{
counts += YIn[j];
error += EIn[j]*EIn[j];
}
nPixels += 1;
sdd += pixelDistance;
}
progress.report("Absolute Scaling");
}
// Get the average SDD for the counted pixels, and transform to mm.
sdd = sdd/nPixels*1000.0;
error = std::sqrt(error);
// Transform from m to mm
double sourceAperture = getProperty("SourceApertureRadius");
sourceAperture *= 1000.0;
// Transform from m to mm
double sampleAperture = getProperty("SampleApertureRadius");
sampleAperture *= 1000.0;
//TODO: replace this by some meaningful value
const double KCG2FluxPerMon_SUGAR = 1.0;
// Solid angle correction scale in 1/(cm^2)/steradian
double solidAngleCorrScale = sdd/(M_PI*sourceAperture*sampleAperture);
solidAngleCorrScale = solidAngleCorrScale*solidAngleCorrScale*100.0;
// Scaling factor in n/(monitor count)/(cm^2)/steradian
double scale = counts/monitor*solidAngleCorrScale/KCG2FluxPerMon_SUGAR;
double scaleErr = std::abs(error/monitor)*solidAngleCorrScale/KCG2FluxPerMon_SUGAR;
scaleErr = std::abs(scale/attTrans)*sqrt( (scaleErr/scale)*(scaleErr/scale) +(attTransErr/attTrans)*(attTransErr/attTrans) );
scale /= attTrans;
std::vector<double> output;
output.push_back(scale);
output.push_back(scaleErr);
setProperty("ScaleFactor", output);
}
