MStatus PRTAttrs::addEnumParameter(MFnDependencyNode & node, MObject & attr, const MString & name, short value, PRTEnum * e) {
MStatus stat;
attr = e->mAttr.create(longName(name), briefName(name), value, &stat);
MCHECK(stat);
MCHECK(e->fill());
MCHECK(addParameter(node, attr, e->mAttr));
MPlug plug(node.object(), attr);
MCHECK(plug.setValue(value));
return MS::kSuccess;
}
void Z3DPunctaFilter::initialize()
{
Z3DGeometryFilter::initialize();
m_sphereRenderer = new Z3DSphereRenderer();
m_rendererBase->addRenderer(m_sphereRenderer);
m_boundBoxRenderer = new Z3DLineWithFixedWidthColorRenderer();
m_boundBoxRenderer->setUseDisplayList(false);
m_boundBoxRenderer->setRespectRendererBaseCoordScales(false);
m_boundBoxRenderer->setLineColorGuiName("Selection BoundBox Line Color");
m_boundBoxRenderer->setLineWidthGuiName("Selection BoundBox Line Width");
m_rendererBase->addRenderer(m_boundBoxRenderer);
std::vector<ZParameter*> paras = m_rendererBase->getParameters();
for (size_t i=0; i<paras.size(); i++) {
//connect(paras[i], SIGNAL(valueChanged()), this, SLOT(invalidateResult()));
addParameter(paras[i]);
}
}
KPIECEChainPlanner::KPIECEChainPlanner(SPACETYPE stype, Sample *init, Sample *goal, SampleSet *samples, WorkSpace *ws) : KauthamDEPlanner(stype, init, goal, samples, ws)
{
_guiName = "KPIECE Chain Planner";
_idName = "KPIECEChainPlanner";
ws->moveRobotsTo(init);
dInitODE2(0);
envPtr= oc::OpenDEEnvironmentPtr(new PlanarChainEnvironment(ws,_maxspeed,_maxContacts,_minControlSteps,_maxControlSteps, _erp, _cfm, _isKchain));
stateSpacePtr = ob::StateSpacePtr(new PlanarChainStateSpace(envPtr));
ss = new oc::OpenDESimpleSetup(stateSpacePtr);
oc::SpaceInformationPtr si=ss->getSpaceInformation();
ob::PlannerPtr planner(new oc::KPIECE1(si));
addParameter("Goal Bias", _GoalBias);
planner->as<oc::KPIECE1>()->setGoalBias( _GoalBias);
//set the planner
ss->setPlanner(planner);
}
int setParameter(const char* paramName, const char* paramValue, int force){
#ifdef MDIS_IO_CONFIG_DEBUG
printf("Setting parameter '%s' to value '%s'\n", paramName, paramValue);
#endif
for(int i = 0; i < paramCount; i++){
if(strcmp(paramName, paramNames[i]) == 0){
strncpy(paramValues[i], paramValue, VALUE_LENGTH);
return 0;
}
}
#ifdef MDIS_IO_CONFIG_DEBUG
printf("Parameter '%s' not found!\n", paramName);
#endif
if (force) {
return addParameter(paramName, paramValue);
}
return 1;
}
//! Constructor
omplLazyTRRTPlanner::omplLazyTRRTPlanner(SPACETYPE stype, Sample *init, Sample *goal,
SampleSet *samples, WorkSpace *ws, og::SimpleSetup *ssptr) :
omplPlanner(stype, init, goal, samples, ws, ssptr) {
_guiName = "ompl Lazy TRRT Planner";
_idName = "omplLazyTRRT";
//create planner
ob::PlannerPtr planner(new og::LazyTRRT(si));
_opti = ob::OptimizationObjectivePtr(new myMWOptimizationObjective(ss->getSpaceInformation(), this, false));
ob::ProblemDefinitionPtr pdefPtr = ss->getProblemDefinition();
pdefPtr->setOptimizationObjective(_opti);
planner->setProblemDefinition(pdefPtr);
//set the planner
ss->setPlanner(planner);
//set planner parameters: range and goalbias
_Range=(planner->as<og::LazyTRRT>())->getRange();
_GoalBias=(planner->as<og::LazyTRRT>())->getGoalBias();
_maxStatesFailed = (planner->as<og::LazyTRRT>())->getMaxStatesFailed();
_tempChangeFactor = (planner->as<og::LazyTRRT>())->getTempChangeFactor();
_frontierThreshold = (planner->as<og::LazyTRRT>())->getFrontierThreshold();
_frontierNodesRatio = (planner->as<og::LazyTRRT>())->getFrontierNodeRatio();
addParameter("Goal Bias", _GoalBias);
addParameter("Max States Failed", _maxStatesFailed);
addParameter("T Change Factor", _tempChangeFactor);
addParameter("Frontier Nodes Ratio", _frontierNodesRatio);
addParameter("Path Length Weight",0.00001);
addParameter("Min Temp",planner->as<og::LazyTRRT>()->getMinTemperature());
addParameter("Init Temp",planner->as<og::LazyTRRT>()->getInitTemperature());
addParameter("Min Collision Threshold",planner->as<og::LazyTRRT>()->getMinCollisionThreshold());
addParameter("Max Collision Threshold",planner->as<og::LazyTRRT>()->getMaxCollisionThreshold());
}
HashTable::HashTable(CActionSet *actions, CStateModifier* sm, MultiBoost::AdaBoostMDPClassifierContinous* classifier, int numDim) : CAbstractQFunction(actions)
{
_stateProperties = sm;
_classifier = classifier;
_actions = actions;
_numberOfActions = (int)actions->size();
addParameter("QLearningRate", 0.2);
_numDimensions = numDim;
// if (_numDimensions == 2) --_numDimensions;
//
// _numDimensions = 1;
_stepResolution = 1. / 9;
_numWinnerClasses = 1;
}
bool ParameterContainer::read(std::istream& is, const std::map<std::string, std::string>* _renamedTypesLookup){
stringstream currentLine;
string token;
Factory* factory = Factory::instance();
HyperGraph::GraphElemBitset elemBitset;
elemBitset[HyperGraph::HGET_PARAMETER] = 1;
while (1) {
int bytesRead = readLine(is, currentLine);
if (bytesRead == -1)
break;
currentLine >> token;
if (bytesRead == 0 || token.size() == 0 || token[0] == '#')
continue;
if (_renamedTypesLookup && _renamedTypesLookup->size()>0){
map<string, string>::const_iterator foundIt = _renamedTypesLookup->find(token);
if (foundIt != _renamedTypesLookup->end()) {
token = foundIt->second;
}
}
HyperGraph::HyperGraphElement* element = factory->construct(token, elemBitset);
if (! element) // not a parameter or otherwise unknown tag
continue;
assert(element->elementType() == HyperGraph::HGET_PARAMETER && "Should be a param");
Parameter* p = static_cast<Parameter*>(element);
int pid;
currentLine >> pid;
p->setId(pid);
bool r = p->read(currentLine);
if (! r) {
cerr << __PRETTY_FUNCTION__ << ": Error reading data " << token << " for parameter " << pid << endl;
delete p;
} else {
if (! addParameter(p) ){
cerr << __PRETTY_FUNCTION__ << ": Parameter of type:" << token << " id:" << pid << " already defined" << endl;
}
}
} // while read line
return true;
}
CRocheLobe_FF::CRocheLobe_FF() : AU(1.496e11), rsun(6.955e8), G(6.67428e-11), parsec(3.08567758e16), CHealpixSpheroid()
{
mID = "roche_lobe_FF";
mName = "Roche Lobe (Fill Factor)";
addParameter("T_eff_pole", 5000, 2E3, 1E6, false, 100, "T_pole", "Effective Polar temperature (kelvin)", 0);
addParameter("von_zeipel_beta", 0.25, 0.0, 1.0, false, 0.1, "Beta", "Von Zeipel gravity darkening parameter (unitless)", 2);
addParameter("F", 0.5 , 0.001, 1.0, false, 0.01, "Fill factor", "Fill factor, as defined by Mochnacki", 2);
addParameter("separation", 4.0 , 0.1, 100.0, false, 0.01, "Separation", "Separation between components (mas)", 2);
addParameter("q", 3.0 , 0.001, 100.0, false, 0.01, "Mass ratio", "M2/M1 mass ratio; M1 = this Roche lobe (unitless)", 2);
addParameter("P", 1.0 , 0.01, 2.0, false, 0.01, "Async ratio", "Ratio self-rotation period/orbital revolution period (unitless)", 2);
// omega_rot = 2.0 * PI / (orbital_period * 3600. * 24.); // in Hz
}
MStatus PRTAttrs::addFileParameter(MFnDependencyNode & node, MObject & attr, const MString & name, const MString & value, MString & exts ) {
MStatus stat;
MStatus stat2;
MFnStringData stringData;
MFnTypedAttribute sAttr;
attr = sAttr.create(longName(name), briefName(name), MFnData::kString, stringData.create("", &stat2), &stat );
MCHECK(stat2);
MCHECK(stat);
MCHECK(sAttr.setUsedAsFilename(true));
MCHECK(addParameter(node, attr, sAttr));
MCHECK(sAttr.setNiceNameOverride(exts));
MPlug plug(node.object(), attr);
MCHECK(plug.setValue(value));
return MS::kSuccess;
}
SerialModule::SerialModule(const String &name) :
Module(name),
port(nullptr)
{
portParam = new SerialDeviceParameter("Port", "Serial Port to connect",true);
addParameter(portParam);
modeParam = addEnumParameter("Mode", "Protocol for treating the incoming data");
modeParam->addOption("Lines", SerialDevice::LINES);
modeParam->addOption("Raw", SerialDevice::RAW);
modeParam->addOption("Data255", SerialDevice::DATA255);
modeParam->addOption("COBS", SerialDevice::COBS);
scriptObject.setMethod(sendId, SerialModule::sendStringFromScript);
scriptObject.setMethod(sendLineId, SerialModule::sendStringWithNewLineFromScript);
scriptObject.setMethod(writeId, SerialModule::sendBytesFromScript);
SerialManager::getInstance()->addSerialManagerListener(this);
}
Z3DTextureBlendRenderer::Z3DTextureBlendRenderer(const QString &mode, QObject *parent)
: Z3DPrimitiveRenderer(parent)
, m_colorTexture1(NULL)
, m_depthTexture1(NULL)
, m_colorTexture2(NULL)
, m_depthTexture2(NULL)
, m_blendMode("Blend Mode")
{
m_blendMode.addOptionsWithData(qMakePair<QString,QString>("DepthTest", "DEPTH_TEST"),
qMakePair<QString,QString>("FirstOnTop", "FIRST_ON_TOP"),
qMakePair<QString,QString>("SecondOnTop", "SECOND_ON_TOP"),
qMakePair<QString,QString>("DepthTestBlending", "DEPTH_TEST_BLENDING"),
qMakePair<QString,QString>("FirstOnTopBlending", "FIRST_ON_TOP_BLENDING"),
qMakePair<QString,QString>("SecondOnTopBlending", "SECOND_ON_TOP_BLENDING")
);
m_blendMode.select(mode);
addParameter(m_blendMode);
connect(&m_blendMode, SIGNAL(valueChanged()), this, SLOT(compile()));
}
AbstractIAFController::AbstractIAFController(const AbstractIAFControllerConf& conf)
: AbstractController("AbstractIAFController", "$Id$"), conf(conf), range(1.0) {
addParameter("leaki", conf.leakI);
addParameter("leako", conf.leakO);
addParameter("thresholdi", conf.thresholdI);
addParameter("thresholdo", conf.thresholdO);
addParameter("wiinitscale", conf.wIInitScale);
addParameter("wiinitscale", conf.wOInitScale);
addParameter("niafperinput", conf.numberIAFNeuronsPerInput);
addParameter("niafperoutput", conf.numberIAFNeuronsPerOutput);
// addInspectableValue("[I]leak", conf.leakI);
// addInspectableValue("[O]leak", conf.leakO);
// addInspectableValue("[I]t",conf.thresholdI);
// addInspectableValue("[O]t",conf.thresholdO);
addInspectableMatrix("[I]sum",&sumI);
addInspectableMatrix("[O]sum",&sumO);
// addInspectableMatrix("[I]W",&wI);
// addInspectableMatrix("[O]W",&wO);
addInspectableMatrix("[I]x",&xI);
addInspectableMatrix("[O]x",&xO);
initialised = false;
}
UniformParameterPtr Program::resolveParameter(GpuProgramParameters::AutoConstantType autoType, size_t data)
{
UniformParameterPtr param;
// Check if parameter already exists.
param = getParameterByAutoType(autoType);
if (param)
{
return param;
}
// Create new parameter
size_t size = 0;
if(isArray(autoType)) std::swap(size, data); // for array autotypes the extra parameter is the size
param = UniformParameterPtr(OGRE_NEW UniformParameter(autoType, data, size));
addParameter(param);
return param;
}
void ATCommand::extractParameters()
{
// kdDebug() << "Arg String: " << cmdString() << endl;
int pos = cmdString().find("=");
if (pos < 0) return;
QString paraString = cmdString().mid(pos+1);
// kdDebug() << "Para String: " << paraString << endl;
QStringList paraList = QStringList::split(",",paraString);
QStringList::ConstIterator it = paraList.begin();
QStringList::ConstIterator end = paraList.end();
int argNum = 1;
while(it != end) {
addParameter(new ATParameter(*it,i18n("Arg %1").arg(QString::number(argNum++)),
false));
++it;
}
}
SliderTestsProc()
: cont {new parameter::ParamStep {"id", "name", 0, 10, 5, 0}},
step {new parameter::ParamStep {"id", "name", 0, 10, 5, 10}},
stepSizeParam {new parameter::ParamStepBroadcast {"sid", "sname", 0.01f, 3, 0.75, 0, 0}},
gainParam {new parameter::ParamStepListenGain {"gid", "gname", -10, 10, 1, 20, 0, *stepSizeParam}},
numFreqStepsParam {new parameter::ParamStepBroadcast {"sid", "sname", 1, 16, 4, 15, 0}},
freqParam {new parameter::ParamStepListenFreq {"gid", "gname", 20, 20000, 200, 0, 3, *numFreqStepsParam}}
{
addParameter (cont);
addParameter (step);
addParameter (stepSizeParam);
addParameter (gainParam);
addParameter (numFreqStepsParam);
addParameter (freqParam);
}
Pendants::Pendants(string name, int startAddress):Fixture(name, startAddress) {
mPanel->add(mDoUpdate.set("update", true));
mPanel->add(mOnTime.set("ontime", 0.2, 0.01, 0.5));
mPanel->add(mBrightness.set("brightness", 255, 0, 255));
for (int i = 0; i < 5; i++) {
auto param = make_shared<ofParameter<unsigned char>>("light" + ofToString(i+1), 0, 0, 255);
// param->addListener(this, &Pendants::paramChanged);
addParameter(param, i);
states.push_back(false);
offTimes.push_back(0);
onTimes.push_back(0);
auto h = make_shared<ofParameter<unsigned char>>("hits" + ofToString(i+1), 0, 0, 127);
h->addListener(this, &Pendants::hitChanged);
mPanel->add(*h.get());
hits.push_back(h);
}
mFixedAddress = true;
}
CExperiment * CExperimentSet::addExperiment(const CExperiment & experiment)
{
// We need to make sure that the experiment name is unique.
std::string name = experiment.getObjectName();
int i = 0;
while (getParameter(name))
{
i++;
name = StringPrint("%s_%d", experiment.getObjectName().c_str(), i);
}
CExperiment * pExperiment = new CExperiment(experiment, NO_PARENT);
pExperiment->setObjectName(name);
addParameter(pExperiment);
sort();
return pExperiment;
}
HelmPlugin::HelmPlugin() {
output_memory_ = new mopo::Memory(MAX_MEMORY_SAMPLES);
keyboard_state_ = new MidiKeyboardState();
midi_manager_ = new MidiManager(&synth_, keyboard_state_, &gui_state_, &getCallbackLock(), this);
set_state_time_ = 0;
current_program_ = 0;
num_programs_ = LoadSave::getNumPatches();
if (num_programs_ <= 0)
num_programs_ = 1;
Startup::doStartupChecks(midi_manager_);
controls_ = synth_.getControls();
for (auto control : controls_) {
ValueBridge* bridge = new ValueBridge(control.first, control.second);
bridge->setListener(this);
bridge_lookup_[control.first] = bridge;
addParameter(bridge);
}
}
MStatus PRTAttrs::addFloatParameter(MFnDependencyNode & node, MObject & attr, const MString & name, double value, double min, double max) {
MStatus stat;
MFnNumericAttribute nAttr;
attr = nAttr.create(longName(name), briefName(name), MFnNumericData::kDouble, value, &stat );
if ( stat != MS::kSuccess ) throw stat;
if(!isnan(min)) {
MCHECK(nAttr.setMin(min));
}
if(!isnan(max)) {
MCHECK(nAttr.setMax( max ));
}
MCHECK(addParameter(node, attr, nAttr));
MPlug plug(node.object(), attr);
MCHECK(plug.setValue(value));
return MS::kSuccess;
}
void Z3DAxis::initialize()
{
Z3DGeometryFilter::initialize();
m_arrowRenderer = new Z3DArrowRenderer();
m_arrowRenderer->setUseDisplayList(false);
m_arrowRenderer->setRespectRendererBaseCoordScales(false);
m_rendererBase->addRenderer(m_arrowRenderer);
m_lineRenderer = new Z3DLineRenderer();
m_lineRenderer->setUseDisplayList(false);
m_lineRenderer->setRespectRendererBaseCoordScales(false);
m_rendererBase->addRenderer(m_lineRenderer);
m_fontRenderer = new Z3DFontRenderer();
m_fontRenderer->setRespectRendererBaseCoordScales(false);
m_rendererBase->addRenderer(m_fontRenderer);
setupCamera();
std::vector<ZParameter*> paras = m_rendererBase->getParameters();
for (size_t i=0; i<paras.size(); i++) {
//connect(paras[i], SIGNAL(valueChanged()), this, SLOT(invalidateResult()));
addParameter(paras[i]);
}
}
QFFitFunctionGeneral2LogNormal::QFFitFunctionGeneral2LogNormal():
QFDistributionFitFunctionBase(1.0/2.3548, true)
{
// type, id, name, label (HTML), unit, unitlabel (HTML), fit, userEditable, userRangeEditable, displayError, initialFix, initialValue, minValue, maxValue, inc, absMin, absMax
addParameter(FloatNumber, "offset", "offset", "Y<sub>0</sub>", "", "", true, true, true, QFFitFunction::DisplayError, false, 0.0, -1e10, 1e10, 1 );
#define PARAM_OFFSET 0
addParameter(FloatNumber, "amplitude", "amplitude", "A<sub>1</sub>", "", "", true, true, true, QFFitFunction::DisplayError, false, 1.0, -1e10, 1e10, 1 );
#define PARAM_AMPLITUDE 1
addParameter(FloatNumber, "position", "position", "X<sub>1</sub>", "", "", true, true, true, QFFitFunction::DisplayError, false, 0, -1e10, 1e10, 1 );
#define PARAM_POSITION 2
addParameter(FloatNumber, "width", "1/sqrt(e) width", "σ<sub>1</sub>", "", "", true, true, true, QFFitFunction::DisplayError, false, 1, 1e-10, 1e10, 1 );
#define PARAM_WIDTH 3
addParameter(FloatNumber, "amplitude2", "amplitude 2", "A<sub>2</sub>", "", "", true, true, true, QFFitFunction::DisplayError, false, 0.5, -1e10, 1e10, 1 );
#define PARAM_AMPLITUDE2 4
addParameter(FloatNumber, "position2", "position 2", "X<sub>2</sub>", "", "", true, true, true, QFFitFunction::DisplayError, false, 2, -1e10, 1e10, 1 );
#define PARAM_POSITION2 5
addParameter(FloatNumber, "width2", "1/sqrt(e) width 2", "σ<sub>2</sub>", "", "", true, true, true, QFFitFunction::DisplayError, false, 1, -1e10, 1e10, 1 );
#define PARAM_WIDTH2 6
}
//-----------------------------------------------------------------------------
UniformParameterPtr Program::resolveParameter(GpuConstantType type,
int index, uint16 variability,
const String& suggestedName,
size_t size)
{
UniformParameterPtr param;
if (index == -1)
{
index = 0;
// Find the next available index of the target type.
UniformParameterIterator it;
for (it = mParameters.begin(); it != mParameters.end(); ++it)
{
if ((*it)->getType() == type &&
(*it)->isAutoConstantParameter() == false)
{
index++;
}
}
}
else
{
// Check if parameter already exists.
param = getParameterByType(type, index);
if (param.get() != NULL)
{
return param;
}
}
// Create new parameter.
param = ParameterFactory::createUniform(type, index, variability, suggestedName, size);
addParameter(param);
return param;
}
/**
* Constructs a new ScriptableSelfRegulatingNeuronActivationFunction.
*/
ScriptableSelfRegulatingNeuronActivationFunction::ScriptableSelfRegulatingNeuronActivationFunction()
: QObject(), SelfRegulatingNeuronActivationFunction("Script_SRN_V1", false), mEquationScript(0)
{
mTransmitterEquation = new StringValue("default");
mReceptorEquation = new StringValue("default");
mEtaEquation = new StringValue("default");
mXiEquation = new StringValue("default");
mThetaEquation = new StringValue("");
mEquationTester = new StringValue("");
mEquationTestOutput = new DoubleValue();
addParameter("Trans-Eq (eta,h)", mTransmitterEquation);
addParameter("Recept-Eq (xi,g)", mReceptorEquation);
addParameter("Eta-Eq", mEtaEquation);
addParameter("Xi-Eq", mXiEquation);
addParameter("Theta-Eq", mThetaEquation);
addParameter("Tester", mEquationTester);
addObservableOutput("TestOutput", mEquationTestOutput);
mTransmitterEquation->setDescription("2. Equation"
"\nVariables: alpha, beta, gamma, delta, theta, aStar, eta, xi, a, ap, x, y, z"
"\nFunctions: tf()"
"\n<default> recovers standard equation.");
mReceptorEquation->setDescription("1. Equation"
"\nVariables: alpha, beta, gamma, delta, theta, aStar, eta, xi, a, ap, x, y, z"
"\nFunctions: tf()"
"\n<default> recovers standard equation.");
mEtaEquation->setDescription("4. Equation"
"\nVariables: alpha, beta, gamma, delta, theta, aStar, eta, xi, a, ap, x, y, z, g, h"
"\nFunctions: tf()"
"\n<default> recovers standard equation.");
mXiEquation->setDescription("3. Equation"
"\nVariables: alpha, beta, gamma, delta, theta, aStar, eta, xi, a, ap, x, y, z, g, h"
"\nFunctions: tf()"
"\n<default> recovers standard equation.");
mThetaEquation->setDescription("An optional equation to update the neuron bias."
"\nVariables: alpha, beta, gamma, delta, theta, aStar, eta, xi, a, ap, x, y, z, g, h"
"\nFunctions: tf()");
mEquationTester->setDescription("Allows to test variables and equations on-the-fly. The result of this equation is passed "
"to the observable 'TestOutput\n"
"The testequation is calculated AFTER all other equations.\n"
"\nVariables: alpha, beta, gamma, delta, theta, aStar, eta, xi, a, ap, x, y, z, g, h"
"\nFunctions: tf()");
}
//-----------------------------------------------------------------------------
UniformParameterPtr Program::resolveAutoParameterInt(GpuProgramParameters::AutoConstantType autoType, GpuConstantType type,
size_t data, size_t size)
{
UniformParameterPtr param;
// Check if parameter already exists.
param = getParameterByAutoType(autoType);
if (param.get() != NULL)
{
if (param->isAutoConstantIntParameter() &&
param->getAutoConstantIntData() == data)
{
param->setSize(std::max(size, param->getSize()));
return param;
}
}
// Create new parameter.
param = UniformParameterPtr(OGRE_NEW UniformParameter(autoType, data, size, type));
addParameter(param);
return param;
}
bool getParameters(void)
{
bool bReturn = false;
ocString sql
= "select Id,Customer_Pmt_Service_Id,Pmt_Type_Param_Id,Machine_Name,Value "
"from Customer_Payment_Parameter where Customer_Pmt_Service_Id = ";
sql.append(Id);
if( rs.open(sql) )
{
bReturn = true;
do
{
addParameter();
} while(rs.next());
}
else
{
m_result += "Get Parameter Failed - sql: ";
m_result +=sql;
}
return bReturn;
}
ScriptParametersDialog::ScriptParametersDialog(QAbstractItemModel *completitionModel, ActionTools::Script *script, QWidget *parent)
: QDialog(parent),
ui(new Ui::ScriptParametersDialog),
mCodeEditorDialog(new ActionTools::CodeEditorDialog(completitionModel, this)),
mScript(script),
mCurrentParameter(-1),
mCurrentLine(-1),
mCurrentColumn(-1)
{
ui->setupUi(this);
ui->parameterTable->setColumnWidth(1, 250);
int parameterCount = script->parameterCount();
for(int parameterIndex = 0; parameterIndex < parameterCount; ++parameterIndex)
{
const ActionTools::ScriptParameter ¶meter = script->parameter(parameterIndex);
addParameter(parameter.name(), parameter.value(), parameter.isCode(), parameter.type());
}
on_addParameter_clicked();//Add an empty parameter at the end
}
CAdaptiveParameterBoundedValuesCalculator::CAdaptiveParameterBoundedValuesCalculator(CParameters *l_targetObject, string l_targetParameter, int functionKind, double paramOffset, double paramScale, double targetMin, double targetMax) : CAdaptiveParameterCalculator(l_targetObject, l_targetParameter, functionKind)
{
this->targetMin = targetMin;
this->targetMax = targetMax;
this->paramOffset = paramOffset;
this->paramScale = paramScale;
addParameter("APTargetMin", targetMin);
addParameter("APTargetMax", targetMax);
addParameter("APParamOffset", paramOffset);
addParameter("APParamScale", paramScale);
addParameter("APInvertTargetFunction", 0.0);
addParameter("APTargetScale", 1.0);
invertTarget = false;
targetScale = 1.0;
}
virtual void copy(ISecResource* from)
{
if(!from)
return;
CSecurityResource* _res = (CSecurityResource*)(from);
if(!_res)
return;
setDescription(_res->m_description.str());
setValue(_res->m_value.str());
setAccessFlags(_res->getAccessFlags());
if(!_res->m_parameters)
return;
Owned<IPropertyIterator> Itr = _res->m_parameters->getIterator();
Itr->first();
while(Itr->isValid())
{
addParameter(Itr->getPropKey(), _res->m_parameters->queryProp(Itr->getPropKey()));
Itr->next();
}
return;
}
/**
* Default constructor.
* @param "CModel *" pModel
*/
CSensProblem::CSensProblem(const CCopasiContainer * pParent):
CCopasiProblem(CCopasiTask::sens, pParent),
mpSubTaskType(NULL),
mpTargetFunctions(NULL),
mpVariablesGroup(NULL),
mpResultAnnotation(NULL),
mpScaledResultAnnotation(NULL),
mpCollapsedResultAnnotation(NULL)
{
addParameter("SubtaskType", CCopasiParameter::UINT, (unsigned C_INT32) 0);
mpSubTaskType = (CSensProblem::SubTaskType*)getValue("SubtaskType").pUINT;
//---------------------------------------------------
addGroup("TargetFunctions");
mpTargetFunctions = dynamic_cast<CCopasiParameterGroup*>(getParameter("TargetFunctions"));
createParametersInGroup(mpTargetFunctions);
//---------------------------------------------------
addGroup("ListOfVariables");
mpVariablesGroup = dynamic_cast<CCopasiParameterGroup*>(getParameter("ListOfVariables"));
//create a useful default problem
setSubTaskType(SteadyState);
CSensItem item;
item.setListType(CObjectLists::NON_CONST_METAB_CONCENTRATIONS);
changeTargetFunctions(item);
item.setListType(CObjectLists::ALL_PARAMETER_VALUES);
addVariables(item);
// initDebugProblem();
initObjects();
CONSTRUCTOR_TRACE;
}
LyapunovExponent::LyapunovExponent() : DynamicsPlotter("Lyapunov") {
// initialising
mVariedElement = new StringValue("0");
mVariedElement->setDescription("Specifies the element and parameter to vary in order "
"to simulate different initial conditions of the system");
mVariedRange = new StringValue("-1,1");
mVariedRange->setDescription("Parameter range to vary initial conditions in");
mResolutionX = new IntValue(400);
mResolutionX->setDescription("How many data points to generate for X axis");
mResolutionY = new IntValue(400);
mResolutionY->setDescription("How many data points to generate for Y axis");
mStepsPrePlot = new IntValue(0);
mStepsPrePlot->setDescription("Number of simulation steps that are computed "
"_before_ plotting!");
mStepsToPlot = new IntValue(100);
mStepsToPlot->setDescription("Number of simulation steps that are calculated and plotted");
mDrawNL = new BoolValue(true);
mDrawNL->setDescription("Draw a red line at y=0 for orientation");
addParameter("Config/VariedElement", mVariedElement, true);
addParameter("Config/VariedRange", mVariedRange, true);
addParameter("Config/ResolutionX", mResolutionX, true);
addParameter("Config/ResolutionY", mResolutionY, true);
addParameter("Config/StepsPrePlot", mStepsPrePlot, true);
addParameter("Config/StepsToPlot", mStepsToPlot, true);
addParameter("Config/DrawNL", mDrawNL, true);
mTitleNames->set("Lyapunov Exponent");
}
