/** Do the initial copy of the data from the input to the output workspace for histogram workspaces. * Takes out the bin width if necessary. * @param inputWS The input workspace * @param outputWS The output workspace */ void ConvertUnits::fillOutputHist(const API::MatrixWorkspace_const_sptr inputWS, const API::MatrixWorkspace_sptr outputWS) { const int size = static_cast<int>(inputWS->blocksize()); // Loop over the histograms (detector spectra) Progress prog(this,0.0,0.2,m_numberOfSpectra); int64_t numberOfSpectra_i = static_cast<int64_t>(m_numberOfSpectra); // cast to make openmp happy PARALLEL_FOR2(inputWS,outputWS) for (int64_t i = 0; i < numberOfSpectra_i; ++i) { PARALLEL_START_INTERUPT_REGION // Take the bin width dependency out of the Y & E data if (m_distribution) { for (int j = 0; j < size; ++j) { const double width = std::abs( inputWS->dataX(i)[j+1] - inputWS->dataX(i)[j] ); outputWS->dataY(i)[j] = inputWS->dataY(i)[j]*width; outputWS->dataE(i)[j] = inputWS->dataE(i)[j]*width; } } else { // Just copy over outputWS->dataY(i) = inputWS->dataY(i); outputWS->dataE(i) = inputWS->dataE(i); } // Copy over the X data outputWS->setX( i, inputWS->refX(i) ); prog.report("Convert to " + m_outputUnit->unitID()); PARALLEL_END_INTERUPT_REGION } PARALLEL_CHECK_INTERUPT_REGION }
/** Execute the algorithm. */ void DampSq::exec() { // TODO Auto-generated execute stub // 1. Generate new workspace API::MatrixWorkspace_const_sptr isqspace = getProperty("InputWorkspace"); API::MatrixWorkspace_sptr osqspace = WorkspaceFactory::Instance().create(isqspace, 1, isqspace->size(), isqspace->size()); int mode = getProperty("Mode"); double qmax = getProperty("QMax"); if (mode < 1 || mode > 4) { g_log.error("Damp mode can only be 1, 2, 3, or 4"); return; } // 2. Get access to all const MantidVec& iQVec = isqspace->dataX(0); const MantidVec& iSVec = isqspace->dataY(0); const MantidVec& iEVec = isqspace->dataE(0); MantidVec& oQVec = osqspace->dataX(0); MantidVec& oSVec = osqspace->dataY(0); MantidVec& oEVec = osqspace->dataE(0); // 3. Calculation double dqmax = qmax - iQVec[0]; double damp; for (unsigned int i = 0; i < iQVec.size(); i ++) { // a) calculate damp coefficient switch (mode) { case 1: damp = dampcoeff1(iQVec[i], qmax, dqmax); break; case 2: damp = dampcoeff2(iQVec[i], qmax, dqmax);; break; case 3: damp = dampcoeff3(iQVec[i], qmax, dqmax);; break; case 4: damp = dampcoeff4(iQVec[i], qmax, dqmax);; break; default: damp = 0; break; } // b) calculate new S(q) oQVec[i] = iQVec[i]; oSVec[i] = 1 + damp*(iSVec[i]-1); oEVec[i] = damp*iEVec[i]; } // i // 4. Over setProperty("OutputWorkspace", osqspace); return; }
/** Initialization method: @param bkgWS -- shared pointer to the workspace which contains background @param sourceWS -- shared pointer to the workspace to remove background from @param emode -- energy conversion mode used during internal units conversion (0 -- elastic, 1-direct, 2 indirect, as defined in Units conversion @param pLog -- pointer to the logger class which would report errors @param nThreads -- number of threads to be used for background removal @param inPlace -- if the background removal occurs from the existing workspace or target workspace has to be cloned. */ void BackgroundHelper::initialize(const API::MatrixWorkspace_const_sptr &bkgWS, const API::MatrixWorkspace_sptr &sourceWS, int emode, Kernel::Logger *pLog, int nThreads, bool inPlace) { m_bgWs = bkgWS; m_wkWS = sourceWS; m_Emode = emode; m_pgLog = pLog; m_inPlace = inPlace; std::string bgUnits = bkgWS->getAxis(0)->unit()->unitID(); if (bgUnits != "TOF") throw std::invalid_argument(" Background Workspace: " + bkgWS->getName() + " should be in the units of TOF"); if (!(bkgWS->getNumberHistograms() == 1 || sourceWS->getNumberHistograms() == bkgWS->getNumberHistograms())) throw std::invalid_argument(" Background Workspace: " + bkgWS->getName() + " should have the same number of spectra as " "source workspace or be a single histogram " "workspace"); auto WSUnit = sourceWS->getAxis(0)->unit(); if (!WSUnit) throw std::invalid_argument(" Source Workspace: " + sourceWS->getName() + " should have units"); Geometry::IComponent_const_sptr source = sourceWS->getInstrument()->getSource(); m_Sample = sourceWS->getInstrument()->getSample(); if ((!source) || (!m_Sample)) throw std::invalid_argument( "Instrument on Source workspace:" + sourceWS->getName() + "is not sufficiently defined: failed to get source and/or sample"); m_L1 = source->getDistance(*m_Sample); // just in case. this->deleteUnitsConverters(); // allocate the array of units converters to avoid units reallocation within a // loop m_WSUnit.assign(nThreads, NULL); for (int i = 0; i < nThreads; i++) { m_WSUnit[i] = WSUnit->clone(); } m_singleValueBackground = false; if (bkgWS->getNumberHistograms() == 0) m_singleValueBackground = true; const MantidVec &dataX = bkgWS->dataX(0); const MantidVec &dataY = bkgWS->dataY(0); // const MantidVec& dataE = bkgWS->dataE(0); m_NBg = dataY[0]; m_dtBg = dataX[1] - dataX[0]; // m_ErrSq = dataE[0]*dataE[0]; // needs further clarification m_Efix = this->getEi(sourceWS); }
double BivariateNormal::initCommon() { double penalty = 0; bool ParamsOK = true; bool CommonsOK = true; if (!expVals) CommonsOK = false; API::MatrixWorkspace_const_sptr ws = getMatrixWorkspace(); MantidVec D = ws->dataY(0); MantidVec X = ws->dataY(1); MantidVec Y = ws->dataY(2); if (NCells < 0) { NCells = (int)std::min<size_t>(D.size(), std::min<size_t>(X.size(), Y.size())); CommonsOK = false; } double Attrib[12] = {0.0}; double MinX, MinY, MaxX, MaxY, MaxD, MinD; MinX = MaxX = X[0]; MinY = MaxY = Y[0]; MaxD = MinD = D[0]; if (!CommonsOK) { for (int i = 0; i < NCells; i++) { Attrib[S_int] += D[i]; Attrib[S_xint] += D[i] * X[i]; Attrib[S_yint] += D[i] * Y[i]; Attrib[S_x2int] += D[i] * X[i] * X[i]; Attrib[S_y2int] += D[i] * Y[i] * Y[i]; Attrib[S_xyint] += D[i] * X[i] * Y[i]; Attrib[S_y] += Y[i]; Attrib[S_x] += X[i]; Attrib[S_x2] += X[i] * X[i]; Attrib[S_y2] += Y[i] * Y[i]; Attrib[S_xy] += X[i] * Y[i]; Attrib[S_1] += 1.0; if (X[i] < MinX) MinX = X[i]; if (X[i] > MaxX) MaxX = X[i]; if (Y[i] < MinY) MinY = Y[i]; if (Y[i] > MaxY) MaxY = Y[i]; if (D[i] < MinD) MinD = D[i]; if (D[i] > MaxD) MaxD = D[i]; } mIx = Attrib[S_xint] / Attrib[S_int]; mIy = Attrib[S_yint] / Attrib[S_int]; mx = Attrib[S_x] / Attrib[S_1]; my = Attrib[S_y] / Attrib[S_1]; SIxx = Attrib[S_x2int] - (Attrib[S_xint] * Attrib[S_xint]) / Attrib[S_int]; SIyy = Attrib[S_y2int] - (Attrib[S_yint]) * (Attrib[S_yint]) / Attrib[S_int]; SIxy = Attrib[S_xyint] - (Attrib[S_xint]) * (Attrib[S_yint]) / Attrib[S_int]; Sxx = Attrib[S_x2] - (Attrib[S_x]) * (Attrib[S_x]) / Attrib[S_1]; Syy = Attrib[S_y2] - (Attrib[S_y]) * (Attrib[S_y]) / Attrib[S_1]; Sxy = Attrib[S_xy] - (Attrib[S_x]) * (Attrib[S_y]) / Attrib[S_1]; // CommonsOK = false; TotI = Attrib[S_int]; TotN = Attrib[S_1]; // CommonsOK = false; if (getConstraint(0) == NULL) { addConstraint((new BoundaryConstraint(this, "Background", 0, Attrib[S_int] / Attrib[S_1]))); } double maxIntensity = Attrib[S_int] + 3 * sqrt(Attrib[S_int]); if (maxIntensity < 100) maxIntensity = 100; if (getConstraint(1) == NULL) { addConstraint(new BoundaryConstraint(this, "Intensity", 0, maxIntensity)); } double minMeany = MinY * .9 + .1 * MaxY; double maxMeany = MinY * .1 + .9 * MaxY; if (getConstraint(3) == NULL) { addConstraint(new BoundaryConstraint(this, "Mrow", minMeany, maxMeany)); } double minMeanx = MinX * .9 + .1 * MaxX; double maxMeanx = MinX * .1 + .9 * MaxX; if (getConstraint(2) == NULL) { addConstraint(new BoundaryConstraint(this, "Mcol", minMeanx, maxMeanx)); } if (CalcVariances && nParams() > 6) { std::ostringstream ssxx, ssyy, ssxy; ssyy << std::string("(") << (SIyy) << "+(Mrow-" << (mIy) << ")*(Mrow-" << (mIy) << ")*" << Attrib[S_int] << "-Background*" << (Syy) << "-Background*(Mrow-" << (my) << ")*(Mrow-" << (my) << ")*" << Attrib[S_1] << ")/(" << (Attrib[S_int]) << "-Background*" << (Attrib[S_1]) << ")"; if (getTie(IVYY) == NULL) { tie("SSrow", ssyy.str()); CalcVxx = true; } ssxx << std::string("(") << (SIxx) << "+(Mcol-" << (mIx) << ")*(Mcol-" << (mIx) << ")*" << Attrib[S_int] << "-Background*" << (Sxx) << "-Background*(Mcol-" << (mx) << ")*(Mcol-" << (mx) << ")*" << Attrib[S_1] << ")/(" << (Attrib[S_int]) << "-Background*" << (Attrib[S_1]) << ")"; if (getTie(IVXX) == NULL) { tie("SScol", ssxx.str()); CalcVyy = true; } ssxy << std::string("(") << (SIxy) << "+(Mcol-" << (mIx) << ")*(Mrow-" << (mIy) << ")*" << Attrib[S_int] << "-Background*" << (Sxy) << "-Background*(Mcol-" << (mx) << ")*(Mrow-" << (my) << ")*" << Attrib[S_1] << ")/(" << (Attrib[S_int]) << "-Background*" << (Attrib[S_1]) << ")"; if (getTie(IVXY) == NULL) { tie("SSrc", ssxy.str()); CalcVxy = true; } } CommonsOK = true; } if (LastParams[IVXX] < 0) { ParamsOK = false; CommonsOK = false; } else for (size_t i = 0; i < nParams() && ParamsOK; i++) if (getParameter(i) != LastParams[i]) ParamsOK = false; if (!ParamsOK) { for (size_t i = 0; i < nParams(); i++) LastParams[i] = getParameter(i); } if (!CommonsOK || !ParamsOK) { int NCells1; double Varxx, Varxy, Varyy; Varxx = Varxy = Varyy = -1; penalty = initCoeff(D, X, Y, coefNorm, expCoeffx2, expCoeffy2, expCoeffxy, NCells1, Varxx, Varxy, Varyy); if (Varx0 < 0 && penalty <= 0) { Varx0 = Varxx; Vary0 = Varyy; } LastParams[IVXX] = Varxx; LastParams[IVXY] = Varxy; LastParams[IVYY] = Varyy; delete[] expVals; expVals = new double[NCells]; for (int i = 0; i < NCells; i++) { double dx = X[i] - LastParams[IXMEAN]; double dy = Y[i] - LastParams[IYMEAN]; expVals[i] = exp(expCoeffx2 * dx * dx + expCoeffxy * dx * dy + expCoeffy2 * dy * dy); } } return penalty; }