void LoadDaveGrp::getData(std::vector<MantidVec *> &data,
std::vector<MantidVec *> &errs)
{
double data_val = 0.0;
double err_val = 0.0;
API::Progress progress(this, 0.0, 1.0, this->nGroups);
for(int j = 0; j < this->nGroups; j++)
{
// Skip the group comment line
this->readLine();
// Read the data block
MantidVec *d = new MantidVec();
MantidVec *e = new MantidVec();
for(std::size_t k = 0; k < static_cast<std::size_t>(this->xLength); k++)
{
this->readLine();
std::istringstream is(this->line);
is >> data_val >> err_val;
d->push_back(data_val);
e->push_back(err_val);
}
data.push_back(d);
errs.push_back(e);
progress.report();
}
}
/** Calculates Sn as estimator of scale for given vector
*
* This method implements a naive calculation of Sn, as defined by Rousseeuw
*and Croux (http://dx.doi.org/10.2307%2F2291267).
* In contrast to standard deviation, this is more robust towards outliers.
*
* @param begin :: Beginning of vector.
* @param end :: End of vector.
* @return Sn of supplied data.
*/
double PoldiPeakSearch::getSn(MantidVec::const_iterator begin,
MantidVec::const_iterator end) const {
size_t numberOfPoints = std::distance(begin, end);
MantidVec absoluteDifferenceMedians(numberOfPoints);
PARALLEL_FOR_NO_WSP_CHECK()
for (int i = 0; i < static_cast<int>(numberOfPoints); ++i) {
double currentValue = *(begin + i);
MantidVec temp;
temp.reserve(numberOfPoints - 1);
for (int j = 0; j < static_cast<int>(numberOfPoints); ++j) {
if (j != i) {
temp.push_back(fabs(*(begin + j) - currentValue));
}
}
std::sort(temp.begin(), temp.end());
absoluteDifferenceMedians[i] =
getMedianFromSortedVector(temp.begin(), temp.end());
}
std::sort(absoluteDifferenceMedians.begin(), absoluteDifferenceMedians.end());
return 1.1926 * getMedianFromSortedVector(absoluteDifferenceMedians.begin(),
absoluteDifferenceMedians.end());
}
/**
* load vectors onto a Workspace2D with 3 bins (the three components of the
* vectors)
* dataX for the origin of the vector (assumed (0,0,0) )
* dataY for the tip of the vector
* dataE is assumed (0,0,0), no errors
* @param h5file file identifier
* @param gws pointer to WorkspaceGroup being filled
* @param sorting_indexes permutation of qvmod indexes to render it in
* increasing order of momemtum transfer
*/
const MantidVec LoadSassena::loadQvectors(const hid_t &h5file,
API::WorkspaceGroup_sptr gws,
std::vector<int> &sorting_indexes) {
const std::string gwsName = this->getPropertyValue("OutputWorkspace");
const std::string setName("qvectors");
hsize_t dims[3];
if (dataSetInfo(h5file, setName, dims) < 0) {
throw Kernel::Exception::FileError(
"Unable to read " + setName + " dataset info:", m_filename);
}
int nq = static_cast<int>(dims[0]); // number of q-vectors
double *buf = new double[nq * 3];
this->dataSetDouble(h5file, "qvectors", buf);
MantidVec qvmod; // store the modulus of the vector
double *curr = buf;
for (int iq = 0; iq < nq; iq++) {
qvmod.push_back(
sqrt(curr[0] * curr[0] + curr[1] * curr[1] + curr[2] * curr[2]));
curr += 3;
}
if (getProperty("SortByQVectors")) {
std::vector<mypair> qvmodpair;
for (int iq = 0; iq < nq; iq++)
qvmodpair.push_back(mypair(qvmod[iq], iq));
std::sort(qvmodpair.begin(), qvmodpair.end(), compare);
for (int iq = 0; iq < nq; iq++)
sorting_indexes.push_back(qvmodpair[iq].second);
std::sort(qvmod.begin(), qvmod.end());
} else
for (int iq = 0; iq < nq; iq++)
sorting_indexes.push_back(iq);
DataObjects::Workspace2D_sptr ws =
boost::dynamic_pointer_cast<DataObjects::Workspace2D>(
API::WorkspaceFactory::Instance().create("Workspace2D", nq, 3, 3));
std::string wsName = gwsName + std::string("_") + setName;
ws->setTitle(wsName);
for (int iq = 0; iq < nq; iq++) {
MantidVec &Y = ws->dataY(iq);
const int index = sorting_indexes[iq];
curr = buf + 3 * index;
Y.assign(curr, curr + 3);
}
delete[] buf;
ws->getAxis(0)->unit() = Kernel::UnitFactory::Instance().create(
"MomentumTransfer"); // Set the Units
this->registerWorkspace(
gws, wsName, ws, "X-axis: origin of Q-vectors; Y-axis: tip of Q-vectors");
return qvmod;
}
/** Retrieves a vector with all counts that belong to the background
*
* In this method, a vector is assembled which contains all count data that is
*considered to be background.
* Whether a point is considered background depends on its distance to the
*given peak positions.
*
* @param peakPositions :: Peak positions.
* @param correlationCounts :: Vector with the complete correlation spectrum.
* @return Vector only with counts that belong to the background.
*/
MantidVec PoldiPeakSearch::getBackground(
std::list<MantidVec::const_iterator> peakPositions,
const MantidVec &correlationCounts) const {
size_t backgroundPoints =
getNumberOfBackgroundPoints(peakPositions, correlationCounts);
MantidVec background;
background.reserve(backgroundPoints);
for (MantidVec::const_iterator point = correlationCounts.begin() + 1;
point != correlationCounts.end() - 1; ++point) {
if (distanceToPeaksGreaterThanMinimum(peakPositions, point)) {
background.push_back(*point);
}
}
return background;
}
void GoniometerAnglesFromPhiRotation::exec() {
PeaksWorkspace_sptr PeaksRun1 = getProperty("PeaksWorkspace1");
PeaksWorkspace_sptr PeaksRun2 = getProperty("PeaksWorkspace2");
double Tolerance = getProperty("Tolerance");
Kernel::Matrix<double> Gon1(3, 3);
Kernel::Matrix<double> Gon2(3, 3);
if (!CheckForOneRun(PeaksRun1, Gon1) || !CheckForOneRun(PeaksRun2, Gon2)) {
g_log.error("Each peaks workspace MUST have only one run");
throw std::invalid_argument("Each peaks workspace MUST have only one run");
}
Kernel::Matrix<double> UB1;
bool Run1HasOrientedLattice = true;
if (!PeaksRun1->sample().hasOrientedLattice()) {
Run1HasOrientedLattice = false;
const std::string fft("FindUBUsingFFT");
API::IAlgorithm_sptr findUB = this->createChildAlgorithm(fft);
findUB->initialize();
findUB->setProperty<PeaksWorkspace_sptr>("PeaksWorkspace",
getProperty("PeaksWorkspace1"));
findUB->setProperty("MIND", static_cast<double>(getProperty("MIND")));
findUB->setProperty("MAXD", static_cast<double>(getProperty("MAXD")));
findUB->setProperty("Tolerance", Tolerance);
findUB->executeAsChildAlg();
if (!PeaksRun1->sample().hasOrientedLattice()) {
g_log.notice(std::string("Could not find UB for ") +
std::string(PeaksRun1->getName()));
throw std::invalid_argument(std::string("Could not find UB for ") +
std::string(PeaksRun1->getName()));
}
}
//-------------get UB raw :No goniometer----------------
UB1 = PeaksRun1->sample().getOrientedLattice().getUB();
UB1 = getUBRaw(UB1, Gon1);
int N1;
double avErrIndx, avErrAll;
IndexRaw(PeaksRun1, UB1, N1, avErrIndx, avErrAll, Tolerance);
if (N1 < .6 * PeaksRun1->getNumberPeaks()) {
g_log.notice(std::string("UB did not index well for ") +
std::string(PeaksRun1->getName()));
throw std::invalid_argument(std::string("UB did not index well for ") +
std::string(PeaksRun1->getName()));
}
//----------------------------------------------
Geometry::OrientedLattice lat2 = PeaksRun1->sample().getOrientedLattice();
lat2.setUB(UB1);
PeaksRun2->mutableSample().setOrientedLattice(&lat2);
if (!Run1HasOrientedLattice)
PeaksRun1->mutableSample().setOrientedLattice(nullptr);
double dphi = static_cast<double>(getProperty("Phi2")) -
static_cast<double>(getProperty("Run1Phi"));
Kernel::Matrix<double> Gon22(3, 3, true);
for (int i = 0; i < PeaksRun2->getNumberPeaks(); i++) {
PeaksRun2->getPeak(i).setGoniometerMatrix(Gon22);
}
int RunNum = PeaksRun2->getPeak(0).getRunNumber();
std::string RunNumStr = std::to_string(RunNum);
int Npeaks = PeaksRun2->getNumberPeaks();
// n indexed, av err, phi, chi,omega
std::array<double, 5> MinData = {{0., 0., 0., 0., 0.}};
MinData[0] = 0.0;
std::vector<V3D> directionList = IndexingUtils::MakeHemisphereDirections(50);
API::FrameworkManager::Instance();
for (auto dir : directionList)
for (int sgn = 1; sgn > -2; sgn -= 2) {
dir.normalize();
Quat Q(sgn * dphi, dir);
Q.normalize();
Kernel::Matrix<double> Rot(Q.getRotation());
int Nindexed;
double dummyAvErrIndx, dummyAvErrAll;
IndexRaw(PeaksRun2, Rot * UB1, Nindexed, dummyAvErrIndx, dummyAvErrAll,
Tolerance);
if (Nindexed > MinData[0]) {
MinData[0] = Nindexed;
MinData[1] = sgn;
MinData[2] = dir[0];
MinData[3] = dir[1];
MinData[4] = dir[2];
}
}
g_log.debug() << "Best direction unOptimized is ("
<< (MinData[1] * MinData[2]) << "," << (MinData[1] * MinData[3])
<< "," << (MinData[1] * MinData[4]) << ")\n";
//----------------------- Optimize around best----------------------------
auto ws = createWorkspace<Workspace2D>(1, 3 * Npeaks, 3 * Npeaks);
MantidVec Xvals;
for (int i = 0; i < Npeaks; ++i) {
Xvals.push_back(i);
Xvals.push_back(i);
Xvals.push_back(i);
}
ws->setPoints(0, Xvals);
//--------------------Set up other Fit function arguments------------------
V3D dir(MinData[2], MinData[3], MinData[4]);
dir.normalize();
Quat Q(MinData[1] * dphi, dir);
Q.normalize();
Kernel::Matrix<double> Rot(Q.getRotation());
Goniometer Gon(Rot);
std::vector<double> omchiphi = Gon.getEulerAngles("yzy");
MinData[2] = omchiphi[2];
MinData[3] = omchiphi[1];
MinData[4] = omchiphi[0];
std::string FunctionArgs =
"name=PeakHKLErrors, PeakWorkspaceName=" + PeaksRun2->getName() +
",OptRuns=" + RunNumStr + ",phi" + RunNumStr + "=" +
boost::lexical_cast<std::string>(MinData[2]) + ",chi" + RunNumStr + "=" +
boost::lexical_cast<std::string>(MinData[3]) + ",omega" + RunNumStr +
"=" + boost::lexical_cast<std::string>(MinData[4]);
std::string Constr = boost::lexical_cast<std::string>(MinData[2] - 5) +
"<phi" + RunNumStr + "<" +
boost::lexical_cast<std::string>(MinData[2] + 5);
Constr += "," + boost::lexical_cast<std::string>(MinData[3] - 5) + "<chi" +
RunNumStr + "<" + boost::lexical_cast<std::string>(MinData[3] + 5) +
",";
Constr += boost::lexical_cast<std::string>(MinData[4] - 5) + "<omega" +
RunNumStr + "<" + boost::lexical_cast<std::string>(MinData[4] + 5);
std::string Ties = "SampleXOffset=0.0,SampleYOffset=0.0,SampleZOffset=0.0,"
"GonRotx=0.0,GonRoty=0.0,GonRotz=0.0";
boost::shared_ptr<Algorithm> Fit = createChildAlgorithm("Fit");
Fit->initialize();
Fit->setProperty("Function", FunctionArgs);
Fit->setProperty("Ties", Ties);
Fit->setProperty("Constraints", Constr);
Fit->setProperty("InputWorkspace", ws);
Fit->setProperty("CreateOutput", true);
std::string outputName = "out";
Fit->setProperty("Output", outputName);
Fit->executeAsChildAlg();
boost::shared_ptr<API::ITableWorkspace> results =
Fit->getProperty("OutputParameters");
double chisq = Fit->getProperty("OutputChi2overDoF");
MinData[0] = chisq;
MinData[2] = results->Double(6, 1);
MinData[3] = results->Double(7, 1);
MinData[4] = results->Double(8, 1);
g_log.debug() << "Best direction Optimized is (" << (MinData[2]) << ","
<< (MinData[3]) << "," << (MinData[4]) << ")\n";
// ---------------------Find number indexed -----------------------
Quat Q1 = Quat(MinData[4], V3D(0, 1, 0)) * Quat(MinData[3], V3D(0, 0, 1)) *
Quat(MinData[2], V3D(0, 1, 0));
int Nindexed;
Kernel::Matrix<double> Mk(Q1.getRotation());
IndexRaw(PeaksRun2, Mk * UB1, Nindexed, avErrIndx, avErrAll, Tolerance);
//------------------------------------ Convert/Save Results
//-----------------------------
double deg, ax1, ax2, ax3;
Q1.getAngleAxis(deg, ax1, ax2, ax3);
if (dphi * deg < 0) {
deg = -deg;
ax1 = -ax1;
ax2 = -ax2;
ax3 = -ax3;
}
double phi2 = static_cast<double>(getProperty("Run1Phi")) + dphi;
double chi2 = acos(ax2) / M_PI * 180;
double omega2 = atan2(ax3, -ax1) / M_PI * 180;
g_log.notice()
<< "============================ Results ============================\n";
g_log.notice() << " phi,chi, and omega= (" << phi2 << "," << chi2 << ","
<< omega2 << ")\n";
g_log.notice() << " #indexed =" << Nindexed << '\n';
g_log.notice()
<< " ==============================================\n";
setProperty("Phi2", phi2);
setProperty("Chi2", chi2);
setProperty("Omega2", omega2);
setProperty("NIndexed", Nindexed);
setProperty("AvErrIndex", avErrIndx);
setProperty("AvErrAll", avErrAll);
Q1 = Quat(omega2, V3D(0, 1, 0)) * Quat(chi2, V3D(0, 0, 1)) *
Quat(phi2, V3D(0, 1, 0));
Kernel::Matrix<double> Gon2a(Q1.getRotation());
for (int i = 0; i < PeaksRun2->getNumberPeaks(); i++) {
PeaksRun2->getPeak(i).setGoniometerMatrix(Gon2a);
}
OrientedLattice latt2(PeaksRun2->mutableSample().getOrientedLattice());
// Kernel::Matrix<double> UB = latt2.getUB();
Rot.Invert();
Gon2a.Invert();
latt2.setUB(Gon2a * Mk * UB1);
PeaksRun2->mutableSample().setOrientedLattice(&latt2);
}