/** Restore function parameter values saved in a (string,double) map to a function object * and a (string, Parameter) map */ void restoreFunctionParameterValue(map<string, pair<double, double> > parvaluemap, IFunction_sptr function, map<string, Parameter>& parammap) { vector<string> parnames = function->getParameterNames(); for (size_t i = 0; i < parnames.size(); ++i) { string& parname = parnames[i]; map<string, pair<double, double> >::iterator miter; miter = parvaluemap.find(parname); if (miter != parvaluemap.end()) { double parvalue = miter->second.first; double parerror = miter->second.second; // 1. Function function->setParameter(parname, parvalue); // 2. Parameter map map<string, Parameter>::iterator pariter = parammap.find(parname); if (pariter != parammap.end()) { // Find the entry pariter->second.value = parvalue; pariter->second.error = parerror; } } } return; }
IFunction_sptr IqtFit::createUserFunction(const QString &name, bool tie) { IFunction_sptr result = FunctionFactory::Instance().createFunction("UserFunction"); std::string formula; if (name.startsWith("Exp")) { formula = "Intensity*exp(-(x/Tau))"; } else { formula = "Intensity*exp(-(x/Tau)^Beta)"; } IFunction::Attribute att(formula); result->setAttribute("Formula", att); QList<QtProperty *> props = m_properties[name]->subProperties(); for (int i = 0; i < props.size(); i++) { std::string name = props[i]->propertyName().toStdString(); result->setParameter(name, m_dblManager->value(props[i])); // add tie if parameter is fixed if (tie || !props[i]->subProperties().isEmpty()) { std::string value = props[i]->valueText().toStdString(); result->tie(name, value); } } result->applyTies(); return result; }
/** * Create a function from an expression. * @param expr :: The input expression * @param parentAttributes :: An output map filled with the attribute name & values of the parent function * @return A pointer to the created function */ IFunction_sptr FunctionFactoryImpl::createSimple(const Expression& expr, std::map<std::string,std::string>& parentAttributes)const { if (expr.name() == "=" && expr.size() > 1) { return createFunction(expr.terms()[1].name()); } if (expr.name() != "," || expr.size() == 0) { inputError(expr.str()); } const std::vector<Expression>& terms = expr.terms(); std::vector<Expression>::const_iterator term = terms.begin(); if (term->name() != "=") inputError(expr.str()); if (term->terms()[0].name() != "name" && term->terms()[0].name() != "composite") { throw std::invalid_argument("Function name must be defined before its parameters"); } std::string fnName = term->terms()[1].name(); IFunction_sptr fun = createFunction(fnName); for(++term;term!=terms.end();++term) {// loop over function's parameters/attributes if (term->name() != "=") inputError(expr.str()); std::string parName = term->terms()[0].name(); std::string parValue = term->terms()[1].str(); if (fun->hasAttribute(parName)) {// set attribute if (parValue.size() > 1 && parValue[0] == '"') {// remove the double quotes parValue = parValue.substr(1,parValue.size()-2); } IFunction::Attribute att = fun->getAttribute(parName); att.fromString(parValue); fun->setAttribute(parName,att); } else if (parName.size() >= 10 && parName.substr(0,10) == "constraint") {// or it can be a list of constraints addConstraints(fun,(*term)[1]); } else if (parName == "ties") { addTies(fun,(*term)[1]); } else if (!parName.empty() && parName[0] == '$') { parName.erase(0,1); parentAttributes[parName] = parValue; } else {// set initial parameter value fun->setParameter(parName,atof(parValue.c_str())); } }// for term fun->applyTies(); return fun; }
/** * Adds background functions for the background if applicable * * If specified by the user via the corresponding algorithm parameters, * this function adds a constant and a linear background term to the * supplied Poldi2DFunction. * * @param poldi2DFunction :: Poldi2DFunction to which the background is added. */ void PoldiFitPeaks2D::addBackgroundTerms( Poldi2DFunction_sptr poldi2DFunction) const { bool addConstantBackground = getProperty("FitConstantBackground"); if (addConstantBackground) { IFunction_sptr constantBackground = FunctionFactory::Instance().createFunction( "PoldiSpectrumConstantBackground"); constantBackground->setParameter( 0, getProperty("ConstantBackgroundParameter")); poldi2DFunction->addFunction(constantBackground); } bool addLinearBackground = getProperty("FitLinearBackground"); if (addLinearBackground) { IFunction_sptr linearBackground = FunctionFactory::Instance().createFunction( "PoldiSpectrumLinearBackground"); linearBackground->setParameter(0, getProperty("LinearBackgroundParameter")); poldi2DFunction->addFunction(linearBackground); } }
/** Set parameter values to function from Parameter map */ void RefinePowderInstrumentParameters2::setFunctionParameterValues(IFunction_sptr function, map<string, Parameter> params) { // 1. Prepare vector<string> funparamnames = function->getParameterNames(); // 2. Set up stringstream msgss; msgss << "Set Instrument Function Parameter : " << endl; std::map<std::string, Parameter>::iterator paramiter; for (size_t i = 0; i < funparamnames.size(); ++i) { string parname = funparamnames[i]; paramiter = params.find(parname); if (paramiter != params.end()) { // Found, set up the parameter Parameter& param = paramiter->second; function->setParameter(parname, param.value); msgss << setw(10) << parname << " = " << param.value << endl; } else { // Not found and thus quit stringstream errss; errss << "Peak profile parameter " << parname << " is not found in input parameters. "; g_log.error(errss.str()); throw runtime_error(errss.str()); } } // ENDFOR parameter name g_log.information(msgss.str()); return; }
CompositeFunction_sptr IqtFit::createFunction(bool tie) { CompositeFunction_sptr result(new CompositeFunction); QString fname; const int fitType = m_uiForm.cbFitType->currentIndex(); IFunction_sptr func = FunctionFactory::Instance().createFunction("LinearBackground"); func->setParameter("A0", m_ffRangeManager->value(m_properties["BackgroundA0"])); result->addFunction(func); result->tie("f0.A1", "0"); if (tie) { result->tie("f0.A0", m_properties["BackgroundA0"]->valueText().toStdString()); } if (fitType == 2) { fname = "StretchedExp"; } else { fname = "Exponential1"; } result->addFunction(createUserFunction(fname, tie)); if (fitType == 1 || fitType == 3) { if (fitType == 1) { fname = "Exponential2"; } else { fname = "StretchedExp"; } result->addFunction(createUserFunction(fname, tie)); } // Return CompositeFunction object to caller. result->applyTies(); return result; }