void KstBasicPlugin::createFitScalars() {
// Assumes that this is called with a write lock in place on this object
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
if (_isFit && _outputVectors.contains("Parameters")) {
KstVectorPtr vectorParam = _outputVectors["Parameters"];
if (vectorParam) {
QString paramName;
int i = 0;
int length = vectorParam->length();
KstWriteLocker blockScalarUpdates(&KST::scalarList.lock());
KST::scalarList.setUpdateDisplayTags(false);
for (paramName = parameterName(i);
!paramName.isEmpty() && i < length;
paramName = parameterName(++i)) {
double scalarValue = vectorParam->value(i);
if (!_outputScalars.contains(paramName)) {
KstScalarPtr s = new KstScalar(KstObjectTag(paramName, tag()), this, scalarValue);
s->KstObject::writeLock(); // must write lock, since fit scalars are created from update()
_outputScalars.insert(paramName, s);
} else {
_outputScalars[paramName]->setValue(scalarValue);
}
}
KST::scalarList.setUpdateDisplayTags(true);
}
}
}
// If a plugin provides a Parameters Vector, then scalars will be created, as well as a label.
void BasicPlugin::createScalars() {
// Assumes that this is called with a write lock in place on this object
Q_ASSERT(myLockStatus() == KstRWLock::WRITELOCKED);
if (hasParameterVector()) {
VectorPtr vectorParam = _outputVectors["Parameters Vector"];
if (vectorParam) {
QString paramName;
int i = 0;
int length = vectorParam->length();
Q_ASSERT(store());
for (paramName = parameterName(i);
!paramName.isEmpty() && i < length;
paramName = parameterName(++i)) {
double scalarValue = vectorParam->value(i);
if (!_outputScalars.contains(paramName)) {
ScalarPtr s = store()->createObject<Scalar>();
s->setProvider(this);
s->setSlaveName(paramName);
s->setValue(scalarValue);
s->writeLock();
_outputScalars.insert(paramName, s);
} else {
_outputScalars[paramName]->setValue(scalarValue);
}
}
}
}
}
/**
* Return a vector with all parameter names.
*/
std::vector<std::string> IFunction::getParameterNames() const {
std::vector<std::string> out;
for (size_t i = 0; i < nParams(); ++i) {
out.push_back(parameterName(i));
}
return out;
}
void Abragam::setActiveParameter(size_t i,double value)
{
size_t j = i;
if (parameterName(j) == "Sigma" )
setParameter(j,fabs(value),false); // Make sigma positive
else if (parameterName(j) == "Phi")
{
// Put angle in range of (-180 to 180] degrees
double a = fmod(value, 2*M_PI);
if( a<=-M_PI ) a += 2*M_PI;
if( a>M_PI ) a-= 2*M_PI;
setParameter(j,a,false);
}
else
setParameter(j,value,false);
}
/**
* Writes a string that can be used in Fit.IFunction to create a copy of this
* IFunction
* @return string representation of the function
*/
std::string IFunction::asString() const {
std::ostringstream ostr;
ostr << "name=" << this->name();
// print the attributes
std::vector<std::string> attr = this->getAttributeNames();
for (const auto &attName : attr) {
std::string attValue = this->getAttribute(attName).value();
if (!attValue.empty() && attValue != "\"\"") {
ostr << ',' << attName << '=' << attValue;
}
}
// print the parameters
for (size_t i = 0; i < nParams(); i++) {
const ParameterTie *tie = getTie(i);
if (!tie || !tie->isDefault()) {
ostr << ',' << parameterName(i) << '=' << getParameter(i);
}
}
// collect non-default constraints
std::string constraints;
for (size_t i = 0; i < nParams(); i++) {
const IConstraint *c = getConstraint(i);
if (c && !c->isDefault()) {
std::string tmp = c->asString();
if (!tmp.empty()) {
if (!constraints.empty()) {
constraints += ",";
}
constraints += tmp;
}
}
}
// print constraints
if (!constraints.empty()) {
ostr << ",constraints=(" << constraints << ")";
}
// collect the non-default ties
std::string ties;
for (size_t i = 0; i < nParams(); i++) {
const ParameterTie *tie = getTie(i);
if (tie && !tie->isDefault()) {
std::string tmp = tie->asString(this);
if (!tmp.empty()) {
if (!ties.empty()) {
ties += ",";
}
ties += tmp;
}
}
}
// print the ties
if (!ties.empty()) {
ostr << ",ties=(" << ties << ")";
}
return ostr.str();
}
QString BasicPlugin::label(int precision) const {
Q_UNUSED(precision)
QString label;
QString paramName;
label = Name();
if (hasParameterVector()) {
VectorPtr vectorParam = _outputVectors["Parameters Vector"];
int length = vectorParam->length();
int i=0;
for (paramName = parameterName(i);
!paramName.isEmpty() && i < length;
paramName = parameterName(++i)) {
if (_outputScalars.contains(paramName)) {
label += QString("\n%1: [%2]").arg(paramName).arg(_outputScalars[paramName]->Name());
}
}
}
return label;
}
/** Returns the name of parameter i as it declared in its function
* @param i :: The parameter index
* @param recursive :: If true call parameterLocalName recusively until
* a non-composite function is reached.
* @return The pure parameter name (without the function identifier f#.)
*/
std::string CompositeFunction::parameterLocalName(size_t i,
bool recursive) const {
size_t iFun = functionIndex(i);
auto localIndex = i - m_paramOffsets[iFun];
auto localFunction = m_functions[iFun].get();
if (recursive) {
auto cf = dynamic_cast<const CompositeFunction *>(localFunction);
if (cf) {
return cf->parameterLocalName(localIndex, recursive);
}
}
return localFunction->parameterName(localIndex);
}
QStringList specSpectrumCalculatorAction::descriptorNames(QString& teststring)
{
QRegExp re("\"([^\"]|\\\\\")*\"") ;
QStringList descriptorNames ;
int i = 0 ;
int index = 0 ;
while((index = re.indexIn(teststring)) != -1)
{
descriptorNames << re.cap().mid(1, re.cap().length() - 2) ;
teststring.remove(index, re.matchedLength()) ;
teststring.insert(index, parameterName(i++)) ;
}
return descriptorNames ;
}
void ALCPeakFittingPresenter::onPeakPickerChanged()
{
auto index = m_view->currentFunctionIndex();
// If PeakPicker is changed, it should be enabled, which means a peak function should be selected
// (See onCurrentFunctionChanged)
assert(index);
auto peakFunc = m_view->peakPicker();
// Update all the defined parameters of the peak function
for (size_t i = 0; i < peakFunc->nParams(); ++i)
{
QString paramName = QString::fromStdString(peakFunc->parameterName(i));
m_view->setParameter(*index, paramName, peakFunc->getParameter(paramName.toStdString()));
}
}
std::string IPeakFunction::getCentreParameterName() const {
FunctionParameterDecorator_sptr fn =
boost::dynamic_pointer_cast<FunctionParameterDecorator>(
FunctionFactory::Instance().createFunction("PeakParameterFunction"));
if (!fn) {
throw std::runtime_error(
"PeakParameterFunction could not be created successfully.");
}
fn->setDecoratedFunction(this->name());
FunctionDomain1DVector domain(std::vector<double>(4, 0.0));
TempJacobian jacobian(4, fn->nParams());
fn->functionDeriv(domain, jacobian);
return parameterName(jacobian.maxParam(0));
}
/**
* Initializes the mu::Parser.
*/
void UserFunctionMD::setFormula() {
// variables must be already defined
if (m_vars.empty())
return;
if (m_formula.empty()) {
m_formula = "0";
}
m_parser.SetVarFactory(AddVariable, this);
m_parser.SetExpr(m_formula);
// declare function parameters using mu::Parser's implicit variable setting
m_parser.Eval();
m_parser.ClearVar();
// set muParser variables
for (size_t i = 0; i < m_vars.size(); ++i) {
m_parser.DefineVar(m_varNames[i], &m_vars[i]);
}
for (size_t i = 0; i < nParams(); i++) {
m_parser.DefineVar(parameterName(i), getParameterAddress(i));
}
m_parser.SetExpr(m_formula);
}
/**
* Writes a string that can be used in Fit.IFunction to create a copy of this IFunction
* @param fmt :: Formatting flag. Set to true to ctreated formatted output.
* @return string representation of the function
*/
std::string IFunction::asString(bool fmt, size_t level)const
{
std::string nl = fmt? "\n" : "";
std::string padding = fmt && level ? std::string(level*2,' ') : "";
std::string padding2 = padding + " ";
std::ostringstream ostr;
// write function name
ostr << padding << this->name() << "(" << nl;
bool needComma = false;
// write function attributes
std::vector<std::string> attr = this->getAttributeNames();
for(size_t i=0;i<attr.size();i++)
{
std::string attName = attr[i];
std::string attValue = this->getAttribute(attr[i]).value();
if (!attValue.empty())
{
if (needComma)
{
ostr << ',' << nl;
}
needComma = true;
ostr << padding2 << attName << '=' << attValue;
}
}
// write function parameters
for(size_t i=0;i<nParams();i++)
{
if (needComma)
{
ostr << ',' << nl;
}
needComma = true;
ostr << padding2 << parameterName(i) << '=' << getParameter(i);
}
// write constraints
std::string constraints;
for(size_t i=0;i<nParams();i++)
{
const IConstraint* c = getConstraint(i);
if (c)
{
std::string tmp = c->asString();
if (!tmp.empty())
{
if (!constraints.empty())
{
constraints += ",";
}
constraints += tmp;
}
}
}
if (!constraints.empty())
{
ostr << ",constraints=(" << constraints << ")";
}
// write ties
std::string ties;
for(size_t i=0;i<nParams();i++)
{
const ParameterTie* tie = getTie(i);
if (tie)
{
std::string tmp = tie->asString(this);
if (!tmp.empty())
{
if (!ties.empty())
{
ties += ",";
}
ties += tmp;
}
}
}
if (!ties.empty())
{
ostr << ",ties=(" << ties << ")";
}
ostr << nl << padding << ")";
return ostr.str();
}
////////////////////////////////////////////////////////////////
//
// addWMIParametersToCIMMethod
//
// Add parameters from a WMI class to a CIMMethod.
//
///////////////////////////////////////////////////////////////
void addWMIParametersToCIMMethod(
const CComPtr<IWbemClassObject>& wmiParameters,
CIMMethod& method,
Boolean includeQualifiers)
{
// Check if wmiParameters is NULL (this will ocurr when there are none)
HRESULT hr;
if (wmiParameters)
{
// Enumerate all output parameters
hr = wmiParameters->BeginEnumeration(WBEM_FLAG_LOCAL_ONLY);
while(true)
{
// Get current parameter name and value
CComBSTR bstrParamName;
CComVariant vParamValue;
CIMTYPE wmiType;
hr = wmiParameters->Next(0, &bstrParamName,
&vParamValue, &wmiType, NULL);
// Check errors
if (WBEM_S_NO_MORE_DATA == hr)
{
break;
}
if (FAILED(hr))
{
bstrParamName.Empty();
vParamValue.Clear();
throw CIMException(CIM_ERR_FAILED);
}
// Convert to CIMParameter
BSTR tmpBstr = (BSTR)bstrParamName.Copy();
String parameterName(_bstr_t(tmpBstr, FALSE));
SysFreeString(tmpBstr);
// Add the parameter to this method if it is not the return value
// and it does not already exist in the method.
// If the parameter already exists (i.e., an in & out parameter),
// then there is no need to re-add or modify it here
// (the in version is an exact copy of the out version):
String strRetVal("ReturnValue");
if (!(String::equalNoCase(parameterName, strRetVal)) &&
method.findParameter(parameterName) == PEG_NOT_FOUND)
{
// Get the qualifier list for this param from WMI:
CComPtr<IWbemQualifierSet> pParamQualifiers;
HRESULT hr =
wmiParameters->GetPropertyQualifierSet(bstrParamName,
&pParamQualifiers);
// create the CIMParameter
CIMParameter cimParam =
cimParamFromWMIParam(parameterName,
wmiType,
pParamQualifiers,
includeQualifiers);
// Now, add the new parameter to the CIMMethod:
method.addParameter(cimParam);
if (pParamQualifiers)
pParamQualifiers.Release();
}
bstrParamName.Empty();
vParamValue.Clear();
}
hr = wmiParameters->EndEnumeration();
}
}
int DOUserValueModified(const CKBehaviorContext& behcontext)
{
CKBehavior* beh = behcontext.Behavior;
CKMessageManager* mm = behcontext.MessageManager;
CKContext* ctx = behcontext.Context;
//////////////////////////////////////////////////////////////////////////
//connection id :
int connectionID = vtTools::BehaviorTools::GetInputParameterValue<int>(beh,0);
if (beh->IsInputActive(1))
{
beh->ActivateInput(1,FALSE);
beh->ActivateOutput(1);
return 0;
}
//////////////////////////////////////////////////////////////////////////
//the object :
CK3dEntity *obj= (CK3dEntity*)beh->GetInputParameterObject(1);
if (!obj)
{
beh->ActivateOutput(3);
return CKBR_ACTIVATENEXTFRAME;
}
//////////////////////////////////////////////////////////////////////////
//network ok ?
xNetInterface *cin = GetNM()->GetClientNetInterface();
if (!cin)
{
CKParameterOut *pout = beh->GetOutputParameter(2);
XString errorMesg("distributed object creation failed,no network connection !");
pout->SetStringValue(errorMesg.Str());
beh->ActivateOutput(3);
return CKBR_ACTIVATENEXTFRAME;
}
//use objects name, if not specified :
CKSTRING name= obj->GetName();
IDistributedObjects*doInterface = cin->getDistObjectInterface();
IDistributedClasses*cInterface = cin->getDistributedClassInterface();
XString className((CKSTRING) beh->GetLocalParameterReadDataPtr(0));
XString parameterName((CKSTRING) beh->GetLocalParameterReadDataPtr(1));
xDistributedClass *_class = cInterface->get(className.CStr());
//////////////////////////////////////////////////////////////////////////
//dist class ok ?
if (_class==NULL)
{
beh->ActivateOutput(3);
ctx->OutputToConsoleEx("Distributed Class doesn't exists : %s",className.CStr());
return CKBR_ACTIVATENEXTFRAME;
}
const char * cNAme = _class->getClassName().getString();
int classType = _class->getEnitityType();
int bcount = beh->GetInputParameterCount();
//////////////////////////////////////////////////////////////////////////
//we come in by input 0 :
xDistributedObject *dobjDummy = NULL;
xDistributedObject *dobj = doInterface->getByEntityID(obj->GetID());
if (!dobj)
{
beh->ActivateOutput(3);
return CKBR_ACTIVATENEXTFRAME;
}
if (dobj)
{
xDistributedProperty * prop = dobj->getUserProperty(parameterName.CStr());
if (prop)
{
if ( dobj->getGhostUpdateBits().testStrict(1 << prop->getBlockIndex()))
{
CKParameterManager *pam = static_cast<CKParameterManager *>(ctx->GetParameterManager());
CKParameterOut *ciIn = beh->GetOutputParameter(1);
CKParameterType pType = ciIn->GetType();
int sType = vtTools::ParameterTools::GetVirtoolsSuperType(ctx,pam->ParameterTypeToGuid(pType));
int userType = xDistTools::ValueTypeToSuperType(prop->getPropertyInfo()->mValueType);
if ( userType ==sType )
{
beh->ActivateOutput(2);
dobj->getGhostUpdateBits().set(1 << prop->getBlockIndex(),false);
switch(xDistTools::ValueTypeToSuperType(prop->getPropertyInfo()->mValueType))
{
case vtFLOAT:
{
xDistributedPoint1F *propValue = static_cast<xDistributedPoint1F*>(prop);
if (propValue)
{
float ovalue = propValue->mLastServerValue;
beh->SetOutputParameterValue(1,&ovalue);
break;
}
}
case vtVECTOR2D:
{
xDistributedPoint2F *propValue = static_cast<xDistributedPoint2F*>(prop);
if (propValue)
{
Point2F ovalue = propValue->mLastServerValue;
Vx2DVector ovaluex(ovalue.x,ovalue.y);
beh->SetOutputParameterValue(1,&ovaluex);
break;
}
}
case vtVECTOR:
{
xDistributedPoint3F *propValue = static_cast<xDistributedPoint3F*>(prop);
if (propValue)
{
Point3F ovalue = propValue->mLastServerValue;
VxVector ovaluex(ovalue.x,ovalue.y,ovalue.z);
beh->SetOutputParameterValue(1,&ovaluex);
break;
}
}
case vtQUATERNION:
{
xDistributedQuatF*propValue = static_cast<xDistributedQuatF*>(prop);
if (propValue)
{
QuatF ovalue = propValue->mLastServerValue;
VxQuaternion ovaluex(ovalue.x,ovalue.y,ovalue.z,ovalue.w);
beh->SetOutputParameterValue(1,&ovaluex);
break;
}
}
case vtSTRING:
{
xDistributedString*propValue = static_cast<xDistributedString*>(prop);
if (propValue)
{
TNL::StringPtr ovalue = propValue->mCurrentValue;
CKParameterOut *pout = beh->GetOutputParameter(1);
XString errorMesg(ovalue.getString());
pout->SetStringValue(errorMesg.Str());
break;
}
}
case vtINTEGER:
{
xDistributedInteger*propValue = static_cast<xDistributedInteger*>(prop);
if (propValue)
{
int ovalue = propValue->mLastServerValue;
beh->SetOutputParameterValue(1,&ovalue);
break;
}
}
}
}
}
}
}
return CKBR_ACTIVATENEXTFRAME;
if (beh->IsInputActive(0))
{
beh->ActivateOutput(0);
}
/*
//////////////////////////////////////////////////////////////////////////
//we come in by input 0 :
if (beh->IsInputActive(0))
{
beh->ActivateOutput(0);
for (int i = BEH_IN_INDEX_MIN_COUNT ; i < beh->GetInputParameterCount() ; i++ )
{
beh->ActivateInput(0,FALSE);
xDistributedObject *dobj = doInterface->get(name);
if (!dobj)
{
beh->ActivateOutput(0);
return 0;
}
CKParameterIn *ciIn = beh->GetInputParameter(i);
CKParameterType pType = ciIn->GetType();
int sType = vtTools::ParameterTools::GetVirtoolsSuperType(ctx,pam->ParameterTypeToGuid(pType));
xDistributedPropertyArrayType &props = *dobj->getDistributedPorperties();
int propID = _class->getInternalUserFieldIndex(i - BEH_IN_INDEX_MIN_COUNT);
if (propID==-1 || propID > props.size() )
{
beh->ActivateOutput(1);
return 0;
}
xDistributedProperty *prop = props[propID];
if (prop)
{
xDistributedPropertyInfo*propInfo = prop->getPropertyInfo();
if (propInfo)
{
if (xDistTools::ValueTypeToSuperType(propInfo->mValueType) ==sType )
{
TNL::U32 currentTime = TNL::Platform::getRealMilliseconds();
switch(propInfo->mValueType)
{
case E_DC_PTYPE_3DVECTOR:
{
xDistributedPoint3F * dpoint3F = (xDistributedPoint3F*)prop;
if (dpoint3F)
{
VxVector vvalue;
beh->GetInputParameterValue(i,&vvalue);
bool update = dpoint3F->updateValue(xMath::getFrom(vvalue),currentTime);
}
break;
}
case E_DC_PTYPE_FLOAT:
{
xDistributedPoint1F * dpoint3F = (xDistributedPoint1F*)prop;
if (dpoint3F)
{
float vvalue;
beh->GetInputParameterValue(i,&vvalue);
bool update = dpoint3F->updateValue(vvalue,currentTime);
}
break;
}
}
}
}
}
}
beh->ActivateOutput(0);
}
*/
//////////////////////////////////////////////////////////////////////////
//we come in by loop :
return 0;
}
//----------------------------------------------------------------------------------------------
/// Execute the algorithm.
void EstimateFitParameters::execConcrete() {
auto costFunction = getCostFunctionProperty();
auto func = costFunction->getFittingFunction();
// Use additional constraints on parameters tied in some way
// to the varied parameters to exculde unwanted results.
std::vector<std::unique_ptr<IConstraint>> constraints;
std::string constraintStr = getProperty("Constraints");
if (!constraintStr.empty()) {
Expression expr;
expr.parse(constraintStr);
expr.toList();
for (auto &term : expr.terms()) {
IConstraint *c =
ConstraintFactory::Instance().createInitialized(func.get(), term);
constraints.push_back(std::unique_ptr<IConstraint>(c));
}
}
// Ranges to use with random number generators: one for each free parameter.
std::vector<std::pair<double, double>> ranges;
ranges.reserve(costFunction->nParams());
for (size_t i = 0; i < func->nParams(); ++i) {
if (func->isFixed(i)) {
continue;
}
auto constraint = func->getConstraint(i);
if (constraint == nullptr) {
func->fix(i);
continue;
}
auto boundary = dynamic_cast<Constraints::BoundaryConstraint *>(constraint);
if (boundary == nullptr) {
throw std::runtime_error("Parameter " + func->parameterName(i) +
" must have a boundary constraint. ");
}
if (!boundary->hasLower()) {
throw std::runtime_error("Constraint of " + func->parameterName(i) +
" must have a lower bound.");
}
if (!boundary->hasUpper()) {
throw std::runtime_error("Constraint of " + func->parameterName(i) +
" must have an upper bound.");
}
// Use the lower and upper bounds of the constraint to set the range
// of a generator with uniform distribution.
ranges.push_back(std::make_pair(boundary->lower(), boundary->upper()));
}
// Number of parameters could have changed
costFunction->reset();
if (costFunction->nParams() == 0) {
throw std::runtime_error("No parameters are given for which to estimate "
"initial values. Set boundary constraints to "
"parameters that need to be estimated.");
}
size_t nSamples = static_cast<int>(getProperty("NSamples"));
size_t seed = static_cast<int>(getProperty("Seed"));
if (getPropertyValue("Type") == "Monte Carlo") {
runMonteCarlo(*costFunction, ranges, constraints, nSamples, seed);
} else {
size_t nSelection = static_cast<int>(getProperty("Selection"));
size_t nIterations = static_cast<int>(getProperty("NIterations"));
runCrossEntropy(*costFunction, ranges, constraints, nSamples, nSelection,
nIterations, seed);
}
bool fixBad = getProperty("FixBadParameters");
if (fixBad) {
fixBadParameters(*costFunction, ranges);
}
}
//----------------------------------------------------------------------------------------------
/// Execute the algorithm.
void EstimateFitParameters::execConcrete() {
auto costFunction = getCostFunctionInitialized();
auto func = costFunction->getFittingFunction();
// Use additional constraints on parameters tied in some way
// to the varied parameters to exculde unwanted results.
std::vector<std::unique_ptr<IConstraint>> constraints;
std::string constraintStr = getProperty("Constraints");
if (!constraintStr.empty()) {
Expression expr;
expr.parse(constraintStr);
expr.toList();
for (auto &term : expr.terms()) {
IConstraint *c =
ConstraintFactory::Instance().createInitialized(func.get(), term);
constraints.push_back(std::unique_ptr<IConstraint>(c));
}
}
// Ranges to use with random number generators: one for each free parameter.
std::vector<std::pair<double, double>> ranges;
ranges.reserve(costFunction->nParams());
for (size_t i = 0; i < func->nParams(); ++i) {
if (!func->isActive(i)) {
continue;
}
auto constraint = func->getConstraint(i);
if (constraint == nullptr) {
func->fix(i);
continue;
}
auto boundary = dynamic_cast<Constraints::BoundaryConstraint *>(constraint);
if (boundary == nullptr) {
throw std::runtime_error("Parameter " + func->parameterName(i) +
" must have a boundary constraint. ");
}
if (!boundary->hasLower()) {
throw std::runtime_error("Constraint of " + func->parameterName(i) +
" must have a lower bound.");
}
if (!boundary->hasUpper()) {
throw std::runtime_error("Constraint of " + func->parameterName(i) +
" must have an upper bound.");
}
// Use the lower and upper bounds of the constraint to set the range
// of a generator with uniform distribution.
ranges.push_back(std::make_pair(boundary->lower(), boundary->upper()));
}
// Number of parameters could have changed
costFunction->reset();
if (costFunction->nParams() == 0) {
throw std::runtime_error("No parameters are given for which to estimate "
"initial values. Set boundary constraints to "
"parameters that need to be estimated.");
}
size_t nSamples = static_cast<int>(getProperty("NSamples"));
unsigned int seed = static_cast<int>(getProperty("Seed"));
if (getPropertyValue("Type") == "Monte Carlo") {
int nOutput = getProperty("NOutputs");
auto outputWorkspaceProp = getPointerToProperty("OutputWorkspace");
if (outputWorkspaceProp->isDefault() || nOutput <= 0) {
nOutput = 1;
}
auto output = runMonteCarlo(*costFunction, ranges, constraints, nSamples,
static_cast<size_t>(nOutput), seed);
if (!outputWorkspaceProp->isDefault()) {
auto table = API::WorkspaceFactory::Instance().createTable();
auto column = table->addColumn("str", "Name");
column->setPlotType(6);
for (size_t i = 0; i < output.size(); ++i) {
column = table->addColumn("double", std::to_string(i + 1));
column->setPlotType(2);
}
for (size_t i = 0, ia = 0; i < m_function->nParams(); ++i) {
if (m_function->isActive(i)) {
TableRow row = table->appendRow();
row << m_function->parameterName(i);
for (auto &j : output) {
row << j[ia];
}
++ia;
}
}
setProperty("OutputWorkspace", table);
}
} else {
size_t nSelection = static_cast<int>(getProperty("Selection"));
size_t nIterations = static_cast<int>(getProperty("NIterations"));
runCrossEntropy(*costFunction, ranges, constraints, nSamples, nSelection,
nIterations, seed);
}
bool fixBad = getProperty("FixBadParameters");
if (fixBad) {
fixBadParameters(*costFunction, ranges);
}
}
specUndoCommand* specSpectrumCalculatorAction::generateUndoCommand()
{
// prepare items
QList<specModelItem*> items, folders ;
expandSelectedFolders(items, folders);
if(items.isEmpty()) return 0 ; // TODO include this in requirements
// get formulae
if(!dialog->exec()) return 0 ;
// prepare multi command
specMultiCommand* parentCommand = new specMultiCommand ;
parentCommand->setParentObject(model) ;
parentCommand->setMergeable(false) ;
// prepare the parsers
mu::Parser xParser, yParser ;
QString xFormula(dialog->xFormula()), yFormula(dialog->yFormula()) ;
QStringList xDescriptors(descriptorNames(xFormula)), yDescriptors(descriptorNames(yFormula)) ;
try
{
xParser.DefineOprt("%", modulo, 6);
yParser.DefineOprt("%", modulo, 6);
xParser.SetExpr(xFormula.toStdString()) ;
yParser.SetExpr(yFormula.toStdString()) ;
}
catch(...)
{
QMessageBox::critical(0, tr("Failed evaluation"), tr("Failed parsing the given formulae.")) ;
return 0;
}
// generate new data
int failCount = 0 ;
foreach(specModelItem * item, items)
{
size_t count = item->dataSize() ;
double* oldX = new double[count],
*oldY = new double[count],
*newX = new double[count],
*newY = new double[count];
for(size_t i = 0 ; i < count ; ++i)
{
QPointF point = item->sample(i) ;
oldX[i] = point.x() ;
oldY[i] = point.y() ;
}
bool evaluationOk = false ;
QVector<specDataPoint> newData ;
try
{
xParser.ClearVar();
yParser.ClearVar();
xParser.ClearConst();
yParser.ClearConst();
xParser.DefineVar("x", oldX) ;
yParser.DefineVar("x", oldX) ;
xParser.DefineVar("y", oldY) ;
yParser.DefineVar("y", oldY) ;
for(int i = 0 ; i < xDescriptors.size() ; ++i)
xParser.DefineConst(parameterName(i).toStdString(), item->descriptorValue(xDescriptors[i])) ;
for(int i = 0 ; i < yDescriptors.size() ; ++i)
yParser.DefineConst(parameterName(i).toStdString(), item->descriptorValue(yDescriptors[i])) ;
xParser.Eval(newX, count) ;
yParser.Eval(newY, count) ;
for(size_t i = 0 ; i < count ; ++i)
newData << specDataPoint(newX[i], newY[i], 0.) ;
evaluationOk = true ;
}
catch(...) {}
delete[] oldX ;
delete[] oldY ;
delete[] newX ;
delete[] newY ;
failCount += !evaluationOk ;
// prepare the command
if(evaluationOk)
{
if(specDataItem* dataItem = dynamic_cast<specDataItem*>(item))
dataItem->reverseCorrection(newData) ;
specExchangeDataCommand* command = new specExchangeDataCommand(parentCommand) ;
command->setParentObject(model) ;
command->setItem(item, newData);
}
}
bool ObjectTypeTemplate::isParameterPrivate(int index) const
{
const std::string& name = parameterName(index);
return !name.empty() && name[0] == '_';
}
