//----------------------------------------------------------------------------- void MadShiftaNumberCircle::draw(DGGraphicsContext * inContext) { // draw the outer edge of the background circle CGContextRef cgContext = inContext->getPlatformGraphicsContext(); CGRect backgroundBounds = getBounds()->convertToCGRect( inContext->getPortHeight() ); CGContextAddEllipseInRect(cgContext, backgroundBounds); inContext->setFillColor(kControlFillColor_alt); inContext->endPath(); inContext->fillPath(); // draw the inner filling of the background circle inContext->beginPath(); inContext->setFillColor(kControlBackgroundColor); const CGFloat backgroundFrameWidth = 1.0f; CGRect fillBounds = CGRectInset(backgroundBounds, backgroundFrameWidth, backgroundFrameWidth); CGContextAddEllipseInRect(cgContext, fillBounds); inContext->endPath(); inContext->fillPath(); // draw the pie portion filling inContext->beginPath(); inContext->setFillColor(kControlFillColor); CGFloat centerX = fillBounds.origin.x + (fillBounds.size.width * 0.5); CGFloat centerY = fillBounds.origin.y + (fillBounds.size.height * 0.5); SInt32 min = GetControl32BitMinimum( getCarbonControl() ); SInt32 max = GetControl32BitMaximum( getCarbonControl() ); SInt32 val = GetControl32BitValue( getCarbonControl() ); if (val <= min) { inContext->setStrokeColor(kControlFillColor_alt); float linePosX = floorf(centerX) + 0.5f; // CoreGraphics lines are positioned between pixels rather than on them float lineStartY = fillBounds.origin.y; float lineEndY = roundf(centerY); inContext->drawLine(linePosX, lineStartY, linePosX, lineEndY, 1.0f); } else if (val >= max) { CGContextAddEllipseInRect(cgContext, fillBounds); inContext->fillPath(); } else { double paramValue_gen = getDfxGuiEditor()->getparameter_f( getParameterID() ); const CAAUParameter auParam = getAUVP(); paramValue_gen = AUParameterValueToLinear(paramValue_gen, &auParam); CGFloat radius = fillBounds.size.width * 0.5; CGFloat startAngle = 0.0; CGFloat angle = paramValue_gen * (kDFX_PI_d * 2.0); startAngle = kDFX_PI_d * 0.5; angle = kDFX_PI_d; CGContextAddArc(cgContext, centerX, centerY, radius, startAngle, angle + startAngle, 0); inContext->endPath(); inContext->fillPath(); inContext->beginPath(); if (paramValue_gen >= 0.5) { startAngle -= (paramValue_gen - 0.5) * (kDFX_PI_d * 2.0); CGContextAddArc(cgContext, centerX, centerY, radius, startAngle, angle + startAngle, 0); } else { inContext->setFillColor(kControlBackgroundColor); radius += backgroundFrameWidth; startAngle -= paramValue_gen * (kDFX_PI_d * 2.0); CGContextAddArc(cgContext, centerX, centerY, radius, startAngle, angle + startAngle, 0); } inContext->endPath(); inContext->fillPath(); } DGTextDisplay::draw(inContext); }
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); }