double QFUsesResultsEvaluation::getFitValue(const QFRawDataRecord *r, const QString &resultID, const QString ¶meterID) const {
//qDebug()<<"getFitValue("<<resultID<<", "<<parameterID<<")";
double res=0;
res=fitParamGlobalSettings->value(getParameterStoreIDInQSettings(parameterID), res).toDouble();
res=fitParamSettings->value(getParameterStoreIDInQSettings(parameterID), res).toDouble();
QFUsesResultsEvaluation::FitParameterDefault defVal;
if (getParameterDefault(r, resultID, parameterID, defVal)) {
res=defVal.value;
}
QString psID=getParameterStoreID(parameterID);
if (parameterStore.contains(psID)) {
if (parameterStore[psID].valueSet) {
res=parameterStore[psID].value;
}
}
double sval=res, serr=0;
if (hasSpecial(r, resultID, parameterID, sval, serr)) {
//qDebug()<<" - hasSpecial "<<sval;
res=sval;
}
if (r && hasResults(r, resultID)) {
QString tresultID=transformResultID(resultID);
QString pid=getFitParamID(parameterID);
//qDebug()<<" - hasResults "<<tresultID<<pid;
//qDebug()<<" "<<r->resultsCalcNames(tresultID);
if (r->resultsExists(tresultID, pid)) {
res=r->resultsGetAsDouble(tresultID, pid);
//qDebug()<<" - resultsExists "<<res;
}
}
//qDebug()<<" getFitValue("<<resultID<<", "<<parameterID<<") = "<<res;
return res;
}
std::unique_ptr<Cask::CdapOdbc::DataReader> Cask::CdapOdbc::QueryCommand::executeReader() {
if (this->queryHandle.size() == 0) {
this->queryHandle = this->getConnection()->getExploreClient().execute(this->query);
}
auto status = this->getConnection()->getExploreClient().getQueryStatus(this->queryHandle);
switch (status.getOperationStatus()) {
case OperationStatus::FINISHED:
this->hasData = status.hasResults();
break;
case OperationStatus::INITIALIZED:
case OperationStatus::PENDING:
case OperationStatus::RUNNING:
throw StillExecutingException("The query is still executing.");
case OperationStatus::UNKNOWN:
case OperationStatus::ERROR:
throw std::exception("An error occured during query execution.");
case OperationStatus::CANCELED:
throw std::exception("Query canceled.");
case OperationStatus::CLOSED:
throw std::exception("Query closed.");
}
return std::make_unique<QueryDataReader>(this);
}
Node *getBestCandidate( void )
{
if ( !hasResults() ) {
return nullptr;
}
return _candidates.front();
}
bool QFUsesResultsEvaluation::fitValueExists(QFRawDataRecord *r, const QString &resultID, const QString ¶meterID) const
{
if (r && hasResults(r, resultID)) {
QString tresultID=transformResultID(resultID);
QString pid=getFitParamID(parameterID);
if (r->resultsExists(tresultID, pid)) {
return true;
}
}
//qDebug()<<" getFitValue("<<resultID<<", "<<parameterID<<") = "<<res;
return false;
}
void QFUsesResultsEvaluation::setFitError(QFRawDataRecord *r, const QString &resultID, const QString ¶meterID, double error) {
if (r!=NULL) {
QString dsid=getParameterStoreID(parameterID);
if (hasResults(r, resultID)) {
setFitResultError(r, resultID, parameterID, error);
} else {
parameterStore[dsid].error=error;
parameterStore[dsid].errorSet=true;
//emitPropertiesChanged();
project->setDataChanged();
}
}
}
void QFUsesResultsEvaluation::setFitFix(QFRawDataRecord *r, const QString &resultID, const QString ¶meterID, bool fix) {
if (r!=NULL) {
QString dsid=getParameterStoreID(parameterID);
if (hasResults(r, resultID)) {
setFitResultFix(r, resultID, parameterID, fix);
} else {
parameterStore[dsid].fix=fix;
parameterStore[dsid].fixSet=true;
//emitPropertiesChanged();
project->setDataChanged();
}
}
}
void QFUsesResultsEvaluation::setFitValue(QFRawDataRecord *r, const QString &resultID, const QString ¶meterID, double value, const QString& unit) {
if (r!=NULL) {
QString dsid=getParameterStoreID(parameterID);
if (hasResults(r, resultID)) {
setFitResultValue(r, resultID, parameterID, value, getFitError(r, resultID, parameterID), unit);
} else {
parameterStore[getParameterStoreID(parameterID)].value=value;
parameterStore[getParameterStoreID(parameterID)].valueSet=true;
//emitPropertiesChanged();
project->setDataChanged();
}
}
}
QVector<double> QFUsesResultsEvaluation::getFitValueErrorArray(const QFRawDataRecord *r, const QString &resultID, const QString ¶meterID) const {
QVector<double> res;
if (r) {
QFUsesResultsEvaluation::FitParameterDefault defVal;
if (getParameterDefault(r, resultID, parameterID, defVal)) {
res=defVal.errorVector;
}
if (hasResults(r, resultID)) {
QString tresultID=transformResultID(resultID);
QString pid=getFitParamID(parameterID);
if (r->resultsExists(tresultID, pid)) res=r->resultsGetErrorAsDoubleList(tresultID, pid);
}
}
return res;
}
bool QFUsesResultsEvaluation::getFitFix(const QFRawDataRecord *r, const QString &resultID, const QString ¶meterID) const {
bool res=false;
res=fitParamGlobalSettings->value(getParameterStoreIDInQSettings(parameterID)+"_fix", res).toBool();
res=fitParamSettings->value(getParameterStoreIDInQSettings(parameterID)+"_fix", res).toBool();
QFUsesResultsEvaluation::FitParameterDefault defVal;
if (getParameterDefault(r, resultID, parameterID, defVal)) {
res=defVal.fix;
}
QString psID=getParameterStoreID(parameterID);
if (parameterStore.contains(psID)) {
if (parameterStore[psID].fixSet) {
res=parameterStore[psID].fix;
}
}
if (r && hasResults(r, resultID)) {
QString en=transformResultID(resultID);
QString pid=getFitParamFixID(parameterID);
if (r->resultsExists(en, pid)) res=r->resultsGetAsDouble(en, pid);
}
return res;
}
QFFitStatistics QFFCSMaxEntEvaluationItem::calcFitStatistics(QFRawDataRecord *record, int index, int model, double *taus, double* modelValsIn, uint32_t N, uint32_t MaxEntParams, int datacut_min, int datacut_max, int runAvgWidth, int residualHistogramBins) {
QFRDRFCSDataInterface* data=qobject_cast<QFRDRFCSDataInterface*>(record);
if (data) {
double* corrdata=data->getCorrelationMean();
if (index>=0) corrdata=data->getCorrelationRun(index);
double* modelVals=modelValsIn;
bool freeModelVals=false;
if (!modelVals) {
modelVals=(double*)qfMalloc(N*sizeof(double));
QVector<double> dist=getDistribution(record, index, model);
QVector<double> distTau=getDistributionTaus(record, index, model);
evaluateModel(record, index, model, taus, modelVals, N, distTau.data(), dist.data(), dist.size());
freeModelVals=true;
}
//double* modelVals=(double*)qfMalloc(N*sizeof(double));
//
//(record, index, model, taus, modelVals, N);
double* weights=allocWeights(NULL, record, index);
QFFitStatistics result= calculateFitStatistics(N, taus, modelVals, corrdata, weights, datacut_min, datacut_max, MaxEntParams, runAvgWidth, residualHistogramBins);
if (record) {
if (hasResults(record, index)) {
setFitResultFitStatistics(record, index, model, result, "fitstat_", tr("fit statistics"));
}
}
qfFree(weights);
if (freeModelVals) qfFree(modelVals);
return result;
}
return QFFitStatistics();
}
double QFUsesResultsEvaluation::getFitError(const QFRawDataRecord *r, const QString &resultID, const QString ¶meterID) const {
double sval=0, serr=0;
if (hasResults(r, resultID)) {
if (r!=NULL) {
return r->resultsGetErrorAsDouble(transformResultID(resultID), getFitParamID(parameterID));
}
}
if (hasSpecial(r, resultID, parameterID, sval, serr)) {
return serr;
}
QString psID=getParameterStoreID(parameterID);
if (parameterStore.contains(psID)) {
if (parameterStore[psID].errorSet) {
return parameterStore[psID].error;
}
}
QFUsesResultsEvaluation::FitParameterDefault defVal;
if (getParameterDefault(r, resultID, parameterID, defVal)) {
return defVal.error;
}
return 0.0;
}
bool QFUsesResultsEvaluation::hasResults() const {
return hasResults(getHighlightedRecord());
}
bool QFUsesResultsEvaluation::hasResults(const QFRawDataRecord *r1) const {
return hasResults(r1, getEvaluationResultID());
}
