//-----------------------------------------------------------------------------
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);
}
