String AudioProcessor::getParameterName (int index, int maximumStringLength) { if (AudioProcessorParameter* p = managedParameters[index]) return p->getName (maximumStringLength); return getParameterName (index).substring (0, maximumStringLength); }
void OscController::parameterChanged(ofAbstractParameter & parameter){ string paramName = getParameterName(parameter); string address = getAddressByParamName(paramName); if(address == ""){ return; } ofxOscMessage msg; msg.setAddress(address); // NOTE: all parameters are sent as float args if(parameter.type()==typeid(ofParameter<int>).name()){ //msg.addFloatArg(parameter.cast<int>()); ofParameter<int> & p = parameter.cast<int>(); msg.addFloatArg( ofMap(p.get(), p.getMin(), p.getMax(), 0.0, 1.0) ); }else if(parameter.type()==typeid(ofParameter<float>).name()){ //msg.addFloatArg(parameter.cast<float>()); ofParameter<float> & p = parameter.cast<float>(); msg.addFloatArg( ofMap(p.get(), p.getMin(), p.getMax(), 0.0, 1.0) ); }else if(parameter.type()==typeid(ofParameter<bool>).name()){ msg.addFloatArg(parameter.cast<bool>()); } // send message // for (int i = 0; i < oscOut.size(); i++) { // oscOut[i]->sendMessage(msg); // } //senderTouchOSC.sendMessage(msg); senderVezer.sendMessage(msg); }
//============================================================================== void SuperSpreadAudioProcessor::getStateInformation (MemoryBlock& destData) { XmlElement xml("STATE"); for (int i=0; i<getNumParameters(); ++i) xml.setAttribute(getParameterName(i), getParameter(i)); copyXmlToBinary(xml, destData); }
//============================================================================== void LuftikusAudioProcessor::getStateInformation (MemoryBlock& destData) { XmlElement xml("LUFTIKUSDATA"); for (int i=0; i<getNumParameters(); ++i) xml.setAttribute(getParameterName(i).replace(" ", "_", false).replace(".", "-", false), getParameter(i)); xml.setAttribute("tooltips", showTooltips ? 1 : 0); copyXmlToBinary(xml, destData); }
void SuperSpreadAudioProcessor::setStateInformation (const void* data, int sizeInBytes) { ScopedPointer<XmlElement> xml(getXmlFromBinary(data, sizeInBytes)); if (xml != nullptr) { for (int i=0; i<getNumParameters(); ++i) setParameterNotifyingHost(i, static_cast<float> (xml->getDoubleAttribute(getParameterName(i), getParameter(i)))); } }
void LuftikusAudioProcessor::setStateInformation (const void* data, int sizeInBytes) { ScopedPointer<XmlElement> xml(getXmlFromBinary(data, sizeInBytes)); if (xml != nullptr) { for (int i=0; i<getNumParameters(); ++i) setParameterNotifyingHost(i, (float) xml->getDoubleAttribute(getParameterName(i).replace(" ", "_", false).replace(".", "-", false))); showTooltips = xml->getBoolAttribute("tooltips", true); } }
//============================================================================== void PitchedDelayAudioProcessor::getStateInformation (MemoryBlock& destData) { XmlElement xml("PitchedDelay"); for (int i=0; i<getNumParameters(); ++i) xml.setAttribute(getParameterName(i), getParameter(i)); xml.setAttribute("currenttab", jmax(0, currentTab)); xml.setAttribute("showtooltips", showTooltips ? 1 : 0); xml.setAttribute("extended", "1"); copyXmlToBinary(xml, destData); }
std::set< const CCopasiObject * > CReactionInterface::getDeletedParameters() const { std::set< const CCopasiObject * > ToBeDeleted; // We need to compare the current visible local parameter with the one stored // in the reaction. const CReaction * pReaction = dynamic_cast< CReaction *>(CCopasiRootContainer::getKeyFactory()->get(mReactionReferenceKey)); if (pReaction == NULL) return ToBeDeleted; if (pReaction->getFunction() == NULL) return ToBeDeleted; const CFunctionParameters & OriginalParameters = pReaction->getFunction()->getVariables(); size_t j, jmax = size(); size_t i, imax = OriginalParameters.size(); const CFunctionParameter * pParameter; for (i = 0; i < imax; ++i) { pParameter = OriginalParameters[i]; if (pParameter->getUsage() == CFunctionParameter::PARAMETER && pReaction->isLocalParameter(i)) { const std::string & Name = pParameter->getObjectName(); //find parameter with same name in current parameters for (j = 0; j < jmax; ++j) if (Name == getParameterName(j)) break; if (j < jmax && mIsLocal[j]) continue; // The old parameter is either not found or is no longer local, i.e., it needs to // be added to values to be deleted. ToBeDeleted.insert(pReaction->getParameters().getParameter(Name)); } } return ToBeDeleted; }
//------------------------------------------------------------------------------------------------------- VstIntPtr AudioEffect::dispatcher (VstInt32 opcode, VstInt32 index, VstIntPtr value, void* ptr, float opt) { VstIntPtr v = 0; switch (opcode) { case effOpen: open (); break; case effClose: close (); break; case effSetProgram: if (value < numPrograms) setProgram ((VstInt32)value); break; case effGetProgram: v = getProgram (); break; case effSetProgramName: setProgramName ((char*)ptr); break; case effGetProgramName: getProgramName ((char*)ptr); break; case effGetParamLabel: getParameterLabel (index, (char*)ptr); break; case effGetParamDisplay: getParameterDisplay (index, (char*)ptr); break; case effGetParamName: getParameterName (index, (char*)ptr); break; case effSetSampleRate: setSampleRate (opt); break; case effSetBlockSize: setBlockSize ((VstInt32)value); break; case effMainsChanged: if (!value) suspend (); else resume (); break; #if !VST_FORCE_DEPRECATED case effGetVu: v = (VstIntPtr)(getVu () * 32767.); break; #endif //---Editor------------ case effEditGetRect: if (editor) v = editor->getRect ((ERect**)ptr) ? 1 : 0; break; case effEditOpen: if (editor) v = editor->open (ptr) ? 1 : 0; break; case effEditClose: if (editor) editor->close (); break; case effEditIdle: if (editor) editor->idle (); break; #if (TARGET_API_MAC_CARBON && !VST_FORCE_DEPRECATED) case effEditDraw: if (editor) editor->draw ((ERect*)ptr); break; case effEditMouse: if (editor) v = editor->mouse (index, value); break; case effEditKey: if (editor) v = editor->key (value); break; case effEditTop: if (editor) editor->top (); break; case effEditSleep: if (editor) editor->sleep (); break; #endif case DECLARE_VST_DEPRECATED (effIdentify): v = CCONST ('N', 'v', 'E', 'f'); break; //---Persistence------- case effGetChunk: v = getChunk ((void**)ptr, index ? true : false); break; case effSetChunk: v = setChunk (ptr, (VstInt32)value, index ? true : false); break; } return v; }
//----------------------------------------------------------------------------- long AudioEffect::dispatcher(long opCode, long index, long value, void *ptr, float opt) { long v = 0; switch(opCode) { case effOpen: open(); break; case effClose: close(); break; case effSetProgram: if(value < numPrograms) setProgram(value); break; case effGetProgram: v = getProgram(); break; case effSetProgramName: setProgramName((char *)ptr); break; case effGetProgramName: getProgramName((char *)ptr); break; case effGetParamLabel: getParameterLabel(index, (char *)ptr); break; case effGetParamDisplay: getParameterDisplay(index, (char *)ptr); break; case effGetParamName: getParameterName(index, (char *)ptr); break; case effSetSampleRate: setSampleRate(opt); break; case effSetBlockSize: setBlockSize(value); break; case effMainsChanged: if(!value) suspend(); else resume(); break; case effGetVu: v = (long)(getVu() * 32767.); break; // editor case effEditGetRect: if(editor) v = editor->getRect((ERect **)ptr); break; case effEditOpen: if(editor) v = editor->open(ptr); break; case effEditClose: if(editor) editor->close(); break; case effEditIdle: if(editor) editor->idle(); break; #if MAC case effEditDraw: if(editor) editor->draw((ERect *)ptr); break; case effEditMouse: if(editor) v = editor->mouse(index, value); break; case effEditKey: if(editor) v = editor->key(value); break; case effEditTop: if(editor) editor->top(); break; case effEditSleep: if(editor) editor->sleep(); break; #endif // new case effIdentify: v = 'NvEf'; break; case effGetChunk: v = getChunk((void**)ptr, index ? true : false); break; case effSetChunk: v = setChunk(ptr, value, index ? true : false); break; } return v; }
void OscController::enableParameterSync(){ if(bParamenterSyncEnabled){ return; } bParamenterSyncEnabled = true; // we need this because a group can only have one parent // because the parent of this parameter might not be // the panel group, we need to find the current parent. // with multiple parents we could just have added the listener to the panel. // iterate through the stored controls for(map<string,ofxBaseGui*>::iterator it=controls.begin(); it!=controls.end(); ++it){ string controlName = it->first; ofxBaseGui* control = it->second; string oscAddress = getAddressByControlName(controlName); ofAbstractParameter& parameter = control->getParameter(); // if this control is mapped to an address, create a link between // the parameter name and the osc address if(oscAddress != ""){ string paramName = getParameterName(parameter); paramNameToAddress[paramName] = oscAddress; } // what is the last parent of this param? ofParameterGroup* lastParent = parameter.getParent(); while(lastParent->getParent()){ lastParent = lastParent->getParent(); } lastParents[ lastParent->getName() ] = lastParent; // use a map to store the lastParent of the parameter } // add listerner for(map<string,ofParameterGroup*>::iterator it=lastParents.begin(); it!=lastParents.end(); ++it){ ofParameterGroup* lastParent = it->second; cout << lastParent->getName() << endl; ofAddListener(lastParent->parameterChangedE, this, &OscController::parameterChanged); } }
void CReactionInterface::printDebug() const { std::cout << "Reaction interface " << std::endl; std::cout << " Function: " << getFunctionName() << std::endl; std::cout << " ChemEq: " << getChemEqString() << std::endl; size_t i, imax = size(); for (i = 0; i < imax; ++i) { std::cout << " --- " << i << ": " << getParameterName(i) << ", vector: " << isVector(i) << " local: " << isLocalValue(i) << ", value: " << mValues[i] << std::endl; size_t j, jmax = mNameMap[i].size(); for (j = 0; j < jmax; ++j) std::cout << " " << mNameMap[i][j] << std::endl; } std::cout << std::endl; }
void CParameterObject::parametersChanged() { std::list<paramPair>::iterator it = parameterObjects->begin(); for (;it != parameterObjects->end(); it ++) { string prefix = (*it).second; for (int i = 0; i < getNumParameters(); i++) { string paramName = getParameterName(i); double value = getParameter(paramName); if (prefix == paramName.substr(0, prefix.length())) { paramName = paramName.substr(prefix.length()); if ((*it).first->getParameterIndex(paramName) >= 0 && fabs((*it).first->getParameter(paramName) - value) > 0.00001) { (*it).first->setParameter(paramName, value); } } } } onParametersChanged(); }
String AudioProcessor::getParameterName (int parameterIndex, int maximumStringLength) { return getParameterName (parameterIndex).substring (0, maximumStringLength); }
plugMainUnion plugMain(DWORD functionCode, DWORD inputValue, DWORD instanceID) #endif { plugMainUnion retval; // declare pPlugObj - pointer to this instance CFreeFrameGLPlugin* pPlugObj; // typecast DWORD into pointer to a CFreeFrameGLPlugin pPlugObj = (CFreeFrameGLPlugin*) instanceID; switch (functionCode) { case FF_GETINFO: retval.PISvalue = (PluginInfoStruct*)getInfo(); break; case FF_INITIALISE: retval.ivalue = initialise(); break; case FF_DEINITIALISE: retval.ivalue = deInitialise(); break; case FF_GETNUMPARAMETERS: retval.ivalue = getNumParameters(); break; case FF_GETPARAMETERNAME: retval.svalue = getParameterName(inputValue); break; case FF_GETPARAMETERDEFAULT: retval.ivalue = getParameterDefault(inputValue); break; case FF_GETPLUGINCAPS: retval.ivalue = getPluginCaps(inputValue); break; case FF_GETEXTENDEDINFO: retval.ivalue = (DWORD) getExtendedInfo(); break; case FF_GETPARAMETERTYPE: retval.ivalue = getParameterType(inputValue); break; case FF_GETPARAMETERDISPLAY: if (pPlugObj != NULL) retval.svalue = pPlugObj->GetParameterDisplay(inputValue); else retval.svalue = (char*)FF_FAIL; break; case FF_SETPARAMETER: if (pPlugObj != NULL) retval.ivalue = pPlugObj->SetParameter((const SetParameterStruct*) inputValue); else retval.ivalue = FF_FAIL; break; case FF_GETPARAMETER: if (pPlugObj != NULL) retval.ivalue = pPlugObj->GetParameter(inputValue); else retval.ivalue = FF_FAIL; break; case FF_INSTANTIATEGL: retval.ivalue = (DWORD)instantiateGL((const FFGLViewportStruct *)inputValue); break; case FF_DEINSTANTIATEGL: if (pPlugObj != NULL) retval.ivalue = deInstantiateGL(pPlugObj); else retval.ivalue = FF_FAIL; break; case FF_GETIPUTSTATUS: if (pPlugObj != NULL) retval.ivalue = pPlugObj->GetInputStatus(inputValue); else retval.ivalue = FF_FAIL; break; case FF_PROCESSOPENGL: if (pPlugObj != NULL) { ProcessOpenGLStruct *pogls = (ProcessOpenGLStruct *)inputValue; if (pogls!=NULL) retval.ivalue = pPlugObj->ProcessOpenGL(pogls); else retval.ivalue = FF_FAIL; } else retval.ivalue = FF_FAIL; break; case FF_SETTIME: if (pPlugObj != NULL) { double *inputTime = (double *)inputValue; if (inputTime!=NULL) retval.ivalue = pPlugObj->SetTime(*inputTime); else retval.ivalue = FF_FAIL; } else retval.ivalue = FF_FAIL; break; //these old FF functions must always fail for FFGL plugins case FF_INSTANTIATE: case FF_DEINSTANTIATE: case FF_PROCESSFRAME: case FF_PROCESSFRAMECOPY: default: retval.ivalue = FF_FAIL; break; } return retval; }
void QFFCSMaxEntEvaluationItem::doFit(QFRawDataRecord* record, int index, int model, int defaultMinDatarange, int defaultMaxDatarange, int runAvgWidth, int residualHistogramBins) { bool doEmit=record->isEmitResultsChangedEnabled(); bool thisDoEmitResults=get_doEmitResultsChanged(); bool thisDoEmitProps=get_doEmitResultsChanged(); set_doEmitResultsChanged(false); set_doEmitPropertiesChanged(false); record->disableEmitResultsChanged(); //qDebug() << "START DEBUGGING 0: We enter the do fit Method with MODEL = " << model; /* IMPLEMENT THIS Ergebnisse koennen einfach mit einer der setFitResult... Methoden gespeichert werden: // PARAMETERNAME WERT setFitResultValueBool(record, index, model, "evaluation_completed", true); // PARAMETERNAME WERT FEHLER und EINHEIT (z.B. "ms") dazu setFitResultValue(record, index, model, "my_parameter", value, error, unit); */ // HERE IS A DUMMY IMPLEMENTATION THAT OUTPUTS A SIMPLE GAUSSIAN QFRDRFCSDataInterface* data=qobject_cast<QFRDRFCSDataInterface*>(record); if (data) { getProject()->getServices()->log_text(tr("running MaxEnt fit with model '%1' on raw data record '%2', run %3 ... \n").arg(getModelName(model)).arg(record->getName()).arg(index)); // which datapoints should we actually use? int rangeMinDatarange=0; int rangeMaxDatarange=data->getCorrelationN(); if (defaultMinDatarange>=0) rangeMinDatarange=defaultMinDatarange; if (defaultMaxDatarange>=0) rangeMaxDatarange=defaultMaxDatarange; getProject()->getServices()->log_text(tr(" - fit data range: %1...%2 (%3 datapoints)\n").arg(defaultMinDatarange).arg(defaultMaxDatarange).arg(defaultMaxDatarange-defaultMinDatarange)); uint32_t N=data->getCorrelationN(); double* taus=data->getCorrelationT(); double* distTaus=NULL;//(double*)qfCalloc(Ndist,sizeof(double)); double* distDs=NULL;//(double*)qfCalloc(Ndist,sizeof(double)); double* dist=NULL;//(double*)qfCalloc(Ndist,sizeof(double)); double* modelEval=(double*)qfMalloc(N*sizeof(double)); bool weightsOK=false; double* corrdata=data->getCorrelationMean(); if (index>=0) corrdata=data->getCorrelationRun(index); double* weights=allocWeights(&weightsOK, record, index); if (!weightsOK) getProject()->getServices()->log_warning(tr(" - weights have invalid values => setting all weights to 1\n")); //////////Load Algorithm Parameters //////////////////////////////////////////////// double alpha=getFitValue(record,index,model,"maxent_alpha"); int NumIter=getFitValue(record,index,model,"maxent_numiter"); uint32_t Ndist=getFitValue(record,index,model,"maxent_Ndist"); //////////////////////////////////////////////////////////////////////////////////// bool fitSuccess=false; //qDebug() << "DEBUG #1: alpha = " << alpha << " NumIter = " << NumIter << "Ndist =" << Ndist ; //////////Load Model Parameters////////////////////////////////////////////////////// //int parameter_count=getParameterCount(model); QVector<double> param_vector(getParameterCount(model)); switch(model) { // FCS 3D diffusion with triplet case 0: param_vector[0]=getFitValue(record,index,model,"trip_tau")*1e-6; param_vector[1]=getFitValue(record,index,model,"trip_theta"); param_vector[2]=getFitValue(record,index,model,"focus_struct_fac"); param_vector[3]=getFitValue(record,index,model,"offset"); break; // FCS 3D diffusion with 2 blinking components case 1: param_vector[0]=getFitValue(record,index,model,"trip_tau")*1e-6; param_vector[1]=getFitValue(record,index,model,"trip_theta"); param_vector[2]=getFitValue(record,index,model,"focus_struct_fac"); param_vector[3]=getFitValue(record,index,model,"dark_tau")*1e-6; param_vector[4]=getFitValue(record,index,model,"dark_theta"); param_vector[5]=getFitValue(record,index,model,"offset"); break; // FCS 2D diffusion with 2 blinking components case 2: param_vector[0]=getFitValue(record,index,model,"trip_tau")*1e-6; param_vector[1]=getFitValue(record,index,model,"trip_theta"); param_vector[2]=getFitValue(record,index,model,"dark_tau")*1e-6; param_vector[3]=getFitValue(record,index,model,"dark_theta"); param_vector[4]=getFitValue(record,index,model,"offset"); break; case 3: param_vector[0]=getFitValue(record,index,model,"A"); break; case 4: param_vector[0]=getFitValue(record,index,model,"tau_1")*1e-6; param_vector[1]=getFitValue(record,index,model,"tau_2")*1e-6; param_vector[2]=getFitValue(record,index,model,"focus_struct_fac"); param_vector[3]=getFitValue(record,index,model,"fraction"); param_vector[4]=getFitValue(record,index,model,"particle_number"); param_vector[5]=getFitValue(record,index,model,"offset"); break; case 5: //param_vector[0]=getFitValue(record,index,model,"maxent_wxy")*1e-3; param_vector[0]=getFitValue(record,index,model,"focus_height")*1e-3; param_vector[1]=getFitValue(record,index,model,"pixel_size")*1e-3; param_vector[2]=getFitValue(record,index,model,"offset"); break; case 6: param_vector[0]=getFitValue(record,index,model,"pixel_size")*1e-3; param_vector[1]=getFitValue(record,index,model,"offset"); break; } double *param_list=param_vector.data(); ////////////////////////////////////////////////////////////////////////////////////////////////// /* double kappa=getFitValue(record,index,model,"focus_struct_fac"); double tripTau=getFitValue(record,index,model,"trip_tau")*1e-6; double tripTheta=getFitValue(record,index,model,"trip_theta"); */ QVector<double> init_tau=getFitValueNumberArray(record, index, model, "maxent_tau"); QVector<double> init_dist=getFitValueNumberArray(record, index, model, "maxent_distribution"); //qDebug()<<init_tau; bool old_distribution=false; // default value if (init_tau.size()>0 && init_dist.size()>0) { Ndist=qMin(init_tau.size(), init_dist.size()); distTaus=(double*)qfCalloc(Ndist,sizeof(double)); dist=(double*)qfCalloc(Ndist,sizeof(double)); for (uint32_t i=0; i<Ndist; i++) { distTaus[i]=init_tau[i]; dist[i]=init_dist[i]; } old_distribution=true; //qDebug()<< "OLDDIST TRUE"; } else { distTaus=NULL; dist=NULL; old_distribution=false; //qDebug()<< "OLDDIST FALSE"; if (int64_t(Ndist)>(rangeMaxDatarange-rangeMinDatarange)) { Ndist=(rangeMaxDatarange-rangeMinDatarange); } } QElapsedTimer time; time.start(); ///////////////////////////////////////////////////////// /// MaxEnt Implementation /////////////////////////////// ///////////////////////////////////////////////////////// double tau_min=getFitValue(record,index,model,"maxent_taumin"); double tau_max=getFitValue(record,index,model,"maxent_taumax"); MaxEntB040::TauMode tau_mode= (MaxEntB040::TauMode)getFitValue(record,index,model,"maxent_taumode"); MaxEntB040 mem; mem.setData(taus,corrdata,weights,N,rangeMinDatarange,rangeMaxDatarange,Ndist,dist,distTaus, model,getParameterCount(model),param_list, getFitValue(record,index,model,"maxent_wxy")*1e-3, tau_mode, tau_min, tau_max); mem.run(alpha,NumIter,param_list,model,getParameterCount(model)); fitSuccess=true; if (old_distribution==false) { distTaus=(double*)qfCalloc(Ndist,sizeof(double)); dist=(double*)qfCalloc(Ndist,sizeof(double)); } mem.writeDistTaus(distTaus); mem.writeDistribution(dist); ///////////////////////////////////////////////////////// ///////////////////////////////////////////////////////// ///////////////////////////////////////////////////////// // reset all NAN to 0 for (unsigned int i=0; i<Ndist; i++) { double d=dist[i]; if (!QFFloatIsOK(dist[i])) dist[i]=0; //qDebug()<<distTaus[i]<<" ,\t"<<d<<" ,\t"<<dist[i]; } ////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////// /* // REPLACE THIS WITH THE ACTUAL MAXENT FIT!!! double T0=1e-4; double sigma=2e-5; double dSum=0; for (int i=rangeMinDatarange; i<rangeMaxDatarange; i++) { const double t=taus[i]; dist[i]=exp(-0.5*sqr(t-T0)/sqr(sigma)); dSum=dSum+dist[i]; } for (int i=rangeMinDatarange; i<rangeMaxDatarange; i++) { dist[i]=dist[i]/dSum; } fitSuccess=true; // FIT CODE COMPLETE */ // duration measurement double duration=double(time.elapsed())/1000.0; getProject()->getServices()->log_text(tr(" - fit completed after %1 msecs with result %2\n").arg(duration).arg(fitSuccess?tr("success"):tr("no convergence"))); distDs=(double*)qfCalloc(Ndist, sizeof(double)); if (model!=3) { const double wxy=getWXY(); for (uint32_t i=0; i<Ndist; i++) { distDs[i]=wxy*wxy/1000000.0/(4.0*distTaus[i]); } } else if (model==3) { const double q2=qfSqr(getDLSQ()); //qDebug()<<"q2="<<q2; for (uint32_t i=0; i<Ndist; i++) { distDs[i]=1.0/(q2*distTaus[i]); } } // now store the results: QString param,paramtau,paramD,parammem; setFitResultValueNumberArray(record, index, model, paramtau=param="maxent_tau", distTaus, Ndist, QString("seconds")); setFitResultGroup(record, index, model, param, tr("fit results")); setFitResultLabel(record, index, model, param, tr("MaxEnt distribution: lag times"), QString("MaxEnt distribution: lag times <i>τ</i>")); setFitResultSortPriority(record, index, model, param, true); setFitResultValueNumberArray(record, index, model, paramD=param="maxent_D", distDs, Ndist, QString("seconds")); setFitResultGroup(record, index, model, param, tr("fit results")); setFitResultLabel(record, index, model, param, tr("MaxEnt distribution: diffusion coefficients"), QString("MaxEnt distribution: diffusion coefficients <i>D</i>")); setFitResultSortPriority(record, index, model, param, true); setFitResultValueNumberArray(record, index, model, parammem=param="maxent_distribution", dist, Ndist); setFitResultGroup(record, index, model, param, tr("fit results")); setFitResultLabel(record, index, model, param, tr("MaxEnt distribution"), QString("MaxEnt distribution: <i>p(τ)</i>")); setFitResultSortPriority(record, index, model, param, true); setFitResultValueInt(record, index, model, param="maxent_taumode", tau_mode); setFitResultGroup(record, index, model, param, tr("fit results")); setFitResultLabel(record, index, model, param, tr("MaxEnt distribution: tau mode"), tr("MaxEnt distribution: tau mode")); setFitResultSortPriority(record, index, model, param, true); QFRawDataRecord::evaluationCompoundResult comp; comp.type=QFRawDataRecord::qfrdrctGraph1D; comp.metadata["logX"]=true; comp.metadata["logY"]=false; comp.metadata["labelX"]=tr("correlation time \\tau_D [s]"); comp.metadata["labelY"]=tr("MaxEnt distribution"); comp.label=tr("MaxEnt(tauD)"); comp.referencedResults<<paramtau<<parammem; record->resultsCompoundSet(getEvaluationResultID(index, model), "maxent_tau_curve", comp); comp.metadata["labelX"]=tr("diffusion coefficient D [{\\mu}m^2/s]"); comp.label=tr("MaxEnt(D)"); comp.referencedResults.clear(); comp.referencedResults<<paramD<<parammem; record->resultsCompoundSet(getEvaluationResultID(index, model), "maxent_d_curve", comp); if (tau_mode>2) { double wxy=getFitValue(record,index,model,"maxent_wxy")*1e-3; setFitResultValue(record, index, model, param="maxent_taumax", wxy*wxy/(4.0*distTaus[0]), QString("seconds")); setFitResultGroup(record, index, model, param, tr("fit results")); setFitResultLabel(record, index, model, param, tr("MaxEnt distribution: minimum distribution times"), QString("MaxEnt distribution: minimum distribution times <i>τ<sub>min</sub></i>")); setFitResultSortPriority(record, index, model, param, true); setFitResultValue(record, index, model, param="maxent_taumin", wxy*wxy/(4.0*distTaus[Ndist-1]), QString("seconds")); setFitResultGroup(record, index, model, param, tr("fit results")); setFitResultLabel(record, index, model, param, tr("MaxEnt distribution: maximum distribution times"), QString("MaxEnt distribution: maximum distribution times <i>τ<sub>max</sub></i>")); setFitResultSortPriority(record, index, model, param, true); } else { setFitResultValue(record, index, model, param="maxent_taumin", distTaus[0], QString("seconds")); setFitResultGroup(record, index, model, param, tr("fit results")); setFitResultLabel(record, index, model, param, tr("MaxEnt distribution: minimum distribution times"), QString("MaxEnt distribution: minimum distribution times <i>τ<sub>min</sub></i>")); setFitResultSortPriority(record, index, model, param, true); setFitResultValue(record, index, model, param="maxent_taumax", distTaus[Ndist-1], QString("seconds")); setFitResultGroup(record, index, model, param, tr("fit results")); setFitResultLabel(record, index, model, param, tr("MaxEnt distribution: maximum distribution times"), QString("MaxEnt distribution: maximum distribution times <i>τ<sub>max</sub></i>")); setFitResultSortPriority(record, index, model, param, true); } // save all the default values for all fit parameters as results. for (int i=0; i<getParameterCount(model); i++) { param=getParameterID(model, i); double value=getFitValue(record, index, model, param); //qDebug()<<"model param "<<i<<": "<<param<<" = "<<value; setFitResultValue(record, index, model, param, value, getParameterUnit(model, i, false)); setFitResultGroup(record, index, model, param, tr("fit results")); setFitResultLabel(record, index, model, param, getParameterName(model, i, false), getParameterName(model, i, true)); setFitResultSortPriority(record, index, model, param, true); //qDebug()<<"model param "<<i<<": "<<param<<" = "<< getFitValue(record, index, model, param)<<getParameterUnit(model, i, false); } // you can overwrite certain of these parameters using code like this: /*setFitResultValue(record, index, model, param="focus_struct_fac", getFitValue(record, index, model, param)); setFitResultGroup(record, index, model, param, tr("fit results")); setFitResultLabel(record, index, model, param, tr("focus structure factor"), QString("focus structure factor <i>γ</i>")); setFitResultSortPriority(record, index, model, param, true);*/ // store number of iterations ... you may also store more fit algorithm properties like this setFitResultValue(record, index, model, param="maxent_alpha", alpha); setFitResultGroup(record, index, model, param, tr("fit properties")); setFitResultLabel(record, index, model, param, tr("MaxEnt scaling parameter alpha"), tr("scaling parameter α")); setFitResultValueInt(record, index, model, param="maxent_iterations", ceil(getFitValue(record, index, model, param)+NumIter)); setFitResultGroup(record, index, model, param, tr("fit properties")); setFitResultLabel(record, index, model, param, tr("number of MaxEnt iterations"), tr("number of MaxEnt iterations")); setFitResultValueInt(record, index, model, param="maxent_numiter", NumIter); setFitResultGroup(record, index, model, param, tr("fit properties")); setFitResultLabel(record, index, model, param, tr("number of MaxEnt iterations in last run of algorithm"), tr("last MaxEnt iterations")); setFitResultValueString(record, index, model, param="used_model", getModelName(model)); setFitResultGroup(record, index, model, param, tr("fit properties")); setFitResultLabel(record, index, model, param, tr("used model name"), tr("used model name")); setFitResultValueInt(record, index, model, param="maxent_Ndist",Ndist); setFitResultGroup(record, index, model, param, tr("fit properties")); setFitResultLabel(record, index, model, param, tr("MaxEnt number of distribution points"), tr("MaxEnt number of distribution points")); setFitResultValueInt(record, index, model, param="used_model_id", model); setFitResultGroup(record, index, model, param, tr("fit properties")); setFitResultLabel(record, index, model, param, tr("used model id"), tr("used model id")); setFitResultValueInt(record, index, model, param="used_run", index); setFitResultGroup(record, index, model, param, tr("fit properties")); setFitResultLabel(record, index, model, param, tr("used run"), tr("used run")); setFitResultValue(record, index, model, param="runtime", duration, tr("seconds")); setFitResultGroup(record, index, model, param, tr("fit properties")); setFitResultLabel(record, index, model, param, tr("fit runtime"), tr("fit runtime")); setFitResultValueString(record, index, model, param="fitalg_message", tr("MaxEnt finished successfully after %1 iterations with alpha=%2").arg(NumIter).arg(alpha)); setFitResultGroup(record, index, model, param, tr("fit properties")); setFitResultLabel(record, index, model, param, tr("MaxEnt message"), tr("MaxEnt message")); setFitResultValueString(record, index, model, param="fitalg_messageHTML", tr("<b>MaxEnt finished successfully</b><br>after %1 iterations with α=%2").arg(NumIter).arg(alpha)); setFitResultGroup(record, index, model, param, tr("fit properties")); setFitResultLabel(record, index, model, param, tr("MaxEnt message"), tr("MaxEnt message")); // CALCULATE FIT STATISTICS // now we evaluate the model for the given distribution ///////////////////////// ///////////////////////// // I changed the 7th argument in the evaluateModel call from &(taus[rangeMindatarange]) to &(distTaus[rangeMinDatarange]) // this is what the 7th and 8th argument used to be like: &(distTaus[rangeMinDatarange]), &(dist[rangeMinDatarange]) // this was the last argument: rangeMaxDatarange-rangeMinDatarange, now changed to Ndist //////////////////////// evaluateModel(record, index, model, taus, modelEval, N, distTaus,dist,Ndist); // then we can call calcFitStatistics() QFFitStatistics fit_stat=calcFitStatistics(record, index, model, taus, corrdata, N,Ndist, rangeMinDatarange, rangeMaxDatarange, runAvgWidth, residualHistogramBins); // finally we have to free the memory allocated in the calcFitStatistics() result. fit_stat.free(); qfFree(dist); qfFree(weights); qfFree(modelEval); qfFree(distTaus); qfFree(distDs); } if (doEmit) record->enableEmitResultsChanged(true); set_doEmitResultsChanged(thisDoEmitResults); set_doEmitPropertiesChanged(thisDoEmitProps); }
plugMainUnion plugMain( DWORD functionCode, LPVOID pParam, LPVOID instanceID ) #endif { plugMainUnion retval; // declare pPlugObj - pointer to this instance WhorldPlug *pPlugObj; // typecast LPVOID into pointer to a WhorldPlug pPlugObj = (WhorldPlug*) instanceID; switch(functionCode) { case FF_GETINFO: retval.PISvalue = getInfo(); break; case FF_INITIALISE: retval.ivalue = initialise(); break; case FF_DEINITIALISE: retval.ivalue = deInitialise(); // todo: pass on instance IDs etc break; case FF_GETNUMPARAMETERS: retval.ivalue = getNumParameters(); break; case FF_GETPARAMETERNAME: retval.svalue = getParameterName( (DWORD) pParam ); break; case FF_GETPARAMETERDEFAULT: retval.fvalue = getParameterDefault( (DWORD) pParam ); break; case FF_GETPARAMETERDISPLAY: retval.svalue = pPlugObj->getParameterDisplay( (DWORD) pParam ); break; // parameters are passed in here as a packed struct of two DWORDS: // index and value case FF_SETPARAMETER: retval.ivalue= pPlugObj->setParameter( (SetParameterStruct*) pParam ); break; case FF_PROCESSFRAME: retval.ivalue = pPlugObj->processFrame(pParam); break; case FF_GETPARAMETER: retval.fvalue = pPlugObj->getParameter((DWORD) pParam); break; case FF_GETPLUGINCAPS: retval.ivalue = getPluginCaps( (DWORD) pParam); break; // Russell - FF 1.0 upgrade in progress ... case FF_INSTANTIATE: retval.ivalue = (DWORD) instantiate( (VideoInfoStruct*) pParam); break; case FF_DEINSTANTIATE: retval.ivalue = deInstantiate(pPlugObj); break; case FF_GETEXTENDEDINFO: retval.ivalue = (DWORD) getExtendedInfo(); break; case FF_PROCESSFRAMECOPY: retval.ivalue = pPlugObj->processFrameCopy((ProcessFrameCopyStruct*)pParam); break; case FF_GETPARAMETERTYPE: // not implemented yet retval.ivalue = FF_FAIL; break; // .................................... default: retval.ivalue = FF_FAIL; break; } return retval; }
int getOptModelParameterName(emb_optimizer optim, int name_idx, char par_name[], size_t maxlen, size_t *reqlen) { return getParameterName(myModel, name_idx, par_name, maxlen, reqlen); }
void CReactionInterface::copyMapping() { if (!mpParameters) //nothing to copy { initMapping(); return; } // save the old information CFunctionParameters *oldParameters = mpParameters; std::vector<std::vector<std::string> > oldMap = mNameMap; std::vector<C_FLOAT64> oldValues = mValues; std::vector<bool> oldIsLocal = mIsLocal; //create new mapping initMapping(); //try to preserve as much information from the old mapping as possible size_t j, jmax = oldParameters->size(); size_t i, imax = size(); for (i = 0; i < imax; ++i) { //find parameter with same name in old parameters for (j = 0; j < jmax; ++j) if ((*oldParameters)[j]->getObjectName() == getParameterName(i)) break; if (j == jmax) continue; //see if usage matches if (getUsage(i) != (*oldParameters)[j]->getUsage()) continue; //see if vector property matches if (isVector(i) != ((*oldParameters)[j]->getType() == CFunctionParameter::VFLOAT64)) continue; mIsLocal[i] = oldIsLocal[j]; mValues[i] = oldValues[j]; switch (getUsage(i)) { case CFunctionParameter::SUBSTRATE: case CFunctionParameter::PRODUCT: //TODO: check with chemeq mNameMap[i] = oldMap[j]; break; case CFunctionParameter::MODIFIER: //TODO: check existence? mNameMap[i] = oldMap[j]; //TODO: add to chemeq break; case CFunctionParameter::PARAMETER: case CFunctionParameter::VOLUME: case CFunctionParameter::TIME: //TODO: check existence? mNameMap[i] = oldMap[j]; break; default: break; } } pdelete(oldParameters); }
double CParameters::getParameterFromIndex(unsigned int index) { return getParameter(getParameterName(index)); }
bool CReactionInterface::writeBackToReaction(CReaction * rea) { bool success = true; //CReaction *rea; if (rea == NULL) rea = dynamic_cast< CReaction *>(CCopasiRootContainer::getKeyFactory()->get(mReactionReferenceKey)); if (rea == NULL) return false; // Now we can safely write to the equation as we are sure that only unique metabolites // may have the empty string as compartments mChemEqI.writeToChemEq(rea->getChemEq()); if (!isValid()) return false; // do nothing if (mpFunction == NULL) return false; if (mpFunction->getObjectName() == "undefined") return false; if (mpParameters == NULL) return false; if (!(*mpParameters == mpFunction->getVariables())) return false; // do nothing // TODO. check if function has changed since it was set in the R.I. rea->setFunction(mpFunction->getObjectName()); size_t j, jmax; size_t i, imax = size(); std::pair< std::string, std::string > Names; for (i = 0; i < imax; ++i) { switch (getUsage(i)) { case CFunctionParameter::PARAMETER: if (mIsLocal[i]) rea->setParameterValue(getParameterName(i), mValues[i]); else { rea->setParameterValue(getParameterName(i), mValues[i], false); rea->setParameterMapping(i, mpModel->getModelValues()[mNameMap[i][0]]->getKey()); } break; case CFunctionParameter::VOLUME: rea->setParameterMapping(i, mpModel->getCompartments()[mNameMap[i][0]]->getKey()); break; case CFunctionParameter::TIME: rea->setParameterMapping(i, mpModel->getKey()); //time is the value of the model break; case CFunctionParameter::SUBSTRATE: case CFunctionParameter::PRODUCT: case CFunctionParameter::MODIFIER: if (isVector(i)) { rea->clearParameterMapping(i); jmax = mNameMap[i].size(); for (j = 0; j < jmax; ++j) { Names = CMetabNameInterface::splitDisplayName(mNameMap[i][j]); rea->addParameterMapping(i, CMetabNameInterface::getMetaboliteKey(mpModel, Names.first, Names.second)); } } else { Names = CMetabNameInterface::splitDisplayName(mNameMap[i][0]); rea->setParameterMapping(i, CMetabNameInterface::getMetaboliteKey(mpModel, Names.first, Names.second)); } break; default: break; } } rea->compile(); mpModel->setCompileFlag(); //TODO: check if really necessary return success; }
bool CReactionInterface::loadMappingAndValues(const CReaction & rea) { bool success = true; std::vector< std::vector<std::string> >::const_iterator it; std::vector< std::vector<std::string> >::const_iterator iEnd; std::vector<std::string>::const_iterator jt; std::vector<std::string>::const_iterator jEnd; size_t i; std::string metabName; const CModelEntity* pObj; std::vector<std::string> SubList; SubList.resize(1); SubList[0] = "unknown"; mNameMap.resize(size()); for (i = 0; i != size(); ++i) { mNameMap[i] = SubList; } mValues.resize(size(), 0.1); mIsLocal.resize(size(), false); it = rea.getParameterMappings().begin(); iEnd = rea.getParameterMappings().end(); for (i = 0; it != iEnd; ++it, ++i) { if (isVector(i)) { assert((getUsage(i) == CFunctionParameter::SUBSTRATE) || (getUsage(i) == CFunctionParameter::PRODUCT) || (getUsage(i) == CFunctionParameter::MODIFIER)); SubList.clear(); for (jt = it->begin(), jEnd = it->end(); jt != jEnd; ++jt) { metabName = CMetabNameInterface::getDisplayName(mpModel, *jt, true); assert(metabName != ""); SubList.push_back(metabName); } } else { assert(it->size() == 1); SubList.resize(1); SubList[0] = "unknown"; switch (getUsage(i)) { case CFunctionParameter::SUBSTRATE: case CFunctionParameter::PRODUCT: case CFunctionParameter::MODIFIER: metabName = CMetabNameInterface::getDisplayName(mpModel, *(it->begin()), true); // assert(metabName != ""); SubList[0] = metabName; //TODO: check if the metabolite is in the chemical equation with the correct rule break; case CFunctionParameter::VOLUME: pObj = dynamic_cast<const CCompartment*>(CCopasiRootContainer::getKeyFactory()->get(*(it->begin()))); assert(pObj); SubList[0] = pObj->getObjectName(); break; case CFunctionParameter::TIME: pObj = dynamic_cast<const CModel*>(CCopasiRootContainer::getKeyFactory()->get(*(it->begin()))); assert(pObj); SubList[0] = pObj->getObjectName(); break; case CFunctionParameter::PARAMETER: { const CCopasiParameter * pParameter = rea.getParameters().getParameter(getParameterName(i)); if (pParameter != NULL) { mValues[i] = * pParameter->getValue().pDOUBLE; } else { mValues[i] = std::numeric_limits< C_FLOAT64 >::quiet_NaN(); } mIsLocal[i] = rea.isLocalParameter(i); if (!mIsLocal[i]) { pObj = dynamic_cast<const CModelValue*>(CCopasiRootContainer::getKeyFactory()->get(*(it->begin()))); if (pObj) { SubList[0] = pObj->getObjectName(); mValues[i] = pObj->getInitialValue(); } } } break; default: break; } } mNameMap[i] = SubList; } return success; }
void RemotePluginServer::dispatchControlEvents() { RemotePluginOpcode opcode = RemotePluginNoOpcode; static float *parameterBuffer = 0; tryRead(m_controlRequestFd, &opcode, sizeof(RemotePluginOpcode)); switch (opcode) { case RemotePluginGetVersion: writeFloat(m_controlResponseFd, getVersion()); break; case RemotePluginGetName: writeString(m_controlResponseFd, getName()); break; case RemotePluginGetMaker: writeString(m_controlResponseFd, getMaker()); break; case RemotePluginTerminate: terminate(); break; case RemotePluginGetInputCount: m_numInputs = getInputCount(); writeInt(m_controlResponseFd, m_numInputs); break; case RemotePluginGetOutputCount: m_numOutputs = getOutputCount(); writeInt(m_controlResponseFd, m_numOutputs); break; case RemotePluginGetParameterCount: writeInt(m_controlResponseFd, getParameterCount()); break; case RemotePluginGetParameterName: writeString(m_controlResponseFd, getParameterName(readInt(m_controlRequestFd))); break; case RemotePluginGetParameter: writeFloat(m_controlResponseFd, getParameter(readInt(m_controlRequestFd))); break; case RemotePluginGetParameterDefault: writeFloat(m_controlResponseFd, getParameterDefault(readInt(m_controlRequestFd))); break; case RemotePluginGetParameters: { if (!parameterBuffer) { parameterBuffer = new float[getParameterCount()]; } int p0 = readInt(m_controlRequestFd); int pn = readInt(m_controlRequestFd); getParameters(p0, pn, parameterBuffer); tryWrite(m_controlResponseFd, parameterBuffer, (pn - p0 + 1) * sizeof(float)); break; } case RemotePluginHasMIDIInput: { bool m = hasMIDIInput(); tryWrite(m_controlResponseFd, &m, sizeof(bool)); break; } case RemotePluginGetProgramCount: writeInt(m_controlResponseFd, getProgramCount()); break; case RemotePluginGetProgramName: writeString(m_controlResponseFd, getProgramName(readInt(m_controlRequestFd))); break; case RemotePluginIsReady: { if (!m_shm) sizeShm(); bool b(isReady()); std::cerr << "isReady: returning " << b << std::endl; tryWrite(m_controlResponseFd, &b, sizeof(bool)); } case RemotePluginSetDebugLevel: { RemotePluginDebugLevel newLevel = m_debugLevel; tryRead(m_controlRequestFd, &newLevel, sizeof(RemotePluginDebugLevel)); setDebugLevel(newLevel); m_debugLevel = newLevel; break; } case RemotePluginWarn: { bool b = warn(readString(m_controlRequestFd)); tryWrite(m_controlResponseFd, &b, sizeof(bool)); break; } case RemotePluginShowGUI: { showGUI(readString(m_controlRequestFd)); break; } case RemotePluginHideGUI: { hideGUI(); break; } //Deryabin Andrew: vst chunks support case RemotePluginGetVSTChunk: { std::vector<char> chunk = getVSTChunk(); writeRaw(m_controlResponseFd, chunk); break; } case RemotePluginSetVSTChunk: { std::vector<char> chunk = readRaw(m_controlRequestFd); setVSTChunk(chunk); break; } //Deryabin Andrew: vst chunks support: end code case RemotePluginNoOpcode: break; case RemotePluginReset: reset(); break; default: std::cerr << "WARNING: RemotePluginServer::dispatchControlEvents: unexpected opcode " << opcode << std::endl; } }
const String DemoJuceFilter::getParameterXMLName (int index) { String name = getParameterName(index); name = name.replace(T(" "), T("_")); return name; }