/**
* Looks at each of the parameters, to see if they are default, and if they are,
* over-writes them
* with the values set in the instrument parameters (if they exist).
* @param instrument : Instrument on input workspace.
* @param ndims : Number of dimensions in output workspace.
*/
void BoxControllerSettingsAlgorithm::takeDefaultsFromInstrument(
Mantid::Geometry::Instrument_const_sptr instrument, const size_t ndims) {
const std::string splitThresholdName = "SplitThreshold";
const std::string splitIntoName = "SplitInto";
const std::string maxRecursionDepthName = "MaxRecursionDepth";
Property *p = getProperty(splitThresholdName);
if (p->isDefault()) {
std::vector<double> instrumentSplitThresholds =
instrument->getNumberParameter(splitThresholdName, true);
if (!instrumentSplitThresholds.empty()) {
setProperty(splitThresholdName,
static_cast<int>(instrumentSplitThresholds.front()));
}
}
p = getProperty(splitIntoName);
if (p->isDefault()) {
std::vector<double> instrumentSplitInto =
instrument->getNumberParameter(splitIntoName, true);
if (!instrumentSplitInto.empty()) {
const int splitInto = static_cast<int>(instrumentSplitInto.front());
std::vector<int> newSplitInto(ndims, splitInto);
setProperty(splitIntoName, newSplitInto);
}
}
p = getProperty(maxRecursionDepthName);
if (p->isDefault()) {
std::vector<double> instrumentMaxRecursionDepth =
instrument->getNumberParameter(maxRecursionDepthName, true);
if (!instrumentMaxRecursionDepth.empty()) {
setProperty(maxRecursionDepthName,
static_cast<int>(instrumentMaxRecursionDepth.front()));
}
}
}
/**
* This function either shows or hides the given QCheckBox, based on the named property
* inside the instrument param file. When hidden, the default state will be used to
* reset to the "unused" state of the checkbox.
*
* @param parameterName :: The name of the property to look for inside the current inst param file.
* @param checkBox :: The checkbox to set the state of, and to either hide or show based on the current inst.
* @param defaultState :: The state to which the checkbox will be set upon hiding it.
*/
void IndirectDataReduction::setInstSpecificWidget(const std::string & parameterName, QCheckBox * checkBox, QCheckBox::ToggleState defaultState)
{
// Get access to instrument specific parameters via the loaded empty workspace.
std::string instName = m_uiForm.cbInst->currentText().toStdString();
Mantid::API::MatrixWorkspace_sptr input = boost::dynamic_pointer_cast<Mantid::API::MatrixWorkspace>(Mantid::API::AnalysisDataService::Instance().retrieve("__empty_" + instName));
if(input == NULL)
return;
Mantid::Geometry::Instrument_const_sptr instr = input->getInstrument();
// See if the instrument params file requests that the checkbox be shown to the user.
std::vector<std::string> showParams = instr->getStringParameter(parameterName);
std::string show = "";
if(!showParams.empty())
show = showParams[0];
if(show == "Show")
checkBox->setHidden(false);
else
{
checkBox->setHidden(true);
checkBox->setState(defaultState);
}
}
/**
* Attempt to extract an instrument double parameter from a specified
* instrument.
*
* @param instrument The instrument to extract the parameter from.
* @param parameterName The name of the parameter to extract.
*
* @return The extracted parameter if it is found, else
* boost::none.
*/
boost::optional<double> CalculatePaalmanPings::getInstrumentParameter(
Mantid::Geometry::Instrument_const_sptr instrument,
const std::string ¶meterName) {
if (instrument->hasParameter(parameterName)) {
const auto parameterValue = QString::fromStdString(
instrument->getStringParameter(parameterName)[0]);
return parameterValue.toDouble();
}
return boost::none;
}
/**
* Get the detector component. Use the name provided as a property as the basis
*for the lookup as a priority.
*
* Throws if the name is invalid.
* @param workspace : Workspace from instrument with detectors
* @param isPointDetector : True if this is a point detector. Used to guess a
*name.
* @return The component : The component object found.
*/
boost::shared_ptr<const Mantid::Geometry::IComponent>
SpecularReflectionAlgorithm::getDetectorComponent(
MatrixWorkspace_sptr workspace, const bool isPointDetector) const {
boost::shared_ptr<const IComponent> searchResult;
if (!isPropertyDefault("SpectrumNumbersOfDetectors")) {
const std::vector<int> spectrumNumbers =
this->getProperty("SpectrumNumbersOfDetectors");
const bool strictSpectrumChecking =
this->getProperty("StrictSpectrumChecking");
checkSpectrumNumbers(spectrumNumbers, strictSpectrumChecking, g_log);
auto specToWorkspaceIndex = workspace->getSpectrumToWorkspaceIndexMap();
DetectorGroup_sptr allDetectors = boost::make_shared<DetectorGroup>();
const auto &spectrumInfo = workspace->spectrumInfo();
for (auto index : spectrumNumbers) {
const size_t spectrumNumber{static_cast<size_t>(index)};
auto it = specToWorkspaceIndex.find(index);
if (it == specToWorkspaceIndex.end()) {
std::stringstream message;
message << "Spectrum number " << spectrumNumber
<< " does not exist in the InputWorkspace";
throw std::invalid_argument(message.str());
}
const size_t workspaceIndex = it->second;
auto detector = workspace->getDetector(workspaceIndex);
if (spectrumInfo.isMasked(workspaceIndex))
g_log.warning() << "Adding a detector (ID:" << detector->getID()
<< ") that is flagged as masked.\n";
allDetectors->addDetector(detector);
}
searchResult = allDetectors;
} else {
Mantid::Geometry::Instrument_const_sptr inst = workspace->getInstrument();
std::string componentToCorrect =
isPointDetector ? "point-detector" : "linedetector";
if (!isPropertyDefault("DetectorComponentName")) {
componentToCorrect = this->getPropertyValue("DetectorComponentName");
}
searchResult = inst->getComponentByName(componentToCorrect);
if (searchResult == nullptr) {
throw std::invalid_argument(componentToCorrect +
" does not exist. Check input properties.");
}
}
return searchResult;
}
/**
* Get the sample component. Use the name provided as a property as the basis
*for the lookup as a priority.
*
* Throws if the name is invalid.
* @param inst : Instrument to search through
* @return : The component : The component object found.
*/
Mantid::Geometry::IComponent_const_sptr
SpecularReflectionAlgorithm::getSurfaceSampleComponent(
Mantid::Geometry::Instrument_const_sptr inst) const {
std::string sampleComponent = "some-surface-holder";
if (!isPropertyDefault("SampleComponentName")) {
sampleComponent = this->getPropertyValue("SampleComponentName");
}
auto searchResult = inst->getComponentByName(sampleComponent);
if (searchResult == nullptr) {
throw std::invalid_argument(sampleComponent +
" does not exist. Check input properties.");
}
return searchResult;
}
double ReflectometryReductionOneAuto::checkForDefault(
std::string propName, Mantid::Geometry::Instrument_const_sptr instrument,
std::string idf_name) const {
auto algProperty = this->getPointerToProperty(propName);
if (algProperty->isDefault()) {
auto defaults = instrument->getNumberParameter(idf_name);
if (defaults.size() == 0) {
throw std::runtime_error("No data could be retrieved from the parameters "
"and argument wasn't provided: " +
propName);
}
return defaults[0];
} else {
return boost::lexical_cast<double, std::string>(algProperty->value());
}
}
/**
@param inst Instrument
@param bankName Name of detector bank
@param col Column number containing peak
@param row Row number containing peak
@param Edge Number of edge points for each bank
@return True if peak is on edge
*/
bool edgePixel(Mantid::Geometry::Instrument_const_sptr inst,
std::string bankName, int col, int row, int Edge) {
if (bankName == "None")
return false;
boost::shared_ptr<const Geometry::IComponent> parent =
inst->getComponentByName(bankName);
if (parent->type() == "RectangularDetector") {
boost::shared_ptr<const Geometry::RectangularDetector> RDet =
boost::dynamic_pointer_cast<const Geometry::RectangularDetector>(
parent);
return col < Edge || col >= (RDet->xpixels() - Edge) || row < Edge ||
row >= (RDet->ypixels() - Edge);
} else {
std::vector<Geometry::IComponent_const_sptr> children;
boost::shared_ptr<const Geometry::ICompAssembly> asmb =
boost::dynamic_pointer_cast<const Geometry::ICompAssembly>(parent);
asmb->getChildren(children, false);
int startI = 1;
if (children[0]->getName() == "sixteenpack") {
startI = 0;
parent = children[0];
children.clear();
boost::shared_ptr<const Geometry::ICompAssembly> asmb =
boost::dynamic_pointer_cast<const Geometry::ICompAssembly>(parent);
asmb->getChildren(children, false);
}
boost::shared_ptr<const Geometry::ICompAssembly> asmb2 =
boost::dynamic_pointer_cast<const Geometry::ICompAssembly>(children[0]);
std::vector<Geometry::IComponent_const_sptr> grandchildren;
asmb2->getChildren(grandchildren, false);
int NROWS = static_cast<int>(grandchildren.size());
int NCOLS = static_cast<int>(children.size());
// Wish pixels and tubes start at 1 not 0
return col - startI < Edge || col - startI >= (NCOLS - Edge) ||
row - startI < Edge || row - startI >= (NROWS - Edge);
}
return false;
}
/**
* Gets the eFixed value from the workspace using the instrument parameters.
*
* @param ws Pointer to the workspace
* @return eFixed value
*/
double IndirectTab::getEFixed(Mantid::API::MatrixWorkspace_sptr ws) {
Mantid::Geometry::Instrument_const_sptr inst = ws->getInstrument();
if (!inst)
throw std::runtime_error("No instrument on workspace");
// Try to get the parameter form the base instrument
if (inst->hasParameter("Efixed"))
return inst->getNumberParameter("Efixed")[0];
// Try to get it form the analyser component
if (inst->hasParameter("analyser")) {
std::string analyserName = inst->getStringParameter("analyser")[0];
auto analyserComp = inst->getComponentByName(analyserName);
if (analyserComp && analyserComp->hasParameter("Efixed"))
return analyserComp->getNumberParameter("Efixed")[0];
}
throw std::runtime_error("Instrument has no efixed parameter");
}
/**
* @return List of columns to hide by default.
*/
std::vector<int> QPeaksTableModel::defaultHideCols()
{
std::vector<int> result;
// figure out if there are any rectangular detectors
Mantid::Geometry::Instrument_const_sptr instr = m_peaksWS->getInstrument();
{ // shrink variable scope
std::vector<Mantid::detid_t> ids = instr->getDetectorIDs(true);
size_t numToCheck(ids.size());
if (numToCheck > 20) // arbitrary cutoff
numToCheck = 20;
const std::string RECT_DET("RectangularDetector");
for (size_t i = 0; i < numToCheck; ++i)
{
boost::shared_ptr<const Mantid::Geometry::IComponent> component = instr->getDetector(ids[i]);
if (component->type().compare(RECT_DET) == 0)
{
break;
}
else
{
component = component->getParent();
if (component->type().compare(RECT_DET) == 0)
{
break;
}
}
}
}
// only show bank name for SNS instruments
std::string instrName = instr->getName();
try
{
Mantid::Kernel::InstrumentInfo instrInfo =
Mantid::Kernel::ConfigService::Instance().getInstrument(instrName);
if (instrInfo.facility().name() != "SNS")
result.push_back(COL_BANKNAME);
// hide some columns based on the techniques
{ // shrink variable scope
std::set<std::string> techniques = instrInfo.techniques();
// required for showing final and delta energy
const std::string IGS("TOF Indirect Geometry Spectroscopy");
// required for showing initial and delta energy
const std::string DGS("TOF Direct Geometry Spectroscopy");
bool showEnergy(false);
if (techniques.find(DGS) == techniques.end())
result.push_back(COL_FINAL_ENERGY);
else
showEnergy = true;
if (techniques.find(IGS) == techniques.end())
result.push_back(COL_INITIAL_ENERGY);
else
showEnergy = true;
if (!showEnergy)
result.push_back(COL_ENERGY);
}
} catch (Mantid::Kernel::Exception::NotFoundError&)
{
// Unable to fetch instrument info, so continue without it.
}
return result;
}
void InstrumentWidget::setSurfaceType(int type) {
// we cannot do 3D without OpenGL
if (type == FULL3D && !isGLEnabled()) {
QMessageBox::warning(
this, "Mantid - Warning",
"OpenGL must be enabled to render the instrument in 3D.");
return;
}
if (type < RENDERMODE_SIZE) {
QApplication::setOverrideCursor(Qt::WaitCursor);
SurfaceType surfaceType = SurfaceType(type);
if (!m_instrumentActor)
return;
ProjectionSurface *surface = getSurface().get();
int peakLabelPrecision = 6;
bool showPeakRow = true;
bool showPeakLabels = true;
bool showPeakRelativeIntensity = true;
if (surface) {
peakLabelPrecision = surface->getPeakLabelPrecision();
showPeakRow = surface->getShowPeakRowsFlag();
showPeakLabels = surface->getShowPeakLabelsFlag();
} else {
QSettings settings;
settings.beginGroup(InstrumentWidgetSettingsGroup);
peakLabelPrecision = settings.value("PeakLabelPrecision", 2).toInt();
showPeakRow = settings.value("ShowPeakRows", true).toBool();
showPeakLabels = settings.value("ShowPeakLabels", true).toBool();
// By default this is should be off for now.
showPeakRelativeIntensity =
settings.value("ShowPeakRelativeIntensities", false).toBool();
settings.endGroup();
}
// Surface factory
// If anything throws during surface creation, store error message here
QString errorMessage;
try {
Mantid::Geometry::Instrument_const_sptr instr =
m_instrumentActor->getInstrument();
Mantid::Geometry::IComponent_const_sptr sample = instr->getSample();
if (!sample) {
throw InstrumentHasNoSampleError();
}
Mantid::Kernel::V3D sample_pos = sample->getPos();
auto axis = getSurfaceAxis(surfaceType);
// create the surface
if (surfaceType == FULL3D) {
surface = new Projection3D(m_instrumentActor.get(),
getInstrumentDisplayWidth(),
getInstrumentDisplayHeight());
} else if (surfaceType <= CYLINDRICAL_Z) {
surface =
new UnwrappedCylinder(m_instrumentActor.get(), sample_pos, axis);
} else if (surfaceType <= SPHERICAL_Z) {
surface =
new UnwrappedSphere(m_instrumentActor.get(), sample_pos, axis);
} else // SIDE_BY_SIDE
{
surface = new PanelsSurface(m_instrumentActor.get(), sample_pos, axis);
}
} catch (InstrumentHasNoSampleError &) {
QApplication::restoreOverrideCursor();
throw;
} catch (std::exception &e) {
errorMessage = e.what();
} catch (...) {
errorMessage = "Unknown exception thrown.";
}
if (!errorMessage.isNull()) {
// if exception was thrown roll back to the current surface type.
QApplication::restoreOverrideCursor();
QMessageBox::critical(
this, "MantidPlot - Error",
"Surface cannot be created because of an exception:\n\n " +
errorMessage + "\n\nPlease select a different surface type.");
// if suface change was initialized by the GUI this should ensure its
// consistency
emit surfaceTypeChanged(m_surfaceType);
return;
}
// end Surface factory
m_surfaceType = surfaceType;
surface->setPeakLabelPrecision(peakLabelPrecision);
surface->setShowPeakRowsFlag(showPeakRow);
surface->setShowPeakLabelsFlag(showPeakLabels);
surface->setShowPeakRelativeIntensityFlag(showPeakRelativeIntensity);
// set new surface
setSurface(surface);
// init tabs with new surface
foreach (InstrumentWidgetTab *tab, m_tabs) { tab->initSurface(); }
connect(surface, SIGNAL(executeAlgorithm(Mantid::API::IAlgorithm_sptr)),
this, SLOT(executeAlgorithm(Mantid::API::IAlgorithm_sptr)));
connect(surface, SIGNAL(updateInfoText()), this, SLOT(updateInfoText()),
Qt::QueuedConnection);
QApplication::restoreOverrideCursor();
}