/**
* Attempts to load a grouping information referenced by IDF.
* @param instrument :: Intrument which we went the grouping for
* @param mainFieldDirection :: (MUSR) orientation of the instrument
* @return Grouping information
*/
boost::shared_ptr<Grouping> getGroupingFromIDF(Instrument_const_sptr instrument,
const std::string& mainFieldDirection)
{
std::string parameterName = "Default grouping file";
// Special case for MUSR, because it has two possible groupings
if (instrument->getName() == "MUSR")
{
parameterName.append(" - " + mainFieldDirection);
}
std::vector<std::string> groupingFiles = instrument->getStringParameter(parameterName);
if ( groupingFiles.size() == 1 )
{
const std::string groupingFile = groupingFiles[0];
// Get search directory for XML instrument definition files (IDFs)
std::string directoryName = ConfigService::Instance().getInstrumentDirectory();
auto loadedGrouping = boost::make_shared<Grouping>();
loadGroupingFromXML(directoryName + groupingFile, *loadedGrouping);
return loadedGrouping;
}
else
{
throw std::runtime_error("Multiple groupings specified for the instrument");
}
}
/**
* Store required caches
*/
void ModeratorChopperResolution::initCaches() {
Instrument_const_sptr instr = m_observation.experimentInfo().getInstrument();
IComponent_const_sptr source = instr->getSource();
m_modChopDist = m_observation.moderatorToFirstChopperDistance();
m_chopSampleDist = m_observation.firstChopperToSampleDistance();
}
void CalculateDIFC::calculate() {
Instrument_const_sptr instrument = m_inputWS->getInstrument();
SpecialWorkspace2D_sptr localWS =
boost::dynamic_pointer_cast<SpecialWorkspace2D>(m_outputWS);
double l1;
Kernel::V3D beamline, samplePos;
double beamline_norm;
instrument->getInstrumentParameters(l1, beamline, beamline_norm, samplePos);
// To get all the detector ID's
detid2det_map allDetectors;
instrument->getDetectors(allDetectors);
// Now go through all
detid2det_map::const_iterator it = allDetectors.begin();
for (; it != allDetectors.end(); ++it) {
Geometry::IDetector_const_sptr det = it->second;
if ((!det->isMasked()) && (!det->isMonitor())) {
const detid_t detID = it->first;
double offset = 0.;
if (m_offsetsWS)
offset = m_offsetsWS->getValue(detID, 0.);
double difc = Geometry::Instrument::calcConversion(
l1, beamline, beamline_norm, samplePos, det, offset);
difc = 1. / difc; // calcConversion gives 1/DIFC
localWS->setValue(detID, difc);
}
}
}
/** Extract mask information from a workspace containing instrument
* @return vector of detector IDs of detectors that are masked
*/
std::vector<detid_t> ExtractMaskToTable::extractMaskFromMatrixWorkspace() {
// Clear input
std::vector<detid_t> maskeddetids;
// Get on hold of instrument
Instrument_const_sptr instrument = m_dataWS->getInstrument();
if (!instrument)
throw runtime_error("There is no instrument in input workspace.");
// Extract
size_t numdets = instrument->getNumberDetectors();
vector<detid_t> detids = instrument->getDetectorIDs();
for (size_t i = 0; i < numdets; ++i) {
detid_t tmpdetid = detids[i];
IDetector_const_sptr tmpdetector = instrument->getDetector(tmpdetid);
bool masked = tmpdetector->isMasked();
if (masked) {
maskeddetids.push_back(tmpdetid);
}
g_log.debug() << "[DB] Detector No. " << i << ": ID = " << tmpdetid
<< ", Masked = " << masked << ".\n";
}
g_log.notice() << "Extract mask: There are " << maskeddetids.size()
<< " detectors that"
" are masked."
<< ".\n";
return maskeddetids;
}
/** Retrieves the properties and checks that they have valid values.
* @throw std::invalid_argument If either workspace has no instrument or the instruments have different base instruments.
*/
void CopyInstrumentParameters::checkProperties()
{
// Check that both workspaces have an instrument
Instrument_const_sptr inst = m_givingWorkspace->getInstrument();
if( !inst )
{
throw std::invalid_argument("Input workspace has no instrument");
}
Instrument_const_sptr inst2 = m_receivingWorkspace->getInstrument();
if( !inst2 )
{
throw std::invalid_argument("Output workspace has no instrument");
}
Instrument_const_sptr baseInstGiv = inst->baseInstrument();
Instrument_const_sptr baseInstRec = inst2->baseInstrument();
// Check that both workspaces have the same instrument name
if( baseInstRec != baseInstGiv )
{
m_different_instrument_sp=true;
g_log.warning() << "The base instrument in the output workspace is not the same as the base instrument in the input workspace."<< std::endl;
}
}
/**
* Handles setting default spectra range when an instrument configuration is
*selected.
*
* @param instrumentName Name of selected instrument
* @param analyserName Name of selected analyser (should always be
*"diffraction")
* @param reflectionName Name of diffraction mode selected
*/
void IndirectDiffractionReduction::instrumentSelected(
const QString &instrumentName, const QString &analyserName,
const QString &reflectionName) {
UNUSED_ARG(analyserName);
// Set the search instrument for runs
m_uiForm.rfSampleFiles->setInstrumentOverride(instrumentName);
m_uiForm.rfCanFiles->setInstrumentOverride(instrumentName);
MatrixWorkspace_sptr instWorkspace = loadInstrument(
instrumentName.toStdString(), reflectionName.toStdString());
Instrument_const_sptr instrument = instWorkspace->getInstrument();
// Get default spectra range
double specMin = instrument->getNumberParameter("spectra-min")[0];
double specMax = instrument->getNumberParameter("spectra-max")[0];
m_uiForm.spSpecMin->setValue(static_cast<int>(specMin));
m_uiForm.spSpecMax->setValue(static_cast<int>(specMax));
// Determine whether we need vanadium input
std::vector<std::string> correctionVector =
instrument->getStringParameter("Workflow.Diffraction.Correction");
bool vanadiumNeeded = false;
if (correctionVector.size() > 0)
vanadiumNeeded = (correctionVector[0] == "Vanadium");
if (vanadiumNeeded)
m_uiForm.swVanadium->setCurrentIndex(0);
else
m_uiForm.swVanadium->setCurrentIndex(1);
// Hide options that the current instrument config cannot process
if (instrumentName == "OSIRIS" && reflectionName == "diffonly") {
// Disable individual grouping
m_uiForm.ckIndividualGrouping->setToolTip(
"OSIRIS cannot group detectors individually in diffonly mode");
m_uiForm.ckIndividualGrouping->setEnabled(false);
m_uiForm.ckIndividualGrouping->setChecked(false);
// Disable sum files
m_uiForm.ckSumFiles->setToolTip("OSIRIS cannot sum files in diffonly mode");
m_uiForm.ckSumFiles->setEnabled(false);
m_uiForm.ckSumFiles->setChecked(false);
} else {
// Re-enable sum files
m_uiForm.ckSumFiles->setToolTip("");
m_uiForm.ckSumFiles->setEnabled(true);
m_uiForm.ckSumFiles->setChecked(true);
// Re-enable individual grouping
m_uiForm.ckIndividualGrouping->setToolTip("");
m_uiForm.ckIndividualGrouping->setEnabled(true);
// Re-enable spectra range
m_uiForm.spSpecMin->setEnabled(true);
m_uiForm.spSpecMax->setEnabled(true);
}
}
/**
* Calculate the twoTheta angle from the detector and sample locations.
* @return: twoTheta
*/
double SpecularReflectionAlgorithm::calculateTwoTheta() const {
MatrixWorkspace_sptr inWS = this->getProperty("InputWorkspace");
const std::string analysisMode = this->getProperty("AnalysisMode");
Instrument_const_sptr instrument = inWS->getInstrument();
IComponent_const_sptr detector =
this->getDetectorComponent(inWS, analysisMode == pointDetectorAnalysis);
IComponent_const_sptr sample = this->getSurfaceSampleComponent(instrument);
const V3D detSample = detector->getPos() - sample->getPos();
boost::shared_ptr<const ReferenceFrame> refFrame =
instrument->getReferenceFrame();
const double upoffset = refFrame->vecPointingUp().scalar_prod(detSample);
const double beamoffset =
refFrame->vecPointingAlongBeam().scalar_prod(detSample);
const double twoTheta = std::atan2(upoffset, beamoffset) * 180 / M_PI;
return twoTheta;
}
/**
* Updates the analyser and reflection names in the UI when an instrument is selected.
*
* @param instrumentName Nmae of instrument
*/
void IndirectInstrumentConfig::updateInstrumentConfigurations(const QString & instrumentName)
{
if(instrumentName.isEmpty())
return;
g_log.debug() << "Loading configuration for instrument: " << instrumentName.toStdString() << std::endl;
bool analyserPreviousBlocking = m_uiForm.cbAnalyser->signalsBlocked();
m_uiForm.cbAnalyser->blockSignals(true);
m_uiForm.cbAnalyser->clear();
IAlgorithm_sptr loadInstAlg = AlgorithmManager::Instance().create("CreateSimulationWorkspace");
loadInstAlg->initialize();
loadInstAlg->setChild(true);
loadInstAlg->setProperty("Instrument", instrumentName.toStdString());
loadInstAlg->setProperty("BinParams", "0,0.5,1");
loadInstAlg->setProperty("OutputWorkspace", "__empty_instrument_workspace");
loadInstAlg->execute();
MatrixWorkspace_sptr instWorkspace = loadInstAlg->getProperty("OutputWorkspace");
QList<QPair<QString, QString>> instrumentModes;
Instrument_const_sptr instrument = instWorkspace->getInstrument();
std::vector<std::string> ipfAnalysers = instrument->getStringParameter("analysers");
if(ipfAnalysers.size() == 0)
return;
QStringList analysers = QString::fromStdString(ipfAnalysers[0]).split(",");
for(auto it = analysers.begin(); it != analysers.end(); ++it)
{
QString analyser = *it;
std::string ipfReflections = instrument->getStringParameter("refl-" + analyser.toStdString())[0];
QStringList reflections = QString::fromStdString(ipfReflections).split(",");
if(m_removeDiffraction && analyser == "diffraction")
continue;
if(m_forceDiffraction && analyser != "diffraction")
continue;
if(reflections.size() > 0)
{
QVariant data = QVariant(reflections);
m_uiForm.cbAnalyser->addItem(analyser, data);
}
else
{
m_uiForm.cbAnalyser->addItem(analyser);
}
}
int index = m_uiForm.cbAnalyser->currentIndex();
updateReflectionsList(index);
m_uiForm.cbAnalyser->blockSignals(analyserPreviousBlocking);
}
/** Get the list of banks, given the settings
*
* @return map with key = bank number; value = pointer to the rectangular
*detector
*/
std::map<int, RectangularDetector_const_sptr>
ConvertToDetectorFaceMD::getBanks() {
Instrument_const_sptr inst = in_ws->getInstrument();
std::vector<int> bankNums = this->getProperty("BankNumbers");
std::sort(bankNums.begin(), bankNums.end());
std::map<int, RectangularDetector_const_sptr> banks;
if (bankNums.empty()) {
// --- Find all rectangular detectors ----
// Get all children
std::vector<IComponent_const_sptr> comps;
inst->getChildren(comps, true);
for (auto &comp : comps) {
// Retrieve it
RectangularDetector_const_sptr det =
boost::dynamic_pointer_cast<const RectangularDetector>(comp);
if (det) {
std::string name = det->getName();
if (name.size() < 5)
continue;
std::string bank = name.substr(4, name.size() - 4);
int bankNum;
if (Mantid::Kernel::Strings::convert(bank, bankNum))
banks[bankNum] = det;
g_log.debug() << "Found bank " << bank << ".\n";
}
}
} else {
// -- Find detectors using the numbers given ---
for (auto &bankNum : bankNums) {
std::string bankName =
"bank" + Mantid::Kernel::Strings::toString(bankNum);
IComponent_const_sptr comp = inst->getComponentByName(bankName);
RectangularDetector_const_sptr det =
boost::dynamic_pointer_cast<const RectangularDetector>(comp);
if (det)
banks[bankNum] = det;
}
}
for (auto &bank : banks) {
RectangularDetector_const_sptr det = bank.second;
// Track the largest detector
if (det->xpixels() > m_numXPixels)
m_numXPixels = det->xpixels();
if (det->ypixels() > m_numYPixels)
m_numYPixels = det->ypixels();
}
if (banks.empty())
throw std::runtime_error("No RectangularDetectors with a name like "
"'bankXX' found in the instrument.");
return banks;
}
/** Execute the algorithm.
*/
void PolarizationCorrection::exec() {
WorkspaceGroup_sptr inWS = getProperty("InputWorkspace");
const std::string analysisMode = getProperty("PolarizationAnalysis");
const size_t nWorkspaces = inWS->size();
validateInputWorkspace(inWS);
Instrument_const_sptr instrument = fetchInstrument(inWS.get());
// Check if we need to fetch polarization parameters from the instrument's
// parameters
std::map<std::string, std::string> loadableProperties;
loadableProperties[crhoLabel()] = "crho";
loadableProperties[cppLabel()] = "cPp";
// In PA mode, we also require cap and calpha
if (analysisMode == pALabel()) {
loadableProperties[cApLabel()] = "cAp";
loadableProperties[cAlphaLabel()] = "calpha";
}
for (auto propName = loadableProperties.begin();
propName != loadableProperties.end(); ++propName) {
Property *prop = getProperty(propName->first);
if (!prop)
continue;
if (prop->isDefault()) {
auto vals = instrument->getStringParameter(propName->second);
if (vals.empty())
throw std::runtime_error(
"Cannot find value for " + propName->first +
" in parameter file. Please specify this property manually.");
prop->setValue(vals[0]);
}
}
WorkspaceGroup_sptr outWS;
if (analysisMode == pALabel()) {
if (nWorkspaces != 4) {
throw std::invalid_argument(
"For PA analysis, input group must have 4 periods.");
}
g_log.notice("PA polarization correction");
outWS = execPA(inWS);
} else if (analysisMode == pNRLabel()) {
if (nWorkspaces != 2) {
throw std::invalid_argument(
"For PNR analysis, input group must have 2 periods.");
}
outWS = execPNR(inWS);
g_log.notice("PNR polarization correction");
}
this->setProperty("OutputWorkspace", outWS);
}
/**
* Make a map of the conversion factors between tof and D-spacing
* for all pixel IDs in a workspace.
*
* @param DFileName name of dspacemap file
* @param offsetsWS :: OffsetsWorkspace with instrument and offsets
*/
void SaveDspacemap::CalculateDspaceFromCal(Mantid::DataObjects::OffsetsWorkspace_sptr offsetsWS,
std::string DFileName)
{
const char * filename = DFileName.c_str();
// Get a pointer to the instrument contained in the workspace
Instrument_const_sptr instrument = offsetsWS->getInstrument();
double l1;
Kernel::V3D beamline,samplePos;
double beamline_norm;
instrument->getInstrumentParameters(l1,beamline,beamline_norm, samplePos);
//To get all the detector ID's
detid2det_map allDetectors;
instrument->getDetectors(allDetectors);
detid2det_map::const_iterator it;
detid_t maxdetID = 0;
for (it = allDetectors.begin(); it != allDetectors.end(); it++)
{
detid_t detectorID = it->first;
if(detectorID > maxdetID) maxdetID = detectorID;
}
detid_t paddetID = detid_t(getProperty("PadDetID"));
if (maxdetID < paddetID)maxdetID = paddetID;
// Now write the POWGEN-style Dspace mapping file
std::ofstream fout(filename, std::ios_base::out|std::ios_base::binary);
Progress prog(this,0.0,1.0,maxdetID);
for (detid_t i = 0; i != maxdetID; i++)
{
//Compute the factor
double factor;
Geometry::IDetector_const_sptr det;
// Find the detector with that detector id
it = allDetectors.find(i);
if (it != allDetectors.end())
{
det = it->second;
factor = Instrument::calcConversion(l1, beamline, beamline_norm, samplePos, det, offsetsWS->getValue(i, 0.0));
//Factor of 10 between ISAW and Mantid
factor *= 0.1 ;
if(factor<0)factor = 0.0;
fout.write( reinterpret_cast<char*>( &factor ), sizeof(double) );
}
else
{
factor = 0;
fout.write( reinterpret_cast<char*>( &factor ), sizeof(double) );
}
//Report progress
prog.report();
}
fout.close();
}
/**
* Recalculate the detector colors based on the integrated values in m_specIntegrs and
* the masking information in ....
*/
void InstrumentActor::resetColors()
{
QwtDoubleInterval qwtInterval(m_DataMinScaleValue,m_DataMaxScaleValue);
m_colors.resize(m_specIntegrs.size());
auto sharedWorkspace = getWorkspace();
Instrument_const_sptr inst = getInstrument();
IMaskWorkspace_sptr mask = getMaskWorkspaceIfExists();
//PARALLEL_FOR1(m_workspace)
for (int iwi=0; iwi < int(m_specIntegrs.size()); iwi++)
{
size_t wi = size_t(iwi);
double integratedValue = m_specIntegrs[wi];
try
{
// Find if the detector is masked
const std::set<detid_t>& dets = sharedWorkspace->getSpectrum(wi)->getDetectorIDs();
bool masked = false;
if ( mask )
{
masked = mask->isMasked( dets );
}
else
{
masked = inst->isDetectorMasked(dets);
}
if (masked)
{
m_colors[wi] = m_maskedColor;
}
else
{
QRgb color = m_colorMap.rgb(qwtInterval,integratedValue);
m_colors[wi] = GLColor(qRed(color), qGreen(color), qBlue(color));
}
}
catch(NotFoundError &)
{
m_colors[wi] = m_failedColor;
continue;
}
}
if (m_scene.getNumberOfActors() > 0)
{
if (auto actor = dynamic_cast<CompAssemblyActor*>(m_scene.getActor(0))) {
actor->setColors();
invalidateDisplayLists();
}
}
emit colorMapChanged();
}
void AnvredCorrection::scale_init(IDetector_const_sptr det, Instrument_const_sptr inst, int& bank, double& L2, double& depth, double& pathlength, std::string bankName)
{
bankName = det->getParent()->getParent()->getName();
std::string bankNameStr = bankName;
// Take out the "bank" part of the bank name and convert to an int
bankNameStr.erase(remove_if(bankNameStr.begin(), bankNameStr.end(), not1(std::ptr_fun (::isdigit))), bankNameStr.end());
Strings::convert(bankNameStr, bank);
IComponent_const_sptr sample = inst->getSample();
double cosA = inst->getComponentByName(bankName)->getDistance(*sample) / L2;
pathlength = depth / cosA;
}
void EstimatePDDetectorResolution::retrieveInstrumentParameters()
{
#if 0
// Call SolidAngle to get solid angles for all detectors
Algorithm_sptr calsolidangle = createChildAlgorithm("SolidAngle", -1, -1, true);
calsolidangle->initialize();
calsolidangle->setProperty("InputWorkspace", m_inputWS);
calsolidangle->execute();
if (!calsolidangle->isExecuted())
throw runtime_error("Unable to run solid angle. ");
m_solidangleWS = calsolidangle->getProperty("OutputWorkspace");
if (!m_solidangleWS)
throw runtime_error("Unable to get solid angle workspace from SolidAngle(). ");
size_t numspec = m_solidangleWS->getNumberHistograms();
for (size_t i = 0; i < numspec; ++i)
g_log.debug() << "[DB]: " << m_solidangleWS->readY(i)[0] << "\n";
#endif
// Calculate centre neutron velocity
Property* cwlproperty = m_inputWS->run().getProperty("LambdaRequest");
if (!cwlproperty)
throw runtime_error("Unable to locate property LambdaRequest as central wavelength. ");
TimeSeriesProperty<double>* cwltimeseries = dynamic_cast<TimeSeriesProperty<double>* >(cwlproperty);
if (!cwltimeseries)
throw runtime_error("LambdaReqeust is not a TimeSeriesProperty in double. ");
if (cwltimeseries->size() != 1)
throw runtime_error("LambdaRequest should contain 1 and only 1 entry. ");
double centrewavelength = cwltimeseries->nthValue(0);
string unit = cwltimeseries->units();
if (unit.compare("Angstrom") == 0)
centrewavelength *= 1.0E-10;
else
throw runtime_error("Unit is not recognized");
m_centreVelocity = PhysicalConstants::h/PhysicalConstants::NeutronMass/centrewavelength;
g_log.notice() << "Centre wavelength = " << centrewavelength << ", Centre neutron velocity = " << m_centreVelocity << "\n";
// Calcualte L1 sample to source
Instrument_const_sptr instrument = m_inputWS->getInstrument();
V3D samplepos = instrument->getSample()->getPos();
V3D sourcepos = instrument->getSource()->getPos();
m_L1 = samplepos.distance(sourcepos);
g_log.notice() << "L1 = " << m_L1 << "\n";
return;
}
void PeakIntegration::retrieveProperties() {
inputW = getProperty("InputWorkspace");
if (inputW->readY(0).size() <= 1)
throw std::runtime_error("Must Rebin data with more than 1 bin");
// Check if detectors are RectangularDetectors
Instrument_const_sptr inst = inputW->getInstrument();
boost::shared_ptr<RectangularDetector> det;
for (int i = 0; i < inst->nelements(); i++) {
det = boost::dynamic_pointer_cast<RectangularDetector>((*inst)[i]);
if (det)
break;
}
}
int LoadIsawPeaks::findPixelID(Instrument_const_sptr inst, std::string bankName, int col, int row)
{
boost::shared_ptr<const IComponent> parent = inst->getComponentByName(bankName);
if (parent->type().compare("RectangularDetector") == 0)
{
boost::shared_ptr<const RectangularDetector> RDet = boost::dynamic_pointer_cast<
const RectangularDetector>(parent);
boost::shared_ptr<Detector> pixel = RDet->getAtXY(col, row);
return pixel->getID();
}
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 col0 = (col%2==0 ? col/2+75 : (col-1)/2);
boost::shared_ptr<const Geometry::ICompAssembly> asmb2 = boost::dynamic_pointer_cast<const Geometry::ICompAssembly>(children[col0]);
std::vector<Geometry::IComponent_const_sptr> grandchildren;
asmb2->getChildren(grandchildren,false);
Geometry::IComponent_const_sptr first = grandchildren[row-1];
Geometry::IDetector_const_sptr det = boost::dynamic_pointer_cast<const Geometry::IDetector>(first);
return det->getID();
}
}
/** Creates a mapping based on a fixed number of groups for a given instrument
*component
*
* @param compName Name of component in instrument
* @param numGroups Number of groups to group detectors into
* @param inst Pointer to instrument
* @param prog Progress reporter
* @returns :: Map of detector IDs to group number
*/
std::map<detid_t, int> makeGroupingByNumGroups(const std::string compName,
int numGroups,
Instrument_const_sptr inst,
Progress &prog) {
std::map<detid_t, int> detIDtoGroup;
// Get detectors for given instument component
std::vector<IDetector_const_sptr> detectors;
inst->getDetectorsInBank(detectors, compName);
size_t numDetectors = detectors.size();
// Sanity check for following calculation
if (numGroups > static_cast<int>(numDetectors))
throw std::runtime_error("Number of groups must be less than or "
"equal to number of detectors");
// Calculate number of detectors per group
int detectorsPerGroup = static_cast<int>(numDetectors) / numGroups;
// Map detectors to group
for (unsigned int detIndex = 0; detIndex < numDetectors; detIndex++) {
int detectorID = detectors[detIndex]->getID();
int groupNum = (detIndex / detectorsPerGroup) + 1;
// Ignore any detectors the do not fit nicely into the group divisions
if (groupNum <= numGroups)
detIDtoGroup[detectorID] = groupNum;
prog.report();
}
return detIDtoGroup;
}
/**
* Returns the value associated to a parameter name in the IDF
* @param parameterName :: parameter name in the IDF
* @return the value associated to the parameter name
*/
std::string DetectorEfficiencyCorUser::getValFromInstrumentDef(
const std::string ¶meterName) {
const ParameterMap &pmap = m_inputWS->constInstrumentParameters();
Instrument_const_sptr instrument = m_inputWS->getInstrument();
Parameter_sptr par =
pmap.getRecursive(instrument->getChild(0).get(), parameterName);
if (par) {
std::string ret = par->asString();
g_log.debug() << "Parsed parameter " << parameterName << ": " << ret
<< "\n";
return ret;
} else {
throw Kernel::Exception::InstrumentDefinitionError(
"There is no <" + parameterName + "> in the instrument definition!");
}
}
/** Method for updating m_waveLength.
* If size of m_waveLength is equal to number of data (for a new instance of
*this
* class this vector is empty initially) then don't recalculate it.
*
* @param xValues :: x values
* @param nData :: length of xValues
*/
void IkedaCarpenterPV::calWavelengthAtEachDataPoint(const double *xValues,
const size_t &nData) const {
// if wavelength vector already have the right size no need for resizing it
// further we make the assumption that no need to recalculate this vector if
// it already has the right size
if (m_waveLength.size() != nData) {
m_waveLength.resize(nData);
Mantid::Kernel::Unit_sptr wavelength =
Mantid::Kernel::UnitFactory::Instance().create("Wavelength");
for (size_t i = 0; i < nData; i++) {
m_waveLength[i] = xValues[i];
}
// note if a version of convertValue was added which allows a double* as
// first argument
// then could avoid copying above plus only have to resize m_wavelength when
// its size smaller than nData
API::MatrixWorkspace_const_sptr mws = getMatrixWorkspace();
if (mws) {
API::MatrixWorkspace_const_sptr mws = getMatrixWorkspace();
Instrument_const_sptr instrument = mws->getInstrument();
Geometry::IComponent_const_sptr sample = instrument->getSample();
if (sample != nullptr) {
convertValue(m_waveLength, wavelength, mws, m_workspaceIndex);
} else {
g_log.warning()
<< "No sample set for instrument in workspace.\n"
<< "Can't calculate wavelength in IkedaCarpenter.\n"
<< "Default all wavelengths to one.\n"
<< "Solution is to load appropriate instrument into workspace.\n";
for (size_t i = 0; i < nData; i++)
m_waveLength[i] = 1.0;
}
} else {
g_log.warning() << "Workspace not set.\n"
<< "Can't calculate wavelength in IkedaCarpenter.\n"
<< "Default all wavelengths to one.\n"
<< "Solution call setMatrixWorkspace() for function.\n";
for (size_t i = 0; i < nData; i++)
m_waveLength[i] = 1.0;
}
}
}
/** Extract a spectrum from the Efficiencies workspace as a 1D workspace.
* @param label :: A label of the spectrum to extract.
* @return :: A workspace with a single spectrum.
*/
boost::shared_ptr<Mantid::API::MatrixWorkspace>
PolarizationCorrectionFredrikze::getEfficiencyWorkspace(
const std::string &label) {
MatrixWorkspace_sptr efficiencies = getProperty(efficienciesLabel);
auto const &axis = dynamic_cast<TextAxis &>(*efficiencies->getAxis(1));
size_t index = axis.length();
for (size_t i = 0; i < axis.length(); ++i) {
if (axis.label(i) == label) {
index = i;
break;
}
}
if (index == axis.length()) {
// Check if we need to fetch polarization parameters from the instrument's
// parameters
static std::map<std::string, std::string> loadableProperties{
{crhoLabel, "crho"},
{cppLabel, "cPp"},
{cApLabel, "cAp"},
{cAlphaLabel, "calpha"}};
WorkspaceGroup_sptr inWS = getProperty("InputWorkspace");
Instrument_const_sptr instrument = fetchInstrument(inWS.get());
auto vals = instrument->getStringParameter(loadableProperties[label]);
if (vals.empty()) {
throw std::invalid_argument("Efficiencey property not found: " + label);
}
auto extract = createChildAlgorithm("CreatePolarizationEfficiencies");
extract->initialize();
extract->setProperty("InputWorkspace", efficiencies);
extract->setProperty(label, vals.front());
extract->execute();
MatrixWorkspace_sptr outWS = extract->getProperty("OutputWorkspace");
return outWS;
} else {
auto extract = createChildAlgorithm("ExtractSingleSpectrum");
extract->initialize();
extract->setProperty("InputWorkspace", efficiencies);
extract->setProperty("WorkspaceIndex", static_cast<int>(index));
extract->execute();
MatrixWorkspace_sptr outWS = extract->getProperty("OutputWorkspace");
return outWS;
}
}
/**
* Make a map of the conversion factors between tof and D-spacing
* for all pixel IDs in a workspace.
*
* @param DFileName :: name of dspacemap file
* @param offsetsWS :: OffsetsWorkspace to be filled.
*/
void LoadDspacemap::CalculateOffsetsFromDSpacemapFile(
const std::string DFileName,
Mantid::DataObjects::OffsetsWorkspace_sptr offsetsWS) {
// Get a pointer to the instrument contained in the workspace
Instrument_const_sptr instrument = offsetsWS->getInstrument();
double l1;
Kernel::V3D beamline, samplePos;
double beamline_norm;
instrument->getInstrumentParameters(l1, beamline, beamline_norm, samplePos);
// To get all the detector ID's
detid2det_map allDetectors;
instrument->getDetectors(allDetectors);
// Read in the POWGEN-style Dspace mapping file
const char *filename = DFileName.c_str();
std::ifstream fin(filename, std::ios_base::in | std::ios_base::binary);
std::vector<double> dspace;
double read;
while (!fin.eof()) {
fin.read(reinterpret_cast<char *>(&read), sizeof read);
// Factor of 10 between ISAW and Mantid
read *= 10.;
dspace.push_back(read);
}
detid2det_map::const_iterator it;
for (it = allDetectors.begin(); it != allDetectors.end(); ++it) {
detid_t detectorID = it->first;
Geometry::IDetector_const_sptr det = it->second;
// Compute the factor
double offset = 0.0;
double factor = Instrument::calcConversion(l1, beamline, beamline_norm,
samplePos, det, offset);
offset = dspace[detectorID] / factor - 1.0;
// Save in the map
try {
offsetsWS->setValue(detectorID, offset);
} catch (std::invalid_argument &) {
}
}
}
/**
* @param offsetsWS
* @param index
* @return The offset adjusted value of DIFC
*/
double calculateDIFC(OffsetsWorkspace_const_sptr offsetsWS, const size_t index) {
Instrument_const_sptr instrument = offsetsWS->getInstrument();
const detid_t detid = getDetID(offsetsWS, index);
const double offset = getOffset(offsetsWS, detid);
double l1;
Kernel::V3D beamline, samplePos;
double beamline_norm;
instrument->getInstrumentParameters(l1, beamline, beamline_norm, samplePos);
Geometry::IDetector_const_sptr detector = instrument->getDetector(detid);
// the factor returned is what is needed to convert TOF->d-spacing
// the table is supposed to be filled with DIFC which goes the other way
const double factor = Instrument::calcConversion(l1, beamline, beamline_norm,
samplePos, detector, offset);
return 1./factor;
}
/**
* Update the list of analysers based on an instrument workspace.
*
* @param ws Instrument workspace
* @return If the workspace contained valid analysers
*/
bool IndirectInstrumentConfig::updateAnalysersList(MatrixWorkspace_sptr ws)
{
if(!ws)
return false;
QList<QPair<QString, QString>> instrumentModes;
Instrument_const_sptr instrument = ws->getInstrument();
std::vector<std::string> ipfAnalysers = instrument->getStringParameter("analysers");
QStringList analysers;
if(ipfAnalysers.size() > 0)
analysers = QString::fromStdString(ipfAnalysers[0]).split(",");
// Do not try to display analysers if there are none
if(analysers.size() == 0)
return false;
for(auto it = analysers.begin(); it != analysers.end(); ++it)
{
QString analyser = *it;
std::string ipfReflections = instrument->getStringParameter("refl-" + analyser.toStdString())[0];
QStringList reflections = QString::fromStdString(ipfReflections).split(",");
if(m_removeDiffraction && analyser == "diffraction")
continue;
if(m_forceDiffraction && analyser != "diffraction")
continue;
if(reflections.size() > 0)
{
QVariant data = QVariant(reflections);
m_uiForm.cbAnalyser->addItem(analyser, data);
}
else
{
m_uiForm.cbAnalyser->addItem(analyser);
}
}
return true;
}
void EstimateResolutionDiffraction::retrieveInstrumentParameters() {
double centrewavelength = getWavelength();
g_log.notice() << "Centre wavelength = " << centrewavelength << " Angstrom\n";
if (centrewavelength > WAVELENGTH_MAX) {
throw runtime_error("unphysical wavelength used");
}
// Calculate centre neutron velocity
m_centreVelocity = WAVELENGTH_TO_VELOCITY / centrewavelength;
g_log.notice() << "Centre neutron velocity = " << m_centreVelocity << "\n";
// Calculate L1 sample to source
Instrument_const_sptr instrument = m_inputWS->getInstrument();
V3D samplepos = instrument->getSample()->getPos();
V3D sourcepos = instrument->getSource()->getPos();
m_L1 = samplepos.distance(sourcepos);
g_log.notice() << "L1 = " << m_L1 << "\n";
return;
}
/**
* Returns a "dummy" grouping which a single group with all the detectors in it.
* @param instrument :: Instrument we want a dummy grouping for
* @return Grouping information
*/
boost::shared_ptr<Grouping> getDummyGrouping(Instrument_const_sptr instrument)
{
// Group with all the detectors
std::ostringstream all;
all << "1-" << instrument->getNumberDetectors();
auto dummyGrouping = boost::make_shared<Grouping>();
dummyGrouping->description = "Dummy grouping";
dummyGrouping->groupNames.push_back("all");
dummyGrouping->groups.push_back(all.str());
return dummyGrouping;
}
PoldiDeadWireDecorator::PoldiDeadWireDecorator(Instrument_const_sptr poldiInstrument, boost::shared_ptr<PoldiAbstractDetector> detector) :
PoldiDetectorDecorator(detector),
m_deadWireSet(),
m_goodElements()
{
setDecoratedDetector(detector);
std::vector<detid_t> allDetectorIds = poldiInstrument->getDetectorIDs();
std::vector<detid_t> deadDetectorIds(allDetectorIds.size());
std::vector<detid_t>::iterator endIterator = std::remove_copy_if(allDetectorIds.begin(), allDetectorIds.end(), deadDetectorIds.begin(), boost::bind<bool>(&PoldiDeadWireDecorator::detectorIsNotMasked, poldiInstrument, _1));
deadDetectorIds.resize(std::distance(deadDetectorIds.begin(), endIterator));
setDeadWires(std::set<int>(deadDetectorIds.begin(), deadDetectorIds.end()));
}
/**
* Constructor. Creates a tree of GLActors. Each actor is responsible for displaying insrument components in 3D.
* Some of the components have "pick ID" assigned to them. Pick IDs can be uniquely converted to a RGB colour value
* which in turn can be used for picking the component from the screen.
* @param wsName :: Workspace name
* @param autoscaling :: True to start with autoscaling option on. If on the min and max of
* the colormap scale are defined by the min and max of the data.
* @param scaleMin :: Minimum value of the colormap scale. Used to assign detector colours. Ignored if autoscaling == true.
* @param scaleMax :: Maximum value of the colormap scale. Used to assign detector colours. Ignored if autoscaling == true.
*/
InstrumentActor::InstrumentActor(const QString &wsName, bool autoscaling, double scaleMin, double scaleMax):
m_workspace(AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(wsName.toStdString())),
m_ragged(true),
m_autoscaling(autoscaling),
m_defaultPos(),
m_maskedColor(100,100,100),
m_failedColor(200,200,200)
{
// settings
loadSettings();
auto sharedWorkspace = m_workspace.lock();
if (!sharedWorkspace)
throw std::logic_error("InstrumentActor passed a workspace that isn't a MatrixWorkspace");
// set up the color map
if (!m_currentColorMapFilename.isEmpty())
{
loadColorMap(m_currentColorMapFilename,false);
}
m_colorMap.changeScaleType(m_scaleType);
// set up data ranges and colours
setUpWorkspace(sharedWorkspace, scaleMin, scaleMax);
Instrument_const_sptr instrument = getInstrument();
// If the instrument is empty, maybe only having the sample and source
const int nelements = instrument->nelements();
if ( ( nelements == 0 ) ||
( nelements == 1 && ( instrument->getSource() || instrument->getSample() ) ) ||
( nelements == 2 && instrument->getSource() && instrument->getSample() )
)
{
QMessageBox::warning(NULL,"MantidPlot - Warning","This instrument appears to contain no detectors","OK");
}
// this adds actors for all instrument components to the scene and fills in m_detIDs
m_scene.addActor(new CompAssemblyActor(*this,instrument->getComponentID()));
setupPickColors();
if ( !m_showGuides )
{
// hide guide and other components
showGuides( m_showGuides );
}
}
/** Executes the algorithm
*
* @throw Exception::FileError If the grouping file cannot be opened or read successfully
* @throw runtime_error If unable to run one of the Child Algorithms successfully
*/
void ReadGroupsFromFile::exec()
{
MatrixWorkspace_const_sptr ws = getProperty("InstrumentWorkspace");
// Get the instrument.
Instrument_const_sptr inst = ws->getInstrument();
// Create a copy (without the data) of the workspace - it will contain the
Workspace2D_sptr localWorkspace =
boost::dynamic_pointer_cast<Workspace2D>(WorkspaceFactory::Instance().create(ws, ws->getNumberHistograms(), 2, 1));
if (!localWorkspace)
throw std::runtime_error("Failed when creating a Workspace2D from the input!");
const std::string groupfile=getProperty("GroupingFilename");
if ( ! groupfile.empty() )
{
std::string filename(groupfile);
std::transform(filename.begin(), filename.end(), filename.begin(), tolower);
if ( filename.find(".xml") != std::string::npos )
{
readXMLGroupingFile(groupfile);
}
else
{
readGroupingFile(groupfile);
}
}
// Get the instrument.
const int64_t nHist=localWorkspace->getNumberHistograms();
// Determine whether the user wants to see unselected detectors or not
const std::string su=getProperty("ShowUnselected");
bool showunselected=(!su.compare("True"));
bool success=false;
for (int64_t i=0;i<nHist;i++)
{
ISpectrum * spec = localWorkspace->getSpectrum(i);
const std::set<detid_t> & dets = spec->getDetectorIDs();
if (dets.empty()) // Nothing
{
spec->dataY()[0]=0.0;
continue;
}
// Find the first detector ID in the list
calmap::const_iterator it=calibration.find(*dets.begin());
if (it==calibration.end()) //Could not find the detector
{
spec->dataY()[0]=0.0;
continue;
}
if (showunselected)
{
if (((*it).second).second==0)
spec->dataY()[0]=0.0;
else
spec->dataY()[0]=static_cast<double>(((*it).second).first);
}
else
spec->dataY()[0]=static_cast<double>(((*it).second).first);
if (!success) success=true; //At least one detector is found in the cal file
}
progress(1);
calibration.clear();
if (!success) //Do some cleanup
{
localWorkspace.reset();
throw std::runtime_error("Fail to found a detector in "+groupfile+" existing in instrument "+inst->getName());
}
setProperty("OutputWorkspace",localWorkspace);
return;
}
/** Execute the algorithm.
*/
void CreateChunkingFromInstrument::exec() {
// get the instrument
Instrument_const_sptr inst = this->getInstrument();
// setup the output workspace
ITableWorkspace_sptr strategy =
WorkspaceFactory::Instance().createTable("TableWorkspace");
strategy->addColumn("str", "BankName");
this->setProperty("OutputWorkspace", strategy);
// get the correct level of grouping
string groupLevel = this->getPropertyValue(PARAM_CHUNK_BY);
vector<string> groupNames =
getGroupNames(this->getPropertyValue(PARAM_CHUNK_NAMES));
if (groupLevel.compare("All") == 0) {
return; // nothing to do
} else if (inst->getName().compare("SNAP") == 0 &&
groupLevel.compare("Group") == 0) {
groupNames.clear();
groupNames.push_back("East");
groupNames.push_back("West");
}
// set up a progress bar with the "correct" number of steps
int maxBankNum = this->getProperty(PARAM_MAX_BANK_NUM);
Progress progress(this, .2, 1., maxBankNum);
// search the instrument for the bank names
int maxRecurseDepth = this->getProperty(PARAM_MAX_RECURSE);
map<string, vector<string>> grouping;
// cppcheck-suppress syntaxError
PRAGMA_OMP(parallel for schedule(dynamic, 1) )
for (int num = 0; num < maxBankNum; ++num) {
PARALLEL_START_INTERUPT_REGION
ostringstream mess;
mess << "bank" << num;
IComponent_const_sptr comp =
inst->getComponentByName(mess.str(), maxRecurseDepth);
PARALLEL_CRITICAL(grouping)
if (comp) {
// get the name of the correct parent
string parent;
if (groupNames.empty()) {
parent = parentName(comp, groupLevel);
} else {
parent = parentName(comp, groupNames);
}
// add it to the correct chunk
if (!parent.empty()) {
if (grouping.count(parent) == 0)
grouping[parent] = vector<string>();
grouping[parent].push_back(comp->getName());
}
}
progress.report();
PARALLEL_END_INTERUPT_REGION
}
PARALLEL_CHECK_INTERUPT_REGION
// check to see that something happened
if (grouping.empty())
throw std::runtime_error("Failed to find any banks in the instrument");
// fill in the table workspace
for (auto group = grouping.begin(); group != grouping.end(); ++group) {
stringstream banks;
for (auto bank = group->second.begin(); bank != group->second.end();
++bank)
banks << (*bank) << ",";
// remove the trailing comma
string banksStr = banks.str();
banksStr = banksStr.substr(0, banksStr.size() - 1);
// add it to the table
TableRow row = strategy->appendRow();
row << banksStr;
}
}
/** Executes the algorithm
*
* @throw Exception::FileError If the grouping file cannot be opened or read successfully
* @throw runtime_error If unable to run one of the Child Algorithms successfully
*/
void CreateDummyCalFile::exec()
{
// Get the input workspace
MatrixWorkspace_const_sptr inputW = getProperty("InputWorkspace");
if (!inputW)
throw std::invalid_argument("No InputWorkspace");
//Get some stuff from the input workspace
Instrument_const_sptr inst = inputW->getInstrument();
std::string instname = inst->getName();
// Check that the instrument is in store
// Get only the first 3 letters
std::string instshort=instname;
std::transform(instshort.begin(),instshort.end(),instshort.begin(),toupper);
instshort=instshort+"_Definition.xml";
// Determine the search directory for XML instrument definition files (IDFs)
std::string directoryName = Kernel::ConfigService::Instance().getInstrumentDirectory();
// Set up the DOM parser and parse xml file
DOMParser pParser;
Document* pDoc;
try
{
pDoc = pParser.parse(directoryName+instshort);
}
catch(...)
{
g_log.error("Unable to parse file " + m_filename);
throw Kernel::Exception::FileError("Unable to parse File:" , m_filename);
}
// Get pointer to root element
Element* pRootElem = pDoc->documentElement();
if ( !pRootElem->hasChildNodes() )
{
g_log.error("XML file: " + m_filename + "contains no root element.");
throw Kernel::Exception::InstrumentDefinitionError("No root element in XML instrument file", m_filename);
}
// Handle used in the singleton constructor for instrument file should append the value
// of the last-modified tag inside the file to determine if it is already in memory so that
// changes to the instrument file will cause file to be reloaded.
auto temp = instshort + pRootElem->getAttribute("last-modified");// Generate the mangled name by hand (old-style)
// If instrument not in store, insult the user
if (!API::InstrumentDataService::Instance().doesExist(temp))
{
Mantid::Geometry::IDFObject idf(directoryName+instshort);
temp = idf.getMangledName(); // new style.
if (!API::InstrumentDataService::Instance().doesExist(temp))
{
g_log.error("Instrument "+instshort+" is not present in data store.");
throw std::runtime_error("Instrument "+instshort+" is not present in data store.");
}
}
// Get the names of groups
groups=instname;
// Split the names of the group and insert in a vector, throw if group empty
std::vector<std::string> vgroups;
boost::split( vgroups, instname, boost::algorithm::detail::is_any_ofF<char>(",/*"));
if (vgroups.empty())
{
g_log.error("Could not determine group names. Group names should be separated by / or ,");
throw std::runtime_error("Could not determine group names. Group names should be separated by / or ,");
}
// Assign incremental number to each group
std::map<std::string,int> group_map;
int index=0;
for (std::vector<std::string>::const_iterator it=vgroups.begin(); it!=vgroups.end(); ++it)
group_map[(*it)]=++index;
// Not needed anymore
vgroups.clear();
// Find Detectors that belong to groups
typedef boost::shared_ptr<const Geometry::ICompAssembly> sptr_ICompAss;
typedef boost::shared_ptr<const Geometry::IComponent> sptr_IComp;
typedef boost::shared_ptr<const Geometry::IDetector> sptr_IDet;
std::queue< std::pair<sptr_ICompAss,int> > assemblies;
sptr_ICompAss current=boost::dynamic_pointer_cast<const Geometry::ICompAssembly>(inst);
sptr_IDet currentDet;
sptr_IComp currentIComp;
sptr_ICompAss currentchild;
int top_group, child_group;
if (current.get())
{
top_group=group_map[current->getName()]; // Return 0 if not in map
assemblies.push(std::make_pair(current,top_group));
}
std::string filename=getProperty("CalFilename");
// Plan to overwrite file, so do not check if it exists
bool overwrite=false;
int number=0;
Progress prog(this,0.0,0.8,assemblies.size());
while(!assemblies.empty()) //Travel the tree from the instrument point
{
current=assemblies.front().first;
top_group=assemblies.front().second;
assemblies.pop();
int nchilds=current->nelements();
if (nchilds!=0)
{
for (int i=0; i<nchilds; ++i)
{
currentIComp=(*(current.get()))[i]; // Get child
currentDet=boost::dynamic_pointer_cast<const Geometry::IDetector>(currentIComp);
if (currentDet.get())// Is detector
{
if (overwrite) // Map will contains udet as the key
instrcalib[currentDet->getID()]=std::make_pair(number++,top_group);
else // Map will contains the entry number as the key
instrcalib[number++]=std::make_pair(currentDet->getID(),top_group);
}
else // Is an assembly, push in the queue
{
currentchild=boost::dynamic_pointer_cast<const Geometry::ICompAssembly>(currentIComp);
if (currentchild.get())
{
child_group=group_map[currentchild->getName()];
if (child_group==0)
child_group=top_group;
assemblies.push(std::make_pair(currentchild,child_group));
}
}
}
}
prog.report();
}
// Write the results in a file
saveGroupingFile(filename,overwrite);
progress(0.2);
return;
}
