From 2434b2a176f6b11aff0adda11ac9c7fe544ff061 Mon Sep 17 00:00:00 2001 From: wanglong <1553009806@qq.com> Date: Tue, 4 Jun 2024 15:27:02 +0800 Subject: [PATCH] Initial commit on main branch --- AbstractSpectrumDataMessage.cpp | 330 ++ AbstractSpectrumDataMessage.h | 35 + AlertMessage.cpp | 86 + AlertMessage.h | 26 + BgWork.cpp | 1528 +++++++ BgWork.h | 126 + BgWorkDef.h | 407 ++ CplusToJava.cpp | 217 + CplusToJava.h | 388 ++ DataManager_Define.h | 707 ++++ Fit.cpp | 222 + Fit.h | 126 + FitDef.h | 12 + MDC.cpp | 371 ++ MDC.h | 43 + MDCDef.h | 38 + MeteorologicalMessage.cpp | 84 + MeteorologicalMessage.h | 28 + ProcessAlgorithmGlobalVar.cpp | 54 + ProcessAlgorithmGlobalVar.h | 25 + ROI.cpp | 281 ++ ROI.h | 91 + ROIConUncer.cpp | 143 + ROIConUncer.h | 38 + ROIConUncerDef.h | 33 + ROIDef.h | 73 + RadionuclideMessage.cpp | 985 +++++ RadionuclideMessage.h | 57 + ReadPHDFile.pri | 6 + ReadPHDFile.pro | 94 + ReadPHDFile.pro.user | 337 ++ StateOfHealthMessage.cpp | 521 +++ StateOfHealthMessage.h | 40 + XeConUncer.cpp | 107 + XeConUncer.h | 31 + XeConUncerDef.h | 22 + common.pri | 19 + ...dules_native_jni_EnergySpectrumHandler.cpp | 3747 +++++++++++++++++ ...modules_native_jni_EnergySpectrumHandler.h | 116 + 39 files changed, 11594 insertions(+) create mode 100644 AbstractSpectrumDataMessage.cpp create mode 100644 AbstractSpectrumDataMessage.h create mode 100644 AlertMessage.cpp create mode 100644 AlertMessage.h create mode 100644 BgWork.cpp create mode 100644 BgWork.h create mode 100644 BgWorkDef.h create mode 100644 CplusToJava.cpp create mode 100644 CplusToJava.h create mode 100644 DataManager_Define.h create mode 100644 Fit.cpp create mode 100644 Fit.h create mode 100644 FitDef.h create mode 100644 MDC.cpp create mode 100644 MDC.h create mode 100644 MDCDef.h create mode 100644 MeteorologicalMessage.cpp create mode 100644 MeteorologicalMessage.h create mode 100644 ProcessAlgorithmGlobalVar.cpp create mode 100644 ProcessAlgorithmGlobalVar.h create mode 100644 ROI.cpp create mode 100644 ROI.h create mode 100644 ROIConUncer.cpp create mode 100644 ROIConUncer.h create mode 100644 ROIConUncerDef.h create mode 100644 ROIDef.h create mode 100644 RadionuclideMessage.cpp create mode 100644 RadionuclideMessage.h create mode 100644 ReadPHDFile.pri create mode 100644 ReadPHDFile.pro create mode 100644 ReadPHDFile.pro.user create mode 100644 StateOfHealthMessage.cpp create mode 100644 StateOfHealthMessage.h create mode 100644 XeConUncer.cpp create mode 100644 XeConUncer.h create mode 100644 XeConUncerDef.h create mode 100644 common.pri create mode 100644 org_jeecg_modules_native_jni_EnergySpectrumHandler.cpp create mode 100644 org_jeecg_modules_native_jni_EnergySpectrumHandler.h diff --git a/AbstractSpectrumDataMessage.cpp b/AbstractSpectrumDataMessage.cpp new file mode 100644 index 0000000..5849f16 --- /dev/null +++ b/AbstractSpectrumDataMessage.cpp @@ -0,0 +1,330 @@ +#include "AbstractSpectrumDataMessage.h" +#include + +AbstractSpectrumDataMessage::AbstractSpectrumDataMessage() +{ + msg_items.append( "MSG_TYPE" ); // [0] + msg_items.append( "MSG_ID" ); // [1] + msg_items.append( "REF_ID" ); // [2] + msg_items.append( "PROD_ID" ); // [3] + msg_items.append( "DATA_TYPE" ); // [4] + + data_types.append( "SAMPLEPHD" ); // [0] + data_types.append( "SPHDF" ); // [1] + data_types.append( "SPHDP" ); // [2] + data_types.append( "GASBKPHD" ); // [3] + data_types.append( "BLANKPHD" ); // [4] + data_types.append( "DETBKPHD" ); // [5] + data_types.append( "QCPHD" ); // [6] + data_types.append( "CALIBPHD" ); // [7] + data_types.append( "MET" ); // [8] + data_types.append( "RMSSOH" ); // [9] + data_types.append( "ALERT_FLOW" ); // [10] + data_types.append( "ALERT_SYSTEM" ); // [11] + data_types.append( "ALERT_TEMP" ); // [12] + data_types.append( "ALERT_UPS" ); // [13] + + msg.verify_srid = false; +} + +AbstractSpectrumDataMessage::~AbstractSpectrumDataMessage() +{ + +} + +QString AbstractSpectrumDataMessage::GetSpectrumDataTypeFromFile(QString data_file) +{ + QString ret_string; + + QFile file(data_file); + if ( file.open(QIODevice::ReadOnly | QIODevice::Text) ) + { + QTextStream content(&file); + if (!content.atEnd()) + { + if ( AnalyseMessgeInfo(content, true) ) + { + ret_string = msg.data_type; + if ( QLatin1String("SPHDP")==ret_string || QLatin1String("SPHDF")==ret_string ) + { + ret_string = QLatin1String("SAMPLEPHD"); + msg.data_type = ret_string; + } + } + } + } + file.close(); + return ret_string; +} + +QString AbstractSpectrumDataMessage::GetSpectrumDataTypeFromMessage(QString data_msg) +{ + QString ret_string; + + QTextStream content(&data_msg, QIODevice::ReadOnly); + if (!content.atEnd()) + { + if ( AnalyseMessgeInfo(content, true) ) + { + ret_string = msg.msg_type; + if ( QLatin1String("SPHDP")==ret_string && QLatin1String("SPHDF")==ret_string ) + { + ret_string = QLatin1String("SAMPLEPHD"); + } + } + } + return ret_string; +} + +bool AbstractSpectrumDataMessage::AnalyseFile(QString file_name) +{ + bool bRet = true; + QFile file(file_name); + if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) + { + return bRet &= false; + } + + QTextStream content(&file); + if (content.atEnd()) + { + file.close(); + return bRet &= false; + } + + bRet &= AnalyseMessgeInfo(content); + /* + if (bRet) + { + bRet &= AnalyseMessgeBody(content); + } + */ + file.close(); + /* + if ( bRet && msg.verify_srid ) + { + ChangeOriginalFile(file_name); + } + */ + return bRet; +} + +bool AbstractSpectrumDataMessage::AnalyseMsg(QString &msg_string) +{ + bool bRet = true; + QTextStream content(&msg_string, QIODevice::ReadOnly); + if (content.atEnd()) + { + return bRet &= false; + } + + bRet &= AnalyseMessgeInfo(content); + /* + if (bRet) + { + bRet &= AnalyseMessgeBody(content); + } + */ + return bRet; +} + +const MessageInfo &AbstractSpectrumDataMessage::GetMessageInfo() +{ + return msg; +} + +void AbstractSpectrumDataMessage::ClearData() +{ + msg.data_type.clear(); + msg.msg_id.clear(); + msg.msg_type.clear(); + msg.verify_srid = false; +} + +bool AbstractSpectrumDataMessage::AnalyseMessgeInfo(QTextStream &content, bool only_analyse_msg) +{ + bool bRet = true; + QString item_text = content.readLine(); + if ( 0!=item_text.left(5).compare(QLatin1String("BEGIN")) && + 0!=item_text.mid(6).compare(QLatin1String("IMS2.0")) ) + { + bRet &= false; //消息头的协议标示不对，消息无效 + return bRet; + } + + QString line = content.readLine(); + while (bRet) + { + QTextStream line_stream(&line); + line_stream >> item_text; + if ( 0==item_text.compare(msg_items.at(0)) && bRet ) //MSG_TYPE + { + line_stream >> msg.msg_type; + if ( msg.msg_type!=(QLatin1String("DATA")) ) + { + bRet &= false; //消息类型不是指定的“DATA”类型，消息过滤 + break; + } + line = content.readLine(); + } + else if ( 0==item_text.compare(msg_items.at(1)) && bRet ) //MSG_ID + { + for (int i=0; !line_stream.atEnd(); ++i) + { + if ( 0==i ) + { + line_stream >> msg.msg_id; + } + else if (1==i) + { + line_stream >> msg.msg_src_code; + } + } + line = content.readLine(); + } + else if ( 0==item_text.compare(msg_items.at(2)) && bRet ) //REF_ID + { + QString ref_id_after = line_stream.readLine(); + QTextStream ref_id_after_stream(&ref_id_after); + for (int i=0; !ref_id_after_stream.atEnd(); ++i) + { + QString temp; + ref_id_after_stream >> temp; + if (0==i) + { + msg.ref_id_str = temp; + } + else if (1==i) + { + msg.ref_src_code = temp; + } + else if (2==i) + { + msg.seq_num = temp; + } + else if (3==i) + { + msg.tot_num = temp; + } + } + msg.verify_srid = true; + line = content.readLine(); + } + else if ( 0==item_text.compare(msg_items.at(3)) && bRet ) //PROD_ID + { + line_stream >> msg.product_id >> msg.delivery_id; + msg.verify_srid = true; + line = content.readLine(); + } + else if ( 0==item_text.compare(msg_items.at(4)) && bRet ) //DATA_TYPE + { + line_stream >> msg.data_type; + if ( data_types.contains(msg.data_type) && bRet ) + { + if ( !only_analyse_msg ) + { + bRet &= AnalyseMessgeBody(content); + } + return bRet; + } + else + { + line = content.readLine(); + QTextStream data_line_stream(&line); + data_line_stream >> item_text; + while (!msg_items.contains(item_text) && !content.atEnd()) + { + line = content.readLine(); + QTextStream line_stream(&line); + line_stream >> item_text; + } + msg.verify_srid = true; + } + } + else + { + //bRet = false; + // bRet不置为false，表示针对消息头的有效检查持宽容态度，允许跟文件协议有能接受的出入 + break; + } + + if ( content.atEnd() || (content.status()!=QTextStream::Ok) ) + { + bRet = false; + ClearData(); + break; + } + } + + return bRet; +} + +void AbstractSpectrumDataMessage::SetMsgDataType(QString data_type) +{ + msg.data_type = data_type; +} + +void AbstractSpectrumDataMessage::ChangeOriginalFile(QString file_name) +{ + QFile file(file_name); + if (file.open(QIODevice::ReadOnly | QIODevice::Text)) + { + QString temp_file_name = file_name + QLatin1String(".temp"); + QFile temp_file(temp_file_name); + if (!temp_file.open(QIODevice::WriteOnly | QIODevice::Text)) + { + QString error = file.errorString(); + return; + } + QTextStream in(&file); + QTextStream out(&temp_file); + + bool bInBody = true; + QString line = in.readLine(); + while ( !in.atEnd() && (in.status()==QTextStream::Ok) ) + { + QString item_text; + QTextStream line_stream(&line); + line_stream >> item_text; + if ( 0==item_text.compare(msg_items.at(4)) && bInBody ) //DATA_TYPE + { + QString data_type; + line_stream >> data_type; + if ( data_types.contains(data_type) && bInBody ) + { + bInBody = false; + } + else + { + line = in.readLine(); + QTextStream data_line_stream(&line); + data_line_stream >> item_text; + while (!msg_items.contains(item_text) && !in.atEnd()) + { + line = in.readLine(); + QTextStream line_stream(&line); + line_stream >> item_text; + } + } + } + else if ( 0==item_text.compare(msg_items.at(2)) && bInBody ) //REF_ID + { + line = in.readLine(); + } + else if ( 0==item_text.compare(msg_items.at(3)) && bInBody ) //PROD_ID + { + line = in.readLine(); + } + else + { + out << line << "\n"; + line = in.readLine(); + } + } + temp_file.close(); + file.close(); + + QFile::remove(file_name); + QFile::rename(temp_file_name, file_name); + } +} diff --git a/AbstractSpectrumDataMessage.h b/AbstractSpectrumDataMessage.h new file mode 100644 index 0000000..bb6e583 --- /dev/null +++ b/AbstractSpectrumDataMessage.h @@ -0,0 +1,35 @@ +#ifndef ABSTRACTSPECTRUMDATAMESSAGE_H +#define ABSTRACTSPECTRUMDATAMESSAGE_H + +#include "DataManager_Define.h" +#include +#include + +class AbstractSpectrumDataMessage +{ +public: + explicit AbstractSpectrumDataMessage(); + ~AbstractSpectrumDataMessage(); + + QString GetSpectrumDataTypeFromFile(QString data_file); + QString GetSpectrumDataTypeFromMessage(QString data_msg); + bool AnalyseFile(QString file_name); + bool AnalyseMsg(QString &msg_string); + virtual bool IsValid(){return false;} + virtual const MessageInfo& GetMessageInfo(); + virtual void ClearData(); + +protected: + virtual bool AnalyseMessgeInfo(QTextStream& content, bool only_analyse_msg=false); + virtual bool AnalyseMessgeBody(QTextStream& content){ Q_UNUSED(content);return false;} + void SetMsgDataType(QString data_type); + void ChangeOriginalFile(QString file_name); + +private: + MessageInfo msg; + QStringList msg_items; + QStringList data_types; +}; + + +#endif // ABSTRACTSPECTRUMDATAMESSAGE_H diff --git a/AlertMessage.cpp b/AlertMessage.cpp new file mode 100644 index 0000000..33e522a --- /dev/null +++ b/AlertMessage.cpp @@ -0,0 +1,86 @@ +#include "AlertMessage.h" +#include + +using namespace AlertData; + +AlertMessage::AlertMessage() +{ +} + +AlertMessage::~AlertMessage() +{ +} + +bool AlertMessage::IsValid() +{ + return bIsValid; +} + +const AlertsInfo& AlertMessage::GetAlertsInfo() +{ + return alerts_info; +} + +void AlertMessage::ClearData() +{ + bIsValid = false; + + alerts_info.station_code.clear(); + alerts_info.alert_type.clear(); + alerts_info.date.clear(); + alerts_info.time.clear(); + alerts_info.desc.clear(); + + AbstractSpectrumDataMessage::ClearData(); +} + +bool AlertMessage::AnalyseMessgeBody(QTextStream &content) +{ + const MessageInfo& msg = AbstractSpectrumDataMessage::GetMessageInfo(); + if ( QLatin1String("ALERT_FLOW") != msg.data_type && + QLatin1String("ALERT_SYSTEM") != msg.data_type && + QLatin1String("ALERT_TEMP") != msg.data_type && + QLatin1String("ALERT_UPS") != msg.data_type ) + { + return bIsValid = false; + } + content >> alerts_info.station_code >> alerts_info.alert_type >> alerts_info.date >> alerts_info.time; + do + { + QString line = content.readLine(); + if ( 0==line.compare(QLatin1String("STOP")) ) + { + bIsValid = true; //检测到“STOP line”，消息完整，数据有效 + break; + } + else if (content.atEnd()) + { + bIsValid = false; + alerts_info.alert_type.clear(); + alerts_info.date.clear(); + alerts_info.desc.clear(); + alerts_info.station_code.clear(); + alerts_info.time.clear(); + break; + } + else + { + // QString desc_row = QLatin1String("\n") + line; + QString desc_row; + if(alerts_info.desc.isEmpty()) + { + desc_row = line; + } + else + { + desc_row = QLatin1String("\n") + line; + } + + alerts_info.desc.append(desc_row); + } + } + while( !content.atEnd() ); + + return bIsValid; +} + diff --git a/AlertMessage.h b/AlertMessage.h new file mode 100644 index 0000000..78cb495 --- /dev/null +++ b/AlertMessage.h @@ -0,0 +1,26 @@ +#ifndef ALERTMESSAGE_H +#define ALERTMESSAGE_H + +#include "AbstractSpectrumDataMessage.h" +#include "DataManager_Define.h" +#include + +class AlertMessage : public AbstractSpectrumDataMessage +{ +public: + explicit AlertMessage(); + ~AlertMessage(); + + virtual bool IsValid(); + const AlertData::AlertsInfo& GetAlertsInfo(); + virtual void ClearData(); + +private: + bool AnalyseMessgeBody(QTextStream& content); + +private: + bool bIsValid; + AlertData::AlertsInfo alerts_info; +}; + +#endif // ALERTMESSAGE_H diff --git a/BgWork.cpp b/BgWork.cpp new file mode 100644 index 0000000..169c008 --- /dev/null +++ b/BgWork.cpp @@ -0,0 +1,1528 @@ +#include "BgWork.h" +#include +#include "ROI.h" +#include "Fit.h" +#include "QDateTime" +#include "ROIConUncer.h" +#include "XeConUncer.h" +#include "MDC.h" +#include +#include +#include +#include +#define STRING_END QLatin1String("\r\n") +using namespace RadionuclideData; +const double CBgWork::cst_fixed_volXe=0.0; +const double CBgWork::cst_defvolXe=1.1; // Value substituted when Xe volume read as below 0.1 ml - warning issued. +bool CBgWork::m_initAlgorithm=false; + +CBgWork::CBgWork() +{ + m_lastError=E_NONE; +} + +CBgWork::CBgWork(BgFileI& _fileHanle) +{ + m_flag_read_file = SetPara(_fileHanle); +} +CBgWork::~CBgWork() +{ + ; +} + +void CBgWork::SetBgFile(BgFileI &_fileHanle) +{ + m_flag_read_file = SetPara(_fileHanle); +} +BgAllGenerate CBgWork::GetAllValue() +{ + return m_allGenerate; +} +BgUINeed CBgWork::GetUIValue() +{ + return m_uiNeed; +} +BgErrorType CBgWork::GetLastError() +{ + return m_lastError; +} + +BgSample CBgWork::GetSampleUseData() +{ + return m_sampleData; +} +BgGas CBgWork::GetGasUseData() +{ + return m_gasData; +} + +BgDetbgr CBgWork::GetDetbgrUseData() +{ + return m_detbgrData; +} + +void CBgWork::RenameAnalyseFile(BgFileI& _fileHanle) +{ + m_flag_read_file = SetPara(_fileHanle); +} +bool CBgWork::MutialAnalyse(BgCalibratePara& _BgCalPara) +{ + if(!m_flag_read_file) + { + return false; + } + bool bRet = false; + m_bgCalPara = _BgCalPara; + bRet = Analyse(); + m_bgCalPara.bApplyNewCalicDetBg=false; + m_bgCalPara.bApplyNewCalicGasBg=false; + m_bgCalPara.bApplyNewCalicSample=false; + return bRet; +} +bool CBgWork::GetFileFittingPara(QVector& _watch_x,QVector &_watch_y,QVector &_fittingPara) +{ + double vari=0; + bool bRet= false; + switch (global::fit_type) + { + case liner: + bRet = CFit::LinearFit(_watch_x,_watch_y,_fittingPara,vari); + break; + case poly2: + bRet = CFit::_2PloynimialFit(_watch_y,_watch_x,_fittingPara,vari); + break; + case poly3: + bRet = CFit::_3PloynimialFit(_watch_x,_watch_y,_fittingPara,vari); + break; + case gauss: + bRet = CFit::GaussFit(_watch_x,_watch_y,_fittingPara,vari); + break; + case _default: + bRet = CFit::_2PloynimialFit(_watch_y,_watch_x,_fittingPara,vari); + break; + default: + break; + } + return bRet; +} +bool CBgWork::GetFileFittingData(QVector& _watch,QVector &_fittingPara,QVector& _rData) +{ + bool bRet= false; + switch (global::fit_type) + { + case liner: + bRet = CFit::LinearFitEquation(_watch,_fittingPara,_rData); + break; + case poly2: + bRet = CFit::_2PloynimialFitEquation(_watch,_fittingPara,_rData); + break; + case poly3: + bRet = CFit::_3PloynimialFitEquation(_watch,_fittingPara,_rData); + break; + case gauss: + bRet = CFit::GaussFitEquation(_watch,_fittingPara,_rData); + break; + case _default: + bRet = CFit::_2PloynimialFitEquation(_watch,_fittingPara,_rData); + break; + default: + break; + } + return bRet; +} +bool CBgWork::GetFileFittingData(QVector& _watch,QVector &_fittingPara,QVector& _rData) +{ + bool bRet= false; + switch (global::fit_type) + { + case liner: + bRet = CFit::LinearFitEquation(_watch,_fittingPara,_rData); + break; + case poly2: + bRet = CFit::_2PloynimialFitEquation(_watch,_fittingPara,_rData); + break; + case poly3: + bRet = CFit::_3PloynimialFitEquation(_watch,_fittingPara,_rData); + break; + case gauss: + bRet = CFit::GaussFitEquation(_watch,_fittingPara,_rData); + break; + case _default: + bRet = CFit::_2PloynimialFitEquation(_watch,_fittingPara,_rData); + break; + default: + break; + } + return bRet; +} +bool CBgWork::GetFittingPara(QVector& _watch_x,QVector &_watch_y,FitType _fittype,QVector &_fittingPara) +{ + double vari=0; + bool bRet= false; + switch (_fittype) + { + case liner: + bRet = CFit::LinearFit(_watch_x,_watch_y,_fittingPara,vari); + break; + case poly2: + bRet = CFit::_2PloynimialFit(_watch_y,_watch_x,_fittingPara,vari); + break; + case poly3: + bRet = CFit::_3PloynimialFit(_watch_x,_watch_y,_fittingPara,vari); + break; + case gauss: + bRet = CFit::GaussFit(_watch_x,_watch_y,_fittingPara,vari); + break; + case _default: + bRet = CFit::_2PloynimialFit(_watch_y,_watch_x,_fittingPara,vari); + break; + + default: + break; + } + return bRet; +} +bool CBgWork::GetFittingData(QVector& _watch,FitType _fittype,QVector &_fittingPara,QVector& _rData) +{ + bool bRet= false; + switch (_fittype) + { + case liner: + bRet = CFit::LinearFitEquation(_watch,_fittingPara,_rData); + break; + case poly2: + bRet = CFit::_2PloynimialFitEquation(_watch,_fittingPara,_rData); + break; + case poly3: + bRet = CFit::_3PloynimialFitEquation(_watch,_fittingPara,_rData); + break; + case gauss: + bRet = CFit::GaussFitEquation(_watch,_fittingPara,_rData); + break; + case _default: + bRet = CFit::_2PloynimialFitEquation(_watch,_fittingPara,_rData); + break; + default: + break; + } + return bRet; +} +bool CBgWork::GetFittingData(QVector& _watch,FitType _fittype,QVector &_fittingPara,QVector& _rData) +{ + bool bRet= false; + switch (_fittype) + { + case liner: + bRet = CFit::LinearFitEquation(_watch,_fittingPara,_rData); + break; + case poly2: + bRet = CFit::_2PloynimialFitEquation(_watch,_fittingPara,_rData); + break; + case poly3: + bRet = CFit::_3PloynimialFitEquation(_watch,_fittingPara,_rData); + break; + case gauss: + bRet = CFit::GaussFitEquation(_watch,_fittingPara,_rData); + break; + case _default: + bRet = CFit::_2PloynimialFitEquation(_watch,_fittingPara,_rData); + break; + default: + break; + } + return bRet; +} +double CBgWork::CaculateXeActivity(QVector&_watch_x,QVector&_watch_y,const double& _lamadaXe,const double& _acqRealTime,QVector &_fittingPara,int _fittingType) +{ + QVector fittingPara; + double vari=0; + bool bRet = false; + double rData=0; + int pos=0; + switch (_fittingType) + { + case liner: + bRet = CFit::LinearFit(_watch_x,_watch_y,fittingPara,vari); + if(fittingPara.size()>1) + { + pos = 1; + } + break; + case poly2: + bRet = CFit::_2PloynimialFit(_watch_y,_watch_x,fittingPara,vari); + if(fittingPara.size()>0) + { + pos=0; + } + break; + case poly3: + bRet = CFit::_3PloynimialFit(_watch_x,_watch_y,fittingPara,vari); + break; + case gauss: + bRet = CFit::GaussFit(_watch_x,_watch_y,fittingPara,vari); + break; + case _default: + bRet = CFit::_2PloynimialFit(_watch_y,_watch_x,fittingPara,vari); + if(fittingPara.size()>0) + { + pos=0; + } + break; + default: + break; + } + if(!bRet) + { + + } + else + { + rData = fittingPara.at(pos)*(_lamadaXe*_acqRealTime)/(1-qExp(-_lamadaXe*_acqRealTime)); + _fittingPara = fittingPara; + } + return rData; +} +QString CBgWork::GetFittingDescriptionByType(int _type) +{ + QString rData; + switch (_type) { + case liner: + rData = QLatin1String("LinearFitEquation :y = int(_fit_para[0]*_watch_x[n..]+_fit_para[1])"); + break; + case poly2: + rData = QLatin1String("_2PloynimialFitEquation :y = int(_fit_para[0]+_fit_para[1]*_watch_x[n..]+_fit_para[2]*_watch_x[n..]*_watch_x[n..]+0.5)"); + break; + case poly3: + rData = QLatin1String("_3PloynimialFitEquation"); + break; + case gauss: + rData = QLatin1String("GaussFitEquation"); + break; + case _default: + rData = QLatin1String("_2PloynimialFitEquation :y = int(_fit_para[0]+_fit_para[1]*_watch_x[n..]+_fit_para[2]*_watch_x[n..]*_watch_x[n..]+0.5)"); + break; + default: + break; + } + return rData; +} +QString CBgWork::GetFittingEquation(int _type) +{ + QString rData; + switch (_type) { + case liner: + rData = QLatin1String("(?1)+(?2)*x"); + break; + case poly2: + rData = QLatin1String("(?1)+(?2)*x+(?3)x*x"); + break; + case poly3: + rData = QLatin1String("_3PloynimialFitEquation"); + break; + case gauss: + rData = QLatin1String("GaussFitEquation"); + break; + case _default: + rData = QLatin1String("(?1)+(?2)*x+(?3)x*x"); + break; + default: + break; + } + return rData; +} + +bool CBgWork::CalcBgBoundary(BgROILimit& _roi_limit,BgEC& _b_g_e_c,BgCalibratePara& _BgCalPara,BgBoundary& _output,BgFittingPara& _fittingPara) +{ + bool bRet=true; + QVector b_e_cal=_BgCalPara.b_e_cal;//b_系数 + QVector b_cal_e; + double vari; //误差 + double variEC; + + if(_BgCalPara.b_e_cal_flag == _default) + { + _BgCalPara.b_e_cal_flag = global::fit_type; + } + switch (_BgCalPara.b_e_cal_flag) + { + case liner: + if(b_e_cal.isEmpty()) + { + bRet = CFit::LinearFit(_b_g_e_c.b_e_c.channel,_b_g_e_c.b_e_c.energy,b_e_cal,vari); + CFit::LinearFit(_b_g_e_c.b_e_c.energy,_b_g_e_c.b_e_c.channel,b_cal_e,variEC); + if(!bRet) + { + return false; + } + } + bRet = CFit::LinearFitEquation(_roi_limit.ROI_B_start_x1,b_e_cal,_output.ROI_B_Boundary_start); + if(!bRet) + { + return false; + } + bRet = CFit::LinearFitEquation(_roi_limit.ROI_B_stop_x2,b_e_cal,_output.ROI_B_Boundary_stop); + if(!bRet) + { + return false; + } + break; + case poly2: + if(b_e_cal.isEmpty()) + { + bRet = CFit::_2PloynimialFit(_b_g_e_c.b_e_c.channel,_b_g_e_c.b_e_c.energy,b_e_cal,vari); + CFit::_2PloynimialFit(_b_g_e_c.b_e_c.energy,_b_g_e_c.b_e_c.channel,b_cal_e,variEC); + if(!bRet) + { + return false; + } + } + bRet = CFit::_2PloynimialFitEquation(_roi_limit.ROI_B_start_x1,b_e_cal,_output.ROI_B_Boundary_start); + if(!bRet) + { + return false; + } + bRet = CFit::_2PloynimialFitEquation(_roi_limit.ROI_B_stop_x2,b_e_cal,_output.ROI_B_Boundary_stop); + if(!bRet) + { + return false; + } + break; + case poly3: + if(b_e_cal.isEmpty()) + { + bRet = CFit::_3PloynimialFit(_b_g_e_c.b_e_c.channel,_b_g_e_c.b_e_c.energy,b_e_cal,vari); + CFit::_3PloynimialFit(_b_g_e_c.b_e_c.energy,_b_g_e_c.b_e_c.channel,b_cal_e,variEC); + if(!bRet) + { + return false; + } + } + bRet = CFit::_3PloynimialFitEquation(_roi_limit.ROI_B_start_x1,b_e_cal,_output.ROI_B_Boundary_start); + if(!bRet) + { + return false; + } + bRet = CFit::_3PloynimialFitEquation(_roi_limit.ROI_B_stop_x2,b_e_cal,_output.ROI_B_Boundary_stop); + if(!bRet) + { + return false; + } + break; + case gauss: + if(b_e_cal.isEmpty()) + { + bRet = CFit::GaussFit(_b_g_e_c.b_e_c.channel,_b_g_e_c.b_e_c.energy,b_e_cal,vari); + CFit::GaussFit(_b_g_e_c.b_e_c.energy,_b_g_e_c.b_e_c.channel,b_cal_e,variEC); + if(!bRet) + { + return false; + } + } + bRet = CFit::GaussFitEquation(_roi_limit.ROI_B_start_x1,b_e_cal,_output.ROI_B_Boundary_start); + if(!bRet) + { + return false; + } + bRet = CFit::GaussFitEquation(_roi_limit.ROI_B_stop_x2,b_e_cal,_output.ROI_B_Boundary_stop); + if(!bRet) + { + return false; + } + break; + default: + if(b_e_cal.isEmpty()) + { + bRet = CFit::_2PloynimialFit(_b_g_e_c.b_e_c.channel,_b_g_e_c.b_e_c.energy,b_e_cal,vari); + CFit::_2PloynimialFit(_b_g_e_c.b_e_c.energy,_b_g_e_c.b_e_c.channel,b_cal_e,variEC); + if(!bRet) + { + return false; + } + } + bRet = CFit::_2PloynimialFitEquation(_roi_limit.ROI_B_start_x1,b_e_cal,_output.ROI_B_Boundary_start); + if(!bRet) + { + return false; + } + bRet = CFit::_2PloynimialFitEquation(_roi_limit.ROI_B_stop_x2,b_e_cal,_output.ROI_B_Boundary_stop); + if(!bRet) + { + return false; + } + break; + } + + _fittingPara.b_fitting_type = _BgCalPara.b_e_cal_flag; + _fittingPara.b_fitting_e_c = b_e_cal; + _fittingPara.b_fitting_c_e = b_cal_e; + //g_能 刻度方程系数计算 + QVector g_e_cal=_BgCalPara.g_e_cal;//g_系数 + QVector g_cal_e; + if(_BgCalPara.g_e_cal_flag == _default) + { + _BgCalPara.g_e_cal_flag = global::fit_type; + } + switch (_BgCalPara.g_e_cal_flag) + { + case liner: + if(g_e_cal.isEmpty()) + { + bRet = CFit::LinearFit(_b_g_e_c.g_e_c.channel,_b_g_e_c.g_e_c.energy,g_e_cal,vari); + CFit::LinearFit(_b_g_e_c.g_e_c.energy,_b_g_e_c.g_e_c.channel,g_cal_e,vari); + if(!bRet) + { + return false; + } + } + bRet = CFit::LinearFitEquation(_roi_limit.ROI_G_start_y1,g_e_cal,_output.ROI_G_Boundary_start); + if(!bRet) + { + return false; + } + bRet = CFit::LinearFitEquation(_roi_limit.ROI_G_stop_y2,g_e_cal,_output.ROI_G_Boundary_stop); + if(!bRet) + { + return false; + } + break; + case poly2: + if(g_e_cal.isEmpty()) + { + bRet = CFit::_2PloynimialFit(_b_g_e_c.g_e_c.channel,_b_g_e_c.g_e_c.energy,g_e_cal,vari); + CFit::_2PloynimialFit(_b_g_e_c.g_e_c.energy,_b_g_e_c.g_e_c.channel,g_cal_e,vari); + if(!bRet) + { + return false; + } + } + bRet = CFit::_2PloynimialFitEquation(_roi_limit.ROI_G_start_y1,g_e_cal,_output.ROI_G_Boundary_start); + if(!bRet) + { + return false; + } + bRet = CFit::_2PloynimialFitEquation(_roi_limit.ROI_G_stop_y2,g_e_cal,_output.ROI_G_Boundary_stop); + if(!bRet) + { + return false; + } + break; + case poly3: + if(g_e_cal.isEmpty()) + { + bRet = CFit::_3PloynimialFit(_b_g_e_c.g_e_c.channel,_b_g_e_c.g_e_c.energy,g_e_cal,vari); + CFit::_3PloynimialFit(_b_g_e_c.g_e_c.energy,_b_g_e_c.g_e_c.channel,g_cal_e,vari); + if(!bRet) + { + return false; + } + } + bRet = CFit::_3PloynimialFitEquation(_roi_limit.ROI_G_start_y1,g_e_cal,_output.ROI_G_Boundary_start); + if(!bRet) + { + return false; + } + bRet = CFit::_3PloynimialFitEquation(_roi_limit.ROI_G_stop_y2,g_e_cal,_output.ROI_G_Boundary_stop); + if(!bRet) + { + return false; + } + break; + case gauss: + if(g_e_cal.isEmpty()) + { + bRet = CFit::GaussFit(_b_g_e_c.g_e_c.channel,_b_g_e_c.g_e_c.energy,g_e_cal,vari); + CFit::GaussFit(_b_g_e_c.g_e_c.energy,_b_g_e_c.g_e_c.channel,g_cal_e,vari); + if(!bRet) + { + return false; + } + } + bRet = CFit::GaussFitEquation(_roi_limit.ROI_G_start_y1,g_e_cal,_output.ROI_G_Boundary_start); + if(!bRet) + { + return false; + } + bRet = CFit::GaussFitEquation(_roi_limit.ROI_G_stop_y2,g_e_cal,_output.ROI_G_Boundary_stop); + if(!bRet) + { + return false; + } + break; + default: + if(g_e_cal.isEmpty()) + { + bRet = CFit::_2PloynimialFit(_b_g_e_c.g_e_c.channel,_b_g_e_c.g_e_c.energy,g_e_cal,vari); + CFit::_2PloynimialFit(_b_g_e_c.g_e_c.energy,_b_g_e_c.g_e_c.channel,g_cal_e,vari); + if(!bRet) + { + return false; + } + + } + bRet = CFit::_2PloynimialFitEquation(_roi_limit.ROI_G_start_y1,g_e_cal,_output.ROI_G_Boundary_start); + if(!bRet) + { + return false; + } + bRet = CFit::_2PloynimialFitEquation(_roi_limit.ROI_G_stop_y2,g_e_cal,_output.ROI_G_Boundary_stop); + if(!bRet) + { + return false; + } + break; + } + _fittingPara.g_fitting_type = _BgCalPara.g_e_cal_flag; + _fittingPara.g_fitting_e_c = g_e_cal; + _fittingPara.g_fitting_c_e = g_cal_e; + return bRet; +} + +bool CBgWork::CalcBgBoundary(BgROILimit& _roi_limit,BgEC& _b_g_e_c,BgCalibratePara& _BgCalPara,BgBoundary& _output) +{ + bool bRet=true; + QVector b_e_cal=_BgCalPara.b_e_cal;//b_系数 + double vari; //误差 + + if(_BgCalPara.b_e_cal_flag == _default) + { + _BgCalPara.b_e_cal_flag = global::fit_type; + } + switch (_BgCalPara.b_e_cal_flag) + { + case liner: + if(b_e_cal.isEmpty()) + { + bRet = CFit::LinearFit(_b_g_e_c.b_e_c.channel,_b_g_e_c.b_e_c.energy,b_e_cal,vari); + if(!bRet) + { + return false; + } + } + bRet = CFit::LinearFitEquation(_roi_limit.ROI_B_start_x1,b_e_cal,_output.ROI_B_Boundary_start); + if(!bRet) + { + return false; + } + bRet = CFit::LinearFitEquation(_roi_limit.ROI_B_stop_x2,b_e_cal,_output.ROI_B_Boundary_stop); + if(!bRet) + { + return false; + } + break; + case poly2: + if(b_e_cal.isEmpty()) + { + bRet = CFit::_2PloynimialFit(_b_g_e_c.b_e_c.channel,_b_g_e_c.b_e_c.energy,b_e_cal,vari); + if(!bRet) + { + return false; + } + } + bRet = CFit::_2PloynimialFitEquation(_roi_limit.ROI_B_start_x1,b_e_cal,_output.ROI_B_Boundary_start); + if(!bRet) + { + return false; + } + bRet = CFit::_2PloynimialFitEquation(_roi_limit.ROI_B_stop_x2,b_e_cal,_output.ROI_B_Boundary_stop); + if(!bRet) + { + return false; + } + break; + case poly3: + if(b_e_cal.isEmpty()) + { + bRet = CFit::_3PloynimialFit(_b_g_e_c.b_e_c.channel,_b_g_e_c.b_e_c.energy,b_e_cal,vari); + if(!bRet) + { + return false; + } + } + bRet = CFit::_3PloynimialFitEquation(_roi_limit.ROI_B_start_x1,b_e_cal,_output.ROI_B_Boundary_start); + if(!bRet) + { + return false; + } + bRet = CFit::_3PloynimialFitEquation(_roi_limit.ROI_B_stop_x2,b_e_cal,_output.ROI_B_Boundary_stop); + if(!bRet) + { + return false; + } + break; + case gauss: + if(b_e_cal.isEmpty()) + { + bRet = CFit::GaussFit(_b_g_e_c.b_e_c.channel,_b_g_e_c.b_e_c.energy,b_e_cal,vari); + if(!bRet) + { + return false; + } + } + bRet = CFit::GaussFitEquation(_roi_limit.ROI_B_start_x1,b_e_cal,_output.ROI_B_Boundary_start); + if(!bRet) + { + return false; + } + bRet = CFit::GaussFitEquation(_roi_limit.ROI_B_stop_x2,b_e_cal,_output.ROI_B_Boundary_stop); + if(!bRet) + { + return false; + } + break; + default: + if(b_e_cal.isEmpty()) + { + bRet = CFit::_2PloynimialFit(_b_g_e_c.b_e_c.channel,_b_g_e_c.b_e_c.energy,b_e_cal,vari); + if(!bRet) + { + return false; + } + } + bRet = CFit::_2PloynimialFitEquation(_roi_limit.ROI_B_start_x1,b_e_cal,_output.ROI_B_Boundary_start); + if(!bRet) + { + return false; + } + bRet = CFit::_2PloynimialFitEquation(_roi_limit.ROI_B_stop_x2,b_e_cal,_output.ROI_B_Boundary_stop); + if(!bRet) + { + return false; + } + break; + } + + + //g_能 刻度方程系数计算 + QVector g_e_cal=_BgCalPara.g_e_cal;//g_系数 + if(_BgCalPara.g_e_cal_flag == _default) + { + _BgCalPara.g_e_cal_flag = global::fit_type; + } + switch (_BgCalPara.g_e_cal_flag) + { + case liner: + if(g_e_cal.isEmpty()) + { + bRet = CFit::LinearFit(_b_g_e_c.g_e_c.channel,_b_g_e_c.g_e_c.energy,g_e_cal,vari); + if(!bRet) + { + return false; + } + } + bRet = CFit::LinearFitEquation(_roi_limit.ROI_G_start_y1,g_e_cal,_output.ROI_G_Boundary_start); + if(!bRet) + { + return false; + } + bRet = CFit::LinearFitEquation(_roi_limit.ROI_G_stop_y2,g_e_cal,_output.ROI_G_Boundary_stop); + if(!bRet) + { + return false; + } + break; + case poly2: + if(g_e_cal.isEmpty()) + { + bRet = CFit::_2PloynimialFit(_b_g_e_c.g_e_c.channel,_b_g_e_c.g_e_c.energy,g_e_cal,vari); + if(!bRet) + { + return false; + } + } + bRet = CFit::_2PloynimialFitEquation(_roi_limit.ROI_G_start_y1,g_e_cal,_output.ROI_G_Boundary_start); + if(!bRet) + { + return false; + } + bRet = CFit::_2PloynimialFitEquation(_roi_limit.ROI_G_stop_y2,g_e_cal,_output.ROI_G_Boundary_stop); + if(!bRet) + { + return false; + } + break; + case poly3: + if(g_e_cal.isEmpty()) + { + bRet = CFit::_3PloynimialFit(_b_g_e_c.g_e_c.channel,_b_g_e_c.g_e_c.energy,g_e_cal,vari); + if(!bRet) + { + return false; + } + } + bRet = CFit::_3PloynimialFitEquation(_roi_limit.ROI_G_start_y1,g_e_cal,_output.ROI_G_Boundary_start); + if(!bRet) + { + return false; + } + bRet = CFit::_3PloynimialFitEquation(_roi_limit.ROI_G_stop_y2,g_e_cal,_output.ROI_G_Boundary_stop); + if(!bRet) + { + return false; + } + break; + case gauss: + if(g_e_cal.isEmpty()) + { + bRet = CFit::GaussFit(_b_g_e_c.g_e_c.channel,_b_g_e_c.g_e_c.energy,g_e_cal,vari); + if(!bRet) + { + return false; + } + } + bRet = CFit::GaussFitEquation(_roi_limit.ROI_G_start_y1,g_e_cal,_output.ROI_G_Boundary_start); + if(!bRet) + { + return false; + } + bRet = CFit::GaussFitEquation(_roi_limit.ROI_G_stop_y2,g_e_cal,_output.ROI_G_Boundary_stop); + if(!bRet) + { + return false; + } + break; + default: + if(g_e_cal.isEmpty()) + { + bRet = CFit::_2PloynimialFit(_b_g_e_c.g_e_c.channel,_b_g_e_c.g_e_c.energy,g_e_cal,vari); + if(!bRet) + { + return false; + } + } + bRet = CFit::_2PloynimialFitEquation(_roi_limit.ROI_G_start_y1,g_e_cal,_output.ROI_G_Boundary_start); + if(!bRet) + { + return false; + } + bRet = CFit::_2PloynimialFitEquation(_roi_limit.ROI_G_stop_y2,g_e_cal,_output.ROI_G_Boundary_stop); + if(!bRet) + { + return false; + } + break; + } + return bRet; +} + +bool CBgWork::ExtractSROIcts() +{ + bool bRet=false; + //样品谱 + BgBoundary boundary; + BgCalibratePara dbgCalPara; + if(m_bgCalPara.bApplyNewCalicSample) + { + dbgCalPara = m_bgCalPara; + } + bRet = CalcBgBoundary(m_sampleData.s_limit,m_sampleData.s_e_c,dbgCalPara,boundary,m_allGenerate.BgSample.s_fittingPara); + if(!bRet) + { + return false; + } + //感兴趣区输入参数赋值 + ROIctsI s_roiCtsI; + s_roiCtsI.histogram.b_channels = m_sampleData.s_histogram.b_channels; + s_roiCtsI.histogram.g_channels = m_sampleData.s_histogram.g_channels; + s_roiCtsI.histogram.counts = m_sampleData.s_histogram.counts; + s_roiCtsI.roi_boundary.ROI_B_start_x = boundary.ROI_B_Boundary_start; + s_roiCtsI.roi_boundary.ROI_B_stop_x = boundary.ROI_B_Boundary_stop; + s_roiCtsI.roi_boundary.ROI_G_start_y = boundary.ROI_G_Boundary_start; + s_roiCtsI.roi_boundary.ROI_G_stop_y = boundary.ROI_G_Boundary_stop; + //提取感兴趣计数 以及 中间数据 + ROIctsO s_roiCtsO; + bRet = CROI::ExtractROIcts(s_roiCtsI,s_roiCtsO); + m_allGenerate.BgSample.s_roi_cts = s_roiCtsO.roi_cts; + m_allGenerate.BgSample.s_boungdary = boundary; + return true; +} +bool CBgWork::ExtractGROIcts() +{ + bool bRet=false; + //气体本底谱 + //样品谱 + BgBoundary boundary; + BgCalibratePara dbgCalPara; + if(m_bgCalPara.bApplyNewCalicGasBg) + { + dbgCalPara = m_bgCalPara; + } + bRet = CalcBgBoundary(m_gasData.g_limit,m_gasData.g_e_c,dbgCalPara,boundary,m_allGenerate.BgGas.g_fittingPara); + if(!bRet) + { + return false; + } + //感兴趣区输入参数赋值 + ROIctsI g_roiCtsI; + g_roiCtsI.histogram.b_channels = m_gasData.g_histogram.b_channels; + g_roiCtsI.histogram.g_channels = m_gasData.g_histogram.g_channels; + g_roiCtsI.histogram.counts = m_gasData.g_histogram.counts; + g_roiCtsI.roi_boundary.ROI_B_start_x = boundary.ROI_B_Boundary_start; + g_roiCtsI.roi_boundary.ROI_B_stop_x = boundary.ROI_B_Boundary_stop; + g_roiCtsI.roi_boundary.ROI_G_start_y = boundary.ROI_G_Boundary_start; + g_roiCtsI.roi_boundary.ROI_G_stop_y = boundary.ROI_G_Boundary_stop; + //提取感兴趣计数 以及 中间数据 + ROIctsO g_roiCtsO; + bRet = CROI::ExtractROIcts(g_roiCtsI,g_roiCtsO); + m_allGenerate.BgGas.g_boungdary = boundary; + m_allGenerate.BgGas.g_roi_cts = g_roiCtsO.roi_cts; + return true; +} +bool CBgWork::ExtractDROIcts() +{ + bool bRet=false; + //探测器本地谱 + BgBoundary boundary; + //使用默认刻度系数 + // m_UII.b_e_cal_flag = false; + // m_UII.g_e_cal_flag = false; + BgCalibratePara dbgCalPara; + if(m_bgCalPara.bApplyNewCalicDetBg) + { + dbgCalPara = m_bgCalPara; + } + bRet = CalcBgBoundary(m_detbgrData.d_limit,m_detbgrData.d_e_c,dbgCalPara,boundary,m_allGenerate.BgDetbgr.d_fittingPara); + if(!bRet) + { + return false; + } + //感兴趣区输入参数赋值 + ROIctsI d_roiCtsI; + d_roiCtsI.histogram.b_channels = m_detbgrData.d_histogram.b_channels; + d_roiCtsI.histogram.g_channels = m_detbgrData.d_histogram.g_channels; + d_roiCtsI.histogram.counts = m_detbgrData.d_histogram.counts; + d_roiCtsI.roi_boundary.ROI_B_start_x = boundary.ROI_B_Boundary_start; + d_roiCtsI.roi_boundary.ROI_B_stop_x = boundary.ROI_B_Boundary_stop; + d_roiCtsI.roi_boundary.ROI_G_start_y = boundary.ROI_G_Boundary_start; + d_roiCtsI.roi_boundary.ROI_G_stop_y = boundary.ROI_G_Boundary_stop; + //提取感兴趣计数 以及 中间数据 + ROIctsO d_roiCtsO; + bRet = CROI::ExtractROIcts(d_roiCtsI,d_roiCtsO); + m_allGenerate.BgDetbgr.d_boungdary=boundary; + m_allGenerate.BgDetbgr.d_roi_cts = d_roiCtsO.roi_cts; + return true; +} +bool CBgWork::SDetuctDcts() +{ + bool bRet =false; + NetXectsI s_d_XectsI; + s_d_XectsI.roi_ratios = m_sampleData.s_count_ratio; + s_d_XectsI.roi_cts = m_allGenerate.BgSample.s_roi_cts; + s_d_XectsI.roi_detbg_cts =m_allGenerate.BgDetbgr.d_roi_cts; + s_d_XectsI.ratio = m_sampleData.s_acquisition_live_time/m_detbgrData.s_acquisition_live_time; + bRet = CROI::CalcNetXects(s_d_XectsI,m_allGenerate.BgSample.s_deduct_d_cts); + return bRet; +} +bool CBgWork::GDetuctDcts() +{ + bool bRet =false; + NetXectsI g_d_XectsI; + g_d_XectsI.roi_ratios = m_gasData.g_count_ratio; + g_d_XectsI.roi_cts = m_allGenerate.BgGas.g_roi_cts; + g_d_XectsI.roi_detbg_cts =m_allGenerate.BgDetbgr.d_roi_cts; + g_d_XectsI.ratio = m_gasData.g_acquisition_live_time/m_detbgrData.s_acquisition_live_time; + bRet = CROI::CalcNetXects(g_d_XectsI,m_allGenerate.BgGas.g_deduct_d_cts); + return bRet; +} +bool CBgWork::ExtractNetCounts() +{ + bool bRet = false; + NetCountsI netCountsI; + netCountsI.g_netXe = m_allGenerate.BgGas.g_deduct_d_cts; + netCountsI.s_netXe = m_allGenerate.BgSample.s_deduct_d_cts; + netCountsI.time.g_acquisition_live_time = m_gasData.g_acquisition_live_time; + netCountsI.time.g_acquisition_real_time = m_gasData.g_acquisition_real_time; + netCountsI.time.s_acquisition_live_time = m_sampleData.s_acquisition_live_time; + netCountsI.time.s_acquisition_real_time = m_sampleData.s_acquisition_real_time; + netCountsI.time.gtos_acqStartDiff = SubtractTime(\ + m_gasData.g_acquisition_start_date+m_gasData.g_acquisition_start_time,\ + m_sampleData.s_acquisition_start_date+m_sampleData.s_acquisition_start_time); + bRet = CROI::CalcNetCounts(netCountsI,m_allGenerate.BgOther.ROI_net_coutns); + return bRet; +} +double CBgWork::SubtractTime(QString _begin,QString _end) +{ + double begin = QDateTime::fromString(_begin,"yyyy/MM/ddhh:mm:ss.z").toTime_t(); + double end = QDateTime::fromString(_end,"yyyy/MM/ddhh:mm:ss.z").toTime_t(); + return (end - begin); +} +bool CBgWork::AutoAnalyse() +{ +// if(!m_flag_read_file) +// { +// return false; +// } + bool bRet = false; + bRet = Analyse(); + return bRet; +} + +bool CBgWork::Analyse() +{ + bool bRet = false; + //初始化算法全局变量 + /* + if(!m_initAlgorithm) + { + m_initAlgorithm=true; + QString cfg_file = QCoreApplication::applicationDirPath()+QDir::separator()+QLatin1String("cfg/"); + QDir dir(cfg_file); + if(!dir.exists()) + { + dir.mkpath(dir.absolutePath()); + } + cfg_file = cfg_file+QLatin1String("algorithm.ini"); + + if(QFile::exists(cfg_file)) + { + global::InitAlgorithmVar(cfg_file); + } + else + { + global::GenerateAlgorithmVar(cfg_file); + } + + }*/ + //样品谱感兴趣区计数 + bRet = ExtractSROIcts(); + if(!bRet) + { + m_lastError = E_SAMPLE_ROI_CTS; + return false; + } + //气体本底谱感兴趣区计数 + bRet = ExtractGROIcts(); + if(!bRet) + { + m_lastError = E_GAS_ROI_CTS; + return false; + } + //探测器本体谱感兴趣区计数 + bRet = ExtractDROIcts(); + if(!bRet) + { + m_lastError = E_DETA_ROI_CTS; + return false; + } + //样品普扣除探测器本底谱计数 + bRet = SDetuctDcts(); + if(!bRet) + { + m_lastError = E_S_DETUCT_D_CTS; + return false; + } + //气体本底谱扣除探测器本底谱计数 + bRet = GDetuctDcts(); + if(!bRet) + { + m_lastError = E_G_DETUCT_D_CTS; + return false; + } + //获取净计数 + bRet = ExtractNetCounts(); + if(!bRet) + { + m_lastError = E_NET_COUNTS; + return false; + } + //获取感兴趣浓度和不平衡度 + bRet = CalcRoiConUncer(); + if(!bRet) + { + m_lastError = E_ROI_CON_UNCER; + return false; + } + //获取同位素浓度和不确定度 + bRet = CalcXeConUncer(); + if(!bRet) + { + m_lastError = E_XE_CON_UNCER; + return false; + } + //MDC计算 + bRet =MDC(); + if(!bRet) + { + m_lastError = E_MDC; + return false; + } + return true; +} +bool CBgWork::MDC() +{ + bool bRet = false; + MDCI mdcI; + MDCO mdcO; + mdcI.ROI_con_counts_factor = m_allGenerate.BgOther.ROI_con_counts_factor; + mdcI.ROI_con_uncer = m_allGenerate.BgOther.ROI_con_uncer; + mdcI.ROI_netcts = m_allGenerate.BgOther.ROI_net_coutns; + bRet = CMdc::MDC(mdcI,m_allGenerate.BgOther.XeType,mdcO); + m_allGenerate.BgOther.MDCPara.MDC_Xe131m = mdcO.mdcPara.MDC_Xe131m; + m_allGenerate.BgOther.MDCPara.MDC_Xe133 = mdcO.mdcPara.MDC_Xe133; + m_allGenerate.BgOther.MDCPara.MDC_Xe135 = mdcO.mdcPara.MDC_Xe135; + m_allGenerate.BgOther.MDCPara.MDC_Xe133m = mdcO.mdcPara.MDC_Xe133m; + m_allGenerate.BgOther.MDCPara.MDC = mdcO.mdcPara.MDC; + m_allGenerate.BgOther.MDCPara.MDC_CTS = mdcO.mdcPara.MDC_CTS; + + m_allGenerate.BgOther.LCPara.LC_Xe131m = mdcO.lcPara.LC_Xe131m; + m_allGenerate.BgOther.LCPara.LC_Xe133 = mdcO.lcPara.LC_Xe133; + m_allGenerate.BgOther.LCPara.LC_Xe133m = mdcO.lcPara.LC_Xe133m; + m_allGenerate.BgOther.LCPara.LC_Xe135 = mdcO.lcPara.LC_Xe135; + m_allGenerate.BgOther.LCPara.LC = mdcO.lcPara.LC; + m_allGenerate.BgOther.LCPara.LC_CTS = mdcO.lcPara.LC_CTS; + + m_uiNeed.MDCPara = m_allGenerate.BgOther.MDCPara; + return bRet; +} + +bool CBgWork::CalcXeConUncer() +{ + bool bRet = false; + XeConUncerI xeConUncerI; + xeConUncerI.s_netXe = m_allGenerate.BgSample.s_deduct_d_cts; + xeConUncerI.g_netXe = m_allGenerate.BgGas.g_deduct_d_cts; + xeConUncerI.ROI_con_uncer = m_allGenerate.BgOther.ROI_con_uncer; + XeConUncerO xeConUncerO; + bRet = CXeConUncer::CalcXeConUncer(xeConUncerI,xeConUncerO,m_allGenerate.BgOther.XeType); + m_allGenerate.BgOther.XeConUncer.Xe131m_con = xeConUncerO.Xe131m_con; + m_allGenerate.BgOther.XeConUncer.Xe131m_uncer = xeConUncerO.Xe131m_uncer; + m_allGenerate.BgOther.XeConUncer.Xe133m_con = xeConUncerO.Xe133m_con; + m_allGenerate.BgOther.XeConUncer.Xe133m_uncer = xeConUncerO.Xe133m_uncer; + m_allGenerate.BgOther.XeConUncer.Xe135_con = xeConUncerO.Xe135_con; + m_allGenerate.BgOther.XeConUncer.Xe135_uncer = xeConUncerO.Xe135_uncer; + m_allGenerate.BgOther.XeConUncer.Xe133_con = xeConUncerO.Xe133_con; + m_allGenerate.BgOther.XeConUncer.Xe133_uncer = xeConUncerO.Xe133_uncer; + m_uiNeed.XeConUncer = m_allGenerate.BgOther.XeConUncer; + return bRet; +} +bool CBgWork::CalcRoiConUncer() +{ + bool bRet = false; + ConUncerI conUncerI; + conUncerI.SPara.s_acquisition_real_time = m_sampleData.s_acquisition_real_time; + conUncerI.SPara.s_coll_interval_time = SubtractTime(\ + m_sampleData.s_collection_start_date+m_sampleData.s_collection_start_time,\ + m_sampleData.s_collection_stop_date+m_sampleData.s_collection_stop_time); + conUncerI.SPara.s_pre_time = SubtractTime(\ + m_sampleData.s_collection_stop_date+m_sampleData.s_collection_stop_time,\ + m_sampleData.s_acquisition_start_date+m_sampleData.s_acquisition_start_time); + if(cst_fixed_volXe != 0.0) + { + conUncerI.SPara.s_volume_of_Xe = cst_fixed_volXe; + } + else if(cst_fixed_volXe==0.1||cst_fixed_volXe<0.0) + { + conUncerI.SPara.s_volume_of_Xe = cst_defvolXe; + } + else if(m_sampleData.s_volume_of_Xe==0.0) + { + conUncerI.SPara.s_volume_of_Xe = m_sampleData.s_uncertainty; + } + else + { + conUncerI.SPara.s_volume_of_Xe = m_sampleData.s_volume_of_Xe; + } + conUncerI._netCts = m_allGenerate.BgOther.ROI_net_coutns; + conUncerI.s_bg_efficiency = m_sampleData.s_bg_efficiency; + ConUncerO conUncerO; + bRet = CRoiConUncer::CalcRoiConUncer(conUncerI,conUncerO); + m_allGenerate.BgOther.ROI_con_counts_factor = conUncerO.ROI_con_counts_factor; + m_allGenerate.BgOther.ROI_con_uncer = conUncerO.ROI_con_uncer; + m_allGenerate.BgSample.s_collection_time = QString::number(conUncerI.SPara.s_coll_interval_time); + return bRet; +} + +bool CBgWork::SetPara(BgFileI& _fileHanle)//先测试使用 +{ + // QString basePath("C:\\caoanqi\\new_caoanqi\\test_data\\JPX38\\"); + // QString qsSample= basePath+"JPX38_001-20110411_0925_S.PHD"; + // QString qsGas=basePath+"JPX38_001-20110410_2125_G.PHD"; + // QString qsDeta=basePath+"JPX38_001-20061220_0015_D.PHD"; + //样品谱值提取 + QString order = QLatin1String("#Acquisition"); + QVariant variant = _fileHanle.sample.GetBlockData(order); + if(!variant.isValid()) + { + m_lastError = E_FILE_CONTEXT_SAMPLE_Acquisition; + return false; + } + AcquisitionBlock acquisition = variant.value(); + m_sampleData.s_acquisition_live_time = acquisition.acquisition_live_time; + m_sampleData.s_acquisition_real_time = acquisition.acquisition_real_time; + m_sampleData.s_acquisition_start_date = acquisition.acquisition_start_date; + m_sampleData.s_acquisition_start_time = acquisition.acquisition_start_time; + order = QLatin1String("#Collection"); + variant = _fileHanle.sample.GetBlockData(order); + if(!variant.isValid()) + { + m_lastError = E_FILE_CONTEXT_SAMPLE_Collection; + return false; + } + CollectionBlock collection = variant.value(); + m_sampleData.s_collection_start_date = collection.collection_start_date; + m_sampleData.s_collection_start_time = collection.collection_start_time; + m_sampleData.s_collection_stop_date = collection.collection_stop_date; + m_sampleData.s_collection_stop_time = collection.collection_stop_time; + m_sampleData.s_xe_stable_volume = collection.air_volume; + order = QLatin1String("#Ratios"); + variant = _fileHanle.sample.GetBlockData(order); + if(!variant.isValid()) + { + m_lastError = E_FILE_CONTEXT_SAMPLE_Ratios; + return false; + } + RatiosBlock ratios = variant.value(); + m_sampleData.s_count_ratio = ratios.count_ratio; + m_sampleData.s_roi_ratio.ratio_id = ratios.ratio_id; + m_sampleData.s_roi_ratio.ROI_num_highter_G_energy_ROI = ratios.ROI_num_highter_G_energy_ROI; + m_sampleData.s_roi_ratio.ROI_num_lower_G_energy_ROI = ratios.ROI_num_lower_G_energy_ROI; + m_sampleData.s_roi_ratio.count_ratio = ratios.count_ratio; + m_sampleData.s_roi_ratio.count_ratio_uncertainty = ratios.count_ratio_uncertainty; + + /* + order = QLatin1String("BEGIN"); + variant = _fileHanle.sample.GetBlockData(order); + if(!variant.isValid()) + { + return false; + } + */ + + // MessageInfo messageinfo = variant.value(); + MessageInfo messageinfo = _fileHanle.sample.GetMessageInfo(); + m_sampleData.s_data_type = messageinfo.data_type; + + order = QLatin1String("#g_Energy"); + variant = _fileHanle.sample.GetBlockData(order); + if(!variant.isValid()) + { + m_lastError = E_FILE_CONTEXT_SAMPLE_g_Energy; + return false; + } + G_EnergyBlock g_Energy = variant.value(); + m_sampleData.s_e_c.g_e_c.energy = g_Energy.g_energy; + m_sampleData.s_e_c.g_e_c.channel = g_Energy.centroid_channel; + m_sampleData.s_e_c.g_e_c.uncertainty = g_Energy.uncertainty; + m_sampleData.s_e_c.g_e_c.record_count = g_Energy.record_count; + order = QLatin1String("#b_Energy"); + variant = _fileHanle.sample.GetBlockData(order); + if(!variant.isValid()) + { + m_lastError = E_FILE_CONTEXT_SAMPLE_b_Energy; + return false; + } + B_EnergyBlock B_Energy = variant.value(); + m_sampleData.s_e_c.b_e_c.energy = B_Energy.electron_energy; + m_sampleData.s_e_c.b_e_c.channel = B_Energy.channel; + m_sampleData.s_e_c.b_e_c.uncertainty = B_Energy.uncertainty; + m_sampleData.s_e_c.b_e_c.mode = B_Energy.decay_mode; + m_sampleData.s_e_c.b_e_c.record_count = B_Energy.record_count; + order = QLatin1String("#ROI_Limits"); + variant = _fileHanle.sample.GetBlockData(order); + if(!variant.isValid()) + { + m_lastError = E_FILE_CONTEXT_SAMPLE_ROI_Limits; + return false; + } + + ROI_LimitsBlock ROI_limits = variant.value(); + m_sampleData.s_limit.ROI_B_start_x1 = ROI_limits.POI_B_x1; + m_sampleData.s_limit.ROI_B_stop_x2 = ROI_limits.POI_B_x2; + m_sampleData.s_limit.ROI_G_start_y1 = ROI_limits.POI_G_y1; + m_sampleData.s_limit.ROI_G_stop_y2 = ROI_limits.POI_G_y2; + + order = QLatin1String("#b-gEfficiency"); + variant = _fileHanle.sample.GetBlockData(order); + if(!variant.isValid()) + { + m_lastError = E_FILE_CONTEXT_SAMPLE_bgEfficiency; + return false; + } + BG_EfficiencyBlock BG_efficiency = variant.value(); + m_sampleData.s_bg_efficiency = BG_efficiency.bg_efficiency; + m_sampleData.s_bg_efficiency_show.bg_efficiency = BG_efficiency.bg_efficiency; + m_sampleData.s_bg_efficiency_show.nuclide_name = BG_efficiency.nuclide_name; + m_sampleData.s_bg_efficiency_show.ROI_number = BG_efficiency.ROI_number; + m_sampleData.s_bg_efficiency_show.uncertainty = BG_efficiency.uncertainty; + order = QLatin1String("#Processing"); + variant = _fileHanle.sample.GetBlockData(order); + if(!variant.isValid()) + { + m_lastError = E_FILE_CONTEXT_SAMPLE_Processing; + return false; + } + ProcessingBlock processing = variant.value(); + m_sampleData.s_volume_of_Xe = processing.sample_volume_of_Xe; + m_sampleData.s_uncertainty = processing.uncertainty_1; + + order = QLatin1String("#Histogram"); + variant = _fileHanle.sample.GetBlockData(order); + if(!variant.isValid()) + { + m_lastError = E_FILE_CONTEXT_SAMPLE_Histogram; + return false; + } + HistogramBlock histogram = variant.value(); + m_sampleData.s_histogram.b_channels = histogram.b_channels; + m_sampleData.s_histogram.counts = histogram.counts; + m_sampleData.s_histogram.g_channels = histogram.g_channels; + + //气体本底谱数据初始化 + + order = QLatin1String("#Acquisition"); + variant = _fileHanle.gas.GetBlockData(order); + if(!variant.isValid()) + { + m_lastError = E_FILE_CONTEXT_GAS_Acquisition; + return false; + } + acquisition = variant.value(); + m_gasData.g_acquisition_live_time = acquisition.acquisition_live_time; + m_gasData.g_acquisition_real_time = acquisition.acquisition_real_time; + m_gasData.g_acquisition_start_date = acquisition.acquisition_start_date; + m_gasData.g_acquisition_start_time = acquisition.acquisition_start_time; + + /* + order = QLatin1String("BEGIN"); + variant = _fileHanle.gas.GetBlockData(order); + if(!variant.isValid()) + { + return false; + } + */ + messageinfo = _fileHanle.gas.GetMessageInfo(); + m_gasData.g_data_type = messageinfo.data_type; + + order = QLatin1String("#g_Energy"); + variant = _fileHanle.gas.GetBlockData(order); + if(!variant.isValid()) + { + m_lastError = E_FILE_CONTEXT_GAS_g_Energy; + return false; + } + g_Energy = variant.value(); + m_gasData.g_e_c.g_e_c.energy = g_Energy.g_energy; + m_gasData.g_e_c.g_e_c.channel = g_Energy.centroid_channel; + m_gasData.g_e_c.g_e_c.uncertainty = g_Energy.uncertainty; + m_gasData.g_e_c.g_e_c.record_count = g_Energy.record_count; + order = QLatin1String("#b_Energy"); + variant = _fileHanle.gas.GetBlockData(order); + if(!variant.isValid()) + { + m_lastError = E_FILE_CONTEXT_GAS_b_Energy; + return false; + } + B_Energy = variant.value(); + m_gasData.g_e_c.b_e_c.energy = B_Energy.electron_energy; + m_gasData.g_e_c.b_e_c.channel = B_Energy.channel; + m_gasData.g_e_c.b_e_c.mode = B_Energy.decay_mode; + m_gasData.g_e_c.b_e_c.uncertainty = B_Energy.uncertainty; + m_gasData.g_e_c.b_e_c.record_count = B_Energy.record_count; + order = QLatin1String("#ROI_Limits"); + variant = _fileHanle.gas.GetBlockData(order); + if(!variant.isValid()) + { + m_lastError = E_FILE_CONTEXT_GAS_ROI_Limits; + return false; + } + ROI_limits = variant.value(); + m_gasData.g_limit.ROI_B_start_x1 = ROI_limits.POI_B_x1; + m_gasData.g_limit.ROI_B_stop_x2 = ROI_limits.POI_B_x2; + m_gasData.g_limit.ROI_G_start_y1 = ROI_limits.POI_G_y1; + m_gasData.g_limit.ROI_G_stop_y2 = ROI_limits.POI_G_y2; + + order = QLatin1String("#Histogram"); + variant = _fileHanle.gas.GetBlockData(order); + if(!variant.isValid()) + { + m_lastError = E_FILE_CONTEXT_GAS_Histogram; + return false; + } + histogram = variant.value(); + m_gasData.g_histogram.b_channels = histogram.b_channels; + m_gasData.g_histogram.counts = histogram.counts; + m_gasData.g_histogram.g_channels = histogram.g_channels; + + order = QLatin1String("#Ratios"); + variant = _fileHanle.gas.GetBlockData(order); + if(!variant.isValid()) + { + m_lastError = E_FILE_CONTEXT_GAS_Ratios; + return false; + } + ratios = variant.value(); + m_gasData.g_count_ratio = ratios.count_ratio; + + //探测器本底谱初始数据 + order = QLatin1String("#Histogram"); + variant = _fileHanle.Detbgr.GetBlockData(order); + if(!variant.isValid()) + { + m_lastError = E_FILE_CONTEXT_DETA_Histogram; + return false; + } + histogram = variant.value(); + m_detbgrData.d_histogram.b_channels = histogram.b_channels; + m_detbgrData.d_histogram.counts = histogram.counts; + m_detbgrData.d_histogram.g_channels = histogram.g_channels; + + order = QLatin1String("#Acquisition"); + variant = _fileHanle.Detbgr.GetBlockData(order); + if(!variant.isValid()) + { + m_lastError = E_FILE_CONTEXT_DETA_Acquisition; + return false; + } + acquisition = variant.value(); + m_detbgrData.s_acquisition_live_time = acquisition.acquisition_live_time; + m_detbgrData.d_acquisition_real_time = acquisition.acquisition_real_time; + + /* + order = QLatin1String("BEGIN"); + variant = _fileHanle.Detbgr.GetBlockData(order); + if(!variant.isValid()) + { + return false; + } + */ + messageinfo = _fileHanle.Detbgr.GetMessageInfo(); + m_detbgrData.d_data_type = messageinfo.data_type;\ + + order = QLatin1String("#g_Energy"); + variant = _fileHanle.Detbgr.GetBlockData(order); + if(!variant.isValid()) + { + m_lastError = E_FILE_CONTEXT_DETA_g_Energy; + return false; + } + g_Energy = variant.value(); + m_detbgrData.d_e_c.g_e_c.energy = g_Energy.g_energy; + m_detbgrData.d_e_c.g_e_c.channel = g_Energy.centroid_channel; + m_detbgrData.d_e_c.g_e_c.uncertainty = g_Energy.uncertainty; + m_detbgrData.d_e_c.g_e_c.record_count = g_Energy.record_count; + order = QLatin1String("#b_Energy"); + variant = _fileHanle.Detbgr.GetBlockData(order); + if(!variant.isValid()) + { + m_lastError = E_FILE_CONTEXT_DETA_b_Energy; + return false; + } + B_Energy = variant.value(); + m_detbgrData.d_e_c.b_e_c.energy = B_Energy.electron_energy; + m_detbgrData.d_e_c.b_e_c.channel = B_Energy.channel; + m_detbgrData.d_e_c.b_e_c.mode = B_Energy.decay_mode; + m_detbgrData.d_e_c.b_e_c.record_count=B_Energy.record_count; + m_detbgrData.d_e_c.b_e_c.uncertainty = B_Energy.uncertainty; + order = QLatin1String("#ROI_Limits"); + variant = _fileHanle.Detbgr.GetBlockData(order); + if(!variant.isValid()) + { + m_lastError = E_FILE_CONTEXT_DETA_ROI_Limits; + return false; + } + ROI_limits = variant.value(); + m_detbgrData.d_limit.ROI_B_start_x1 = ROI_limits.POI_B_x1; + m_detbgrData.d_limit.ROI_B_stop_x2 = ROI_limits.POI_B_x2; + m_detbgrData.d_limit.ROI_G_start_y1 = ROI_limits.POI_G_y1; + m_detbgrData.d_limit.ROI_G_stop_y2 = ROI_limits.POI_G_y2; + return true; +} + +QString CBgWork::BgAnlyseError(const BgErrorType& _error) +{ + QString temp; + switch (_error) { + case E_NONE: + temp = QLatin1String("no error"); + break; + case E_FILE_CONTEXT_SAMPLE_Acquisition: + temp = QLatin1String("sample file #Acquisition read error"); + break; + case E_FILE_CONTEXT_SAMPLE_bgEfficiency: + temp = QLatin1String("sample file #bgEfficiency read error"); + break; + case E_FILE_CONTEXT_SAMPLE_b_Energy: + temp = QLatin1String("sample file #b_Energy read error"); + break; + case E_FILE_CONTEXT_SAMPLE_Collection: + temp = QLatin1String("sample file #Collection read error"); + break; + case E_FILE_CONTEXT_SAMPLE_g_Energy: + temp = QLatin1String("sample file #g_Energy read error"); + break; + case E_FILE_CONTEXT_SAMPLE_Histogram: + temp = QLatin1String("sample file #Histogram read error"); + break; + case E_FILE_CONTEXT_SAMPLE_Processing: + temp = QLatin1String("sample file #Processing read error"); + break; + case E_FILE_CONTEXT_SAMPLE_Ratios: + temp = QLatin1String("sample file #Ratios read error"); + break; + case E_FILE_CONTEXT_SAMPLE_ROI_Limits: + temp = QLatin1String("sample file #ROI_Limits read error"); + break; + case E_FILE_CONTEXT_GAS_Acquisition: + temp = QLatin1String("gas file #Acquisition read error"); + break; + case E_FILE_CONTEXT_GAS_b_Energy: + temp = QLatin1String("gas file #b_Energy read error"); + break; + case E_FILE_CONTEXT_GAS_g_Energy: + temp = QLatin1String("gas file #g_Energy read error"); + break; + case E_FILE_CONTEXT_GAS_Histogram: + temp = QLatin1String("gas file #Histogram read error"); + break; + case E_FILE_CONTEXT_GAS_Ratios: + temp = QLatin1String("gas file #Ratios read error"); + break; + case E_FILE_CONTEXT_GAS_ROI_Limits: + temp = QLatin1String("gas file #ROI_Limits read error"); + break; + case E_FILE_CONTEXT_DETA_Acquisition: + temp = QLatin1String("deta file #Acquisition read error"); + break; + case E_FILE_CONTEXT_DETA_b_Energy: + temp = QLatin1String("deta file #b_Energy read error"); + break; + case E_FILE_CONTEXT_DETA_g_Energy: + temp = QLatin1String("deta file #g_Energy read error"); + break; + case E_FILE_CONTEXT_DETA_Histogram: + temp = QLatin1String("deta file #Histogram read error"); + break; + case E_FILE_CONTEXT_DETA_ROI_Limits: + temp = QLatin1String("deta file #ROI_Limits read error"); + break; + case E_SAMPLE_ROI_CTS: + temp = QLatin1String("sample roi cts error"); + break; + case E_GAS_ROI_CTS: + temp = QLatin1String("gas roi cts error"); + break; + case E_DETA_ROI_CTS: + temp = QLatin1String("deta roi cts error"); + break; + case E_S_DETUCT_D_CTS: + temp = QLatin1String("sampe detuct deta cts error"); + break; + case E_G_DETUCT_D_CTS: + temp = QLatin1String("gas detuct deta cts error"); + break; + case E_NET_COUNTS: + temp = QLatin1String("net counts error"); + break; + case E_ROI_CON_UNCER: + temp = QLatin1String("roi con uncer error"); + break; + case E_XE_CON_UNCER: + temp = QLatin1String("xe con uncer error"); + break; + case E_MDC: + temp = QLatin1String("mdc error"); + break; + default: + break; + } + return QString("Anlyse result : %1%2").arg(temp).arg(STRING_END); +} \ No newline at end of file diff --git a/BgWork.h b/BgWork.h new file mode 100644 index 0000000..6d72df0 --- /dev/null +++ b/BgWork.h @@ -0,0 +1,126 @@ +#ifndef PACKAGING_H +#define PACKAGING_H +//////////////////////////////////////////////////////////////////////// +// 类说明：此类为b_g谱业务逻辑 +// +// 注意事项：1、ExtractSROIcts 用到2次拟合算法 请注意 +// +//////////////////////////////////////////////////////////////////////// +#include +#include +#include "BgWorkDef.h" + +class CBgWork +{ +public: + CBgWork(); + CBgWork(BgFileI& _fileHanle); + ~CBgWork(); + //log拆分而来，错误日志 + static QString BgAnlyseError(const BgErrorType& _error); + void SetBgFile(BgFileI& _fileHanle); + ///////////////////////////////////////////////////////////////////// + // 函数说明：重新设置要分析的文件名 + // _fileHanle + // 返回值：void + ////////////////////////////////////////////////////////////////////// + void RenameAnalyseFile(BgFileI& _fileHanle); + ///////////////////////////////////////////////////////////////////// + // 函数说明：界面交互分析 + // 函数参数：b_e_cal：b能刻度计数方程系数 + // g_e_cal: g能刻度计数方程系数 + // 返回值：void + ////////////////////////////////////////////////////////////////////// + bool MutialAnalyse(BgCalibratePara& _BgCalPara); + //////////////////////////////////////////////////////////////////// + // 函数说明：自动分析 + // 函数参数：void + // 返回值：void + ////////////////////////////////////////////////////////////////////// + bool AutoAnalyse(); + ///////////////////////////////////////////////////////////////////// + // 函数说明：GetAllValue 获取所有分析结果 + // 函数参数：void + // 返回值： 分析的所有结构 详解请看结构 + ////////////////////////////////////////////////////////////////////// + BgAllGenerate GetAllValue(); + ///////////////////////////////////////////////////////////////////// + // 函数说明：GetUIValue 获取与界面相关的结果 + // 函数参数：void + // 返回值： 分析的所有结构 详解请看结构 + ////////////////////////////////////////////////////////////////////// + BgUINeed GetUIValue(); + ///////////////////////////////////////////////////////////////////// + // 函数说明：GetLastError 返回计算标示 + // 函数参数：void + // 返回值： 分析的所有结构 详解请看结构 + ////////////////////////////////////////////////////////////////////// + BgErrorType GetLastError(); + BgSample GetSampleUseData(); + BgGas GetGasUseData(); + BgDetbgr GetDetbgrUseData(); + ///////////////////////////////////////////////////////////////////// + // 函数说明：CaculateXeActivity 计算符合外推 核素活动值 + // 函数参数： _watch_x:拟合观察点x; _watch_y：拟合观察点y;_lamadaXe:Xe参数;_acqRealTime:生存时间；,QVector &_fittingPara:拟合系数返回；_fittingType:拟合方式 + // 返回值： 分析的所有结构 详解请看结构 + ////////////////////////////////////////////////////////////////////// + static double CaculateXeActivity(QVector&_watch_x,QVector&_watch_y,const double& _lamadaXe,const double& _acqRealTime,QVector &_fittingPara,int _fittingType=_default); + static bool GetFittingPara(QVector& _watch_x,QVector &_watch_y,FitType _fittype,QVector &_fittingPara); + static bool GetFittingData(QVector& _watch,FitType _fittype,QVector &_fittingPara,QVector &_rData); + static bool GetFittingData(QVector& _watch,FitType _fittype,QVector &_fittingPara,QVector &_rData); + static bool GetFileFittingPara(QVector& _watch_x,QVector &_watch_y,QVector &_fittingPara); + static bool GetFileFittingData(QVector& _watch,QVector &_fittingPara,QVector &_rData); + static bool GetFileFittingData(QVector& _watch,QVector &_fittingPara,QVector &_rData); + static QString GetFittingDescriptionByType(int _type); + static QString GetFittingEquation(int _type); + + // 根据不同的拟合方法计算边界值， 默认2次拟合 可以继承书写新的拟合 + virtual bool CalcBgBoundary(BgROILimit& _roi_limit,BgEC& _b_g_e_c,BgCalibratePara& _BgCalPara,BgBoundary& _output); +protected: + // 根据不同的拟合方法计算边界值， 默认2次拟合 可以继承书写新的拟合 + virtual bool CalcBgBoundary(BgROILimit& _roi_limit,BgEC& _b_g_e_c,BgCalibratePara& _BgCalPara,BgBoundary& _output,BgFittingPara& _fittingPara); +private: + //初始化 + bool SetPara(BgFileI& _fileHanle); + //处理流程 + bool Analyse(); + //获取样品谱感兴趣区计数 + bool ExtractSROIcts(); + //获取气体本底谱感兴趣区计数 + bool ExtractGROIcts(); + //获取探测器本底谱感兴趣区计数 + bool ExtractDROIcts(); + //样品谱扣除探测器本底谱计数 + bool SDetuctDcts(); + //气体本底谱扣除探测器本底谱计数 + bool GDetuctDcts(); + //获取净计数 + bool ExtractNetCounts(); + //日期差值计算 + double SubtractTime(QString _begin,QString _end); + //计算感兴趣区浓度和不确定度 + bool CalcRoiConUncer(); + //计算同位素浓度和不确定度 + bool CalcXeConUncer(); + //MDC计算 + bool MDC(); + //所需数据 + BgSample m_sampleData; //样品谱数据 + BgGas m_gasData; //气体本底谱数据 + BgDetbgr m_detbgrData; //探测器本地谱数据 + BgAllGenerate m_allGenerate; + BgUINeed m_uiNeed; + BgSampleGenerate m_sampleGenerate; //样品谱生成数据 + BgGasGenerate m_gasGenerate; //气体本底谱生成数据 + BgDetbgrGenerate m_detbgrGenerate; //探测器本地谱生成数据 + BgOtherGenerate m_otherGenerate; //生成的其他数据 + const static double cst_fixed_volXe; + const static double cst_defvolXe; // Value substituted when Xe volume read as below 0.1 ml - warning issued. + static bool m_initAlgorithm; + BgCalibratePara m_bgCalPara; + BgFileI m_file; + bool m_flag_read_file; + BgErrorType m_lastError; +}; + +#endif diff --git a/BgWorkDef.h b/BgWorkDef.h new file mode 100644 index 0000000..b92469f --- /dev/null +++ b/BgWorkDef.h @@ -0,0 +1,407 @@ +#ifndef B_G_WORK_DEFINE_H +#define B_G_WORK_DEFINE_H +#include "ProcessAlgorithmGlobalVar.h" +#include "RadionuclideMessage.h" +//错误类型结构 +enum BgErrorType{ + E_NONE //默认没有错误 + ,E_FILE_CONTEXT_SAMPLE_Acquisition //文件读取错误 + ,E_FILE_CONTEXT_SAMPLE_Collection // + ,E_FILE_CONTEXT_SAMPLE_Ratios // + ,E_FILE_CONTEXT_SAMPLE_g_Energy // + ,E_FILE_CONTEXT_SAMPLE_b_Energy // + ,E_FILE_CONTEXT_SAMPLE_ROI_Limits // + ,E_FILE_CONTEXT_SAMPLE_bgEfficiency // + ,E_FILE_CONTEXT_SAMPLE_Processing // + ,E_FILE_CONTEXT_SAMPLE_Histogram // + ,E_FILE_CONTEXT_GAS_Acquisition // + ,E_FILE_CONTEXT_GAS_g_Energy // + ,E_FILE_CONTEXT_GAS_b_Energy // + ,E_FILE_CONTEXT_GAS_ROI_Limits // + ,E_FILE_CONTEXT_GAS_Histogram // + ,E_FILE_CONTEXT_GAS_Ratios // + ,E_FILE_CONTEXT_DETA_Histogram // + ,E_FILE_CONTEXT_DETA_Acquisition // + ,E_FILE_CONTEXT_DETA_g_Energy // + ,E_FILE_CONTEXT_DETA_b_Energy // + ,E_FILE_CONTEXT_DETA_ROI_Limits // + ,E_SAMPLE_ROI_CTS //样品谱感兴趣区计数错误 + ,E_GAS_ROI_CTS //气体本底谱感兴趣区计数错误 + ,E_DETA_ROI_CTS //探测器本体谱感兴趣区计数错误 + ,E_S_DETUCT_D_CTS //样品普扣除探测器本底谱计数错误 + ,E_G_DETUCT_D_CTS //气体本底谱扣除探测器本底谱计数错误 + ,E_NET_COUNTS //获取净计数错误 + ,E_ROI_CON_UNCER //获取感兴趣浓度和不平衡度错误 + ,E_XE_CON_UNCER //获取同位素浓度和不确定度错误 + ,E_MDC //MDC计算错误 + }; +//处理后数据结构 +//文件传入参数 +typedef struct tagBgFileI +{ + RadionuclideMessage sample; + RadionuclideMessage gas; + RadionuclideMessage Detbgr; +}*pBgFileI,BgFileI; + +//边界值 +typedef struct tagBgBoundary +{ + QVector ROI_B_Boundary_start; + QVector ROI_B_Boundary_stop; + QVector ROI_G_Boundary_start; + QVector ROI_G_Boundary_stop; +}*pBgBoundary,BgBoundary; +//MDC参数结构 +typedef struct tagBgMDCPara +{ + double MDC_Xe135; //MDC XE135 + double MDC_Xe131m; //MDC XE131m + double MDC_Xe133m; //MDC XE133m + double MDC_Xe133; //MDC XE133 + QVector MDC; + QVector MDC_CTS; +}*pBgMDCPara,BgMDCPara; +//LC参数结构 +typedef struct tagBgLCPara +{ + double LC_Xe135; //LC XE135 + double LC_Xe131m; //LC XE131m + double LC_Xe133m; //LC XE133m + double LC_Xe133; //LC XE133 + QVector LC; + QVector LC_CTS; +}*pBgLCPara,BgLCPara; +typedef struct tagBgXeConUncer +{ + double Xe135_con; //135不浓度 + double Xe135_uncer; //135不确定度 + double Xe131m_con; + double Xe131m_uncer; + double Xe133m_con; + double Xe133m_uncer; + double Xe133_con; + double Xe133_uncer; +}*pBgXeConUncer,BgXeConUncer; +//其他数据 +typedef struct tagBgOtherGenerate +{ + QVector ROI_net_coutns; //感兴趣区净计数 + QVector ROI_net_err; + QVector ROI_con_uncer; //感兴趣区浓度和不确定度 [n..0]浓度 [n..1]不确定度 + QVector ROI_con_counts_factor; //感兴趣区浓度计数系数 [n..0]系数 + global::XeType XeType; + BgLCPara LCPara; + BgMDCPara MDCPara; + BgXeConUncer XeConUncer; +}*pBgOtherGenerate,BgOtherGenerate; +//能道拟合处理后的数据 +//交互处理参数 +enum FitType{_default,liner,poly2,poly3,gauss}; +typedef struct tagBgFittingHandleData +{ + int b_fitting_type; + int g_fitting_type; + QVector b_fitting_para; + QVector g_fitting_para; + tagBgFittingHandleData() + { + b_fitting_type=poly2; + g_fitting_type=poly2; + } +}*pBgFittingHandleData,BgFittingHandleData; + +typedef struct tagBgFittingPara +{ + int b_fitting_type; + int g_fitting_type; + QVector b_fitting_e_c; + QVector g_fitting_e_c; + QVector b_fitting_c_e; + QVector g_fitting_c_e; + tagBgFittingPara() + { + b_fitting_type=poly2; + g_fitting_type=poly2; + } + +}*pBgFittingPara,BgFittingPara; + +//样品谱生成数据 +typedef struct tagBgSmapleGenerate +{ + BgBoundary s_boungdary; + QVector s_roi_cts; //样品普感兴趣区计数 + QVector s_deduct_d_cts; //样品谱扣除探测器本底谱数据 + BgFittingPara s_fittingPara; // 拟合后值 + QString s_collection_time; //采集时间 +}*pBgSampleGenerate,BgSampleGenerate; +//气体本地谱生成数据 +typedef struct tagBgGasGenerate +{ + BgBoundary g_boungdary; + QVector g_roi_cts; //气体本底谱感兴趣区计数 + QVector g_deduct_d_cts; //气体本底谱扣除探测器本底谱数据 + BgFittingPara g_fittingPara; // 拟合后值 +}*pBgGasGenerate,BgGasGenerate; +//探测器本地谱生成数据 +typedef struct tagBgDetbgrGenerate +{ + BgBoundary d_boungdary; + QVector d_roi_cts; //探测器本底谱感兴趣区计数 + BgFittingPara d_fittingPara; // 拟合后值 +}*pBgDetbgrGenerate,BgDetbgrGenerate; +//返回所有数据 +typedef struct tagBgAllGenerate +{ + BgGasGenerate BgGas; + BgSampleGenerate BgSample; + BgOtherGenerate BgOther; + BgDetbgrGenerate BgDetbgr; + bool bProcessed; + + tagBgAllGenerate() + { + bProcessed = false; + } + +}*pBgAllGenerate,BgAllGenerate; +//UI界面需要数据 +typedef struct tagBgUINeed +{ + BgMDCPara MDCPara; + BgXeConUncer XeConUncer; +// BgFittingHandleData fittingData; +}*pBgUINeed,BgUINeed; + +//需处理数据结构 +typedef struct tagBgCalibratePara +{ + QVector b_e_cal; //b 能刻度系数 + QVector g_e_cal; //g 能刻度系数 + int b_e_cal_flag; //b 自计算刻度系数配置 + int g_e_cal_flag; //g 自计算刻度系数配置 + bool bApplyNewCalicSample; // 界面交互新刻度应用 + bool bApplyNewCalicDetBg; + bool bApplyNewCalicGasBg; + bool bApplyNewCalicQc; + tagBgCalibratePara() + { + b_e_cal_flag = poly2; + g_e_cal_flag = poly2; + bApplyNewCalicSample = false; + bApplyNewCalicDetBg = false; + bApplyNewCalicGasBg = false; + bApplyNewCalicQc = false; + } +}*pBgCalibratePara, BgCalibratePara; + +//能道数据 +typedef struct tagBgEnergyChannel +{ + QVector energy; // g_Energy:g_energy or b_Energy:electron_energy kev 能量 + QVector channel; // g_Energy:centroid_channel or b_Energy channel 道 + QVector uncertainty; //不确定度 未使用 + QVector mode; //类型 未使用 + int record_count; //记录条数 未使用 + tagBgEnergyChannel() + { + record_count=0; + } +}*pBgEnergyChannel,BgEnergyChannel; +//b g 能 道 +typedef struct tagBgEC +{ + BgEnergyChannel b_e_c;//b_Energy block + BgEnergyChannel g_e_c;//g_Energy block +}*pBgEC,BgEC; +//感应区限值结构 +typedef struct tagBgROILimit +{ + QVector ROI_B_start_x1;// ROI B-rang start,x1(keV) + QVector ROI_B_stop_x2; // ROI B_rang stop,x2(kev) + QVector ROI_G_start_y1;// ROI G-rang start,y1(keV) + QVector ROI_G_stop_y2; // ROI G_rang stop,y2(kev) +}*pBgROILimit,BgROILimit; +typedef struct tagBgHistogram +{ + long b_channels; // β-channels + long g_channels; // γ-channels + QVector counts; // counts at channels +}*pBgHistorgram,BgHistogram; +//样品符合谱所需数据 +typedef struct tagBgROIRatios +{ + QVector ratio_id; + QVector ROI_num_highter_G_energy_ROI; + QVector ROI_num_lower_G_energy_ROI; + QVector count_ratio; + QVector count_ratio_uncertainty; +}*pBgRoiRatios,BgRoiRatios; +typedef struct tagBgEfficiencies +{ + QVector nuclide_name; // nuclide name + QVector ROI_number; // ROI number + QVector bg_efficiency; // β-γ coincidence efficiency (counts in ROI/β-γ pair emitted) + QVector uncertainty; +}*pBgBgEfficiencies,BgBgEfficiencies; + +typedef struct tagBgSample +{ + BgROILimit s_limit; //样品谱限值 + QString s_data_type; //样品数据类型 + QVector s_count_ratio; //样品谱比率计数 + QVector s_bg_efficiency; //样品谱能效感应区个数 + QString s_collection_start_date; //样品谱采集开始日期 格式：yyyy/MM/dd + QString s_collection_start_time; //样品普采集结束时间 格式：hh:mm:ss.z + QString s_collection_stop_time; //样品谱采集结束日期 格式：yyyy/MM/dd + QString s_collection_stop_date; //样品普采集结束时间 格式：hh:mm:ss.z + QString s_acquisition_start_date; //acquisition start date (yyyy/MM/dd) + QString s_acquisition_start_time; //acquisition start time (hh:mm:ss.z) + double s_acquisition_real_time; //acquisition real time (s) + double s_acquisition_live_time; //acquisition live time (s) + double s_volume_of_Xe; //sample volume of Xe (cm 3 ) + double s_xe_stable_volume; //total air volume sampled (standard cubic meters [scm]) + double s_uncertainty; //uncertainty (cm 3 ) + BgHistogram s_histogram; //Histogram Block + BgEC s_e_c; //能道 + BgRoiRatios s_roi_ratio; + BgBgEfficiencies s_bg_efficiency_show; +}*pBgSample,BgSample; +//气体本底谱所需数据 +typedef struct tagBgGas +{ + BgROILimit g_limit; //气体本底谱限值 + QString g_data_type; //气体本底谱数据类型 + QVector g_count_ratio; //气体本底谱比率计数 + QString g_acquisition_start_date; //acquisition start date (yyyy/MM/dd) + QString g_acquisition_start_time; //acquisition start time (hh:mm:ss.z) + double g_acquisition_real_time; //acquisition real time (s) + double g_acquisition_live_time; //acquisition live time (s) + BgHistogram g_histogram; //Histogram Block + BgEC g_e_c; //能道 +}*pBgGas,BgGas; +//探测器本底谱所需数据 +typedef struct tagBgDetbgr +{ + BgROILimit d_limit; //探测器本底谱限值 + QString d_data_type; //探测体本底谱数据类型 + double s_acquisition_live_time; //acquisition live time (s) + double d_acquisition_real_time; //acquisition live time (s) + BgHistogram d_histogram; //Histogram Block + BgEC d_e_c; //能道 +}*pBgDetbgr,BgDetbgr; + +//整合结构，java调用所需 +typedef struct tagBgSGD +{ + //sample + //样品谱限值 + QVector s_ROI_B_start_x1;// ROI B-rang start,x1(keV) + QVector s_ROI_B_stop_x2; // ROI B_rang stop,x2(kev) + QVector s_ROI_G_start_y1;// ROI G-rang start,y1(keV) + QVector s_ROI_G_stop_y2; // ROI G_rang stop,y2(kev) + QString s_data_type; //样品数据类型 + QVector s_count_ratio; //样品谱比率计数 + QVector s_bg_efficiency; //样品谱能效感应区个数 + QString s_collection_start_date; //样品谱采集开始日期 格式：yyyy/MM/dd + QString s_collection_start_time; //样品普采集结束时间 格式：hh:mm:ss.z + QString s_collection_stop_time; //样品谱采集结束日期 格式：yyyy/MM/dd + QString s_collection_stop_date; //样品普采集结束时间 格式：hh:mm:ss.z + QString s_acquisition_start_date; //acquisition start date (yyyy/MM/dd) + QString s_acquisition_start_time; //acquisition start time (hh:mm:ss.z) + double s_acquisition_real_time; //acquisition real time (s) + double s_acquisition_live_time; //acquisition live time (s) + double s_volume_of_Xe; //sample volume of Xe (cm 3 ) + double s_xe_stable_volume; //total air volume sampled (standard cubic meters [scm]) + double s_uncertainty; //uncertainty (cm 3 ) + //Histogram Block + long s_b_channels; // β-channels + long s_g_channels; // γ-channels + QVector s_counts; // counts at channels + + //BgEC s_e_c; //能道 + //BgEnergyChannel b_e_c;//b_Energy block + QVector s_b_energy; // g_Energy:g_energy or b_Energy:electron_energy kev 能量 + QVector s_b_channel; // g_Energy:centroid_channel or b_Energy channel 道 + QVector s_b_uncertainty; //不确定度 未使用 + QVector s_b_mode; //类型 未使用 + int s_b_record_count; //记录条数 未使用 + //BgEnergyChannel g_e_c;//g_Energy block + QVector s_g_energy; // g_Energy:g_energy or b_Energy:electron_energy kev 能量 + QVector s_g_channel; // g_Energy:centroid_channel or b_Energy channel 道 + QVector s_g_uncertainty; //不确定度 未使用 + QVector s_g_mode; //类型 未使用 + int s_g_record_count; //记录条数 未使用 + + //BgRoiRatios s_roi_ratio; + QVector ratio_id; + QVector ROI_num_highter_G_energy_ROI; + QVector ROI_num_lower_G_energy_ROI; + QVector count_ratio; + QVector count_ratio_uncertainty; + + //BgBgEfficiencies s_bg_efficiency_show; + QVector nuclide_name; // nuclide name + QVector ROI_number; // ROI number + QVector bg_efficiency; // β-γ coincidence efficiency (counts in ROI/β-γ pair emitted) + QVector uncertainty; + + //gas + //BgROILimit g_limit; //气体本底谱限值 + QVector g_ROI_B_start_x1;// ROI B-rang start,x1(keV) + QVector g_ROI_B_stop_x2; // ROI B_rang stop,x2(kev) + QVector g_ROI_G_start_y1;// ROI G-rang start,y1(keV) + QVector g_ROI_G_stop_y2; // ROI G_rang stop,y2(kev) + QString g_data_type; //气体本底谱数据类型 + QVector g_count_ratio; //气体本底谱比率计数 + QString g_acquisition_start_date; //acquisition start date (yyyy/MM/dd) + QString g_acquisition_start_time; //acquisition start time (hh:mm:ss.z) + double g_acquisition_real_time; //acquisition real time (s) + double g_acquisition_live_time; //acquisition live time (s) + //BgHistogram g_histogram; //Histogram Block + long g_b_channels; // β-channels + long g_g_channels; // γ-channels + QVector g_counts; // counts at channels + //BgEC g_e_c; //能道 + //BgEnergyChannel b_e_c;//b_Energy block + QVector g_b_energy; // g_Energy:g_energy or b_Energy:electron_energy kev 能量 + QVector g_b_channel; // g_Energy:centroid_channel or b_Energy channel 道 + QVector g_b_uncertainty; //不确定度 未使用 + QVector g_b_mode; //类型 未使用 + int g_b_record_count; //记录条数 未使用 + //BgEnergyChannel g_e_c;//g_Energy block + QVector g_g_energy; // g_Energy:g_energy or b_Energy:electron_energy kev 能量 + QVector g_g_channel; // g_Energy:centroid_channel or b_Energy channel 道 + QVector g_g_uncertainty; //不确定度 未使用 + QVector g_g_mode; //类型 未使用 + int g_g_record_count = 0; //记录条数 未使用 + + //Detbgr + //BgROILimit d_limit; //探测器本底谱限值 + QVector d_ROI_B_start_x1;// ROI B-rang start,x1(keV) + QVector d_ROI_B_stop_x2; // ROI B_rang stop,x2(kev) + QVector d_ROI_G_start_y1;// ROI G-rang start,y1(keV) + QVector d_ROI_G_stop_y2; // ROI G_rang stop,y2(kev) + QString d_data_type; //探测体本底谱数据类型 + double d_acquisition_live_time; //acquisition live time (s) + double d_acquisition_real_time; //acquisition live time (s) + //BgHistogram d_histogram; //Histogram Block + long d_b_channels; // β-channels + long d_g_channels; // γ-channels + QVector d_counts; // counts at channels + //BgEC d_e_c; //能道 + //BgEnergyChannel b_e_c;//b_Energy block + QVector d_b_energy; // g_Energy:g_energy or b_Energy:electron_energy kev 能量 + QVector d_b_channel; // g_Energy:centroid_channel or b_Energy channel 道 + QVector d_b_uncertainty; //不确定度 未使用 + QVector d_b_mode; //类型 未使用 + int d_b_record_count; //记录条数 未使用 + //BgEnergyChannel g_e_c;//g_Energy block + QVector d_g_energy; // g_Energy:g_energy or b_Energy:electron_energy kev 能量 + QVector d_g_channel; // g_Energy:centroid_channel or b_Energy channel 道 + QVector d_g_uncertainty; //不确定度 未使用 + QVector d_g_mode; //类型 未使用 + int d_g_record_count; //记录条数 未使用 +}*pBgSGD,BgSGD; +#endif diff --git a/CplusToJava.cpp b/CplusToJava.cpp new file mode 100644 index 0000000..1932fd3 --- /dev/null +++ b/CplusToJava.cpp @@ -0,0 +1,217 @@ +#include "CplusToJava.h" +#include +jobjectArray CplusToJava::GetjobjectArray(JNIEnv* env, jclass jcls, jobject jstruct, std::string var) +{ + // ȡԱvarֵ + jfieldID fieldIDlist = env->GetFieldID(jcls, var.c_str(), "Ljava/util/List;"); + jobject listObject = env->GetObjectField(jstruct, fieldIDlist); + jclass listClass = env->FindClass("java/util/List"); + jmethodID toArrayMethodID = env->GetMethodID(listClass, "toArray", "()[Ljava/lang/Object;"); + jobjectArray listValue = (jobjectArray)env->CallObjectMethod(listObject, toArrayMethodID); + return listValue; +} + +jobjectArray CplusToJava::QVectorD2jobjectArray(QVector vec, JNIEnv* env) +{ + jint arraySize = vec.size(); + jclass doubleClass = env->FindClass("java/lang/Double"); + jobjectArray array = env->NewObjectArray(arraySize, doubleClass, NULL); + jmethodID constructorID = env->GetMethodID(doubleClass, "", "(D)V"); + for (int i = 0; i < arraySize; i++) { + jobject doubleObject = env->NewObject(doubleClass, constructorID, vec[i]); + env->SetObjectArrayElement(array, i, doubleObject); + } + return array; +} + +jobjectArray CplusToJava::QVectorQS2jobjectArray(QVector vec, JNIEnv* env) +{ + jint arraySize = vec.size(); + jclass stringClass = env->FindClass("java/lang/String"); + jobjectArray array = env->NewObjectArray(arraySize, stringClass, NULL); + jmethodID constructorID = env->GetMethodID(stringClass, "", "(Ljava/lang/String;)V"); + for (int i = 0; i < arraySize; i++) { + jstring tempstr = env->NewStringUTF(vec[i].toStdString().c_str()); + jobject stringObject = env->NewObject(stringClass, constructorID, tempstr); + env->SetObjectArrayElement(array, i, stringObject); + } + return array; +} + +jobjectArray CplusToJava::QVectorL2jobjectArray(QVector vec, JNIEnv* env) +{ + jint arraySize = vec.size(); + jclass longClass = env->FindClass("java/lang/Long"); + jobjectArray array = env->NewObjectArray(arraySize, longClass, NULL); + jmethodID constructorID = env->GetMethodID(longClass, "", "(J)V"); + for (int i = 0; i < arraySize; i++) { + jobject longObject = env->NewObject(longClass, constructorID, vec[i]); + env->SetObjectArrayElement(array, i, longObject); + } + return array; +} + +jobjectArray CplusToJava::QVectorLL2jobjectArray(QVector vec, JNIEnv* env) +{ + jint arraySize = vec.size(); + jclass longClass = env->FindClass("java/lang/Long"); + jobjectArray array = env->NewObjectArray(arraySize, longClass, NULL); + jmethodID constructorID = env->GetMethodID(longClass, "", "(J)V"); + for (int i = 0; i < arraySize; i++) { + jobject longObject = env->NewObject(longClass, constructorID, vec[i]); + env->SetObjectArrayElement(array, i, longObject); + } + return array; +} + +jobjectArray CplusToJava::QVectorI2jobjectArray(QVector vec, JNIEnv* env) +{ + jint arraySize = vec.size(); + jclass intClass = env->FindClass("java/lang/Integer"); + jobjectArray array = env->NewObjectArray(arraySize, intClass, NULL); + jmethodID constructorID = env->GetMethodID(intClass, "", "(I)V"); + for (int i = 0; i < arraySize; i++) { + jobject intObject = env->NewObject(intClass, constructorID, vec[i]); + env->SetObjectArrayElement(array, i, intObject); + } + return array; +} + +jobjectArray CplusToJava::QVectorS2jobjectArray(QVector vec, JNIEnv* env) +{ + jint arraySize = vec.size(); + jclass intClass = env->FindClass("java/lang/Short"); + jobjectArray array = env->NewObjectArray(arraySize, intClass, NULL); + jmethodID constructorID = env->GetMethodID(intClass, "", "(S)V"); + for (int i = 0; i < arraySize; i++) { + jobject intObject = env->NewObject(intClass, constructorID, vec[i]); + env->SetObjectArrayElement(array, i, intObject); + } + return array; +} + +jobject CplusToJava::Createjobject(JNIEnv* env, jint esize, jobjectArray array) +{ + jobject arrayList = env->NewObject(env->FindClass("java/util/ArrayList"), env->GetMethodID(env->FindClass("java/util/ArrayList"), "", "()V")); + jmethodID addMethodID = env->GetMethodID(env->FindClass("java/util/ArrayList"), "add", "(Ljava/lang/Object;)Z"); + for (int i = 0; i < esize; i++) { + jobject element = env->GetObjectArrayElement(array, i); + env->CallBooleanMethod(arrayList, addMethodID, element); + } + return arrayList; +} + +jobjectArray CplusToJava::jobject2jobjectArray(JNIEnv* env, jobject array) +{ + jclass listClass = env->FindClass("java/util/List"); + jmethodID toArrayMethodID = env->GetMethodID(listClass, "toArray", "()[Ljava/lang/Object;"); + jobjectArray listValue = (jobjectArray)env->CallObjectMethod(array, toArrayMethodID); + return listValue; +} + +QVector CplusToJava::jobjectArray2QVectorD(JNIEnv* env, jobjectArray listValue) +{ + // Ԫ + jsize arrayLen = env->GetArrayLength(listValue); + QVector results; + for (int i = 0; i < arrayLen; i++) { + jobject element = env->GetObjectArrayElement(listValue, i); + jdouble value = env->CallDoubleMethod(element, env->GetMethodID(env->FindClass("java/lang/Double"), "doubleValue", "()D")); + results.push_back(value); + } + return results; +} + +QString CplusToJava::jstring2QString(JNIEnv* env, jstring jstr) +{ + const char* str = env->GetStringUTFChars(jstr, NULL); + std::string filename(str); + QString qstr = QString::fromStdString(filename); + + // ͷַڴ + env->ReleaseStringUTFChars(jstr, str); + return qstr; +} + +QString CplusToJava::getStructString(JNIEnv* env,jclass jcls,jobject jstruct, const char* name) +{ + jfieldID fieldIDname = env->GetFieldID(jcls, name, SIG_STRING); + jstring nameValue = (jstring)env->GetObjectField(jstruct, fieldIDname); + const char* aStr = env->GetStringUTFChars(nameValue, NULL); + QString result(aStr); + return result; +} + +double CplusToJava::DoubleLimit(const QString& _data) +{ + double rData = _data.toDouble(); + QString first = _data; + QStringList lstTemp = _data.split('.'); + if (lstTemp.size() > 1) + { + first = lstTemp.at(0); + // return rData; + } + if (first.size() > 3) + { + QString temp = QLatin1String("-"); + for (int pos = 1; pos < first.size(); pos++) + { + temp.append('9'); + } + if (temp == first) + { + return -999; + } + } + return rData; +} + +double CplusToJava::DoubleLimit(const double& _data) +{ + QString limit = QString::number(_data, 'f'); + double rData = DoubleLimit(limit); + return rData; +} + +QVector CplusToJava::DoubleLimit(QVector& data) +{ + for (int pos = 0; pos < data.size(); pos++) + { + data[pos] = QString::number(DoubleLimit(data.at(pos)), 'f'); + } + return data; +} + +QVector CplusToJava::DoubleLimit(QVector _data) +{ + QVector rdata; + for (int pos = 0; pos < _data.size(); pos++) + { + rdata << QString::number(DoubleLimit(_data.at(pos)), 'f'); + } + return rdata; +} + +QString CplusToJava::GetSqlBy(const QVector& _data, bool bSFlag) +{ + QString rData; + for (int pos = 0; pos < _data.size(); pos++) + { + if (bSFlag) + { + rData += QLatin1String("'"); + rData += _data.at(pos); + rData += QLatin1String("'"); + } + else + { + rData += _data.at(pos); + } + if (pos != _data.size() - 1) + { + rData += QLatin1String(","); + } + } + return rData; +} diff --git a/CplusToJava.h b/CplusToJava.h new file mode 100644 index 0000000..9f74aef --- /dev/null +++ b/CplusToJava.h @@ -0,0 +1,388 @@ +#pragma once + +#include "jni.h" +#include + +//javasigӦ +#define SIG_STRING "Ljava/lang/String;" +#define SIG_LIST "Ljava/util/List;" +#define SIG_DOUBLE "D" +#define SIG_INT "I" +#define SIG_LONG "J" +#define SIG_SHORT "S" +#define SIG_BOOL "Z" + +enum BindType { BIND_NONE, BIND_STRING, BIND_CHAR, BIND_DOUBLE, BIND_INT }; + +typedef struct _Read_Result_ +{ + /* Infomations */ + jstring msg_type; + jstring msg_id; + jstring data_type; + + /* Header Black */ + jstring designator; // designator + jstring site_code; // site code + jstring detector_code; // detector code + jstring system_type; // system type: P for particulate; B for gas with 3-D - coincidence detection; and + // G for all other gas systems (high-resolu-tion -spectrometry or 2-D - coinci-dence detection) + jstring sample_geometry; // sample geometry + jstring spectrum_quantity; // spectrum qualifier: preliminary ( PREL )or full ( FULL) + jstring sample_ref_id; // sample reference identification + jstring measurement_id; // measurement identification + jstring detector_bk_measurement_id; // detector background measurement identification + jstring gas_bk_measurement_id; // gas background measurement identification (memory effect) + jstring transmit_date; // transmit date (yyyy / mm / dd) + jstring transmit_time; // transmit time (hh : mm : ss . s) + + /* Comment Block */ + jstring comment; + + /* Sample Block */ + jdouble dimension_1; + jdouble dimension_2; + + /* Acquisition Block */ + jstring acquisition_start_date; // acquisition start date (yyyy / mm / dd) + jstring acquisition_start_time; // acquisition start time (hh : mm : ss . s) + jdouble acquisition_real_time; // acquisition real time (s) + jdouble acquisition_live_time; // acquisition live time (s) + + /* Collection Block */ + jstring collection_start_date; // collection start date (yyyy / mm / dd) + jstring collection_start_time; // collection start time (hh : mm : ss . s) + jstring collection_stop_date; // collection stop date (yyyy / mm / dd) + jstring collection_stop_time; // collection stop time (hh : mm : ss . s) + jdouble air_volume; // total air volume sampled (standard cubic meters [scm]) + + /* Processing Block */ + jdouble sample_volume_of_Xe; // sample volume of Xe (cm 3 ) + jdouble uncertainty_1; // uncertainty (cm 3 ) + jdouble Xe_collection_yield; // Xe collection yield (Xe gas in sample/total Xe gas sampled) + jdouble uncertainty_2; // uncertainty (Xe gas in sample/total Xe gas sampled) + jstring archive_bottle_id; // archive bottle identification + + /* Calibration Block */ + jstring date_calibration; // date of last calibration (yyyy / mm / dd) + jstring time_calibration; // time of last calibration (hh : mm : ss) + + /* g_Energy Block */ + jobjectArray g_energy; // -energy (keV) + jobjectArray g_centroid_channel; // centroid channel + jobjectArray g_uncertainty; // uncertainty (channels) + jint g_record_count; + + /* b_Energy Block */ + jobjectArray b_electron_energy; // electron energy (keV) + jobjectArray b_decay_mode; // decay mode descriptor: B for -particle, C for conversion electron (CE) + jobjectArray b_channel; // maximum channel of -particle distribution or centroid channel of CE (channels) + jobjectArray b_uncertainty; // uncertainty (channels) + jint b_record_count; + + /* g_Resolution Block */ + jobjectArray g_r_energy; // -energy (keV) + jobjectArray g_r_FWHM; // FWHM (keV) + jobjectArray g_r_uncertainty; // uncertainty (keV) + jint g_r_record_count; + + /* b_Resolution Block */ + jobjectArray b_r_electron_energy; // electron energy (keV) + jobjectArray b_r_FWHM; // FWHM (keV) + jobjectArray b_r_uncertainty; // uncertainty (keV) + jint b_r_record_count; + + /* g_Efficiency Block */ + jobjectArray g_e_energy; // -energy (keV) + jobjectArray g_e_efficiency; // efficiency (counts in peak/photon emitted) + jobjectArray g_e_uncertainty; // uncertainty (counts in peak/photon emitted) + jint g_e_record_count; + + /* ROI_Limits Block */ + jobjectArray ROI_number; // ROI number + jobjectArray POI_B_x1; // 2-D ROI -range start, x 1 (keV) + jobjectArray POI_B_x2; // 2-D ROI -range stop, x 2 (keV) + jobjectArray POI_G_y1; // 2-D ROI -range start, y 1 (keV) + jobjectArray POI_G_y2; // 2-D ROI -range stop, y 2 (keV) + jint roi_record_count; + + /* b-gEfficiency Block */ + jobjectArray bg_nuclide_name; // nuclide name + jobjectArray bg_ROI_number; // ROI number + jobjectArray bg_efficiency; // - coincidence efficiency (counts in ROI/- pair emitted) + jobjectArray bg_uncertainty; // uncertainty (counts in ROI/- pair emitted) + jint bg_record_count; + + /* Ratios Block */ + jobjectArray ratio_id; // ratio identifier + jobjectArray ROI_num_highter_G_energy_ROI; // ROI number for the higher -energy ROI + jobjectArray ROI_num_lower_G_energy_ROI; // ROI number for the lower -energy ROI + jobjectArray count_ratio; // Q_DECLARE_METATYPE(RMSSOHData::HeaderBlock)count ratio(counts in higher -energy ROI/counts in lower -energy ROI) + jobjectArray count_ratio_uncertainty; // count ratio uncertainty (percent) + jint ratio_record_count; + + /* g_Spectrum Block */ + jlong num_g_channel; // number of channels + jlong g_energy_span; // -energy span (keV) + jlong g_begin_channel; // begin of channels + jobjectArray g_counts; // count at channel + + /* b_Spectrum Block */ + jlong num_b_channel; // number of -channels + jlong b_energy_span; // -energy span (keV) + jlong b_begin_channel; // begin of channels + jobjectArray b_counts; // counts at channels + + /* Histogram Block */ + jlong b_channels; // -channels + jlong g_channels; // -channels + jlong b_h_energy_span; // -energy span + jlong g_h_energy_span; // -energy span + jobjectArray h_counts; // counts at channels + + /* Certificate Block */ + jdouble total_source_activity = 0; // total source activity (Bq) + jstring assay_date; // assay date (yyyy / mm / dd) + jstring assay_time; // assay time (hh : mm : ss) + jstring units_activity; // units of activity: B, b for Bq or [blank]; if nothing, then B is assigned + jobjectArray nuclide_name; // nuclide name + jobjectArray half_life_time; // half-life in seconds, hours, days, or years + jobjectArray time_unit; // time unit(Y, D, H, S) + jobjectArray activity_nuclide_time_assay; // activity of nuclide at time of assay + jobjectArray uncertainty; // uncertainty (%) + jobjectArray cer_g_energy; // -energy (keV) + jobjectArray g_intensity; // -intensity (percent) + jobjectArray electron_decay_mode; // electron decay mode descriptor: B for particle or C for conversion electron (CE), 0 for none (that is, -only source) + jobjectArray maximum_energy; // maximum -particle energy or CE energy (keV) + jobjectArray intensity_b_particle; // intensity of -particle (percent) + jint record_count = 0; + + /* Totaleff Block */ + jobjectArray t_g_energy; // -energy (keV) + jobjectArray total_efficiency; // total efficiency (counts/photon emitted) + jobjectArray t_uncertainty; // uncertainty (counts/photon emitted) + jint t_record_count; + +}ReadResult; + +typedef struct _Generate_Result_ +{ + //BgGasGenerate BgGas; + jobjectArray g_ROI_B_Boundary_start; + jobjectArray g_ROI_B_Boundary_stop; + jobjectArray g_ROI_G_Boundary_start; + jobjectArray g_ROI_G_Boundary_stop; + jobjectArray g_roi_cts; //屾׸Ȥ + jobjectArray g_deduct_d_cts; //屾׿۳̽ + jint g_b_fitting_type; + jint g_g_fitting_type; + jobjectArray g_b_fitting_e_c; + jobjectArray g_g_fitting_e_c; + jobjectArray g_b_fitting_c_e; + jobjectArray g_g_fitting_c_e; + + //BgSampleGenerate BgSample; + //BgBoundary s_boungdary; + jobjectArray s_ROI_B_Boundary_start; + jobjectArray s_ROI_B_Boundary_stop; + jobjectArray s_ROI_G_Boundary_start; + jobjectArray s_ROI_G_Boundary_stop; + jobjectArray s_roi_cts; //ƷոȤ + jobjectArray s_deduct_d_cts; //Ʒ׿۳̽ + jint s_b_fitting_type; + jint s_g_fitting_type; + jobjectArray s_b_fitting_e_c; + jobjectArray s_g_fitting_e_c; + jobjectArray s_b_fitting_c_e; + jobjectArray s_g_fitting_c_e; + jstring s_collection_time; //ɼʱ + + //BgOtherGenerate BgOther; + jobjectArray ROI_net_coutns; //Ȥ + jobjectArray ROI_net_err; + jobjectArray ROI_con_uncer; //ȤŨȺͲȷ [n..0]Ũ [n..1]ȷ + jobjectArray ROI_con_counts_factor; //ȤŨȼϵ [n..0]ϵ + //enum XeType{both,_131m,_133m,none}; + jstring XeType; + jdouble LC_Xe135; //LC XE135 + jdouble LC_Xe131m; //LC XE131m + jdouble LC_Xe133m; //LC XE133m + jdouble LC_Xe133; //LC XE133 + jobjectArray LC; + jobjectArray LC_CTS; + jdouble MDC_Xe135; //MDC XE135 + jdouble MDC_Xe131m; //MDC XE131m + jdouble MDC_Xe133m; //MDC XE133m + jdouble MDC_Xe133; //MDC XE133 + jobjectArray MDC; + jobjectArray MDC_CTS; + jdouble Xe135_con; //135Ũ + jdouble Xe135_uncer; //135ȷ + jdouble Xe131m_con; + jdouble Xe131m_uncer; + jdouble Xe133m_con; + jdouble Xe133m_uncer; + jdouble Xe133_con; + jdouble Xe133_uncer; + jobjectArray ROI_B_Boundary_start; + jobjectArray ROI_B_Boundary_stop; + jobjectArray ROI_G_Boundary_start; + jobjectArray ROI_G_Boundary_stop; + jobjectArray d_roi_cts; //̽׸Ȥ + // Ϻֵ + jint b_fitting_type; + jint g_fitting_type; + jobjectArray b_fitting_e_c; + jobjectArray g_fitting_e_c; + jobjectArray b_fitting_c_e; + jobjectArray g_fitting_c_e; + //BgDetbgrGenerate BgDetbgr; + jobjectArray d_ROI_B_Boundary_start; + jobjectArray d_ROI_B_Boundary_stop; + jobjectArray d_ROI_G_Boundary_start; + jobjectArray d_ROI_G_Boundary_stop; + jobjectArray d_d_roi_cts; //̽׸Ȥ + jint d_b_fitting_type; + jint d_g_fitting_type; + jobjectArray d_b_fitting_e_c; + jobjectArray d_g_fitting_e_c; + jobjectArray d_b_fitting_c_e; + jobjectArray d_g_fitting_c_e; +}GenerateResult; + +typedef struct _SOHFile_Result_ +{ + /* Header block */ + jstring station_code; // station code + jstring detector_code; // detector code or NA if 1) there is more than one detector or 2) data are from the sam-pling site of a split station + jstring start_date; // SOH data sampling period start date (yyyy/mm/dd) + jstring start_time; // SOH data sampling period start time (hh:mm:ss) + jstring designator; // designator + jstring end_date; // SOH data sampling period end date (yyyy/mm/dd) + jstring end_time; // SOH data sampling period end time (hh:mm:ss) + jstring transmit_date; // transmit date (yyyy/mm/dd) + jstring transmit_time; // transmit time (hh:mm:ss) + + /* Air Sampler Flow block */ + jobjectArray average_flow_rate; // average flow rate (standard cubic metersper hour (scm/h)) + jobjectArray flow_rate_standard_deviation; // flow rate standard deviation (scm/h) + jobjectArray af_start_date; // SOH data sampling interval start date (yyyy/mm/dd) + jobjectArray af_start_time; // SOH data sampling interval start time (hh:mm:ss) + jobjectArray af_interval_duration; // SOH data sampling interval duration (s) + jint af_record_count; + + /* Air Sampler Env block */ + jobjectArray temperature; // average air temperature after filter (C) + jobjectArray pressure; // average static air pressure after filter (hPa) + jobjectArray ae_date; // date (yyyy/mm/dd) + jobjectArray ae_time; // time (hh:mm:ss) + jobjectArray ae_interval_duration; // SOH data sampling interval duration (s) + jint ae_record_count; + + /* Det Env block */ + jobjectArray room_temperature; // average room temperature (C) + jobjectArray detector_shield_status; // detector shield status (OPEN or CLOSED) + jobjectArray humidity; // average room humidity (in percent relative humidity) + jobjectArray d_voltage; // detector high voltage (V) + jobjectArray crystal_temperature; // average crystal temperature (C) + jobjectArray electric_cooler_status; // electric cooler status (ON or OFF) + jobjectArray fill_fraction; // liquid nitrogen fill-fraction + jobjectArray leakage; // detector leakage current (nanoamperes [nA]) + jobjectArray d_date; // date (yyyy/mm/dd) + jobjectArray d_time; // time (hh:mm:ss) + jobjectArray d_interval_duration; // SOH data sampling interval duration (s) + jint d_record_count; + + /* NIMBIN block */ + jobjectArray flag; // +/- + jobjectArray n_voltage; // average NIMBIN voltage (V) + jobjectArray n_date; // date (yyyy/mm/dd) + jobjectArray n_time; // time (hh:mm:ss) + jobjectArray n_interval_duration; // SOH data sampling interval duration (s) + jint n_record_count; + + /* Power Supply block */ + jobjectArray MAIN; // MAIN (for MAIN power supply) + jobjectArray main_power_status; // status of main power supply (ON/OFF) + jobjectArray AUX; // AUX (for AUXiliary power supply) + jobjectArray aux_power_status; // status of auxiliary power supply (ON/OFF) + jobjectArray UPS; // UPS (for Uninterrupted Power Supply) + jobjectArray ups_status; // status of uninterruptedly power supply (ON/ OFF) + jobjectArray p_date; // date (yyyy/mm/dd) + jobjectArray p_time; // time (hh:mm:ss) + jobjectArray p_interval_duration; // SOH data sampling interval duration (s) + jint p_record_count; + + /* Equip Status block */ + jobjectArray C_value; // status of sampling system (ON/OFF) or the SRID of the sample being collected + jobjectArray P_value; // status of sample preparation, processing, or decay (ON/OFF) or the SRID of the sample being processed or decayed + jobjectArray A_value; // status of detector system (ON/OFF) or the SRID of the sample being counted + jobjectArray e_date; // date (yyyy/mm/dd) + jobjectArray e_time; // time (hh:mm:ss) + jobjectArray e_interval_duration; // SOH data sampling interval duration (s) + jint e_record_count; + + /* Tamper Env block */ + jobjectArray tamper_sensor_name; // tamper sensor name + jobjectArray tamper_sensor_status; // tamper sensor status (OPEN or CLOSED) + jobjectArray t_date; // date (yyyy/mm/dd) + jobjectArray t_time; // time (hh:mm:ss) + jobjectArray t_interval_duration; // SOH data sampling interval duration (s) + jint t_record_count; + + /* Process Sensors block */ + jobjectArray sensor_type; // sensor type (TEMP, PRESSURE,PROCESSFLOW, VOLTAGE, COUN-TRATES, DEWPOINT, CO2VOLUME) + jobjectArray sensor_name; // tamper sensor status (OPEN or CLOSED) + jobjectArray sensor_reading; // sensor reading (TEMP in C, PRESSURE in Pa, PROCESSFLOW in m3/h, VOLT-AGE in V, COUNTRATE in counts/s, DEWPOINT in C, CO2VOLUME in cm3) + jobjectArray ps_date; // date (yyyy/mm/dd) + jobjectArray ps_time; // time (hh:mm:ss) + jobjectArray ps_duration; // SOH duration (s) + jint ps_record_count; + + /* Chromatogram block */ + jstring srid; // the SRID of the sample being counted + jobjectArray interval_number; // interval number (starts at 1) + jobjectArray interval_start_channel; // interval start channel + jobjectArray c_duration; // duration between chromatogram readings (in seconds [s]) + jint interval_record_count; + jlong total_number; // total number of chromatogram readings + jobjectArray detector_response; // detector response +}SOHFileResult; + +class CplusToJava +{ +public: + static jobjectArray GetjobjectArray(JNIEnv* env, jclass jcls, jobject jstruct, std::string var); + //QVectorתΪjobjectArray + static jobjectArray QVectorD2jobjectArray(QVector vec, JNIEnv* env); + //QVectorתΪjobjectArray + static jobjectArray QVectorQS2jobjectArray(QVector vec, JNIEnv* env); + //QVectorתΪjobjectArray + static jobjectArray QVectorL2jobjectArray(QVector vec, JNIEnv* env); + //QVectorתΪjobjectArray + static jobjectArray QVectorLL2jobjectArray(QVector vec, JNIEnv* env); + //QVectorתΪjobjectArray + static jobjectArray QVectorI2jobjectArray(QVector vec, JNIEnv* env); + //QVectorתΪjobjectArray + static jobjectArray QVectorS2jobjectArray(QVector vec, JNIEnv* env); + //jobject + static jobject Createjobject(JNIEnv* env, jint esize, jobjectArray array); + //jobjectתΪjobjectArray + static jobjectArray jobject2jobjectArray(JNIEnv* env, jobject array); + //jobjectArrayתΪQVector + static QVector jobjectArray2QVectorD(JNIEnv* env, jobjectArray listValue); + //jstringתΪQString + static QString jstring2QString(JNIEnv* env, jstring jstr); + + //ṹȡ + static QString getStructString(JNIEnv* env, jclass jcls, jobject jstruct, const char* name); + + //-999ж + static double DoubleLimit(const double& _data); + static double DoubleLimit(const QString& _data); + static QVector DoubleLimit(QVector& data); + static QVector DoubleLimit(QVector _data); + + static QString GetSqlBy(const QVector& _data, bool bSFlag); +}; + diff --git a/DataManager_Define.h b/DataManager_Define.h new file mode 100644 index 0000000..191288e --- /dev/null +++ b/DataManager_Define.h @@ -0,0 +1,707 @@ +#ifndef DATA_MANAGE_DEFINE_H +#define DATA_MANAGE_DEFINE_H + +#include +#include +#include +#include + +#define DATE_FORMAT QLatin1String("yyyy/MM/dd") +#define TIME_FORMAT QLatin1String("hh:mm:ss.z") +#define DATATIME_FORMAT QLatin1String("yyyy/MM/dd hh:mm:ss.z") +#define DATATIME_FORMAT_NOSPACE QLatin1String("yyyy/MM/ddhh:mm:ss.z") +#define DATATIME_FORMAT_SECONDS QLatin1String("yyyy/MM/ddhh:mm:ss") + +#define DATATIME_FORMAT_SPACE_SECONDS QLatin1String("yyyy/MM/dd hh:mm:ss") + +#define ORDER_HEADER QLatin1String("#Header") +#define ORDER_COMMENT QLatin1String("#Comment") +#define ORDER_COLLECTION QLatin1String("#Collection") +#define ORDER_ACQUISITION QLatin1String("#Acquisition") +#define ORDER_PROCESSING QLatin1String("#Processing") +#define ORDER_SAMPLE QLatin1String("#Sample") +#define ORDER_G_ENERGY QLatin1String("#g_Energy") +#define ORDER_B_ENERGY QLatin1String("#b_Energy") +#define ORDER_G_RESOLUTION QLatin1String("#g_Resolution") +#define ORDER_B_RESOLUTION QLatin1String("#b_Resolution") +#define ORDER_G_EFFICIENCY QLatin1String("#g_Efficiency") +#define ORDER_ROI_LIMITS QLatin1String("#ROI_Limits") +#define ORDER_B_GEFFICIENCY QLatin1String("#b-gEfficiency") +#define ORDER_TOTALEFF QLatin1String("#TotalEff") +#define ORDER_RATIOS QLatin1String("#Ratios") +#define ORDER_G_SPECTRUM QLatin1String("#g_Spectrum") +#define ORDER_B_SPECTRUM QLatin1String("#b_Spectrum") +#define ORDER_HISTOGRAM QLatin1String("#Histogram") +#define ORDER_CALIBRATION QLatin1String("#Calibration") +#define ORDER_CERTIFICATE QLatin1String("#Certificate") +#define ORDER_STOP QLatin1String("STOP") +#define ORDER_BEGIN QLatin1String("BEGIN") +#define DATATYPE_QCPHD QLatin1String("QCPHD") +#define DATATYPE_DETBKPHD QLatin1String("DETBKPHD") +#define DATATYPE_SAMPLEPHD QLatin1String("SAMPLEPHD") +#define DATATYPE_GASBKPHD QLatin1String("GASBKPHD") +#define DATETYPE_SOH QLatin1String("RMSSOH") +#define DATETYPE_MET QLatin1String("MET") +#define DATETYPE_ALERT_FLOW QLatin1String("ALERT_FLOW") +#define DATETYPE_ALERT_SYSTEM QLatin1String("ALERT_SYSTEM") +#define DATETYPE_ALERT_TEMP QLatin1String("ALERT_TEMP") +#define DATETYPE_ALERT_UPS QLatin1String("ALERT_UPS") +#define SYSTEMTYPE_P QLatin1String("P") //P for particulate; +#define SYSTEMTYPE_B QLatin1String("B") //B for gaswith 3-D β - γ coincidence detection +#define SYSTEMTYPE_G QLatin1String("G") //G for all other gas systems (high-resolu-tion γ-spectrometry or 2-D β-γ coinci-dence detection) + +#define FILE_SAMPLE_NAME_FORMAT QLatin1String("[a-zA-Z]{3}[0-9]{2}_[0-9]{3}-[0-9]{8}_[0-9]{4}(_S.PHD)$") +#define FILE_ALL_NAME_FORMAT QLatin1String("[a-zA-Z]{3}[0-9]{2}_[0-9]{3}-[0-9]{8}_[0-9]{4}(_G.PHD|_Q.PHD|_S.PHD|_D.PHD)$") + + +#define DEFAULT_DATA_PATH QLatin1String("DefaultData") + +#define CFG_FILE_PATH tr("./cfg/") +#define CFG_FILE_NAME tr("filecfg.ini") +#define CFG_DELETE_FILE_NAME tr("filedelete.ini") + +#define GROUP_DELETE_FILE tr("file") +#define KEY_DELETE_FILE tr("time") +//#define VALUE_DELETE_FILE tr("") + +#define GROUP_CFG_FILE tr("FILE_NAME") +#define KEY_BG_AUTO_PROCESS tr("AUTO_DATA_PROCESS") +#define VALUE_BG_AUTO_PROCESS_FILE_NAME tr("auto_data_process.ini") + +#define GROUP_BG_THREAD tr("THREAD") +#define KEY_GROUP_BG_THREAD_LIMIT tr("NUMBER") +#define VALUE_GROUP_BG_THREAD_LIMIT tr("2") + +#define GROUP_BG_AUTO_ACQUIR tr("GET") +#define KEY_BG_AUTO_FILE_SOURCE_PATH tr("DETECT_FILE_PATH") +#define VALUE_BG_AUTO_FILE_SOURCE_PATH tr("./datatest/filesource/") + +//#define GROUP_BG_AUTO_ACQUIR tr("acquire") +//#define KEY_BG_AUTO_FILE_MAIL_SAVE_PATH tr("FILEMAILSAVEPATH") +//#define VALUE_BG_AUTO_FILE_MAIL_SAVE_PATH tr("./datatest/mailload/") + + +//#define KEY_BG_AUTO_ACUIRE_MAILTIMEOUT tr("MAILDETECTTIMEOUT") +//#define VALUE_BG_AUTO_ACUIRE_MAILTIMEOUT tr("3") + +#define KEY_BG_AUTO_ACUIRE_FILETIMEOUT tr("DETECT_FILE_INTERVAL_TIME") +#define VALUE_BG_AUTO_ACUIRE_FILETIMEOUT tr("600") + +#define GROUP_BG_AUTO_LOG tr("LOG") +#define KEY_BG_AUTO_LOG_PATH tr("PATH") +#define VALUE_BG_AUTO_LOG_PATH tr("./datatest/log") + +#define GROUP_BG_AUTO_DEAL tr("DEAL") +#define KEY_BG_AUTO_DEAL_TIMEOUT tr("UN_DEAL_SEARCH_FILE_TIMEOUT") +#define VALUE_BG_AUTO_DEAL_TIMEOUT tr("43200") + +#define KEY_BG_AUTO_DEAL_ID_TIMEOUT tr("UN_DEAL_SEARCH_ID_TIMEOUT") +#define VALUE_BG_AUTO_DEAL_ID_TIMEOUT tr("43200") + +#define KEY_BG_AUTO_DEAL_TIMEDETECT tr("UN_DEAL_FILE_DETECT_TIME") +#define VALUE_BG_AUTO_DEAL_TIMEDETECT tr("1800") + +#define KEY_BG_AUTO_STATISTICS_TIME tr("STATISTICS_TIME") +#define VALUE_BG_AUTO_STATISTICS_TIME tr("24") + +#define KEY_BG_AUTO_DELETE_FILE_INTERVAL_TIMEE tr("DELETE_FILE_INTERVAL_TIME") +#define VALUE_BG_AUTO_SDELETE_FILE_INTERVAL_TIME tr("30") + +#define KEY_BG_AUTO_FILE_SAVE_PATH tr("FILE_SAVE_PATH") +#define VALUE_BG_AUTO_FILE_SAVE_PATH tr("./datatest/savefile/") + +#define KEY_BG_AUTO_DETAGAS_DEFAULT_PATH tr("DETA_GAS_DEFAULT_PATH") +#define VALUE_BG_AUTO_DETAGAS_DEFAULT_PATH tr("./defaultdata/detagas/") + +#define KEY_BG_AUTO_DEAL_NODEALFILEPATH tr("UN_DEAL_FILE_PATH") +#define VALUE_BG_AUTO_DEAL_NODEALFILEPATH tr("./datatest/undeal/") + +#define KEY_DATABASE_FIEL_PATH tr("DATA_BASE") +#define VALUE_DATABASE_FIEL_PATH tr("data_base.ini") + +#define GROUP_DATABASE tr("DATA_BASE") +#define KEY_DATABASE_TYPE tr("TYPE") +#define VALUE_DATABASE_TYPE tr("MYSQL") + +#define GROUP_DATABASE_MYSQL tr("MYSQL") +#define GROUP_DATABASE_ORACLE tr("ORACLE") + +#define KEY_DATABASE_HOSTNAME tr("HOSTNAME") +#define VALUE_DATABASE_HOSTNAME tr("192.168.0.101") + +#define KEY_DATABASE_DATABASENAME tr("DATA_BASE_NAME") +#define VALUE_DATABASE_DATABASENAME tr("configuration") + +#define KEY_DATABASE_USERNAME tr("USERNAME") +#define VALUE_DATABASE_USERNAME tr("root") + +#define KEY_DATABASE_PASSWORD tr("PASSWORD") +#define VALUE_DATABASE_PASSWORD tr("123456") + +#define KEY_DATABASE_PORT tr("PORT") +#define VALUE_DATABASE_PORT tr("3306") + +#define VALUE_DATABAS_ORACLE_HOSTNAME tr("192.168.0.119") + +#define VALUE_DATABASE_ORACLE_DATABASENAME tr("orcl") + +#define VALUE_DATABASE_ORACLE_USERNAME tr("configuration") + +#define VALUE_DATABASE_ORACLE_PASSWORD tr("123456") + +#define VALUE_DATABASE_ORACLE_PORT tr("1521") + + +#define KEY_EMAIL_FIEL_PATH tr("EMAIL") +#define VALUE_EMAIL_FIEL_PATH tr("email.ini") + +#define GROUP_EMAIL_SEND tr("SEND") + +#define KEY_EMAIL_SEND_USER tr("USER") +#define VALUE_EMAIL_SEND_USER tr("xuhai_cpp@sina.com") + +#define KEY_EMAIL_SEND_PASSWD tr("PASSWD") +#define VALUE_EMAIL_SEND_PASSWD tr("abc123456") + +#define KEY_EMAIL_SEND_SERVER tr("SERVER") +#define VALUE_EMAIL_SEND_SERVER tr("smtp.sina.com") + +#define KEY_EMAIL_SEND_PORT tr("PORT") +#define VALUE_EMAIL_SEND_PORT tr("25") + +#define KEY_EMAIL_SEND_CONNECTTYPE tr("CONNECT_TYPE") +#define VALUE_EMAIL_SEND_CONNECTTYPE tr("0") + +#define KEY_EMAIL_SEND_RECEIVER tr("RECEIVER") +#define VALUE_EMAIL_SEND_RECEIVER tr("1327783389@qq.com") + +#define KEY_EMAIL_SEND_INTERVAL tr("SEND_INTERVAL") +#define VALUE_EMAIL_SEND_INTERVAL tr("10") + +//#define GROUP_EMAIL_GET tr("GET") + +#define KEY_EMAIL_GET_USER tr("USER") +#define VALUE_EMAIL_GET_USER tr("cnndc.rn") + +#define KEY_EMAIL_GET_PASSWD tr("PASSWD") +#define VALUE_EMAIL_GET_PASSWD tr("367220") + +#define KEY_EMAIL_GET_SERVER tr("SERVER") +#define VALUE_EMAIL_GET_SERVER tr("192.168.10.59") + +#define KEY_EMAIL_GET_PORT tr("PORT") +#define VALUE_EMAIL_GET_PORT tr("143") + +#define KEY_EMAIL_GET_CONNECTTYPE tr("CONNECT_TYPE") +#define VALUE_EMAIL_GET_CONNECTTYPE tr("0") + +#define KEY_EMAIL_GET_FILE_SAVEPATH tr("FILE_SAVE_PATH") +#define VALUE_EMAIL_GET_FILE_SAVE_PATH tr("./datatest/mailload/") + +#define KEY_EMAIL_GET_EML_SAVE_PATH tr("EML_SAVE_PATH") +#define VALUE_EMAIL_GET_EML_SAVE_PATH tr("./datatest/eml/") + +#define KEY_EMAIL_GET_EML_INTERVAL_TIME tr("GET_EMAIL_INTERVAL_TIME") +#define VALUE_EMAIL_GET_EML_INTERVAL_TIME tr("600") + + +#define GROUP_EMAIL_GET_PROCESS tr("GET_PROCESS") + +#define KEY_EMAIL_GET_FILE_SAVEPATH tr("FILE_SAVE_PATH") +#define VALUE_EMAIL_GET_FILE_SAVE_PATH tr("./datatest/mailload/") + +#define KEY_EMAIL_GET_EML_SAVE_PATH tr("EML_SAVE_PATH") +#define VALUE_EMAIL_GET_EML_SAVE_PATH tr("./datatest/eml/") + +#define KEY_EMAIL_GET_EML_INTERVAL_TIME tr("GET_EMAIL_INTERVAL_TIME") +//#define VALUE_EMAIL_GET_EML_INTERVAL_TIME tr("1800") + + +#define GROUP_EMAIL_GET tr("GET_MAIL") +#define GROUP_EMAIL_GET_ONE tr("GET_MAIL_1") +#define GROUP_EMAIL_GET_TWO tr("GET_MAIL_2") + +#define KEY_EMAIL_GET_USER tr("USER") +#define VALUE_EMAIL_GET_USER tr("cnndc.rn") + +#define KEY_EMAIL_GET_PASSWD tr("PASSWD") +#define VALUE_EMAIL_GET_PASSWD tr("367220") + +#define KEY_EMAIL_GET_SERVER tr("SERVER") +#define VALUE_EMAIL_GET_SERVER tr("192.168.10.59") + +#define KEY_EMAIL_GET_PORT tr("PORT") +#define VALUE_EMAIL_GET_PORT tr("143") + +typedef struct _Message_Infomations_ +{ + /* Infomations */ + QString msg_type; + QString msg_id; + QString msg_src_code; + QString ref_id_str; + QString ref_src_code; + QString seq_num; + QString tot_num; + QString product_id; + QString delivery_id; + QString data_type; + bool verify_srid; +} +MessageInfo, *PtMessageInfo; +Q_DECLARE_METATYPE(MessageInfo) + +/* Commect Block */ +typedef QString CommentBlock; +Q_DECLARE_METATYPE(CommentBlock) + +namespace RadionuclideData +{ + enum AnalyseDataType + { + InvalidData, + GammaAnalyseData, + BetaGammaAnalyseData + }; + + typedef struct _Header_Block_ + { + /* Header Black */ + QString designator; // designator + QString site_code; // site code + QString detector_code; // detector code + QString system_type; // system type: P for particulate; B for gas with 3-D β - γ coincidence detection; and + // G for all other gas systems (high-resolu-tion γ-spectrometry or 2-D β-γ coinci-dence detection) + QString sample_geometry; // sample geometry + QString spectrum_quantity; // spectrum qualifier: preliminary ( PREL )or full ( FULL) + QString sample_ref_id; // sample reference identification + QString measurement_id; // measurement identification + QString detector_bk_measurement_id; // detector background measurement identification + QString gas_bk_measurement_id; // gas background measurement identification (memory effect) + QString transmit_date; // transmit date (yyyy / mm / dd) + QString transmit_time; // transmit time (hh : mm : ss . s) + } + HeaderBlock, *PtHeaderBlock; + + typedef struct _Acquisition_Block_ + { + /* Acquisition Block */ + QString acquisition_start_date; // acquisition start date (yyyy / mm / dd) + QString acquisition_start_time; // acquisition start time (hh : mm : ss . s) + double acquisition_real_time; // acquisition real time (s) + double acquisition_live_time; // acquisition live time (s) + } + AcquisitionBlock, *PtAcquisitionBlock; + + typedef struct _Collection_Block_ + { + /* Collection Block */ + QString collection_start_date; // collection start date (yyyy / mm / dd) + QString collection_start_time; // collection start time (hh : mm : ss . s) + QString collection_stop_date; // collection stop date (yyyy / mm / dd) + QString collection_stop_time; // collection stop time (hh : mm : ss . s) + double air_volume; // total air volume sampled (standard cubic meters [scm]) + } + CollectionBlock, *PtCollectionBlock; + + typedef struct _Processing_Block_ + { + /* Processing Block */ + double sample_volume_of_Xe; // sample volume of Xe (cm 3 ) + double uncertainty_1; // uncertainty (cm 3 ) + double Xe_collection_yield; // Xe collection yield (Xe gas in sample/total Xe gas sampled) + double uncertainty_2; // uncertainty (Xe gas in sample/total Xe gas sampled) + QString archive_bottle_id; // archive bottle identification + } + ProcessingBlock, *PtProcessingBlock; + + typedef struct _Sample_Block_ + { + /* Sample Block */ + double dimension_1; + double dimension_2; + } + SampleBlock, *PtSampleBlock; + + typedef struct _Calibration_Block_ + { + /* Calibration Block */ + QString date_calibration; // date of last calibration (yyyy / mm / dd) + QString time_calibration; // time of last calibration (hh : mm : ss) + } + CalibrationBlock, *PtCalibrationBlock; + + typedef struct _g_Energy_Block_ + { + /* g_Energy Block */ + QVector g_energy; // γ -energy (keV) + QVector centroid_channel; // centroid channel + QVector uncertainty; // uncertainty (channels) + int record_count; + } + G_EnergyBlock, *PtG_EnergyBlock; + + typedef struct _b_Energy_Block_ + { + /* b_Energy Block */ + QVector electron_energy; // electron energy (keV) + QVector decay_mode; // decay mode descriptor: B for β-particle, C for conversion electron (CE) + QVector channel; // maximum channel of β-particle distribution or centroid channel of CE (channels) + QVector uncertainty; // uncertainty (channels) + int record_count; + } + B_EnergyBlock, *PtB_EnergyBlock; + + typedef struct _g_Resolution_Block_ + { + /* g_Resolution Block */ + QVector g_energy; // γ -energy (keV) + QVector FWHM; // FWHM (keV) + QVector uncertainty; // uncertainty (keV) + int record_count; + } + G_ResolutionBlock, *PtG_ResolutionBlock; + + typedef struct _b_Resolution_Block_ + { + /* b_Resolution Block */ + QVector electron_energy; // electron energy (keV) + QVector FWHM; // FWHM (keV) + QVector uncertainty; // uncertainty (keV) + int record_count; + } + B_ResolutionBlock, *PtB_ResolutionBlock; + + typedef struct _g_Efficiency_Block_ + { + /* g_Efficiency Block */ + QVector g_energy; // γ -energy (keV) + QVector efficiency; // efficiency (counts in peak/photon emitted) + QVector uncertainty; // uncertainty (counts in peak/photon emitted) + int record_count; + } + G_EfficiencyBlock, *PtG_EfficiencyBlock; + + typedef struct _ROI_Limits_Block_ + { + /* ROI_Limits Block */ + QVector ROI_number; // ROI number + QVector POI_B_x1; // 2-D ROI β-range start, x 1 (keV) + QVector POI_B_x2; // 2-D ROI β-range stop, x 2 (keV) + QVector POI_G_y1; // 2-D ROI γ-range start, y 1 (keV) + QVector POI_G_y2; // 2-D ROI γ-range stop, y 2 (keV) + int record_count; + } + ROI_LimitsBlock, *PtROI_LimitsBlock; + + typedef struct _BG_Efficiency_Block_ + { + /* b-gEfficiency Block */ + QVector nuclide_name; // nuclide name + QVector ROI_number; // ROI number + QVector bg_efficiency; // β-γ coincidence efficiency (counts in ROI/β-γ pair emitted) + QVector uncertainty; // uncertainty (counts in ROI/β-γ pair emitted) + int record_count; + } + BG_EfficiencyBlock, *PtBG_EfficiencyBlock; + + + typedef struct _Totaleff_Block_ + { + /* Totaleff Block */ + QVector g_energy; // γ-energy (keV) + QVector total_efficiency; // total efficiency (counts/photon emitted) + QVector uncertainty; // uncertainty (counts/photon emitted) + int record_count; + } + TotaleffBlock, *PtTotaleffBlock; + + typedef struct _Ratios_Block_ + { + /* Ratios Block */ + QVector ratio_id; // ratio identifier + QVector ROI_num_highter_G_energy_ROI; // ROI number for the higher γ -energy ROI + QVector ROI_num_lower_G_energy_ROI; // ROI number for the lower γ -energy ROI + QVector count_ratio; // Q_DECLARE_METATYPE(RMSSOHData::HeaderBlock)count ratio(counts in higher γ -energy ROI/counts in lower γ -energy ROI) + QVector count_ratio_uncertainty; // count ratio uncertainty (percent) + int record_count; + } + RatiosBlock, *PtRatiosBlock; + + typedef struct _G_Spectrum_Block_ + { + /* g_Spectrum Block */ + long num_g_channel; // number of γ channels + long g_energy_span; // γ-energy span (keV) + long begin_channel; // begin of channels + QVector counts; // count at channel + + //Add By XYL 20170721 + _G_Spectrum_Block_() + { + num_g_channel = 0; + g_energy_span = 0; + begin_channel = 0; + } + } + G_SpectrumBlock, *PtG_SpectrumBlock; + + typedef struct _B_Spectrum_Block_ + { + /* b_Spectrum Block */ + long num_b_channel; // number of β -channels + long b_energy_span; // β -energy span (keV) + long begin_channel; // begin of channels + QVector counts; // counts at channels + } + B_SpectrumBlock, *PtB_SpectrumBlock; + + typedef struct _Histogram_Block_ + { + /* Histogram Block */ + long b_channels; // β-channels + long g_channels; // γ-channels + long b_energy_span; // β-energy span + long g_energy_span; // γ-energy span + QVector counts; // counts at channels + } + HistogramBlock, *PtHistogramBlock; + + typedef struct _Certificate_Block_ + { + /* Certificate Block */ + double total_source_activity; // total source activity (Bq) + QString assay_date; // assay date (yyyy / mm / dd) + QString assay_time; // assay time (hh : mm : ss) + QString units_activity; // units of activity: “B,” “b” for Bq or “[blank]”; if nothing, then “B” is assigned + QVector nuclide_name; // nuclide name + QVector half_life_time; // half-life in seconds, hours, days, or years + QVector time_unit; // time unit(Y, D, H, S) + QVector activity_nuclide_time_assay;// activity of nuclide at time of assay + QVector uncertainty; // uncertainty (%) + QVector g_energy; // γ-energy (keV) + QVector g_intensity; // γ-intensity (percent) + QVector electron_decay_mode; // electron decay mode descriptor: B for β particle or C for conversion electron (CE), 0 for none (that is, γ-only source) + QVector maximum_energy; // maximum β-particle energy or CE energy (keV) + QVector intensity_b_particle; // intensity of β-particle (percent) + int record_count; + + //Add By XYL 20170721 + _Certificate_Block_() + { + total_source_activity = 0; + record_count = 0; + QString assay_date = ""; + QString assay_time = ""; + QString units_activity = ""; + } + } + CertificateBlock, *PtCertificateBlock; +} +Q_DECLARE_METATYPE(RadionuclideData::HeaderBlock) +Q_DECLARE_METATYPE(RadionuclideData::AcquisitionBlock) +Q_DECLARE_METATYPE(RadionuclideData::CollectionBlock) +Q_DECLARE_METATYPE(RadionuclideData::ProcessingBlock) +Q_DECLARE_METATYPE(RadionuclideData::SampleBlock) +Q_DECLARE_METATYPE(RadionuclideData::CalibrationBlock) +Q_DECLARE_METATYPE(RadionuclideData::G_EnergyBlock) +Q_DECLARE_METATYPE(RadionuclideData::B_EnergyBlock) +Q_DECLARE_METATYPE(RadionuclideData::G_ResolutionBlock) +Q_DECLARE_METATYPE(RadionuclideData::B_ResolutionBlock) +Q_DECLARE_METATYPE(RadionuclideData::G_EfficiencyBlock) +Q_DECLARE_METATYPE(RadionuclideData::ROI_LimitsBlock) +Q_DECLARE_METATYPE(RadionuclideData::BG_EfficiencyBlock) +Q_DECLARE_METATYPE(RadionuclideData::TotaleffBlock) +Q_DECLARE_METATYPE(RadionuclideData::RatiosBlock) +Q_DECLARE_METATYPE(RadionuclideData::G_SpectrumBlock) +Q_DECLARE_METATYPE(RadionuclideData::B_SpectrumBlock) +Q_DECLARE_METATYPE(RadionuclideData::HistogramBlock) +Q_DECLARE_METATYPE(RadionuclideData::CertificateBlock) + +namespace MetData +{ + typedef QString MetDataStationCode; // station code + + typedef struct _Met_Data_Item_ + { + QString met_start_date; // met start date (yyyy/mm/dd) + QString met_start_time; // met start time (hh:mm:ss) + QString met_end_date; // met end date (yyyy/mm/dd) + QString met_end_time; // met end time (hh:mm:ss) + double average_outside_temperature; // average outside temperature (°C) + int average_wind_direction; // average wind-direction (degrees from north) + double average_wind_speed; // average wind-speed (m/s) + double average_barometric_reading; // average barometric reading (hPa) + int humidity; // average relative humidity (percent relative humidity) + double rainfall; // rainfall (mm) + } + MetDataItem, *PtMetDataItem; +} +Q_DECLARE_METATYPE(MetData::MetDataItem) + +namespace RMSSOHData +{ + typedef struct _Header_Block_ + { + /* Header block */ + QString designator; // designator + QString station_code; // station code + QString detector_code; // detector code or NA if 1) there is more than one detector or 2) data are from the sam-pling site of a split station + QString start_date; // SOH data sampling period start date (yyyy/mm/dd) + QString start_time; // SOH data sampling period start time (hh:mm:ss) + QString end_date; // SOH data sampling period end date (yyyy/mm/dd) + QString end_time; // SOH data sampling period end time (hh:mm:ss) + QString transmit_date; // transmit date (yyyy/mm/dd) + QString transmit_time; // transmit time (hh:mm:ss) + } + HeaderBlock, *PtHeaderBlock; + + typedef struct _Air_Sampler_Flow_Block_ + { + /* Air Sampler Flow block */ + QVector average_flow_rate; // average flow rate (standard cubic metersper hour (scm/h)) + QVector flow_rate_standard_deviation; // flow rate standard deviation (scm/h) + QVector start_date; // SOH data sampling interval start date (yyyy/mm/dd) + QVector start_time; // SOH data sampling interval start time (hh:mm:ss) + QVector interval_duration; // SOH data sampling interval duration (s) + int record_count; + } + AirSamplerFlowBlock, *PtAirSamplerFlowBlock; + + typedef struct _Air_Sampler_Env_Block_ + { + /* Air Sampler Env block */ + QVector temperature; // average air temperature after filter (°C) + QVector pressure; // average static air pressure after filter (hPa) + QVector date; // date (yyyy/mm/dd) + QVector time; // time (hh:mm:ss) + QVector interval_duration; // SOH data sampling interval duration (s) + int record_count; + } + AirSamplerEnvBlock, *PtAirSamplerEnvBlock; + + typedef struct _Det_Env_Block_ + { + /* Det Env block */ + QVector room_temperature; // average room temperature (°C) + QVector detector_shield_status; // detector shield status (OPEN or CLOSED) + QVector humidity; // average room humidity (in percent relative humidity) + QVector voltage; // detector high voltage (V) + QVector crystal_temperature; // average crystal temperature (°C) + QVector electric_cooler_status; // electric cooler status (ON or OFF) + QVector fill_fraction; // liquid nitrogen fill-fraction + QVector leakage; // detector leakage current (nanoamperes [nA]) + QVector date; // date (yyyy/mm/dd) + QVector time; // time (hh:mm:ss) + QVector interval_duration; // SOH data sampling interval duration (s) + int record_count; + } + DetEnvBlock, *PtDetEnvBlock; + + typedef struct _NIMBIN_Block_ + { + /* NIMBIN block */ + QVector flag; // +/- + QVector voltage; // average NIMBIN voltage (V) + QVector date; // date (yyyy/mm/dd) + QVector time; // time (hh:mm:ss) + QVector interval_duration; // SOH data sampling interval duration (s) + int record_count; + } + NIMBIN_Block, *PtNIMBIN_Block; + + typedef struct _Power_Supply_Block_ + { + /* Power Supply block */ + QVector MAIN; // MAIN (for MAIN power supply) + QVector main_power_status; // status of main power supply (ON/OFF) + QVector AUX; // AUX (for AUXiliary power supply) + QVector aux_power_status; // status of auxiliary power supply (ON/OFF) + QVector UPS; // UPS (for Uninterrupted Power Supply) + QVector ups_status; // status of uninterruptedly power supply (ON/ OFF) + QVector date; // date (yyyy/mm/dd) + QVector time; // time (hh:mm:ss) + QVector interval_duration; // SOH data sampling interval duration (s) + int record_count; + } + PowerSupplyBlock, *PtPowerSupplyBlock; + + typedef struct _Equip_Status_Block_ + { + /* Equip Status block */ + QVector C_value; // status of sampling system (ON/OFF) or the SRID of the sample being collected + QVector P_value; // status of sample preparation, processing, or decay (ON/OFF) or the SRID of the sample being processed or decayed + QVector A_value; // status of detector system (ON/OFF) or the SRID of the sample being counted + QVector date; // date (yyyy/mm/dd) + QVector time; // time (hh:mm:ss) + QVector interval_duration; // SOH data sampling interval duration (s) + int record_count; + } + EquipStatusBlock, *PtEquipStatusBlock; + + typedef struct _Tamper_Env_Block_ + { + /* Tamper Env block */ + QVector tamper_sensor_name; // tamper sensor name + QVector tamper_sensor_status; // tamper sensor status (OPEN or CLOSED) + QVector date; // date (yyyy/mm/dd) + QVector time; // time (hh:mm:ss) + QVector interval_duration; // SOH data sampling interval duration (s) + int record_count; + } + TamperEnvBlock, *PtTamperEnvBlock; + + typedef struct _Process_Sensors_Block_ + { + /* Process Sensors block */ + QVector sensor_type; // sensor type (TEMP, PRESSURE,PROCESSFLOW, VOLTAGE, COUN-TRATES, DEWPOINT, CO2VOLUME) + QVector sensor_name; // tamper sensor status (OPEN or CLOSED) + QVector sensor_reading; // sensor reading (TEMP in °C, PRESSURE in Pa, PROCESSFLOW in m3/h, VOLT-AGE in V, COUNTRATE in counts/s, DEWPOINT in °C, CO2VOLUME in cm3) + QVector date; // date (yyyy/mm/dd) + QVector time; // time (hh:mm:ss) + QVector duration; // SOH duration (s) + int record_count; + } + ProcessSensorsBlock, *PtProcessSensorsBlock; + + typedef struct _Chromatogram_Block_ + { + /* Chromatogram block */ + QString srid; // the SRID of the sample being counted + QVector interval_number; // interval number (starts at 1) + QVector interval_start_channel; // interval start channel + QVector duration; // duration between chromatogram readings (in seconds [s]) + int interval_record_count; + long total_number; // total number of chromatogram readings + QVector detector_response; // detector response + } + ChromatogramBlock, *PtChromatogramBlock; +} +Q_DECLARE_METATYPE(RMSSOHData::HeaderBlock) +Q_DECLARE_METATYPE(RMSSOHData::AirSamplerFlowBlock) +Q_DECLARE_METATYPE(RMSSOHData::AirSamplerEnvBlock) +Q_DECLARE_METATYPE(RMSSOHData::DetEnvBlock) +Q_DECLARE_METATYPE(RMSSOHData::NIMBIN_Block) +Q_DECLARE_METATYPE(RMSSOHData::PowerSupplyBlock) +Q_DECLARE_METATYPE(RMSSOHData::EquipStatusBlock) +Q_DECLARE_METATYPE(RMSSOHData::TamperEnvBlock) +Q_DECLARE_METATYPE(RMSSOHData::ProcessSensorsBlock) +Q_DECLARE_METATYPE(RMSSOHData::ChromatogramBlock) + +namespace AlertData +{ + typedef QString AlertsDescribe; + + typedef struct _Alerts_Info_ + { + QString station_code; + QString alert_type; + QString date; + QString time; + AlertsDescribe desc; + } + AlertsInfo, *PtAlertsInfo; +} +Q_DECLARE_METATYPE(AlertData::AlertsInfo) + +#endif // DATA_MANAGE_DEFINE_H diff --git a/Fit.cpp b/Fit.cpp new file mode 100644 index 0000000..38fc84b --- /dev/null +++ b/Fit.cpp @@ -0,0 +1,222 @@ +#include "Fit.h" +#include +bool CFit:: LinearFit(QVector& _watch_x,QVector& _watch_y,QVector& _outputData,double &_output_vari) +{ + Q_UNUSED(_output_vari); + //客户默认使用使用的线性 + if(_watch_x.size()!=_watch_y.size()) + { + return false; + } + QVector::size_type size = _watch_x.size(); + double AA=0.0,BB=0.0,CC=0.0,DD=0.0; + for(QVector::size_type pos=0;pos& _watch_x,QVector& _fit_para,QVector& _output_y) +{ + if(_fit_para.size()<2) + { + return false; + } + _output_y.clear(); + double dTemp = 0.0; + QVector::size_type size = _watch_x.size(); + for(QVector::size_type pos=0;pos& _watch_x,QVector& _fit_para,QVector& _output_y) +{ + if(_fit_para.size()<2) + { + return false; + } + _output_y.clear(); + double dTemp = 0.0; + QVector::size_type size = _watch_x.size(); + for(QVector::size_type pos=0;pos& _watch_x,QVector& _watch_y,QVector& _outputData,double &_output_vari) +{ + Q_UNUSED(_output_vari); + QVector rData(3,0); + //取整运算判断: + double divison = 0.0; + divison = (1*ArrayPowerSumAverage(_watch_y,4)-qPow(ArrayPowerSumAverage(_watch_y,2),2)); + if(0.0 == divison) + { + return false; + } + divison = (1*ArrayPowerSumAverage(_watch_y,2)-qPow(ArrayPowerSumAverage(_watch_y),2)); + if(0.0 == divison) + { + return false; + } + divison = (1- + ((ArrayPowerSumAverage(_watch_y)*ArrayPowerSumAverage(_watch_y,2)-1*ArrayPowerSumAverage(_watch_y,3)) / \ + (1*ArrayPowerSumAverage(_watch_y,2)-qPow(ArrayPowerSumAverage(_watch_y),2))) * \ + ((ArrayPowerSumAverage(_watch_y)*ArrayPowerSumAverage(_watch_y,2)-1*ArrayPowerSumAverage(_watch_y,3)) / \ + (1*ArrayPowerSumAverage(_watch_y,4)-qPow(ArrayPowerSumAverage(_watch_y,2),2))) \ + ); + if(0.0 == divison) + { + return false; + } + //开始计算方程系数 + rData[2] = ( \ + ((1*TwoArrayPowerSumAverage(_watch_x,_watch_y,2)-ArrayPowerSumAverage(_watch_x)*ArrayPowerSumAverage(_watch_y,2))/ + (1*ArrayPowerSumAverage(_watch_y,4)-qPow(ArrayPowerSumAverage(_watch_y,2),2))) + \ + ((1*TwoArrayPowerSumAverage(_watch_y,_watch_x)-ArrayPowerSumAverage(_watch_x)*ArrayPowerSumAverage(_watch_y)) / \ + (1*ArrayPowerSumAverage(_watch_y,2)-qPow(ArrayPowerSumAverage(_watch_y),2))) * \ + ((ArrayPowerSumAverage(_watch_y)*ArrayPowerSumAverage(_watch_y,2)-1*ArrayPowerSumAverage(_watch_y,3)) / \ + (1*ArrayPowerSumAverage(_watch_y,4)-qPow(ArrayPowerSumAverage(_watch_y,2),2))) \ + ) / \ + (1- + ((ArrayPowerSumAverage(_watch_y)*ArrayPowerSumAverage(_watch_y,2)-1*ArrayPowerSumAverage(_watch_y,3)) / \ + (1*ArrayPowerSumAverage(_watch_y,2)-qPow(ArrayPowerSumAverage(_watch_y),2))) * \ + ((ArrayPowerSumAverage(_watch_y)*ArrayPowerSumAverage(_watch_y,2)-1*ArrayPowerSumAverage(_watch_y,3)) / \ + (1*ArrayPowerSumAverage(_watch_y,4)-qPow(ArrayPowerSumAverage(_watch_y,2),2))) \ + ); + rData[1] = ( \ + (1*TwoArrayPowerSumAverage(_watch_y,_watch_x)-ArrayPowerSumAverage(_watch_x)*ArrayPowerSumAverage(_watch_y)) / \ + (1*ArrayPowerSumAverage(_watch_y,2)-qPow(ArrayPowerSumAverage(_watch_y),2)) \ + )+ \ + rData[2]*( \ + (ArrayPowerSumAverage(_watch_y)*ArrayPowerSumAverage(_watch_y,2)-1*ArrayPowerSumAverage(_watch_y,3))/ \ + (1*ArrayPowerSumAverage(_watch_y,2)-qPow(ArrayPowerSumAverage(_watch_y),2)) \ + ); + rData[0] = ( \ + ArrayPowerSumAverage(_watch_x)-rData[1]*ArrayPowerSumAverage(_watch_y)-rData[2]*ArrayPowerSumAverage(_watch_y,2) \ + )/ \ + 1; + _outputData = rData; + return true; +} +bool CFit::_2PloynimialFitEquation(QVector& _watch_x,QVector& _fit_para,QVector& _output_y) +{ + _output_y.clear(); + if(_fit_para.size()<3||_watch_x.size()<0) //刻度系数大小错误 或 限制数据不存在 + { + return false; + } + int dataTemp = 0; + for(QVector::size_type pos=0;pos<_watch_x.size();pos++) + { + dataTemp = int(_fit_para[0]+_fit_para[1]*_watch_x[pos]+_fit_para[2]*_watch_x[pos]*_watch_x[pos]+0.5); + _output_y.append(dataTemp); + } + return true; +} +bool CFit::_2PloynimialFitEquation(QVector& _watch_x,QVector& _fit_para,QVector& _output_y) +{ + _output_y.clear(); + if(_fit_para.size()<3||_watch_x.size()<0) //刻度系数大小错误 或 限制数据不存在 + { + return false; + } + double dataTemp = 0; + for(QVector::size_type pos=0;pos<_watch_x.size();pos++) + { + dataTemp = _fit_para[0]+_fit_para[1]*_watch_x[pos]+_fit_para[2]*_watch_x[pos]*_watch_x[pos]; + _output_y.append(dataTemp); + } + return true; +} +bool CFit::_3PloynimialFit(QVector& _watch_x,QVector& _watch_y,QVector& _outputData,double &_output_vari) +{ + Q_UNUSED(_watch_x); + Q_UNUSED(_watch_y); + Q_UNUSED(_outputData); + Q_UNUSED(_output_vari); + return false; +} +bool CFit::_3PloynimialFitEquation(QVector& _watch_x,QVector& _fit_para,QVector& _output_y) +{ + Q_UNUSED(_watch_x); + Q_UNUSED(_fit_para); + Q_UNUSED(_output_y); + return false; +} +bool CFit::_3PloynimialFitEquation(QVector& _watch_x,QVector& _fit_para,QVector& _output_y) +{ + Q_UNUSED(_watch_x); + Q_UNUSED(_fit_para); + Q_UNUSED(_output_y); + return false; +} +bool CFit::GaussFit(QVector& _watch_x,QVector& _watch_y,QVector& _outputData,double &_output_vari) +{ + Q_UNUSED(_watch_x); + Q_UNUSED(_watch_y); + Q_UNUSED(_outputData); + Q_UNUSED(_output_vari); + return false; +} + +bool CFit::GaussFitEquation(QVector& _watch_x,QVector& _fit_para,QVector& _output_y) +{ + Q_UNUSED(_watch_x); + Q_UNUSED(_fit_para); + Q_UNUSED(_output_y); + return false; +} +bool CFit::GaussFitEquation(QVector& _watch_x,QVector& _fit_para,QVector& _output_y) +{ + Q_UNUSED(_watch_x); + Q_UNUSED(_fit_para); + Q_UNUSED(_output_y); + return false; +} +double CFit::ArrayPowerSumAverage(QVector& _data,int _pow) +{ + double rData=0; + size_t size = _data.size(); + for(size_t pos=0;pos& _first,QVector& _second,int _pow) +{ + double rData=0; + size_t minSize = (_first.size()<=_second.size()?_first.size():_second.size()); + for(size_t pos=0;pos +class CFit +{ +public: + ///////////////////////////////////////////////////////////////////// + // 函数说明：LinearFit 线性拟合 + // 参数说明：_watch_x: 观察值x 数组 + // _watch_y： 观察值y 数组 + // _outputData: 拟合返回值 + // _output_vari:拟合误差值 + // + // 返回值： true:正确返回 + // fale:错误返回 + ////////////////////////////////////////////////////////////////////// + static bool LinearFit(QVector& _watch_x,QVector& _watch_y,QVector& _outputData,double &_output_vari); + // 函数说明：LinearFitEquation 拟合方程：y = int(_fit_para[0]*_watch_x[n..]+_fit_para[1]) + // 参数说明：_watch_x: 观察值x 数组 + // _fit_para： 二次拟合方程系数 + // _output_y： 返回值 + // + // 返回值： true:正确返回 + // fale:错误返 + static bool LinearFitEquation(QVector& _watch_x,QVector& _fit_para,QVector& _output_y); + + static bool LinearFitEquation(QVector& _watch_x,QVector& _fit_para,QVector& _output_y); + ///////////////////////////////////////////////////////////////////// + // 函数说明：_2PloynimialFit 2次拟合 + // 参数说明：_watch_x: 观察值x 数组 + // _watch_y： 观察值y 数组 + // _outputData: 拟合返回值 + // _output_vari:拟合误差值 + // + // 返回值： true:正确返回 + // fale:错误返回 + ///////////////////////////////////////////////////////////////////// + static bool _2PloynimialFit(QVector& _watch_x,QVector& _watch_y,QVector& _outputData,double &_output_vari); + ///////////////////////////////////////////////////////////////////// + // 函数说明：_2PloynimialFitEquation 拟合方程：y = int(_fit_para[0]+_fit_para[1]*_watch_x[n..]+_fit_para[2]*_watch_x[n..]*_watch_x[n..]+0.5) + // 参数说明：_watch_x: 观察值x 数组 + // _fit_para： 二次拟合方程系数 + // _output_y： 返回值 + // + // 返回值： true:正确返回 + // fale:错误返回 + ///////////////////////////////////////////////////////////////////// + static bool _2PloynimialFitEquation(QVector& _watch_x,QVector& _fit_para,QVector& _output_y); + ///////////////////////////////////////////////////////////////////// + // 函数说明：__3PloynimialFit 3次拟合 + // 参数说明：_watch_x: 观察值x 数组 + // _watch_y： 观察值y 数组 + // _outputData: 拟合返回值 + // _output_vari:拟合误差值 + // + // 返回值： true:正确返回 + // fale:错误返回 + ///////////////////////////////////////////////////////////////////// + /// \brief _3PloynimialFit + /// \param _watch_x + /// \param _watch_y + /// \param _outputData + /// \param _output_vari + /// \return + static bool _2PloynimialFitEquation(QVector& _watch_x,QVector& _fit_para,QVector& _output_y); + + static bool _3PloynimialFit(QVector& _watch_x,QVector& _watch_y,QVector& _outputData,double &_output_vari); + ///////////////////////////////////////////////////////////////////// + // 函数说明：__3PloynimialFit 3次拟合方程 + // 参数说明：_watch_x: 观察值x 数组 + // _watch_y： 观察值y 数组 + // _outputData: 拟合返回值 + // _output_vari:拟合误差值 + // + // 返回值： true:正确返回 + // fale:错误返回 + ///////////////////////////////////////////////////////////////////// + static bool _3PloynimialFitEquation(QVector& _watch_x,QVector& _fit_para,QVector& _output_y); + static bool _3PloynimialFitEquation(QVector& _watch_x,QVector& _fit_para,QVector& _output_y); + ///////////////////////////////////////////////////////////////////// + // 函数说明：GaussFit 高斯拟合 + // 参数说明：_watch_x: 观察值x 数组 + // _watch_y： 观察值y 数组 + // _outputData: 拟合返回值 + // _output_vari:拟合误差值 + // + // 返回值： true:正确返回 + // fale:错误返回 + ///////////////////////////////////////////////////////////////////// + static bool GaussFit(QVector& _watch_x,QVector& _watch_y,QVector& _outputData,double &_output_vari); + ///////////////////////////////////////////////////////////////////// + // 函数说明：GaussFit 高斯拟合方程 + // 参数说明：_watch_x: 观察值x 数组 + // _watch_y： 观察值y 数组 + // _outputData: 拟合返回值 + // _output_vari:拟合误差值 + // + // 返回值： true:正确返回 + // fale:错误返回 + ///////////////////////////////////////////////////////////////////// + static bool GaussFitEquation(QVector& _watch_x,QVector& _fit_para,QVector& _output_y); + static bool GaussFitEquation(QVector& _watch_x,QVector& _fit_para,QVector& _output_y); +private: + ///////////////////////////////////////////////////////////////////// + // 函数说明：_ArrayPowerSumAverage 数组数据n次方 和的平均值 空数组返回值为零 + // 参数说明：_data: 需要处理的数据 + // + // 返回值： 输入数组为空时 0 + ///////////////////////////////////////////////////////////////////// + static double ArrayPowerSumAverage(QVector& _data,int _pow=1); + ///////////////////////////////////////////////////////////////////// + // 函数说明：_ArrayPowerSumAverage 数组first数据乘以数组sencond数据n次方 和的平均值 + // 参数说明：_data: 需要处理的数据 + // + // 返回值： 输入数组为空时 0 + ///////////////////////////////////////////////////////////////////// + static double TwoArrayPowerSumAverage(QVector& _first,QVector& _second,int _pow=1); +}; + +#endif diff --git a/FitDef.h b/FitDef.h new file mode 100644 index 0000000..24d7aba --- /dev/null +++ b/FitDef.h @@ -0,0 +1,12 @@ +#ifndef FIT_DEFINE_H +#define FIT_DEFINE_H +#include +//2次拟合输入参数 +typedef struct tag2PloynimilFit +{ + QVector first; + QVector second; +}*p2Ploynimainl,_2Ploynimial; + +#endif + diff --git a/MDC.cpp b/MDC.cpp new file mode 100644 index 0000000..32a6ef7 --- /dev/null +++ b/MDC.cpp @@ -0,0 +1,371 @@ +#include "MDC.h" +#include +#include + double CMdc::CalcSqrt(QVector& _data,QVector::size_type _pos) + { + double rData=0.0; + if(_pos < _data.size()) + { + rData = _data[_pos]*_data[_pos]; + } + return rData; + } + double CMdc::CalcLD(QVector& _data,QVector::size_type _pos) + { + double rData=0.0; + if(_pos < _data.size()) + { + rData = _data[_pos]+LD(_data[_pos]); + } + return rData; + } + bool CMdc::MDC(MDCI& _input,global::XeType& _input_Xetype,MDCO& _output) + { + bool bRet=false; + bRet = LC(_input,_input_Xetype,_output.lcPara); + if(!bRet) + { + return false; + } + bRet = MDCFromLC(_input,_input_Xetype,_output); + return bRet; + } + + bool CMdc::MDCFromLC(MDCI& _input,global::XeType _input_Xetype,MDCO& _output) + { + const int cts_grpnum = 3; //净计数 3数1组 +// const int pos_cts = 0; //净计数偏移 +// const int pos_vari = 1; //误差偏移 + const int pos_0_vari = 2; //0信号误差偏移 + const int factor_grpnum = 1; //感兴趣区浓度计算系数 + const int min_cts = 10*cts_grpnum+pos_0_vari; + const int min_factor = 10*factor_grpnum; + //净计数数组大小判断 + if(min_cts>=_input.ROI_netcts.size()) + { + return false; + } + //感兴趣区浓度计算系数 + if(min_factor>=_input.ROI_con_counts_factor.size()) + { + return false; + } + //除数为零判断 + if(_input.ROI_con_counts_factor[2*factor_grpnum]==0.0 || \ + _input.ROI_con_counts_factor[3*factor_grpnum]==0.0 || \ + _input.ROI_con_counts_factor[5*factor_grpnum]==0.0 || \ + _input.ROI_con_counts_factor[6*factor_grpnum]==0.0 || \ + _input.ROI_netcts[3*cts_grpnum+pos_0_vari]==0.0 || \ + _input.ROI_netcts[7*cts_grpnum+pos_0_vari]==0.0 || \ + _input.ROI_netcts[8*cts_grpnum+pos_0_vari]==0.0 || \ + _input.ROI_netcts[9*cts_grpnum+pos_0_vari]==0.0 || \ + _input.ROI_netcts[10*cts_grpnum+pos_0_vari]==0.0) + { + return false; + } + + //Use ROIs 2 + _output.mdcPara.MDC_Xe135 = _output.lcPara.LC_Xe135+global::cst_k*qSqrt(\ + CalcLD(_input.ROI_netcts,2*cts_grpnum+pos_0_vari)/CalcSqrt(_input.ROI_con_counts_factor,2*factor_grpnum)\ + ); + if(qIsNaN(_output.mdcPara.MDC_Xe135)) + { + return false; + } + //Use ROIs 5 + _output.mdcPara.MDC_Xe131m = _output.lcPara.LC_Xe131m+global::cst_k*qSqrt(\ + CalcLD(_input.ROI_netcts,5*cts_grpnum+pos_0_vari)/CalcSqrt(_input.ROI_con_counts_factor,5*factor_grpnum)\ + ); + //Use ROIs 6 + _output.mdcPara.MDC_Xe133m = _output.lcPara.LC_Xe133m+global::cst_k*qSqrt(\ + CalcLD(_input.ROI_netcts,6*cts_grpnum+pos_0_vari)/CalcSqrt(_input.ROI_con_counts_factor,6*factor_grpnum)\ + ); + if(qIsNaN(_output.mdcPara.MDC_Xe133m)) + { + return false; + } + switch ( _input_Xetype) + { + case global::none: + { + //Use ROIs 3 4 + double temp = (CalcSqrt(_input.ROI_con_counts_factor,3*factor_grpnum)*CalcLD(_input.ROI_netcts,4*cts_grpnum+pos_0_vari)+\ + CalcSqrt(_input.ROI_con_counts_factor,4*factor_grpnum)*CalcLD(_input.ROI_netcts,3*cts_grpnum+pos_0_vari)); + if(temp == 0.0) + { + return false; + } + _output.mdcPara.MDC_Xe133 = _output.lcPara.LC_Xe133+ global::cst_k*qSqrt(\ + (CalcLD(_input.ROI_netcts,3*cts_grpnum+pos_0_vari)* CalcLD(_input.ROI_netcts,4*cts_grpnum+pos_0_vari))/ \ + temp\ + ); + if(qIsNaN(_output.mdcPara.MDC_Xe133)) + { + return false; + } + } + break; + case global::_131m: + { + //Use ROIs 3 7 9 + //Roi 3 + double VD3 = CalcLD(_input.ROI_netcts,3*cts_grpnum+pos_0_vari)/CalcSqrt(_input.ROI_con_counts_factor,3*factor_grpnum); + //Roi 7 9 + double temp = (CalcSqrt(_input.ROI_con_counts_factor,7*factor_grpnum)*CalcLD(_input.ROI_netcts,9*cts_grpnum+pos_0_vari)+\ + CalcSqrt(_input.ROI_con_counts_factor,9*factor_grpnum)*CalcLD(_input.ROI_netcts,7*cts_grpnum+pos_0_vari)); + if(temp == 0.0) + { + return false; + } + double VD79 = (\ + (CalcLD(_input.ROI_netcts,7*cts_grpnum+pos_0_vari)* CalcLD(_input.ROI_netcts,9*cts_grpnum+pos_0_vari))/ \ + temp\ + ); + //Roi 3 7 9 + if(0.0==VD3||0.0==VD79||0==(1/VD3+1/VD79)) + { + return false; + } + double VD379 = 1/(1/VD3+1/VD79); + _output.mdcPara.MDC_Xe133 = global::cst_k/qSqrt(\ + CalcSqrt(_input.ROI_con_counts_factor,3*factor_grpnum)/_input.ROI_netcts[3*cts_grpnum+pos_0_vari]+\ + CalcSqrt(_input.ROI_con_counts_factor,7*factor_grpnum)/_input.ROI_netcts[7*cts_grpnum+pos_0_vari]+\ + CalcSqrt(_input.ROI_con_counts_factor,9*factor_grpnum)/_input.ROI_netcts[9*cts_grpnum+pos_0_vari])+\ + global::cst_k*qSqrt(VD379); + if(qIsNaN(_output.mdcPara.MDC_Xe133)) + { + return false; + } + } + break; + case global::_133m: + { + //Use ROIs 3 8 10 + //Roi 3 + double VD3 = CalcLD(_input.ROI_netcts,3*cts_grpnum+pos_0_vari)/CalcSqrt(_input.ROI_con_counts_factor,3*factor_grpnum); + //Roi 8 10 + double temp = (CalcSqrt(_input.ROI_con_counts_factor,7*factor_grpnum)*CalcLD(_input.ROI_netcts,9*cts_grpnum+pos_0_vari)+\ + CalcSqrt(_input.ROI_con_counts_factor,9*factor_grpnum)*CalcLD(_input.ROI_netcts,7*cts_grpnum+pos_0_vari)); + if(temp == 0.0) + { + return false; + } + + double VD810 =(\ + (CalcLD(_input.ROI_netcts,8*cts_grpnum+pos_0_vari)* CalcLD(_input.ROI_netcts,10*cts_grpnum+pos_0_vari))/ \ + temp\ + ); + //Roi 3 8 10 + if(0.0==VD3||0.0==VD810||0==(1/VD3+1/VD810)) + { + return false; + } + double VD3810 = 1/(1/VD3+1/VD810); + + _output.mdcPara.MDC_Xe133 = global::cst_k/qSqrt(\ + CalcSqrt(_input.ROI_con_counts_factor,3*factor_grpnum)/_input.ROI_netcts[3*cts_grpnum+pos_0_vari]+\ + CalcSqrt(_input.ROI_con_counts_factor,8*factor_grpnum)/_input.ROI_netcts[8*cts_grpnum+pos_0_vari]+\ + CalcSqrt(_input.ROI_con_counts_factor,10*factor_grpnum)/_input.ROI_netcts[10*cts_grpnum+pos_0_vari])+\ + global::cst_k*qSqrt(VD3810); + if(qIsNaN(_output.mdcPara.MDC_Xe133)) + { + return false; + } + } + break; + case global::both: + { + //Use ROIs 3 7 8 + //Roi 3 + double VD3 =CalcLD(_input.ROI_netcts,3*cts_grpnum+pos_0_vari)/CalcSqrt(_input.ROI_con_counts_factor,3*factor_grpnum); + //Roi 8 10 + //Roi 7 8 + double VD78 = (\ + (CalcLD(_input.ROI_netcts,7*cts_grpnum+pos_0_vari)* CalcLD(_input.ROI_netcts,8*cts_grpnum+pos_0_vari))/ \ + (CalcSqrt(_input.ROI_con_counts_factor,7*factor_grpnum)*CalcLD(_input.ROI_netcts,8*cts_grpnum+pos_0_vari)+\ + CalcSqrt(_input.ROI_con_counts_factor,8*factor_grpnum)*CalcLD(_input.ROI_netcts,7*cts_grpnum+pos_0_vari))\ + ); + //Roi 3 7 8 + if(0.0==VD3||0.0==VD78||0==(1/VD3+1/VD78)) + { + return false; + } + double VD378 = 1/(1/VD3+1/VD78); + + _output.mdcPara.MDC_Xe133 = global::cst_k/qSqrt(\ + CalcSqrt(_input.ROI_con_counts_factor,3*factor_grpnum)/_input.ROI_netcts[3*cts_grpnum+pos_0_vari]+\ + CalcSqrt(_input.ROI_con_counts_factor,7*factor_grpnum)/_input.ROI_netcts[7*cts_grpnum+pos_0_vari]+\ + CalcSqrt(_input.ROI_con_counts_factor,8*factor_grpnum)/_input.ROI_netcts[8*cts_grpnum+pos_0_vari])+\ + global::cst_k*qSqrt(VD378); + if(qIsNaN(_output.mdcPara.MDC_Xe133)) + { + return false; + } + } + break; + default: + break; + } + + //计算没有使用，客户需要存储数据库 + for(int pos=2;pos<=10;pos++) + { + if((2+3*pos)<_input.ROI_netcts.size() && (pos)<_input.ROI_con_counts_factor.size()) + { + if((_input.ROI_con_counts_factor[pos]!=0.0) + && (_input.ROI_con_counts_factor[pos]*_input.ROI_con_counts_factor[pos] != 0.0)) + { + double temp=global::cst_k*qSqrt(_input.ROI_netcts[2+3*pos])/_input.ROI_con_counts_factor[pos]+ + global::cst_k*qSqrt((_input.ROI_netcts[2+3*pos]+LD(_input.ROI_netcts[2+3*pos]))/ + (_input.ROI_con_counts_factor[pos]*_input.ROI_con_counts_factor[pos])); + if(qIsNaN(temp)) + { + return false; + } + _output.mdcPara.MDC.append(temp); + // double temp= global::cst_k*qSqrt(_input.ROI_netcts[2+3*pos]); + // _output.mdcPara.MDC_CTS.append(temp); + } + } + } + + return true; + } +double CMdc::LD(const double& _inputa) +{ + return global::cst_k*global::cst_k+2*global::cst_k*qSqrt(_inputa); +} +bool CMdc::LC(MDCI& _input,global::XeType _input_Xetype,LCPara& _output) +{ + const int cts_grpnum = 3; //净计数 3数1组 +// const int pos_cts = 0; //净计数偏移 +// const int pos_vari = 1; //误差偏移 + const int pos_0_vari = 2; //0信号误差偏移 + const int factor_grpnum = 1; //感兴趣区浓度计算系数 + const int con_uncer_grpnum = 2; //感兴趣区浓度不平衡度 2数1组 + const int pos_con = 0; //浓度偏移 +// const int pos_uncer = 1; //不平衡度偏移 + const int min_cts = 10*cts_grpnum+pos_0_vari; + const int min_factor = 10*factor_grpnum; + const int min_u = 3*con_uncer_grpnum+pos_con; + //净计数数组大小判断 + if(min_cts>=_input.ROI_netcts.size()) + { + return false; + } + //感兴趣区浓度计算系数 + if(min_factor>=_input.ROI_con_counts_factor.size()) + { + return false; + } + //感兴趣区浓度不平衡度 + if(min_u>=_input.ROI_con_uncer.size()) + { + return false; + } + //除数为零判断 + if(_input.ROI_con_counts_factor[2*factor_grpnum]==0.0 ||\ + _input.ROI_con_counts_factor[5*factor_grpnum]==0.0 ||\ + _input.ROI_con_counts_factor[6*factor_grpnum]==0.0 ||\ + _input.ROI_netcts[3*cts_grpnum+pos_0_vari]==0.0 ||\ + _input.ROI_netcts[4*cts_grpnum+pos_0_vari]==0.0 ||\ + _input.ROI_netcts[7*cts_grpnum+pos_0_vari]==0.0 ||\ + _input.ROI_netcts[8*cts_grpnum+pos_0_vari]==0.0 ||\ + _input.ROI_netcts[9*cts_grpnum+pos_0_vari]==0.0 ||\ + _input.ROI_netcts[10*cts_grpnum+pos_0_vari]==0.0) + { + return false; + } + //Use ROIs 2 + _output.LC_Xe135 = global::cst_k*qSqrt(_input.ROI_netcts[2*cts_grpnum+pos_0_vari])/_input.ROI_con_counts_factor[2*factor_grpnum]; + if(qIsNaN( _output.LC_Xe135)) + { + return false; + } + //Use ROIs 5 + _output.LC_Xe131m = global::cst_k*qSqrt(_input.ROI_netcts[5*cts_grpnum+pos_0_vari])/_input.ROI_con_counts_factor[5*factor_grpnum]; + if(qIsNaN( _output.LC_Xe131m)) + { + return false; + } + //Use ROIs 6 + _output.LC_Xe133m = global::cst_k*qSqrt(_input.ROI_netcts[6*cts_grpnum+pos_0_vari])/_input.ROI_con_counts_factor[6*factor_grpnum]; + if(qIsNaN( _output.LC_Xe133m)) + { + return false; + } + switch (_input_Xetype) + { + + case global::none: + // Use ROIs 3 4 + _output.LC_Xe133 =global::cst_k/qSqrt(\ + (_input.ROI_con_counts_factor[3*factor_grpnum]*_input.ROI_con_counts_factor[3*factor_grpnum])/_input.ROI_netcts[3*cts_grpnum+pos_0_vari]+ \ + ( _input.ROI_con_counts_factor[4*factor_grpnum]*_input.ROI_con_counts_factor[4*factor_grpnum])/_input.ROI_netcts[4*cts_grpnum+pos_0_vari] \ + ); + if(qIsNaN( _output.LC_Xe133)) + { + return false; + } + break; + case global::_131m: + // Use ROIs 3 7 9 + _output.LC_Xe133 = global::cst_k/qSqrt(\ + (_input.ROI_con_uncer[3*con_uncer_grpnum+pos_con]*_input.ROI_con_uncer[3*con_uncer_grpnum+pos_con])/_input.ROI_netcts[3*cts_grpnum+pos_0_vari]+ \ + (_input.ROI_con_counts_factor[7*factor_grpnum]*_input.ROI_con_counts_factor[7*factor_grpnum])/_input.ROI_netcts[7*cts_grpnum+pos_0_vari]+ \ + ( _input.ROI_con_counts_factor[9*factor_grpnum]*_input.ROI_con_counts_factor[9*factor_grpnum])/_input.ROI_netcts[9*cts_grpnum+pos_0_vari] \ + ); + if(qIsNaN( _output.LC_Xe133)) + { + return false; + } + break; + case global::_133m: + //# Use ROIs 3 8 10 + _output.LC_Xe133 = global::cst_k/qSqrt(\ + (_input.ROI_con_counts_factor[3*factor_grpnum]*_input.ROI_con_counts_factor[3*factor_grpnum])/_input.ROI_netcts[3*cts_grpnum+pos_0_vari]+ \ + (_input.ROI_con_counts_factor[8*factor_grpnum]*_input.ROI_con_counts_factor[8*factor_grpnum])/_input.ROI_netcts[8*cts_grpnum+pos_0_vari]+ \ + ( _input.ROI_con_counts_factor[10*factor_grpnum]*_input.ROI_con_counts_factor[10*factor_grpnum])/_input.ROI_netcts[10*cts_grpnum+pos_0_vari] \ + ); + if(qIsNaN( _output.LC_Xe133)) + { + return false; + } + break; + case global::both: + //# Use ROIs 3 7 8 + _output.LC_Xe133 = global::cst_k/qSqrt(\ + (_input.ROI_con_counts_factor[3*factor_grpnum]*_input.ROI_con_counts_factor[3*factor_grpnum])/_input.ROI_netcts[3*cts_grpnum+pos_0_vari]+ \ + (_input.ROI_con_counts_factor[7*factor_grpnum]*_input.ROI_con_counts_factor[7*factor_grpnum])/_input.ROI_netcts[7*cts_grpnum+pos_0_vari]+ \ + ( _input.ROI_con_counts_factor[8*factor_grpnum]*_input.ROI_con_counts_factor[8*factor_grpnum])/_input.ROI_netcts[8*cts_grpnum+pos_0_vari] \ + ); + if(qIsNaN( _output.LC_Xe133)) + { + return false; + } + break; + default: + break; + } + //计算没有使用，客户需要存储数据库 + for(int pos=2;pos<=10;pos++) + { + if((2+3*pos)<_input.ROI_netcts.size() && (2*pos)<_input.ROI_con_uncer.size()) + { + if(_input.ROI_con_uncer[2*pos]!=0.0) + { + double temp = global::cst_k*qSqrt(_input.ROI_netcts[2+3*pos])/(_input.ROI_netcts[3*pos]/_input.ROI_con_uncer[2*pos]); + + _output.LC.append(temp); + temp= global::cst_k*qSqrt(_input.ROI_netcts[2+3*pos]); + if(qIsNaN(temp)) + { + return false; + } + _output.LC_CTS.append(temp); + } + } + } + return true; +} + diff --git a/MDC.h b/MDC.h new file mode 100644 index 0000000..9439775 --- /dev/null +++ b/MDC.h @@ -0,0 +1,43 @@ +#ifndef MDC_H +#define MDC_H +//////////////////////////////////////////////////////////////////////// +// 类说明：此类为MDC计算 +// +// 注意事项：1、此类通过LC计算，在进行MDC计算 +// 2、传入参数应注意MDCI 结构 +// +//////////////////////////////////////////////////////////////////////// +#include "MDCDef.h" +#include "ProcessAlgorithmGlobalVar.h" + +class CMdc +{ +public: + ///////////////////////////////////////////////////////////////////// + // 函数说明：MDC MDC计算 + // 参数说明：MDCI ：输入参数：介绍请查看结构说明 + // Xetype :同位素类型：介绍请看数据结构说明 + // MDCO :输出：介绍请查看结构说明 + // 返回值： true:正确返回 + // fale:错误返回 + ////////////////////////////////////////////////////////////////////// + static bool MDC(MDCI& _input,global::XeType& _input_Xetype,MDCO& _output); +private: + ///////////////////////////////////////////////////////////////////// + // 函数说明：LC LC计算 + // 参数说明：MDCI ：输入参数：介绍请查看结构说明 + // Xetype :同位素类型：介绍请看数据结构说明 + // LCPara :输出：介绍请查看结构说明 + // 返回值： true:正确返回 + // fale:错误返回 + ////////////////////////////////////////////////////////////////////// + static bool LC(MDCI& _input,global::XeType _input_Xetype,LCPara& _output); + static bool MDCFromLC(MDCI& _input,global::XeType _input_Xetype,MDCO& _output); + static double LD(const double& _inputa); + //求平方 x*x + static double CalcSqrt(QVector& _data,QVector::size_type _pos); + //LD计算 (x+LD(X)) + static double CalcLD(QVector& _data,QVector::size_type _pos); +}; + +#endif diff --git a/MDCDef.h b/MDCDef.h new file mode 100644 index 0000000..89f94a4 --- /dev/null +++ b/MDCDef.h @@ -0,0 +1,38 @@ +#ifndef MDC_DEFINE_H +#define MDC_DEFINE_H +#include +//MDC输入参数结构 +typedef struct tagMDCI +{ + QVector ROI_netcts; // 感兴趣区净计数 [n..0] 净计数 [n..1]误差 3 [n...2] 0信号误差 + QVector ROI_con_uncer; // 感兴趣区浓度和不平和度 [n..0] 浓度 [n..1] 不确定度 + QVector ROI_con_counts_factor; // 感兴趣区浓度计数系数 [n...0] 系数 +}*pMDCI,MDCI; +//LC参数结构 +typedef struct tagLCPara +{ + double LC_Xe135; //LC XE135 + double LC_Xe131m; //LC XE131m + double LC_Xe133m; //LC XE133m + double LC_Xe133; //LC XE133 + QVector LC; + QVector LC_CTS; +}*pLCPara,LCPara; +//MDC参数结构 +typedef struct tagMDCPara +{ + double MDC_Xe135; //MDC XE135 + double MDC_Xe131m; //MDC XE131m + double MDC_Xe133m; //MDC XE133m + double MDC_Xe133; //MDC XE133 + QVector MDC; + QVector MDC_CTS; +}*pMDCPara,MDCPara; +//MDC输出结构 +typedef struct tagMDCO +{ + LCPara lcPara; + MDCPara mdcPara; +}*pMDCO,MDCO; + +#endif diff --git a/MeteorologicalMessage.cpp b/MeteorologicalMessage.cpp new file mode 100644 index 0000000..77a036a --- /dev/null +++ b/MeteorologicalMessage.cpp @@ -0,0 +1,84 @@ +#include "MeteorologicalMessage.h" +#include + +using namespace MetData; + +MeteorologicalMessage::MeteorologicalMessage():bIsValid(false) +{ +} + +MeteorologicalMessage::~MeteorologicalMessage() +{ +} + +bool MeteorologicalMessage::IsValid() +{ + return bIsValid; +} + +const QList& MeteorologicalMessage::GetMetDatas() +{ + return met_datas; +} +const MetData::MetDataStationCode& MeteorologicalMessage::GetStationCode() +{ + return station_code; +} + +void MeteorologicalMessage::ClearData() +{ + bIsValid = false; + met_datas.clear(); + AbstractSpectrumDataMessage::ClearData(); +} + +bool MeteorologicalMessage::AnalyseMessgeBody(QTextStream &content) +{ + const MessageInfo& msg = AbstractSpectrumDataMessage::GetMessageInfo(); + if ( QLatin1String("MET")!=msg.data_type ) + { + return bIsValid=false; + } + station_code = content.readLine(); + met_datas.clear(); + do + { + QString line = content.readLine(); + if ( 0==line.compare(QLatin1String("STOP")) ) + { + bIsValid = true; //检测到“STOP line”，消息完整，数据有效 + break; + } + else if (content.atEnd()) + { + bIsValid = false; + met_datas.clear(); + break; + } + else + { + MetDataItem met_data_item; + QTextStream line_stream(&line); + line_stream >> met_data_item.met_start_date; + line_stream >> met_data_item.met_start_time; + line_stream >> met_data_item.met_end_date; + line_stream >> met_data_item.met_end_time; + line_stream >> met_data_item.average_outside_temperature; + line_stream >> met_data_item.average_wind_direction; + line_stream >> met_data_item.average_wind_speed; + line_stream >> met_data_item.average_barometric_reading; + line_stream >> met_data_item.humidity; + line_stream >> met_data_item.rainfall; + met_datas.append(met_data_item); + + if (line_stream.status()==QTextStream::ReadCorruptData) + { + return false; + } + } + + } + while( !content.atEnd() ); + return bIsValid; +} + diff --git a/MeteorologicalMessage.h b/MeteorologicalMessage.h new file mode 100644 index 0000000..8d907e6 --- /dev/null +++ b/MeteorologicalMessage.h @@ -0,0 +1,28 @@ +#ifndef METEOROLOGICALDATA_H +#define METEOROLOGICALDATA_H + +#include "AbstractSpectrumDataMessage.h" +#include "DataManager_Define.h" +#include + +class MeteorologicalMessage : public AbstractSpectrumDataMessage +{ +public: + explicit MeteorologicalMessage(); + ~MeteorologicalMessage(); + + const QList& GetMetDatas(); + const MetData::MetDataStationCode& GetStationCode(); + virtual bool IsValid(); + virtual void ClearData(); + +private: + virtual bool AnalyseMessgeBody(QTextStream& content); + +private: + bool bIsValid; + MetData::MetDataStationCode station_code; + QList met_datas; +}; + +#endif // METEOROLOGICALDATA_H diff --git a/ProcessAlgorithmGlobalVar.cpp b/ProcessAlgorithmGlobalVar.cpp new file mode 100644 index 0000000..02ee62b --- /dev/null +++ b/ProcessAlgorithmGlobalVar.cpp @@ -0,0 +1,54 @@ +#include +#include +#include "ProcessAlgorithmGlobalVar.h" +double global::cst_d_decay_133xeg_lam=1.5301e-6; +double global::cst_d_decay_131xem_lam=6.7416e-7; +double global::cst_d_decay_133xem_lam=3.6633e-6; +double global::cst_d_decay_135xeg_lam=2.10657e-5; +double global::cst_d_br_133xe_80=0.3800; +double global:: cst_d_br_133xe_30=0.49110; +double global::cst_d_br_131xem_30=0.5371; +double global::cst_d_br_133xem_30=0.55770; +double global::cst_d_br_135xeg=0.90200; +double global::cst_d_xe_air=0.087; +double global::cst_k = 1.64485; +int global::fit_type = 2;//默认为2次拟 +QMutex mutex_algorithmvar_global; +void global::InitAlgorithmVar(QString& _cfgFileName) +{ + QMutexLocker locker(&mutex_algorithmvar_global); + QSettings settings(_cfgFileName,QSettings::IniFormat); + settings.beginGroup(QLatin1String("algorithm")); + cst_d_decay_133xeg_lam = settings.value(QLatin1String("decay133xeglam"),cst_d_decay_133xeg_lam).toDouble(); + cst_d_decay_131xem_lam = settings.value(QLatin1String("decay131xeglam"),cst_d_decay_131xem_lam).toDouble(); + cst_d_decay_133xem_lam = settings.value(QLatin1String("decay133mxeglam"),cst_d_decay_133xem_lam).toDouble(); + cst_d_decay_135xeg_lam = settings.value(QLatin1String("decay135xeglam"),cst_d_decay_135xeg_lam).toDouble(); + cst_d_br_133xe_80 = settings.value(QLatin1String("dbr133xeg80"),cst_d_br_133xe_80).toDouble(); + cst_d_br_133xe_30 = settings.value(QLatin1String("dbr133xeg30"),cst_d_br_133xe_30).toDouble(); + cst_d_br_131xem_30 = settings.value(QLatin1String("131xem30"),cst_d_br_131xem_30).toDouble(); + cst_d_br_133xem_30 = settings.value(QLatin1String("133xem30"),cst_d_br_133xem_30).toDouble(); + cst_d_br_135xeg = settings.value(QLatin1String("135xeg"),cst_d_br_135xeg).toDouble(); + cst_d_xe_air = settings.value(QLatin1String("dxeair"),cst_d_xe_air).toDouble(); + cst_k = settings.value(QLatin1String("k"),cst_k).toDouble(); + fit_type = settings.value(QLatin1String("fittype"),fit_type).toInt(); + settings.endGroup(); +} +void global::GenerateAlgorithmVar(QString& _cfgFileName) +{ + QMutexLocker locker(&mutex_algorithmvar_global); + QSettings settings(_cfgFileName,QSettings::IniFormat); + settings.beginGroup(QLatin1String("algorithm")); + settings.setValue(QLatin1String("decay133xeglam"),cst_d_decay_133xeg_lam); + settings.setValue(QLatin1String("decay131xeglam"),cst_d_decay_131xem_lam); + settings.setValue(QLatin1String("decay133mxeglam"),cst_d_decay_133xem_lam); + settings.setValue(QLatin1String("decay135xeglam"),cst_d_decay_135xeg_lam); + settings.setValue(QLatin1String("dbr133xeg80"),cst_d_br_133xe_80); + settings.setValue(QLatin1String("dbr133xeg30"),cst_d_br_133xe_30); + settings.setValue(QLatin1String("131xem30"),cst_d_br_131xem_30); + settings.setValue(QLatin1String("133xem30"),cst_d_br_133xem_30); + settings.setValue(QLatin1String("135xeg"),cst_d_br_135xeg); + settings.setValue(QLatin1String("dxeair"),cst_d_xe_air); + settings.setValue(QLatin1String("k"),cst_k); + settings.setValue(QLatin1String("fittype"),fit_type); + settings.endGroup(); +} diff --git a/ProcessAlgorithmGlobalVar.h b/ProcessAlgorithmGlobalVar.h new file mode 100644 index 0000000..305d460 --- /dev/null +++ b/ProcessAlgorithmGlobalVar.h @@ -0,0 +1,25 @@ +#ifndef PROCESS_ALGORITHM_GLOBALE_VAR_H +#define PROCESS_ALGORITHM_GLOBALE_VAR_H +#include + +class global +{ + //常数变量 +public: + static double cst_d_decay_133xeg_lam; + static double cst_d_decay_131xem_lam; + static double cst_d_decay_133xem_lam; + static double cst_d_decay_135xeg_lam; + static double cst_d_br_133xe_80; + static double cst_d_br_133xe_30; + static double cst_d_br_131xem_30; + static double cst_d_br_133xem_30; + static double cst_d_br_135xeg; + static double cst_d_xe_air; + static double cst_k; + static int fit_type; + enum XeType{both,_131m,_133m,none}; + static void InitAlgorithmVar(QString& _cfgFileName); + static void GenerateAlgorithmVar(QString& _cfgFileName); +}; +#endif diff --git a/ROI.cpp b/ROI.cpp new file mode 100644 index 0000000..9a9b688 --- /dev/null +++ b/ROI.cpp @@ -0,0 +1,281 @@ +#include "ROI.h" +#include "ProcessAlgorithmGlobalVar.h" +#include +bool CROI::CalcNetCounts(NetCountsI& _net_counts,QVector& _output) +{ + //计算同位素系数 + bool bRet=false; + double F135; + double F133; + double F131m; + double F133m; + bRet = CalcF(_net_counts.time,global::cst_d_decay_135xeg_lam,F135); + if(!bRet) + { + return false; + } + bRet = CalcF(_net_counts.time,global::cst_d_decay_133xeg_lam,F133); + if(!bRet) + { + return false; + } + bRet = CalcF(_net_counts.time,global::cst_d_decay_131xem_lam,F131m); + if(!bRet) + { + return false; + } + bRet = CalcF(_net_counts.time,global::cst_d_decay_133xem_lam,F133m); + if(!bRet) + { + return false; + } + QVector factor; + factor.append(F135); + factor.append(F133); + factor.append(F133); + factor.append(F131m); + factor.append(F133m); + factor.append(F133); + //通过系数计算净计数总数 + bRet = CalcNetCountsByFactor(_net_counts,factor,_output); + if(!bRet) + { + return false; + } + return true; +} +bool CROI::CalcF(SGTime& _time,double _Xe,double& _output) +{ + double drData = 1-qExp(-_Xe*_time.g_acquisition_real_time); + if(!_time.g_acquisition_live_time || !_time.s_acquisition_real_time || !drData) + { + return false; + } + else + { + drData = (_time.g_acquisition_real_time/_time.g_acquisition_live_time)*(_time.s_acquisition_live_time/_time.s_acquisition_real_time)*qExp(-_Xe*_time.gtos_acqStartDiff)* \ + (1-qExp(-_Xe*_time.s_acquisition_real_time))/drData; + } + _output = drData; + return true; +} +bool CROI::CalcNetCountsByFactor(NetCountsI& _net_counts,QVector& _factor,QVector& _output) +{ + QVector::size_type size = _net_counts.g_netXe.size(); + //参数传入判断 + if(size!=_net_counts.s_netXe.size()) + { + return false; + } + QVector rData(size,0); + bool bPara1 = true;//默认为一行一个参数 + QVector::size_type bParaPos = 6; //系数起始位 此处理函数没有用到前六个系数 + if(size>_factor.size()) //系数个数判断 + { + bPara1 = false; + bParaPos = 0; + } + //提取数据 + double factor = 1.0; + const int detuct_grpnm = 3; + const int pos_cts = 0; //扣除 计数偏移 + const int pos_vari = 1; //偏差偏移 + const int pos_level = 2; //关键水平偏移 + const int pos_net_counts=0;//输出净计数 偏移值 + const int pos_net_counts_vari=1; //净计数偏差 偏移值 + const int pos_net_counts_0_vari=2; //净计数 0 信号偏移值 + for(QVector::size_type pos=2*detuct_grpnm;pos+pos_level& _output) +{ + const int group_num = 3; //每组个数为3 + const int pos_cts = 0; //净计数位置 + const int pos_variance = 1; //误差位置 + const int pos_level =2; //关键水平位置 + const int pos_one_ratios =-1; //比率第一组相对下标值 + const int pos_two_ratios =6; //比率第二组相对下标值 + QVector rData(group_num,0); + QVector::size_type size = _input.roi_cts.size(); + //大小判断 + if(size-1+pos_two_ratios>=_input.roi_ratios.size()||size>_input.roi_detbg_cts.size()) + { + return false; + } +// QVector::size_type pos = 0; + double dKTemp; + double dVTemp; + double dLTemp; + double dKtempFactor=0.0; + double dVTempFactor=0.0; + + for(QVector::size_type pos=0;posrData.at(1*group_num+pos_level)) + { + if(pos>=3)//第三组以后 + { + double qvctRatiosData1 = _input.roi_ratios.at(pos+pos_one_ratios); + double qvctRatiosData2 = _input.roi_ratios.at(pos+pos_two_ratios); + if(rData.at(3*group_num+pos_cts)>rData.at(3*group_num+pos_level))//第三组k 大于第三组lk + { + dKtempFactor = -(qvctRatiosData1*rData.at(1*group_num+pos_cts) + qvctRatiosData2*rData.at(3*group_num+pos_cts)); + dVTempFactor = qvctRatiosData1*qvctRatiosData1*rData.at(1*group_num+pos_variance)+qvctRatiosData2*qvctRatiosData2*rData.at(3*group_num+pos_variance); + } + else + { + dKtempFactor = -(qvctRatiosData1*rData.at(1*group_num+pos_cts)); + dVTempFactor = qvctRatiosData1*qvctRatiosData1*rData.at(1*group_num+pos_variance); + } + } + else // 1 2 组处理 + { + double qvctRatiosData = _input.roi_ratios.at(pos+pos_one_ratios); + dKtempFactor = -(qvctRatiosData*rData.at(1*group_num+pos_cts)); + dVTempFactor = qvctRatiosData*qvctRatiosData*rData.at(1*group_num+pos_variance); + } + } + else + { + if(pos>=3)//第三组以后 + { + double qvctRatiosData2 = _input.roi_ratios.at(pos+pos_two_ratios); + if(rData.at(3*group_num+pos_cts)>rData.at(3*group_num+pos_level))//第三组k 大于第三组lk + { + dKtempFactor = -(qvctRatiosData2*rData.at(3*group_num+pos_cts)); + dVTempFactor = qvctRatiosData2*qvctRatiosData2*rData.at(3*group_num+pos_variance); + } + else + { + //没有系数 + } + } + else// 1 2 组处理 + { + //没有系数 + } + } + } + //净计数 + dKTemp = _input.roi_cts.at(pos)-_input.ratio*_input.roi_detbg_cts.at(pos)+dKtempFactor; + //不确定度 + dVTemp = _input.roi_cts.at(pos)+_input.ratio*_input.ratio*_input.roi_detbg_cts.at(pos)+dVTempFactor; + //关键水平 + if((dVTemp-dKTemp)<0) + { + return false; + } + dLTemp = global::cst_k*qSqrt(dVTemp-dKTemp); + rData.append(dKTemp); + rData.append(dVTemp); + rData.append(dLTemp); + } + _output = rData; + return true; +} + +bool CROI::ExtractROIcts(ROIctsI& _input,ROIctsO& _output) +{ + bool bRet = false; + //获取总计数 + bRet = CalcROIctsByBoundary(_input.roi_boundary,_input.histogram,_output.roi_cts); + if(!bRet) + { + return false; + } + return true; +} +bool CROI::CalcROIctsByBoundary(ROIBoundary& _boundary,Histogram& _histogram,QVector& _output) +{ + //10个通道数据 + QVector qdDataTemp(10,0); + QString qsDataTemp; + //参数判断 + if(_boundary.ROI_B_start_x.size()<10||\ + _boundary.ROI_B_stop_x.size()<10||\ + _boundary.ROI_G_start_y.size()<10||\ + _boundary.ROI_G_stop_y.size()<10) + { + return false; + } + for(int roi=0;roi<10;roi++) //提取 + { + qdDataTemp[roi] = 0; + QVector::size_type base = 0; + // int row = 0; + int y=0; + for(;y<_boundary.ROI_G_start_y[roi];y++) + { + //row + } + base = y; + // QVector::size_type y=_boundary.ROI_G_start_y[roi]-1; + // base = y+1; + + for(y=0;y<(_boundary.ROI_G_stop_y[roi]-_boundary.ROI_G_start_y[roi]+1);y++) + { + for(QVector::size_type x=_boundary.ROI_B_start_x[roi];x<=_boundary.ROI_B_stop_x[roi];x++) + { + if((base+y)*_histogram.b_channels+x<_histogram.counts.size()&&((base+y)*_histogram.b_channels+x)>=0) + { + qdDataTemp[roi] += _histogram.counts.at((base+y)*_histogram.b_channels+x); + } + else + { + return false; + } + } + } + } + _output = qdDataTemp; + return true; +} + +bool CROI::CalcLimitToBoundary(QVector& _ROI_limit,QVector& _cal_coeffs,QVector& _output) +{ + _output.clear(); + if(_cal_coeffs.size()<3||_ROI_limit.size()<0) //刻度系数大小错误 或 限制数据不存在 + { + return false; + } + int dataTemp = 0; + for(QVector::size_type pos=0;pos<_ROI_limit.size();pos++) + { + dataTemp = int(_cal_coeffs[0]+_cal_coeffs[1]*_ROI_limit[pos]+_cal_coeffs[2]*_ROI_limit[pos]*_ROI_limit[pos]+0.5); + _output.append(dataTemp); + } + return true; +} diff --git a/ROI.h b/ROI.h new file mode 100644 index 0000000..39beb28 --- /dev/null +++ b/ROI.h @@ -0,0 +1,91 @@ +#ifndef ROI_H +#define ROI_H +//////////////////////////////////////////////////////////////////////// +// 类说明：此类为: 感兴趣区总计数 扣除探测器本底计数 净计数计算 +// +// 注意事项：探测器本底计数 净计数有填充0的情况 +// ExtractROIcts 提取感兴趣区总计数 用到了2poly拟合方程 如果用高斯拟合的话需要扩展函数 +// +//////////////////////////////////////////////////////////////////////// +#include "ROIDef.h" + +class CROI +{ +public: + ///////////////////////////////////////////////////////////////////// + // 函数说明：ExtractROIcts 提取感兴趣区总计数 + // 参数说明：ROIctsI :输入参数 请查看结构说明 + // ROIctsO ：输出 请查看结构说明 + // + // 返回值： true:正确返回 + // fale:错误返回 + ////////////////////////////////////////////////////////////////////// + static bool ExtractROIcts(ROIctsI& _input,ROIctsO& _output); + ///////////////////////////////////////////////////////////////////// + // 函数说明：CalcNetXects 扣除探测器本底谱的样品谱或气体谱ROI计数 + // 参数说明：NetXectsI : 输入参数，请查看结构说明 + // _output： [n..0] 计数 [n..1]计数偏差 [n..2]感兴趣区关键水平 [0-2]=0; + // the ROIs are numbered from one, so the first three + // positions are filled with zeroes. + // + // 返回值： true:正确返回 + // fale:错误返回 + ////////////////////////////////////////////////////////////////////// + static bool CalcNetXects(NetXectsI& _input,QVector& _output); + ///////////////////////////////////////////////////////////////////// + // 函数说明：CalcNetCounts 净计数计数 + // 参数说明：NetCountsI : 请查看结构说明 + // _output: [n..0]净计数 [n..1]净计数偏差 [n..2]0信号偏差 [0-5]=0 + // The array is indexed from zero to the maximum ROI + // number, and the ROIs analysed are numbered from two + // (Rn is not analysed), so the first 2 x 3 positions are + // filled with zeroes. + // 返回值： true:正确返回 + // fale:错误返回 + ////////////////////////////////////////////////////////////////////// + static bool CalcNetCounts(NetCountsI& _net_counts,QVector& _output); +private: + ///////////////////////////////////////////////////////////////////// + // 函数说明：CalcF 同位素计算 + // 参数说明：SGTime 样品普 气体本地谱时间参数 + // _Xe 同位素常量值 + // _output 返回值 + // 返回值： true:正确返回 + // fale:错误返回 + ////////////////////////////////////////////////////////////////////// + static bool CalcF(SGTime& _time,double _Xe,double& _output); + ///////////////////////////////////////////////////////////////////// + // 函数说明：CalcNetCounts 净计数计数 + // 参数说明：NetCountsI : 请查看结构说明 + // _output: [n..0]净计数 [n..1]净计数偏差 [n..2]0信号偏差 [0-5]=0 + // The array is indexed from zero to the maximum ROI + // number, and the ROIs analysed are numbered from two + // (Rn is not analysed), so the first 2 x 3 positions are + // filled with zeroes. + // _factor:系数 + // 返回值： true:正确返回 + // fale:错误返回 + ////////////////////////////////////////////////////////////////////// + static bool CalcNetCountsByFactor(NetCountsI& _net_counts,QVector& _factor,QVector& _output); + ///////////////////////////////////////////////////////////////////// + // 函数说明：CalcLimitToBoundary 计算限值的边界值 + // 参数说明：_ROI_limit :限值 + // _cal_coeffs：对应的刻度方程系数 + // _output:返回值 + // + // 返回值： true:正确返回 + // fale:错误返回 + ////////////////////////////////////////////////////////////////////// + static bool CalcLimitToBoundary(QVector& _ROI_limit,QVector& _cal_coeffs,QVector& _output); + ///////////////////////////////////////////////////////////////////// + // 函数说明：CalcROIctsByBoundary 通过边界值计算感兴趣总计数 + // 参数说明：_boundary ：边界值 + // _output:返回值 + // + // 返回值： true:正确返回 + // fale:错误返回 + ////////////////////////////////////////////////////////////////////// + static bool CalcROIctsByBoundary(ROIBoundary& _boundary,Histogram& _histogram,QVector& _output); +}; + +#endif diff --git a/ROIConUncer.cpp b/ROIConUncer.cpp new file mode 100644 index 0000000..a11fe8e --- /dev/null +++ b/ROIConUncer.cpp @@ -0,0 +1,143 @@ +#include "ROIConUncer.h" +#include "ProcessAlgorithmGlobalVar.h" +#include +double CRoiConUncer::CalcCorrect(SPara& _input,double _Xe) +{ + double rData; + rData = (1-qExp(-_Xe*_input.s_coll_interval_time))* \ + qExp(-_Xe*_input.s_pre_time)* \ + (1-qExp(-_Xe*_input.s_acquisition_real_time)); + return rData; +} +bool CRoiConUncer::CalcConc(SPara& _input,double _Xe,double& _output) +{ + double rData=0.0; + if(CalcCorrect(_input,_Xe)==0.0||global::cst_d_xe_air==0.0||_input.s_volume_of_Xe/global::cst_d_xe_air==0.0) + { + return false; + } + else + { + rData = 1000*_Xe*_Xe/CalcCorrect(_input,_Xe)*(_input.s_coll_interval_time/(_input.s_volume_of_Xe/global::cst_d_xe_air)); + } + _output = rData; + return true; +} +bool CRoiConUncer::CalcRoiConUncer(ConUncerI& _input,ConUncerO& _output) +{ + bool bRet = false; + Factor factor; //系数处理 + double dData; + bRet = CalcConc(_input.SPara, global::cst_d_decay_135xeg_lam,dData); + if(!bRet) + { + return false; + } + factor.calcFactor.append(dData); + bRet = CalcConc(_input.SPara, global::cst_d_decay_133xeg_lam,dData); + if(!bRet) + { + return false; + } + factor.calcFactor.append(dData); + factor.calcFactor.append(dData); + bRet = CalcConc(_input.SPara, global::cst_d_decay_131xem_lam,dData); + if(!bRet) + { + return false; + } + factor.calcFactor.append(dData); + bRet = CalcConc(_input.SPara, global::cst_d_decay_133xem_lam,dData); + if(!bRet) + { + return false; + } + factor.calcFactor.append(dData); + bRet = CalcConc(_input.SPara, global::cst_d_decay_133xeg_lam,dData); + if(!bRet) + { + return false; + } + factor.calcFactor.append(dData); + + factor.bgbrFactor.append(global::cst_d_br_135xeg); + factor.bgbrFactor.append(global::cst_d_br_133xe_80); + factor.bgbrFactor.append(global::cst_d_br_133xe_30); + factor.bgbrFactor.append(global::cst_d_br_131xem_30); + factor.bgbrFactor.append(global::cst_d_br_133xem_30); + factor.bgbrFactor.append(global::cst_d_br_133xe_30); + //通过系数和输入值计算输出值 + bRet = CalcRoiConUncerByFactor(_input._netCts,_input.s_bg_efficiency,factor,_output); + if(!bRet) + { + return false; + } + return true; + +} +bool CRoiConUncer::CalcRoiConUncerByFactor(QVector& _netCts,QVector& _s_ROI_number_eff,Factor& _factor,ConUncerO& _output) +{ + QVector con_uncer(4,0); //浓度和不确定度 前两组置零 + QVector con_counts(2,0); //不确定度系数 + double dCalcFactor=0.0; + double dbgbrFactor=0.0; + const int netCtsGroupNmber = 3; //净计数一组三个数据 + QVector::size_type qdNetctsPos=6; + QVector::size_type qdBgeffsPos=0; + const int con_uncer_grpnm = 10; + const int pos_net_cts_vari = 1; + //提取数据 + for(int pos=0;pos +#include "ROIConUncerDef.h" + +class CRoiConUncer +{ +public: + ///////////////////////////////////////////////////////////////////// + // 函数说明：CRoiConUncer 计算浓度和不确定度 + // 参数说明：ConUncerI:输入参数：请查看结构定义 + // _output: 浓度和不确定度 [n..0]浓度 [n..1]不确定度 + // 返回值： true:正确返回 + // fale:错误返回 + ////////////////////////////////////////////////////////////////////// + static bool CalcRoiConUncer(ConUncerI& _input,ConUncerO& _output); +private: + ///////////////////////////////////////////////////////////////////// + // 函数说明：CRoiConUncer 计算浓度和不确定度 + // 参数说明：_netcts // 感兴趣区净计数 [n..0] 净计数 [n..1]误差 3 [n...2] 0信号误差 + // _s_ROI_number_eff 感兴趣区能效个数 + // _factor: 系数 + // _output: 浓度和不确定度 [n..0]浓度 [n..1]不确定度 + // 返回值： true:正确返回 + // fale:错误返回 + ////////////////////////////////////////////////////////////////////// + static bool CalcRoiConUncerByFactor(QVector& _netCts,QVector& _s_ROI_number_eff,Factor& _factor,ConUncerO& _output); + static double CalcCorrect(SPara& _input,double _Xe); + static bool CalcConc(SPara& _input,double _Xe,double& _output); +}; + +#endif diff --git a/ROIConUncerDef.h b/ROIConUncerDef.h new file mode 100644 index 0000000..2a2cf15 --- /dev/null +++ b/ROIConUncerDef.h @@ -0,0 +1,33 @@ +#ifndef ROI_CON_UNCER_DEFINE_H +#define ROI_CON_UNCER_DEFINE_H +#include +//浓度和不确定度输出数据结构 +typedef struct tagConUncerO +{ + QVector ROI_con_uncer; //感兴趣区浓度和不确定度 [n..0]浓度 [n..1]不确定度 + QVector ROI_con_counts_factor; //感兴趣区浓度计数系数 [n..0]系数 +}*pConUncerO,ConUncerO; + +typedef struct tagFactor +{ + QVector bgbrFactor; // #Branching ratio for betakeV gamma decay + QVector calcFactor; //calc for #Decay constant for XE +}*pFactor,Factor; +//样品谱系数 +typedef struct tagSPara +{ + double s_coll_interval_time; //样本谱 Collection stop 和start 间隔时间 + double s_pre_time; //样品谱 Collection stop 和 Acquisition start 间隔时间 + double s_acquisition_real_time; //acquisition real time (s) + double s_volume_of_Xe; //sample volume of Xe (cm 3 ) +}*pSPara,SPara; +//浓度和不确定度输入参数结构 +typedef struct tagConUncerI +{ + QVector _netCts; // 感兴趣区净计数 [n..0] 净计数 [n..1]误差 3 [n...2] 0信号误差 + // QVector _s_ROI_number_eff; //感兴趣区能效个数 + QVector s_bg_efficiency; //样品谱 β-γ coincidence efficiency (counts in ROI/β-γ pair emitted) + tagSPara SPara; + +}*pConUnerI,ConUncerI; +#endif diff --git a/ROIDef.h b/ROIDef.h new file mode 100644 index 0000000..04b1a5f --- /dev/null +++ b/ROIDef.h @@ -0,0 +1,73 @@ +#ifndef ROI_DEFINE_H +#define ROI_DEFINE_H +#include +#include +//感应区限值结构 +/*typedef struct tagROILimit +{ + QVector ROI_B_start_x1;// ROI B-rang start,x1(keV) + QVector ROI_B_stop_x2; // ROI B_rang stop,x2(kev) + QVector ROI_G_start_y1;// ROI G-rang start,y1(keV) + QVector ROI_G_stop_y2; // ROI G_rang stop,y2(kev) +}*pROILimit,ROILimit; +*/ +//感兴趣区 边界值 +typedef struct tagROIBoundary +{ + QVector ROI_B_start_x; + QVector ROI_B_stop_x; + QVector ROI_G_start_y; + QVector ROI_G_stop_y; +}*pROIBoundary,ROIBoundary; + +typedef struct tagHistogram +{ + long b_channels; // β-channels + long g_channels; // γ-channels + QVector counts; // counts at channels +}*pHistogram,Histogram; +//计算感兴趣计数时需要传入数据的结构 +typedef struct tagROIctsI +{ + ROIBoundary roi_boundary; + Histogram histogram; +}*pROIctsI,ROIctsI; +//感兴趣区计数返回值结构 + +//感兴趣区计数返回值 +typedef struct tagROIctsO +{ + QVector roi_cts; //感兴趣兴趣区总计数 + +}*pROIctsO,ROIctsO; + +//计算感兴趣区净计数输入参数 +typedef struct tagROINetXectsI +{ + QVector roi_cts; //样品普或者气体谱感兴趣总计数 + QVector roi_ratios; //感兴趣比率 + QVector roi_detbg_cts; //探测器本地谱感兴区总计数 + double ratio; //样品谱LT和气体本底谱/探测器本底谱LT 比率值 +}*pNetXectsI,NetXectsI; +//计算净计数总数计算输入参数 +//数据校验结构 c +typedef struct tagSGTime //样品普和气体本地谱时间参数 +{ + double s_acquisition_real_time; //acquisition real time (s) + double s_acquisition_live_time; //acquisition live time (s) + double g_acquisition_real_time; //acquisition real time (s) + double g_acquisition_live_time; //acquisition live time (s) + double gtos_acqStartDiff; //气体本地谱与样品谱acquistion的相对时间 +}*pSGTime,SGTime; +typedef struct tagROINetCountsI +{ + QVector s_netXe; //样品谱到探测器本地谱计数 [n..0] 计数 [n..1]计数偏差 [n..2]感兴趣区关键水平 [0-2]=0; + // the ROIs are numbered from one, so the first three + // positions are filled with zeroes. + QVector g_netXe; //气体本地谱道探测器本地谱计数 [n..0] 计数 [n..1]计数偏差 [n..2]感兴趣区关键水平 [0-2]=0; + // the ROIs are numbered from one, so the first three + // positions are filled with zeroes. + SGTime time; +}*pNetCountsI,NetCountsI; + +#endif diff --git a/RadionuclideMessage.cpp b/RadionuclideMessage.cpp new file mode 100644 index 0000000..f99e844 --- /dev/null +++ b/RadionuclideMessage.cpp @@ -0,0 +1,985 @@ +#include "RadionuclideMessage.h" +#include +#include +#include + +#define SECOND 1 +#define HOUR 3600 +#define DAY (12*HOUR) +#define YEAR (365*DAY) + +using namespace RadionuclideData; + +RadionuclideMessage::RadionuclideMessage() +{ + bIsValid = false; + analyse_data_type = InvalidData; + InitBlockFlagInfo(); +} + +RadionuclideMessage::~RadionuclideMessage() +{ +} + +const QVariant RadionuclideMessage::GetBlockData(QString& block_name) +{ + if ( radionuclide_msg_data.contains(block_name) ) + { + return radionuclide_msg_data[block_name]; + } + return QVariant(); +} + +void RadionuclideMessage::ClearData() +{ + bIsValid = false; + radionuclide_msg_data.clear(); + AbstractSpectrumDataMessage::ClearData(); +} + +QVector RadionuclideMessage::GetHistogramProjectedDataValue( + HistogramBlock &histogram, Qt::Orientation orientation) +{ + QVector projected_data_value; + QVector &counts = histogram.counts; + if (Qt::Vertical == orientation) + { + for (int i=0; i> Header.site_code >> Header.detector_code >> Header.system_type >> Header.sample_geometry >> Header.spectrum_quantity; + content >> Header.sample_ref_id; + content.readLine(); + + const MessageInfo& msg = AbstractSpectrumDataMessage::GetMessageInfo(); + if ( msg.verify_srid ) + { + bool bRet = Verity_SampleReferenceId( Header.sample_ref_id ); + if (!bRet) return bRet; + } + if (QString("P") == Header.system_type || QString("G") == Header.system_type) + { + analyse_data_type = GammaAnalyseData; + } + else if (QString("B") == Header.system_type) + { + analyse_data_type = BetaGammaAnalyseData; + } + QString temp_line = content.readLine(); + QStringList temp_str_list; + QTextStream temp_line_stream(&temp_line); + for (;!temp_line_stream.atEnd();) + { + QString temp; + temp_line_stream >> temp; + temp_str_list.append(temp); + } + + for (int i=0, j = 0; i> Header.transmit_date >> Header.transmit_time; + radionuclide_msg_data.insert(block_flag.at(0), QVariant::fromValue(Header)); + + content >> nextBlock; + content.readLine(); //该处的读取行内容操作仅将文件光标移至下一行开头 + + return (content.status()==QTextStream::Ok)?true:false; +} + +bool RadionuclideMessage::Analyse_Comment_Block(QTextStream& content, QString& nextBlock) +{ + CommentBlock comment; + nextBlock = content.readLine(); + QString temp_line = nextBlock.simplified(); + while ( !block_flag.contains(temp_line) && !content.atEnd()) + { + if ( !nextBlock.isEmpty() ) + { + comment.append(nextBlock + QLatin1String("\n")); + } + nextBlock = content.readLine(); + temp_line = nextBlock.simplified(); + } + radionuclide_msg_data.insert(block_flag.at(1), QVariant::fromValue(comment)); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool RadionuclideMessage::Analyse_Collection_Block(QTextStream& content, QString& nextBlock) +{ + CollectionBlock Collection; + content >> Collection.collection_start_date >> Collection.collection_start_time >> Collection.collection_stop_date \ + >> Collection.collection_stop_time >> Collection.air_volume; + radionuclide_msg_data.insert(block_flag.at(2), QVariant::fromValue(Collection)); + + content >> nextBlock; + //change add by caoanqi 2015-12-03 + content.readLine(); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool RadionuclideMessage::Analyse_Acquisition_Block(QTextStream& content, QString& nextBlock) +{ + AcquisitionBlock Acquisition; + content >> Acquisition.acquisition_start_date >> Acquisition.acquisition_start_time \ + >> Acquisition.acquisition_real_time >> Acquisition.acquisition_live_time; + radionuclide_msg_data.insert(block_flag.at(3), QVariant::fromValue(Acquisition)); + + content >> nextBlock; + content.readLine(); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool RadionuclideMessage::Analyse_Processing_Block(QTextStream& content, QString& nextBlock) +{ + ProcessingBlock Processing; + content >> Processing.sample_volume_of_Xe >> Processing.uncertainty_1; + content >> Processing.Xe_collection_yield >> Processing.uncertainty_2; + content >> Processing.archive_bottle_id; + radionuclide_msg_data.insert(block_flag.at(4), QVariant::fromValue(Processing)); + + content >> nextBlock; + content.readLine(); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool RadionuclideMessage::Analyse_Sample_Block(QTextStream &content, QString &nextBlock) +{ + SampleBlock Sample; + content >> Sample.dimension_1 >> Sample.dimension_2; + radionuclide_msg_data.insert(block_flag.at(5), QVariant::fromValue(Sample)); + + content >> nextBlock; + content.readLine(); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool RadionuclideMessage::Analyse_g_Energy_Block(QTextStream& content, QString& nextBlock) +{ + G_EnergyBlock g_Energy; + int row_count = 0; + nextBlock = content.readLine(); + QString temp_line = nextBlock.simplified(); + while (!block_flag.contains(temp_line) && !content.atEnd()) + { + double g_energy, centroid_channel, uncertainty; + QTextStream line_content(&nextBlock); + line_content >> g_energy >> centroid_channel >> uncertainty; + + g_Energy.g_energy << g_energy; + g_Energy.centroid_channel << centroid_channel; + g_Energy.uncertainty << uncertainty; + + ++ row_count; + nextBlock = content.readLine(); + temp_line = nextBlock.simplified(); + + if (line_content.status()==QTextStream::ReadCorruptData) + { + return false; + } + } + g_Energy.record_count = row_count; + radionuclide_msg_data.insert(block_flag.at(6), QVariant::fromValue(g_Energy)); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool RadionuclideMessage::Analyse_b_Energy_Block(QTextStream& content, QString& nextBlock) +{ + B_EnergyBlock b_Energy; + int row_count = 0; + nextBlock = content.readLine(); + QString temp_line = nextBlock.simplified(); + while (!block_flag.contains(temp_line) && !content.atEnd()) + { + QString decay_mode; + double electron_energy, channel, uncertainty; + QTextStream line_content(&nextBlock); + line_content >> electron_energy >> decay_mode >> channel >> uncertainty; + + b_Energy.electron_energy << electron_energy; + b_Energy.decay_mode << decay_mode; + b_Energy.channel << channel; + b_Energy.uncertainty << uncertainty; + + ++ row_count; + nextBlock = content.readLine(); + temp_line = nextBlock.simplified(); + + if (line_content.status()==QTextStream::ReadCorruptData) + { + return false; + } + } + b_Energy.record_count = row_count; + radionuclide_msg_data.insert(block_flag.at(7), QVariant::fromValue(b_Energy)); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool RadionuclideMessage::Analyse_g_Resolution_Block(QTextStream& content, QString& nextBlock) +{ + G_ResolutionBlock g_Resolution; + int row_count = 0; + nextBlock = content.readLine(); + QString temp_line = nextBlock.simplified(); + while (!block_flag.contains(temp_line) && !content.atEnd()) + { + double g_energy, FWHM, uncertainty; + QTextStream line_content(&nextBlock); + line_content >> g_energy >> FWHM >> uncertainty; + + g_Resolution.g_energy << g_energy; + g_Resolution.FWHM << FWHM; + g_Resolution.uncertainty << uncertainty; + + ++ row_count; + nextBlock = content.readLine(); + temp_line = nextBlock.simplified(); + + if (line_content.status()==QTextStream::ReadCorruptData) + { + return false; + } + } + g_Resolution.record_count = row_count; + radionuclide_msg_data.insert(block_flag.at(8), QVariant::fromValue(g_Resolution)); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool RadionuclideMessage::Analyse_b_Resolution_Block(QTextStream& content, QString& nextBlock) +{ + B_ResolutionBlock b_Resolution; + int row_count = 0; + nextBlock = content.readLine(); + QString temp_line = nextBlock.simplified(); + while (!block_flag.contains(temp_line) && !content.atEnd()) + { + double electron_energy, FWHM, uncertainty; + QTextStream line_content(&nextBlock); + line_content >> electron_energy >> FWHM >> uncertainty; + + b_Resolution.electron_energy << electron_energy; + b_Resolution.FWHM << FWHM; + b_Resolution.uncertainty << uncertainty; + + ++ row_count; + nextBlock = content.readLine(); + temp_line = nextBlock.simplified(); + + if (line_content.status()==QTextStream::ReadCorruptData) + { + return false; + } + } + b_Resolution.record_count = row_count; + radionuclide_msg_data.insert(block_flag.at(9), QVariant::fromValue(b_Resolution)); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool RadionuclideMessage::Analyse_g_Efficiency_Block(QTextStream& content, QString& nextBlock) +{ + G_EfficiencyBlock g_Efficiency; + int row_count = 0; + nextBlock = content.readLine(); + QString temp_line = nextBlock.simplified(); + while (!block_flag.contains(temp_line) && !content.atEnd()) + { + double g_energy, efficiency, uncertainty; + QTextStream line_content(&nextBlock); + line_content >> g_energy >> efficiency >> uncertainty; + + g_Efficiency.g_energy << g_energy; + g_Efficiency.efficiency << efficiency; + g_Efficiency.uncertainty << uncertainty; + + ++ row_count; + nextBlock = content.readLine(); + temp_line = nextBlock.simplified(); + + if (line_content.status()==QTextStream::ReadCorruptData) + { + return false; + } + } + g_Efficiency.record_count = row_count; + radionuclide_msg_data.insert(block_flag.at(10), QVariant::fromValue(g_Efficiency)); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool RadionuclideMessage::Analyse_ROI_Limits_Block(QTextStream& content, QString& nextBlock) +{ + ROI_LimitsBlock ROI_Limits; + int row_count = 0; + nextBlock = content.readLine(); + QString temp_line = nextBlock.simplified(); + while (!block_flag.contains(temp_line) && !content.atEnd()) + { + QString ROI_number; + double POI_B_x1, POI_B_x2, POI_G_y1, POI_G_y2; + QTextStream line_content(&nextBlock); + line_content >> ROI_number >> POI_B_x1 >> POI_B_x2 >> POI_G_y1 >> POI_G_y2; + + ROI_Limits.ROI_number << ROI_number; + ROI_Limits.POI_B_x1 << POI_B_x1; + ROI_Limits.POI_B_x2 << POI_B_x2; + ROI_Limits.POI_G_y1 << POI_G_y1; + ROI_Limits.POI_G_y2 << POI_G_y2; + + ++ row_count; + nextBlock = content.readLine(); + temp_line = nextBlock.simplified(); + + if (line_content.status()==QTextStream::ReadCorruptData) + { + return false; + } + } + ROI_Limits.record_count = row_count; + radionuclide_msg_data.insert(block_flag.at(11), QVariant::fromValue(ROI_Limits)); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool RadionuclideMessage::Analyse_bg_Efficiency_Block(QTextStream& content, QString& nextBlock) +{ + BG_EfficiencyBlock bg_Efficiency; + int row_count = 0; + nextBlock = content.readLine(); + QString temp_line = nextBlock.simplified(); + while (!block_flag.contains(temp_line) && !content.atEnd()) + { + QString nuclide_name, ROI_number; + double bg_efficiency, uncertainty; + QTextStream line_content(&nextBlock); + line_content >> nuclide_name >> ROI_number >> bg_efficiency >> uncertainty; + + bg_Efficiency.nuclide_name << nuclide_name; + bg_Efficiency.ROI_number << ROI_number; + bg_Efficiency.bg_efficiency << bg_efficiency; + bg_Efficiency.uncertainty << uncertainty; + + ++ row_count; + nextBlock = content.readLine(); + temp_line = nextBlock.simplified(); + + if (line_content.status()==QTextStream::ReadCorruptData) + { + return false; + } + } + bg_Efficiency.record_count = row_count; + radionuclide_msg_data.insert(block_flag.at(12), QVariant::fromValue(bg_Efficiency)); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool RadionuclideMessage::Analyse_TotalEff_Block(QTextStream& content, QString& nextBlock) +{ + TotaleffBlock Totaleff; + int row_count = 0; + nextBlock = content.readLine(); + QString temp_line = nextBlock.simplified(); + while (!block_flag.contains(temp_line) && !content.atEnd()) + { + double g_energy, total_efficiency, uncertainty; + QTextStream line_content(&nextBlock); + line_content >> g_energy >> total_efficiency >> uncertainty; + + Totaleff.g_energy << g_energy; + Totaleff.total_efficiency << total_efficiency; + Totaleff.uncertainty << uncertainty; + + ++ row_count; + nextBlock = content.readLine(); + temp_line = nextBlock.simplified(); + + if (line_content.status()==QTextStream::ReadCorruptData) + { + return false; + } + } + Totaleff.record_count = row_count; + radionuclide_msg_data.insert(block_flag.at(13), QVariant::fromValue(Totaleff)); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool RadionuclideMessage::Analyse_Ratios_Block(QTextStream& content, QString& nextBlock) +{ + RatiosBlock Ratios; + int row_count = 0; + nextBlock = content.readLine(); + QString temp_line = nextBlock.simplified(); + while (!block_flag.contains(temp_line) && !content.atEnd()) + { + QString ratio_id, ROI_num_highter_G_energy_ROI, ROI_num_lower_G_energy_ROI; + double count_ratio, count_ratio_uncertainty; + QTextStream line_content(&nextBlock); + line_content >> ratio_id >> ROI_num_highter_G_energy_ROI >> ROI_num_lower_G_energy_ROI \ + >> count_ratio >> count_ratio_uncertainty; + + Ratios.ratio_id << ratio_id; + Ratios.ROI_num_highter_G_energy_ROI << ROI_num_highter_G_energy_ROI; + Ratios.ROI_num_lower_G_energy_ROI << ROI_num_lower_G_energy_ROI; + Ratios.count_ratio << count_ratio; + Ratios.count_ratio_uncertainty << count_ratio_uncertainty; + + ++ row_count; + nextBlock = content.readLine(); + temp_line = nextBlock.simplified(); + + if (line_content.status()==QTextStream::ReadCorruptData) + { + return false; + } + } + Ratios.record_count = row_count; + radionuclide_msg_data.insert(block_flag.at(14), QVariant::fromValue(Ratios)); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool RadionuclideMessage::Analyse_g_Spectrum_Block(QTextStream& content, QString& nextBlock) +{ + G_SpectrumBlock g_Spectrum; + content >> g_Spectrum.num_g_channel >> g_Spectrum.g_energy_span; + content.readLine(); + + bool beginFlag=true; + long temp=0; + nextBlock = content.readLine(); + QString temp_line = nextBlock.simplified(); + while (!block_flag.contains(temp_line) && !content.atEnd()) + { + QTextStream line_content(&nextBlock); + if(beginFlag) + { + line_content >> g_Spectrum.begin_channel; + beginFlag = false; + } + else + { + line_content >> temp; + } + for (; !line_content.atEnd();) + { + line_content >> temp; + if (line_content.status()==QTextStream::Ok) + { + g_Spectrum.counts << temp; + } + else if (line_content.status()==QTextStream::ReadCorruptData) + { + return false; + } + } + nextBlock = content.readLine(); + temp_line = nextBlock.simplified(); + } + g_Spectrum.num_g_channel = g_Spectrum.counts.count(); + +#if 0 + long temp=0; + long row_channel_span = g_Spectrum.num_g_channel / 5; + for (long row=0; row> temp; + for (int column=0; column<5; ++column) + { + content >> temp; + g_Spectrum.counts << temp; + } + } + content >> temp; + long channel_remainder = g_Spectrum.num_g_channel % 5; + for (long i=0; i> temp; + g_Spectrum.counts << temp; + } + content >> nextBlock; + content.readLine(); +#endif + + radionuclide_msg_data.insert(block_flag.at(15), QVariant::fromValue(g_Spectrum)); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool RadionuclideMessage::Analyse_b_Spectrum_Block(QTextStream& content, QString& nextBlock) +{ + B_SpectrumBlock b_Spectrum; + content >> b_Spectrum.num_b_channel >> b_Spectrum.b_energy_span; + content.readLine(); + + long temp=0; + bool beginFlag=true; + nextBlock = content.readLine(); + QString temp_line = nextBlock.simplified(); + while (!block_flag.contains(temp_line) && !content.atEnd()) + { + QTextStream line_content(&nextBlock); + if(beginFlag) + { + line_content >> b_Spectrum.begin_channel; + beginFlag = false; + } + else + { + line_content >> temp; + } + for (; !line_content.atEnd();) + { + line_content >> temp; + if (line_content.status()==QTextStream::Ok) + { + b_Spectrum.counts << temp; + } + else if (line_content.status()==QTextStream::ReadCorruptData) + { + return false; + } + } + nextBlock = content.readLine(); + temp_line = nextBlock.simplified(); + } + b_Spectrum.num_b_channel = b_Spectrum.counts.count(); + +#if 0 + long temp; + long row_channel_span = b_Spectrum.num_b_channel / 5; + for (long row=0; row> temp; + for (int column=0; column<5; ++column) + { + content >> temp; + b_Spectrum.counts << temp; + } + } + content >> temp; + long channel_remainder = b_Spectrum.num_b_channel % 5; + for (long i=0; i> temp; + b_Spectrum.counts << temp; + } + content >> nextBlock; + content.readLine(); +#endif + + radionuclide_msg_data.insert(block_flag.at(16), QVariant::fromValue(b_Spectrum)); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool RadionuclideMessage::Analyse_Histogram_Block(QTextStream& content, QString& nextBlock) +{ + HistogramBlock Histogram; + //change by cao 2015-12-3 + // content >> Histogram.b_channels >> Histogram.g_channels >> Histogram.b_energy_span >> Histogram.g_energy_span; + content >> Histogram.b_channels >> Histogram.g_channels >> Histogram.g_energy_span >> Histogram.b_energy_span; + content.readLine(); + + long temp=0, row=0; + nextBlock = content.readLine(); + QString temp_line = nextBlock.simplified(); + while (!block_flag.contains(temp_line) && !content.atEnd()) + { + QTextStream line_content(&nextBlock); + for (; !line_content.atEnd();) + { + line_content >> temp; + if (line_content.status()==QTextStream::Ok) + { + Histogram.counts << temp; + } + else if (line_content.status()==QTextStream::ReadCorruptData) + { + return false; + } + } + ++ row; + nextBlock = content.readLine(); + temp_line = nextBlock.simplified(); + } + Histogram.g_channels = row; + if(row == 0) + { + Histogram.b_channels = 0; + } + else + { + Histogram.b_channels = Histogram.counts.count()/row; + } + +#if 0 + long& row_size = Histogram.b_channels; + long& column_size = Histogram.g_channels; + for (long row=0; row> temp; + Histogram.counts << temp; + } + } + + content >> nextBlock; + content.readLine(); +#endif + + radionuclide_msg_data.insert(block_flag.at(17), QVariant::fromValue(Histogram)); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool RadionuclideMessage::Analyse_Calibration_Block(QTextStream& content, QString& nextBlock) +{ + CalibrationBlock Calibration; + content >> Calibration.date_calibration >> Calibration.time_calibration; + radionuclide_msg_data.insert(block_flag.at(18), QVariant::fromValue(Calibration)); + + content >> nextBlock; + content.readLine(); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool RadionuclideMessage::Analyse_Certificate_Block(QTextStream& content, QString& nextBlock) +{ + CertificateBlock Certificate; + + QString temp_line = content.readLine(); + QTextStream temp_line_stream(&temp_line); + temp_line_stream >> Certificate.total_source_activity >> Certificate.assay_date >> Certificate.assay_time >> Certificate.units_activity; + + int row_count = 0; + nextBlock = content.readLine(); + temp_line = nextBlock.simplified(); + while (!block_flag.contains(temp_line) && !content.atEnd()) + { + if (nextBlock.simplified().isEmpty()) + { + nextBlock = content.readLine(); + continue; + } + QString nuclide_name, half_life_time; + QString time_unit, electron_decay_mode; + double activity_nuclide_time_assay, uncertainty, g_energy, g_intensity, maximum_energy, intensity_b_particle; + QTextStream line_content(&nextBlock); + line_content >> nuclide_name >> half_life_time >> time_unit >> activity_nuclide_time_assay \ + >> uncertainty >> g_energy >> g_intensity >> electron_decay_mode \ + >> maximum_energy >> intensity_b_particle ; + + Certificate.nuclide_name << nuclide_name; + Certificate.half_life_time << half_life_time; + Certificate.time_unit << time_unit; + Certificate.activity_nuclide_time_assay << activity_nuclide_time_assay; + Certificate.uncertainty << uncertainty; + Certificate.g_energy << g_energy; + Certificate.g_intensity << g_intensity; + Certificate.electron_decay_mode << electron_decay_mode; + Certificate.maximum_energy << maximum_energy; + Certificate.intensity_b_particle << intensity_b_particle; + + /* 时间转换办法，暂时使用， 将来启用时，需修改“CertificateBlock”结构 + if (time_unit == QLatin1String("Y")) + { + float time = half_life_time.toFloat(); + Certificate.half_life_time << qulonglong(time*YEAR); + } + else if (time_unit == QLatin1String("D")) + { + float time = half_life_time.toFloat(); + Certificate.half_life_time << qulonglong(time*DAY); + } + else if (time_unit == QLatin1String("H")) + { + float time = half_life_time.toFloat(); + Certificate.half_life_time << qulonglong(time*HOUR); + } + else if (time_unit == QLatin1String("S")) + { + Certificate.half_life_time << half_life_time.toULongLong();; + } + */ + ++ row_count; + nextBlock = content.readLine(); + temp_line = nextBlock.simplified(); + + if (line_content.status()==QTextStream::ReadCorruptData) + { + return false; + } + } + Certificate.record_count = row_count; + radionuclide_msg_data.insert(block_flag.at(19), QVariant::fromValue(Certificate)); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool RadionuclideMessage::Verity_SampleReferenceId(QString srid) +{ + bool bRet = true; + int srid_len = srid.length(); + if ( 14==srid_len || 15==srid_len ) + { + if ( QLatin1String("00G")==srid.right(3) || + QLatin1String("00X")==srid.right(3) ) //GASBKPHD + { + AbstractSpectrumDataMessage::SetMsgDataType( QLatin1String("GASBKPHD") ); + } + else if ( QLatin1String("00000000")==srid.mid(2,8) ) //BLANKPHD + { + AbstractSpectrumDataMessage::SetMsgDataType( QLatin1String("BLANKPHD") ); + } + else if ( QLatin1String("11111111")==srid.mid(2,8) ) //DETBKPHD + { + AbstractSpectrumDataMessage::SetMsgDataType( QLatin1String("DETBKPHD") ); + } + else if ( QLatin1String("77777777")==srid.mid(2,8) ) //Special IMS Samples + { + AbstractSpectrumDataMessage::SetMsgDataType( QLatin1String("SAMPLEPHD") ); + } + else if ( QLatin1String("88888888")==srid.mid(2,8) ) //QCPHD + { + AbstractSpectrumDataMessage::SetMsgDataType( QLatin1String("QCPHD") ); + } + else if ( QLatin1String("99999999")==srid.mid(2,8) ) //CALIBPHD + { + AbstractSpectrumDataMessage::SetMsgDataType( QLatin1String("CALIBPHD") ); + } + else //SAMPLEPHD + { + AbstractSpectrumDataMessage::SetMsgDataType( QLatin1String("SAMPLEPHD") ); + } + } + else + { + bRet &= false; + } + return bRet; +} diff --git a/RadionuclideMessage.h b/RadionuclideMessage.h new file mode 100644 index 0000000..ea9aeac --- /dev/null +++ b/RadionuclideMessage.h @@ -0,0 +1,57 @@ +#ifndef RADIONUCLIDEMESSAGE_H +#define RADIONUCLIDEMESSAGE_H + +#include "AbstractSpectrumDataMessage.h" +#include "DataManager_Define.h" +#include +class QTextStream; + +class RadionuclideMessage : public AbstractSpectrumDataMessage +{ +public: + explicit RadionuclideMessage(); + ~RadionuclideMessage(); + + bool AnalysePHD_Msg(QString &msg_string); + bool AnalysePHD_File(QString phd_name); + RadionuclideData::AnalyseDataType GetAnalyseDataType(); + const QVariant GetBlockData(QString& block_name); + virtual bool IsValid(); + virtual void ClearData(); + + static QVector GetHistogramProjectedDataValue( + RadionuclideData::HistogramBlock &histogram, Qt::Orientation orientation); + +private: + void InitBlockFlagInfo(); + bool AnalyseMessgeBody(QTextStream& content); + bool Analyse_Header_Block(QTextStream& content, QString& nextBlock); + bool Analyse_Comment_Block(QTextStream& content, QString& nextBlock); + bool Analyse_Collection_Block(QTextStream& content, QString& nextBlock); + bool Analyse_Acquisition_Block(QTextStream& content, QString& nextBlock); + bool Analyse_Processing_Block(QTextStream& content, QString& nextBlock); + bool Analyse_Sample_Block(QTextStream& content, QString& nextBlock); + bool Analyse_g_Energy_Block(QTextStream& content, QString& nextBlock); + bool Analyse_b_Energy_Block(QTextStream& content, QString& nextBlock); + bool Analyse_g_Resolution_Block(QTextStream& content, QString& nextBlock); + bool Analyse_b_Resolution_Block(QTextStream& content, QString& nextBlock); + bool Analyse_g_Efficiency_Block(QTextStream& content, QString& nextBlock); + bool Analyse_ROI_Limits_Block(QTextStream& content, QString& nextBlock); + bool Analyse_bg_Efficiency_Block(QTextStream& content, QString& nextBlock); + bool Analyse_TotalEff_Block(QTextStream& content, QString& nextBlock); + bool Analyse_Ratios_Block(QTextStream& textStream, QString& nextBlock); + bool Analyse_g_Spectrum_Block(QTextStream& content, QString& nextBlock); + bool Analyse_b_Spectrum_Block(QTextStream& content, QString& nextBlock); + bool Analyse_Histogram_Block(QTextStream& content, QString& nextBlock); + bool Analyse_Calibration_Block(QTextStream& content, QString& nextBlock); + bool Analyse_Certificate_Block(QTextStream& content, QString& nextBlock); + bool Verity_SampleReferenceId(QString srid); + +private: + bool bIsValid; + QStringList block_flag; + QVariantMap radionuclide_msg_data; // 因解析的数据的结构不同，请其统一存储至QVariantMap容器中 + RadionuclideData::AnalyseDataType analyse_data_type; +}; + +#endif // RADIONUCLIDEMESSAGE_H diff --git a/ReadPHDFile.pri b/ReadPHDFile.pri new file mode 100644 index 0000000..4f9ae85 --- /dev/null +++ b/ReadPHDFile.pri @@ -0,0 +1,6 @@ +INCLUDEPATH += $$PWD/include + +#LIBS += -L$$PWD/lib -larmadillo +LIBS += -L$$PWD/lib -lblas +LIBS += -L$$PWD/lib -llapack +LIBS += -L$$PWD/lib -lgfortran diff --git a/ReadPHDFile.pro b/ReadPHDFile.pro new file mode 100644 index 0000000..e8a67d6 --- /dev/null +++ b/ReadPHDFile.pro @@ -0,0 +1,94 @@ +#------------------------------------------------- +# +# Project created by QtCreator 2015-12-28T13:49:57 +# +#------------------------------------------------- +include(common.pri) + +#QT += core gui xml +QT -= gui +#QT += gui +#QT += core +#greaterThan(QT_MAJOR_VERSION, 4): QT += widgets + +TARGET = ReadPHDFile +TEMPLATE = lib +#TEMPLATE = app +CONFIG += shared +CONFIG += c++11 +#DEFINES += GAMMAANALYALG_LIBRARY + +CONFIG(debug,debug|release){ +DEFINES += DEBUG_INFO_OUTPUT +} + +OBJECTS_DIR = $$PROJECT_OBJ/ReadPHDFile +MOC_DIR = $$PROJECT_MOC/ReadPHDFile +RCC_DIR = $$PROJECT_RCC/ReadPHDFile +UI_DIR = $$PROJECT_UI/ReadPHDFile +DESTDIR = $$PROJECT_LIB + +SOURCES += \ + AbstractSpectrumDataMessage.cpp \ + AlertMessage.cpp \ + BgWork.cpp \ + CplusToJava.cpp \ + Fit.cpp \ + MDC.cpp \ + MeteorologicalMessage.cpp \ + ProcessAlgorithmGlobalVar.cpp \ + ROI.cpp \ + ROIConUncer.cpp \ + RadionuclideMessage.cpp \ + StateOfHealthMessage.cpp \ + XeConUncer.cpp \ + org_jeecg_modules_native_jni_EnergySpectrumHandler.cpp + +HEADERS += \ + AbstractSpectrumDataMessage.h \ + AlertMessage.h \ + BgWork.h \ + BgWorkDef.h \ + CplusToJava.h \ + DataManager_Define.h \ + Fit.h \ + FitDef.h \ + MDC.h \ + MDCDef.h \ + MeteorologicalMessage.h \ + ProcessAlgorithmGlobalVar.h \ + ROI.h \ + ROIConUncer.h \ + ROIConUncerDef.h \ + ROIDef.h \ + RadionuclideMessage.h \ + StateOfHealthMessage.h \ + XeConUncer.h \ + XeConUncerDef.h \ + org_jeecg_modules_native_jni_EnergySpectrumHandler.h + +#FORMS += mainwindow.ui + +win32:INCLUDEPATH += "C:/java64/jdk/include" +win32:INCLUDEPATH += "C:/java64/jdk/include/win32" + +QMAKE_LFLAGS += -Wl,--kill-at + +#LIBS += -L$$PROJECT_LIB -l$$DATAMANAGER_NAME +#LIBS += -L$$PROJECT_LIB -lgammaAlgorithm +#LIBS += -L$$PWD/lib -larmadillo +#LIBS += -L$$PWD/lib -lblas +#LIBS += -L$$PWD/lib -llapack + +DISTFILES += # GammaAnalyALG.pri #\ + #helpApat_list.txt \ + #msgparse.txt \ + #struct_UserData.txt \ + #importMsg.txt \ + #aatami_start.txt \ + #loadCtrlFcn.txt \ + #FitFunc.txt \ + #loadCtrlGUI.txt \ + #setupInit.txt \ + #standardsetting.txt \ + diff --git a/ReadPHDFile.pro.user b/ReadPHDFile.pro.user new file mode 100644 index 0000000..f1eb590 --- /dev/null +++ b/ReadPHDFile.pro.user @@ -0,0 +1,337 @@ + + + + + + EnvironmentId + {358ed4f8-d345-4a95-a955-ca552bad5e85} + + + ProjectExplorer.Project.ActiveTarget + 0 + + + ProjectExplorer.Project.EditorSettings + + true + false + true + + Cpp + + CppGlobal + + + + QmlJS + + QmlJSGlobal + + + 2 + UTF-8 + false + 4 + false + 80 + true + true + 1 + true + false + 0 + true + true + 0 + 8 + true + 1 + true + true + true + false + + + + ProjectExplorer.Project.PluginSettings + + + -fno-delayed-template-parsing + + true + + + + ProjectExplorer.Project.Target.0 + + Desktop Qt 5.13.0 MinGW 64-bit + Desktop Qt 5.13.0 MinGW 64-bit + qt.qt5.5130.win64_mingw73_kit + 1 + 0 + 0 + + D:/project/build-ReadPHDFile-Desktop_Qt_5_13_0_MinGW_64_bit-Debug + + + true + qmake + + QtProjectManager.QMakeBuildStep + true + + false + false + false + + + true + Make + + Qt4ProjectManager.MakeStep + + false + + + false + + 2 + Build + + ProjectExplorer.BuildSteps.Build + + + + true + Make + + Qt4ProjectManager.MakeStep + + true + clean + + false + + 1 + Clean + + ProjectExplorer.BuildSteps.Clean + + 2 + false + + Debug + Debug + Qt4ProjectManager.Qt4BuildConfiguration + 2 + true + + + D:/project/build-ReadPHDFile-Desktop_Qt_5_13_0_MinGW_64_bit-Release + + + true + qmake + + QtProjectManager.QMakeBuildStep + false + + false + false + true + + + true + Make + + Qt4ProjectManager.MakeStep + + false + + + false + + 2 + Build + + ProjectExplorer.BuildSteps.Build + + + + true + Make + + Qt4ProjectManager.MakeStep + + true + clean + + false + + 1 + Clean + + ProjectExplorer.BuildSteps.Clean + + 2 + false + + Release + Release + Qt4ProjectManager.Qt4BuildConfiguration + 0 + true + + + D:/project/build-ReadPHDFile-Desktop_Qt_5_13_0_MinGW_64_bit-Profile + + + true + qmake + + QtProjectManager.QMakeBuildStep + true + + false + true + true + + + true + Make + + Qt4ProjectManager.MakeStep + + false + + + false + + 2 + Build + + ProjectExplorer.BuildSteps.Build + + + + true + Make + + Qt4ProjectManager.MakeStep + + true + clean + + false + + 1 + Clean + + ProjectExplorer.BuildSteps.Clean + + 2 + false + + Profile + Profile + Qt4ProjectManager.Qt4BuildConfiguration + 0 + true + + 3 + + + 0 + 部署 + + ProjectExplorer.BuildSteps.Deploy + + 1 + Deploy Configuration + + ProjectExplorer.DefaultDeployConfiguration + + 1 + + + dwarf + + cpu-cycles + + + 250 + -F + true + 4096 + false + false + 1000 + + true + + false + false + false + false + true + 0.01 + 10 + true + kcachegrind + 1 + 25 + + 1 + true + false + true + valgrind + + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + + 2 + + + Custom Executable + + ProjectExplorer.CustomExecutableRunConfiguration + + 3768 + false + true + false + false + true + + + + 1 + + + + ProjectExplorer.Project.TargetCount + 1 + + + ProjectExplorer.Project.Updater.FileVersion + 21 + + + Version + 21 + + diff --git a/StateOfHealthMessage.cpp b/StateOfHealthMessage.cpp new file mode 100644 index 0000000..0eadbef --- /dev/null +++ b/StateOfHealthMessage.cpp @@ -0,0 +1,521 @@ +#include "StateOfHealthMessage.h" +#include + +using namespace RMSSOHData; + +StateOfHealthMessage::StateOfHealthMessage() +{ + bIsValid = false; + InitBlockFlagInfo(); +} + +StateOfHealthMessage::~StateOfHealthMessage() +{ +} + +bool StateOfHealthMessage::IsValid() +{ + return bIsValid; +} + +const QVariant StateOfHealthMessage::GetBlockData(QString &block_name) +{ + if ( rmssoh_msg_data.contains(block_name) ) + { + return rmssoh_msg_data[block_name]; + } + return QVariant(); +} + +void StateOfHealthMessage::ClearData() +{ + bIsValid = false; + rmssoh_msg_data.clear(); + + AbstractSpectrumDataMessage::ClearData(); +} + +void StateOfHealthMessage::InitBlockFlagInfo() +{ + block_flag.append(QLatin1String("#Header")); // [ 0 ] + block_flag.append(QLatin1String("#Comment")); // [ 1 ] + block_flag.append(QLatin1String("#AirSamplerFlow")); // [ 2 ] + block_flag.append(QLatin1String("#AirSamplerEnv")); // [ 3 ] + block_flag.append(QLatin1String("#DetEnv")); // [ 4 ] + block_flag.append(QLatin1String("#NIMBIN")); // [ 5 ] + block_flag.append(QLatin1String("#PowerSupply")); // [ 6 ] + block_flag.append(QLatin1String("#EquipStatus")); // [ 7 ] + block_flag.append(QLatin1String("#TamperEnv")); // [ 8 ] + block_flag.append(QLatin1String("#ProcessSensors")); // [ 9 ] + block_flag.append(QLatin1String("#Chromatogram")); // [ 10 ] + block_flag.append(QLatin1String("STOP")); // [ STOP ] + block_flag.append(QLatin1String("BEGIN")); // [ BEGIN ] +} + +bool StateOfHealthMessage::AnalyseMessgeBody(QTextStream &content) +{ + const MessageInfo& msg = AbstractSpectrumDataMessage::GetMessageInfo(); + if ( QLatin1String("RMSSOH") != msg.data_type ) + { + return bIsValid = false; + } + bool bRet = true; + QString line = content.readLine(); + do + { + if ( 0==line.left(7).compare(block_flag.at(0)) && bRet) + { + bRet &= Analyse_Header_Block(content, line); + } + else if ( 0==line.compare(block_flag.at(1)) && bRet) + { + bRet &= Analyse_Comment_Block(content, line); + } + else if ( 0==line.compare(block_flag.at(2)) && bRet) + { + bRet &= Analyse_AirSamplerFlow_Block(content, line); + } + else if ( 0==line.compare(block_flag.at(3)) && bRet) + { + bRet &= Analyse_AirSamplerEnv_Block(content, line); + } + else if ( 0==line.compare(block_flag.at(4)) && bRet) + { + bRet &= Analyse_DetEnv_Block(content, line); + } + else if ( 0==line.compare(block_flag.at(5)) && bRet) + { + bRet &= Analyse_NIMBIN_Block(content, line); + } + else if ( 0==line.compare(block_flag.at(6)) && bRet) + { + bRet &= Analyse_PowerSupply_Block(content, line); + } + else if ( 0==line.compare(block_flag.at(7)) && bRet) + { + bRet &= Analyse_EquipStatus_Block(content, line); + } + else if ( 0==line.compare(block_flag.at(8)) && bRet) + { + bRet &= Analyse_TamperEnv_Block(content, line); + } + else if ( 0==line.compare(block_flag.at(9)) && bRet) + { + bRet &= Analyse_ProcessSensors_Block(content, line); + } + else if ( 0==line.compare(block_flag.at(10)) && bRet) + { + bRet &= Analyse_ChromatogramBlock(content, line); + } + else + { // 数据错误，数据有效 + bIsValid = false; + bRet = bIsValid; + } + + if (0==line.compare(block_flag.at(11)) && bRet ) + { + bIsValid = true; //检测到“STOP line”，消息完整，数据有效 + break; + } + else if (content.atEnd()) + { + bIsValid = false; + rmssoh_msg_data.clear(); + bRet = bIsValid; + break; + } + } + while( bRet ); + + return bRet; +} + +bool StateOfHealthMessage::Analyse_Header_Block(QTextStream &content, QString &nextBlock) +{ + HeaderBlock Header; + QString &line = nextBlock; + Header.designator = line.mid(8); + + content >> Header.station_code >> Header.detector_code; + content >> Header.start_date >> Header.start_time >> Header.end_date >> Header.end_time >> Header.transmit_date >> Header.transmit_time; + rmssoh_msg_data.insert(block_flag.at(0), QVariant::fromValue(Header)); + + content >> nextBlock; + content.readLine(); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool StateOfHealthMessage::Analyse_Comment_Block(QTextStream& content, QString& nextBlock) +{ + CommentBlock comment; + nextBlock = content.readLine(); + while ( !block_flag.contains(nextBlock) && !content.atEnd()) + { + if ( !nextBlock.isEmpty() ) + { + comment.append(nextBlock + QLatin1String("\n")); + } + nextBlock = content.readLine(); + } + rmssoh_msg_data.insert(block_flag.at(1), QVariant::fromValue(comment)); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool StateOfHealthMessage::Analyse_AirSamplerFlow_Block(QTextStream &content, QString &nextBlock) +{ + AirSamplerFlowBlock air_sampler_flow; + int row_count = 0; + nextBlock = content.readLine(); + while (!block_flag.contains(nextBlock) && !content.atEnd()) + { + double average_flow_rate; + double flow_rate_standard_deviation; + QString start_date; + QString start_time; + long interval_duration; + + QTextStream line_content(&nextBlock); + line_content >> average_flow_rate >> flow_rate_standard_deviation >> start_date >> start_time >> interval_duration; + + air_sampler_flow.average_flow_rate << average_flow_rate; + air_sampler_flow.flow_rate_standard_deviation << flow_rate_standard_deviation; + air_sampler_flow.start_date << start_date; + air_sampler_flow.start_time << start_time; + air_sampler_flow.interval_duration << interval_duration; + + ++ row_count; + nextBlock = content.readLine(); + + if (line_content.status()==QTextStream::ReadCorruptData) + { + return false; + } + } + air_sampler_flow.record_count = row_count; + rmssoh_msg_data.insert( block_flag.at(2), QVariant::fromValue(air_sampler_flow) ); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool StateOfHealthMessage::Analyse_AirSamplerEnv_Block(QTextStream &content, QString &nextBlock) +{ + AirSamplerEnvBlock air_sampler_env; + int row_count = 0; + nextBlock = content.readLine(); + while (!block_flag.contains(nextBlock) && !content.atEnd()) + { + double temperature; + double pressure; + QString date; + QString time; + long interval_duration; + + QTextStream line_content(&nextBlock); + line_content >> temperature >> pressure >> date >> time >> interval_duration; + + air_sampler_env.temperature << temperature; + air_sampler_env.pressure << pressure; + air_sampler_env.date << date; + air_sampler_env.time << time; + air_sampler_env.interval_duration << interval_duration; + + ++ row_count; + nextBlock = content.readLine(); + + if (line_content.status()==QTextStream::ReadCorruptData) + { + return false; + } + } + air_sampler_env.record_count = row_count; + rmssoh_msg_data.insert( block_flag.at(3), QVariant::fromValue(air_sampler_env) ); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool StateOfHealthMessage::Analyse_DetEnv_Block(QTextStream &content, QString &nextBlock) +{ + DetEnvBlock det_env; + int row_count = 0; + nextBlock = content.readLine(); + while (!block_flag.contains(nextBlock) && !content.atEnd()) + { + double room_temperature; + QString detector_shield_status; + short humidity; + long voltage; + long crystal_temperature; + QString electric_cooler_status; + double fill_fraction; + double leakage; + QString date; + QString time; + long interval_duration; + + QTextStream line_content(&nextBlock); + line_content >> room_temperature >> detector_shield_status >> humidity >> voltage >> \ + crystal_temperature >> electric_cooler_status >> fill_fraction >> leakage >> \ + date >> time >> interval_duration; + + det_env.room_temperature << room_temperature; + det_env.detector_shield_status << detector_shield_status; + det_env.humidity << humidity; + det_env.voltage << voltage; + det_env.crystal_temperature << crystal_temperature; + det_env.electric_cooler_status << electric_cooler_status; + det_env.fill_fraction << fill_fraction; + det_env.leakage << leakage; + det_env.date << date; + det_env.time << time; + det_env.interval_duration << interval_duration; + + ++ row_count; + nextBlock = content.readLine(); + + if (line_content.status()==QTextStream::ReadCorruptData) + { + return false; + } + } + det_env.record_count = row_count; + rmssoh_msg_data.insert( block_flag.at(4), QVariant::fromValue(det_env) ); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool StateOfHealthMessage::Analyse_NIMBIN_Block(QTextStream &content, QString &nextBlock) +{ + NIMBIN_Block nimbin; + int row_count = 0; + nextBlock = content.readLine(); + while (!block_flag.contains(nextBlock) && !content.atEnd()) + { + QString flag; + short voltage; + QString date; + QString time; + long interval_duration; + + QTextStream line_content(&nextBlock); + line_content >> flag >> voltage >> date >> time >> interval_duration; + + nimbin.flag << flag; + nimbin.voltage << voltage; + nimbin.date << date; + nimbin.time << time; + nimbin.interval_duration << interval_duration; + + ++ row_count; + nextBlock = content.readLine(); + + if (line_content.status()==QTextStream::ReadCorruptData) + { + return false; + } + } + nimbin.record_count = row_count; + rmssoh_msg_data.insert( block_flag.at(5), QVariant::fromValue(nimbin) ); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool StateOfHealthMessage::Analyse_PowerSupply_Block(QTextStream &content, QString &nextBlock) +{ + PowerSupplyBlock power_supply; + int row_count = 0; + nextBlock = content.readLine(); + while (!block_flag.contains(nextBlock) && !content.atEnd()) + { + QString MAIN; + QString main_power_status; + QString AUX; + QString aux_power_status; + QString UPS; + QString ups_status; + QString date; + QString time; + long interval_duration; + + QTextStream line_content(&nextBlock); + line_content >> MAIN >> main_power_status >> AUX >> aux_power_status >> UPS >> ups_status >> date >> time >> interval_duration; + + power_supply.MAIN << MAIN; + power_supply.main_power_status << main_power_status; + power_supply.AUX << AUX; + power_supply.aux_power_status << aux_power_status; + power_supply.UPS << ups_status; + power_supply.date << date; + power_supply.time << time; + power_supply.interval_duration << interval_duration; + + ++ row_count; + nextBlock = content.readLine(); + + if (line_content.status()==QTextStream::ReadCorruptData) + { + return false; + } + } + power_supply.record_count = row_count; + rmssoh_msg_data.insert( block_flag.at(6), QVariant::fromValue(power_supply) ); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool StateOfHealthMessage::Analyse_EquipStatus_Block(QTextStream &content, QString &nextBlock) +{ + EquipStatusBlock equip_status; + int row_count = 0; + nextBlock = content.readLine(); + while (!block_flag.contains(nextBlock) && !content.atEnd()) + { + QString temp_flag; + QString C_value; + QString P_value; + QString A_value; + QString date; + QString time; + long interval_duration; + + QTextStream line_content(&nextBlock); + line_content >> temp_flag >> C_value >> temp_flag >> P_value >> temp_flag >> A_value >> date >> time >> interval_duration; + + equip_status.C_value << C_value; + equip_status.P_value << P_value; + equip_status.A_value << A_value; + equip_status.date << date; + equip_status.time << time; + equip_status.interval_duration << interval_duration; + + ++ row_count; + nextBlock = content.readLine(); + + if (line_content.status()==QTextStream::ReadCorruptData) + { + return false; + } + } + equip_status.record_count = row_count; + rmssoh_msg_data.insert( block_flag.at(7), QVariant::fromValue(equip_status) ); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool StateOfHealthMessage::Analyse_TamperEnv_Block(QTextStream &content, QString &nextBlock) +{ + TamperEnvBlock tamper_env; + int row_count = 0; + nextBlock = content.readLine(); + while (!block_flag.contains(nextBlock) && !content.atEnd()) + { + QString tamper_sensor_name; + QString tamper_sensor_status; + QString date; + QString time; + long interval_duration; + + QTextStream line_content(&nextBlock); + line_content >> tamper_sensor_name >> tamper_sensor_status >> date >> time >> interval_duration; + + tamper_env.tamper_sensor_name << tamper_sensor_name; + tamper_env.tamper_sensor_status << tamper_sensor_status; + tamper_env.date << date; + tamper_env.time << time; + tamper_env.interval_duration << interval_duration; + + ++ row_count; + nextBlock = content.readLine(); + + if (line_content.status()==QTextStream::ReadCorruptData) + { + return false; + } + } + tamper_env.record_count = row_count; + rmssoh_msg_data.insert( block_flag.at(8), QVariant::fromValue(tamper_env) ); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool StateOfHealthMessage::Analyse_ProcessSensors_Block(QTextStream &content, QString &nextBlock) +{ + ProcessSensorsBlock process_sensors; + int row_count = 0; + nextBlock = content.readLine(); + while (!block_flag.contains(nextBlock) && !content.atEnd()) + { + QString sensor_type; + QString sensor_name; + double sensor_reading; + QString date; + QString time; + long duration; + + QTextStream line_content(&nextBlock); + line_content >> sensor_type >> sensor_name >> sensor_reading >> date >> time >> duration; + + process_sensors.sensor_type << sensor_type; + process_sensors.sensor_name << sensor_name; + process_sensors.sensor_reading << sensor_reading; + process_sensors.date << date; + process_sensors.time << time; + process_sensors.duration << duration; + + ++ row_count; + nextBlock = content.readLine(); + + if (line_content.status()==QTextStream::ReadCorruptData) + { + return false; + } + } + process_sensors.record_count = row_count; + rmssoh_msg_data.insert( block_flag.at(9), QVariant::fromValue(process_sensors) ); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool StateOfHealthMessage::Analyse_ChromatogramBlock(QTextStream &content, QString &nextBlock) +{ + ChromatogramBlock chromatogram; + content >> chromatogram.srid; + content >> chromatogram.total_number; + + int row_count = 0; + nextBlock = content.readLine(); + + while (!block_flag.contains(nextBlock) && !content.atEnd()) + { + QTextStream line_content(&nextBlock); + long interval_number; + long interval_start_channel; + double duration; + + line_content >> interval_number; + if ( 0==interval_number ) + { + break; + } + line_content >> interval_start_channel >> duration; + + ++ row_count; + nextBlock = content.readLine(); + if (line_content.status()==QTextStream::ReadCorruptData) + { + return false; + } + } + chromatogram.interval_record_count = row_count; + + while (!block_flag.contains(nextBlock) && !content.atEnd()) + { + QTextStream line_content(&nextBlock); + + long detector_response; + line_content >> detector_response; + chromatogram.detector_response << detector_response; + + nextBlock = content.readLine(); + if (line_content.status()==QTextStream::ReadCorruptData) + { + return false; + } + } + + rmssoh_msg_data.insert( block_flag.at(10), QVariant::fromValue(chromatogram) ); + return (content.status()==QTextStream::Ok)?true:false; +} + diff --git a/StateOfHealthMessage.h b/StateOfHealthMessage.h new file mode 100644 index 0000000..92ca4a7 --- /dev/null +++ b/StateOfHealthMessage.h @@ -0,0 +1,40 @@ +#ifndef STATEOFHEALTHDATA_H +#define STATEOFHEALTHDATA_H + +#include "AbstractSpectrumDataMessage.h" +#include "DataManager_Define.h" +#include +#include + +class StateOfHealthMessage : public AbstractSpectrumDataMessage +{ +public: + explicit StateOfHealthMessage(); + ~StateOfHealthMessage(); + + virtual bool IsValid(); + const QVariant GetBlockData(QString& block_name); + virtual void ClearData(); + +private: + void InitBlockFlagInfo(); + virtual bool AnalyseMessgeBody(QTextStream& content); + bool Analyse_Header_Block(QTextStream& content, QString& nextBlock); + bool Analyse_Comment_Block(QTextStream& content, QString& nextBlock); + bool Analyse_AirSamplerFlow_Block(QTextStream& content, QString& nextBlock); + bool Analyse_AirSamplerEnv_Block(QTextStream& content, QString& nextBlock); + bool Analyse_DetEnv_Block(QTextStream& content, QString& nextBlock); + bool Analyse_NIMBIN_Block(QTextStream& content, QString& nextBlock); + bool Analyse_PowerSupply_Block(QTextStream& content, QString& nextBlock); + bool Analyse_EquipStatus_Block(QTextStream& content, QString& nextBlock); + bool Analyse_TamperEnv_Block(QTextStream& content, QString& nextBlock); + bool Analyse_ProcessSensors_Block(QTextStream& content, QString& nextBlock); + bool Analyse_ChromatogramBlock(QTextStream& content, QString& nextBlock); + +private: + bool bIsValid; + QStringList block_flag; + QVariantMap rmssoh_msg_data; +}; + +#endif // STATEOFHEALTHDATA_H diff --git a/XeConUncer.cpp b/XeConUncer.cpp new file mode 100644 index 0000000..b6ca827 --- /dev/null +++ b/XeConUncer.cpp @@ -0,0 +1,107 @@ +#include "XeConUncer.h" +#include +bool CXeConUncer::CalcXeConUncer(XeConUncerI &_input, XeConUncerO &_output, global::XeType& _output_Xetype) +{ + const int cu_grp_num = 2;//浓度和不确定度组数据 2数为一组 + const int pos_con=0; //浓度偏移 + const int pos_uncer=1; //不确定度偏移 + const int cts_grp_num = 3; ////气体，样品扣除探测器本地谱数据计数 [n..0]计数 [n..1]偏差 [n..2]关键水平 + const int pos_cts = 0; + // const int pos_vari = 1; + const int pos_level = 2; + const int max_g_s = 6*cts_grp_num+pos_level; //气体，样品扣除探测器本地谱数据应包含的数据大小 + bool bError = false; + if(8*cu_grp_num+pos_uncer>=_input.ROI_con_uncer.size()||max_g_s>=_input.s_netXe.size()||max_g_s>=_input.g_netXe.size()) + { + return false; + } + _output.Xe135_con = _input.ROI_con_uncer[2*cu_grp_num+pos_con]; + _output.Xe135_uncer=_input.ROI_con_uncer[2*cu_grp_num+pos_uncer]; + _output.Xe131m_con= _input.ROI_con_uncer[5*cu_grp_num+pos_con]; + _output.Xe131m_uncer= _input.ROI_con_uncer[5*cu_grp_num+pos_uncer]; + _output.Xe133m_con= _input.ROI_con_uncer[6*cu_grp_num+pos_con]; + _output.Xe133m_uncer= _input.ROI_con_uncer[6*cu_grp_num+pos_uncer]; + double dVarsum=0.0; + //第n组计数 和 关键水平比较 + if(_input.s_netXe[5*cts_grp_num+pos_cts]>=_input.s_netXe[5*cts_grp_num+pos_level]||_input.g_netXe[5*cts_grp_num+pos_cts]>=_input.g_netXe[5*cts_grp_num+pos_level]) + { + if(_input.s_netXe[6*cts_grp_num+pos_cts]>=_input.s_netXe[6*cts_grp_num+pos_level]||_input.g_netXe[6*cts_grp_num+pos_cts]>=_input.g_netXe[6*cts_grp_num+pos_level]) + { + dVarsum = CalcUncer(_input.ROI_con_uncer[3*cu_grp_num+pos_uncer],bError)+ \ + CalcUncer(_input.ROI_con_uncer[7*cu_grp_num+pos_uncer],bError)+ \ + CalcUncer(_input.ROI_con_uncer[8*cu_grp_num+pos_uncer],bError); + _output.Xe133_con = (CalcConUncer(_input.ROI_con_uncer[3*cu_grp_num+pos_con],_input.ROI_con_uncer[3*cu_grp_num+pos_uncer],bError)+ \ + CalcConUncer(_input.ROI_con_uncer[7*cu_grp_num+pos_con],_input.ROI_con_uncer[7*cu_grp_num+pos_uncer],bError)+ \ + CalcConUncer(_input.ROI_con_uncer[8*cu_grp_num+pos_con],_input.ROI_con_uncer[8*cu_grp_num+pos_uncer],bError) \ + )/dVarsum; + _output_Xetype = global::both; + } + else + { + dVarsum = CalcUncer(_input.ROI_con_uncer[3*cu_grp_num+pos_uncer],bError)+ \ + CalcUncer(_input.ROI_con_uncer[7*cu_grp_num+pos_uncer],bError)+ \ + CalcUncer(_input.ROI_con_uncer[9*cu_grp_num+pos_uncer],bError); + _output.Xe133_con = (CalcConUncer(_input.ROI_con_uncer[3*cu_grp_num+pos_con],_input.ROI_con_uncer[3*cu_grp_num+pos_uncer],bError)+ \ + CalcConUncer(_input.ROI_con_uncer[7*cu_grp_num+pos_con],_input.ROI_con_uncer[7*cu_grp_num+pos_uncer],bError)+ \ + CalcConUncer(_input.ROI_con_uncer[9*cu_grp_num+pos_con],_input.ROI_con_uncer[9*cu_grp_num+pos_uncer],bError) \ + )/dVarsum; + _output_Xetype = global::_131m; + } + } + else if(_input.s_netXe[6*cts_grp_num+pos_cts]>=_input.s_netXe[6*cts_grp_num+pos_level]||_input.g_netXe[6*cts_grp_num+pos_cts]>=_input.g_netXe[6*cts_grp_num+pos_level]) + { + dVarsum = CalcUncer(_input.ROI_con_uncer[3*cu_grp_num+pos_uncer],bError)+ \ + CalcUncer(_input.ROI_con_uncer[8*cu_grp_num+pos_uncer],bError)+ \ + CalcUncer(_input.ROI_con_uncer[10*cu_grp_num+pos_uncer],bError); + _output.Xe133_con = (CalcConUncer(_input.ROI_con_uncer[3*cu_grp_num+pos_con],_input.ROI_con_uncer[3*cu_grp_num+pos_uncer],bError)+ \ + CalcConUncer(_input.ROI_con_uncer[8*cu_grp_num+pos_con],_input.ROI_con_uncer[8*cu_grp_num+pos_uncer],bError)+ \ + CalcConUncer(_input.ROI_con_uncer[10*cu_grp_num+pos_con],_input.ROI_con_uncer[10*cu_grp_num+pos_uncer],bError) \ + )/dVarsum; + _output_Xetype = global::_133m; + } + else + { + dVarsum = CalcUncer(_input.ROI_con_uncer[3*cu_grp_num+pos_uncer],bError)+ \ + CalcUncer(_input.ROI_con_uncer[4*cu_grp_num+pos_uncer],bError); + _output.Xe133_con = (CalcConUncer(_input.ROI_con_uncer[3*cu_grp_num+pos_con],_input.ROI_con_uncer[3*cu_grp_num+pos_uncer],bError)+ \ + CalcConUncer(_input.ROI_con_uncer[4*cu_grp_num+pos_con],_input.ROI_con_uncer[4*cu_grp_num+pos_uncer],bError) \ + )/dVarsum; + _output_Xetype = global::none; + } + if((1/dVarsum)<0) + { + return false; + } + _output.Xe133_uncer = qSqrt(1/dVarsum); + if(bError) + { + return false; + } + return true; +} +double CXeConUncer::CalcUncer(double _uncer,bool& _bError) +{ + double rData=0.0; + if(_uncer == 0.0) + { + _bError = true; + } + else + { + rData=1/(_uncer*_uncer); + } + return rData; +} +double CXeConUncer::CalcConUncer(double _con,double _uncer,bool& _bError) +{ + double rData=0.0; + if(_uncer == 0.0) + { + _bError = true; + } + else + { + rData = _con/(_uncer*_uncer); + } + return rData; +} diff --git a/XeConUncer.h b/XeConUncer.h new file mode 100644 index 0000000..eb9f325 --- /dev/null +++ b/XeConUncer.h @@ -0,0 +1,31 @@ +#ifndef XE_CON_UNCER_H +#define XE_CON_UNCER_H +//////////////////////////////////////////////////////////////////////// +// 类说明：此类为: 同位素浓度和不确定度计算 +// +// 注意事项：1、传入参数应注意 结构 +// +/////////////////////////////////////////////////////////////////////// +#include "XeConUncerDef.h" +#include "ProcessAlgorithmGlobalVar.h" + +class CXeConUncer +{ + public: + ///////////////////////////////////////////////////////////////////// + // 函数说明：CalcXeConUncer 同位素计算浓度和不确定度 + // 参数说明：XeConUncerI 传入参数：请查看结构定义 + // XeConUncerO 输出：请查看结构定义 + // _output_Xetype // 同位素类型 + // 返回值： true:正确返回 + // fale:错误返回 + ////////////////////////////////////////////////////////////////////// + static bool CalcXeConUncer(XeConUncerI& _input,XeConUncerO& _output,global::XeType& _output_Xetype); +private: + //不确定度计算 1/(_uncer*_uncer) + static double CalcUncer(double _uncer,bool& _bError); + //浓度不确定度计算 _con/(_uncer*_uncer) + static double CalcConUncer(double _con,double _uncer,bool& _bError); +}; + +#endif diff --git a/XeConUncerDef.h b/XeConUncerDef.h new file mode 100644 index 0000000..6db838a --- /dev/null +++ b/XeConUncerDef.h @@ -0,0 +1,22 @@ +#ifndef XE_CON_UNCER_DEFINE_H +#define XE_CON_UNCER_DEFINE_H +#include +typedef struct tagXeConUncerI +{ + QVector ROI_con_uncer; //感兴趣区浓度和不确定度 [n..0]浓度 [n..1]不确定度 + QVector s_netXe; //样品普扣除探测器本地谱计数 [n..0] 计数 [n..1]计数偏差 [n..2]感兴趣区关键水平 + QVector g_netXe; //气体本地谱扣除探测器本地谱计数 [n..0] 计数 [n..1]计数偏差 [n..2]感兴趣区关键水平 +}*pXeConUncerI,XeConUncerI; +typedef struct tagXeConUncerO +{ + double Xe135_con; //135不浓度 + double Xe135_uncer; //135不确定度 + double Xe131m_con; + double Xe131m_uncer; + double Xe133m_con; + double Xe133m_uncer; + double Xe133_con; + double Xe133_uncer; +}*pXeConUncerO,XeConUncerO; + +#endif diff --git a/common.pri b/common.pri new file mode 100644 index 0000000..8932692 --- /dev/null +++ b/common.pri @@ -0,0 +1,19 @@ +VERSION_PATH = asrmd_c++_bin_release +VERSION_TEMP_PATH = asrmd_c++_temp_release + +CONFIG(debug,debug|release){ +VERSION_PATH = asrmd_c++_bin_debug +VERSION_TEMP_PATH = asrmd_c++_temp_debug +} +PROJECT_BIN = $$PWD/../$$VERSION_PATH +PROJECT_LIB = $$PWD/../$$VERSION_PATH +PROJECT_PLUGINS = $$PWD/../$$VERSION_PATH/plugins +PROJECT_MOC = $$PWD/../$$VERSION_TEMP_PATH/moc +PROJECT_OBJ = $$PWD/../$$VERSION_TEMP_PATH/obj +PROJECT_RCC = $$PWD/../$$VERSION_TEMP_PATH/rcc +PROJECT_UI = $$PWD/../$$VERSION_TEMP_PATH/ui + +unix { + PROJECT_LIB = $$PWD/../$$VERSION_PATH/lib + QMAKE_RPATHDIR += :\'\$\$ORIGIN\':\'\$\$ORIGIN/lib\' +} diff --git a/org_jeecg_modules_native_jni_EnergySpectrumHandler.cpp b/org_jeecg_modules_native_jni_EnergySpectrumHandler.cpp new file mode 100644 index 0000000..264a3b3 --- /dev/null +++ b/org_jeecg_modules_native_jni_EnergySpectrumHandler.cpp @@ -0,0 +1,3747 @@ +#include "org_jeecg_modules_native_jni_EnergySpectrumHandler.h" + +#include "BgWork.h" +#include +#include +#include +#include "CplusToJava.h" +#include "AlertMessage.h" +#include "MeteorologicalMessage.h" +#include "StateOfHealthMessage.h" + +JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_getSourceData(JNIEnv* env, jclass obj, jstring PHDfile) +{ + //创建结构体对象并填充内容 + ReadResult cresult; + memset(&cresult,0 ,sizeof(cresult)); + + //接收QVector的大小 + QMap allSize; + + //文件名转换 + QString qfilename = CplusToJava::jstring2QString(env, PHDfile); + + //文件解析 + RadionuclideMessage message; + bool readflag = message.AnalysePHD_File(qfilename); + + if (!readflag) + { + // **************** printf("THE PHDfile get failed:"); + printf(qfilename.toStdString().c_str()); + // **************** printf("\n"); + } + + //文件头部分获取 + MessageInfo msgInfo = message.GetMessageInfo(); + cresult.msg_type = env->NewStringUTF(msgInfo.msg_type.toStdString().c_str()); + cresult.msg_id = env->NewStringUTF(msgInfo.msg_id.toStdString().c_str()); + cresult.data_type = env->NewStringUTF(msgInfo.data_type.toStdString().c_str()); + + //各数据块存在标识 + bool headerflag = true; + bool commentflag = true; + bool sampleflag = true; + bool certificateflag = true; + bool acquisitionflag = true; + bool collectionflag = true; + bool processflag = true; + bool calibrationflag = true; + bool g_energyflag = true; + bool b_energyflag = true; + bool g_Resolutionflag = true; + bool b_Resolutionflag = true; + bool g_Efficiencyflag = true; + bool roi_limitsflag = true; + bool b_gEfficiencyflag = true; + bool ratiosflag = true; + bool g_Spectrumflag = true; + bool b_Spectrumflag = true; + bool Histogramflag = true; + bool totalflag = true; + + QString order; + QVariant variant; + + + //header内容获取 + RadionuclideData::HeaderBlock headerBlock; + order = ORDER_HEADER; + variant = message.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + headerflag = false; + } + else + { + headerBlock = variant.value(); + cresult.designator = env->NewStringUTF(headerBlock.designator.toStdString().c_str()); + cresult.site_code = env->NewStringUTF(headerBlock.site_code.toStdString().c_str()); + cresult.detector_code = env->NewStringUTF(headerBlock.detector_code.toStdString().c_str()); + cresult.system_type = env->NewStringUTF(headerBlock.system_type.toStdString().c_str()); + cresult.sample_geometry = env->NewStringUTF(headerBlock.sample_geometry.toStdString().c_str()); + cresult.spectrum_quantity = env->NewStringUTF(headerBlock.spectrum_quantity.toStdString().c_str()); + cresult.sample_ref_id = env->NewStringUTF(headerBlock.sample_ref_id.toStdString().c_str()); + cresult.measurement_id = env->NewStringUTF(headerBlock.measurement_id.toStdString().c_str()); + cresult.detector_bk_measurement_id = env->NewStringUTF(headerBlock.detector_bk_measurement_id.toStdString().c_str()); + cresult.gas_bk_measurement_id = env->NewStringUTF(headerBlock.gas_bk_measurement_id.toStdString().c_str()); + cresult.transmit_date = env->NewStringUTF(headerBlock.transmit_date.toStdString().c_str()); + cresult.transmit_time = env->NewStringUTF(headerBlock.transmit_time.toStdString().c_str()); + } + + //comment内容获取 + order = ORDER_COMMENT; + variant = message.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + commentflag = false; + } + else + { + CommentBlock commentBlock = variant.value(); + QString comment; + if (commentBlock.size() > 1024) + { + comment = commentBlock.mid(0, 1022); + } + else + { + comment = commentBlock; + } + comment = comment.replace(QString("'"), QString("''")); + cresult.comment = env->NewStringUTF(comment.toStdString().c_str()); + } + + //sample内容获取 + RadionuclideData::SampleBlock sampleBlock; + order = ORDER_SAMPLE; + variant = message.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + sampleflag = false; + } + else + { + sampleBlock = variant.value(); + cresult.dimension_1 = sampleBlock.dimension_1; + cresult.dimension_2 = sampleBlock.dimension_2; + } + + //acquisition内容获取 + RadionuclideData::AcquisitionBlock acquisitionBlock; + order = ORDER_ACQUISITION; + variant = message.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + acquisitionflag = false; + } + else + { + acquisitionBlock = variant.value(); + cresult.acquisition_start_date = env->NewStringUTF(acquisitionBlock.acquisition_start_date.toStdString().c_str()); + cresult.acquisition_start_time = env->NewStringUTF(acquisitionBlock.acquisition_start_time.toStdString().c_str()); + cresult.acquisition_real_time = acquisitionBlock.acquisition_real_time; + cresult.acquisition_live_time = acquisitionBlock.acquisition_live_time; + } + + //collection内容获取 + RadionuclideData::CollectionBlock collectionBlock; + order = ORDER_COLLECTION; + variant = message.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + collectionflag = false; + } + else + { + collectionBlock = variant.value(); + cresult.collection_start_date = env->NewStringUTF(collectionBlock.collection_start_date.toStdString().c_str()); + cresult.collection_start_time = env->NewStringUTF(collectionBlock.collection_start_time.toStdString().c_str()); + cresult.collection_stop_date = env->NewStringUTF(collectionBlock.collection_stop_date.toStdString().c_str()); + cresult.collection_stop_time = env->NewStringUTF(collectionBlock.collection_stop_time.toStdString().c_str()); + cresult.air_volume = collectionBlock.air_volume; + } + + //process内容获取 + RadionuclideData::ProcessingBlock process; + order = ORDER_PROCESSING; + variant = message.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + processflag = false; + } + else + { + process = variant.value(); + cresult.sample_volume_of_Xe = process.sample_volume_of_Xe; + cresult.uncertainty_1 = process.uncertainty_1; + cresult.Xe_collection_yield = process.Xe_collection_yield; + cresult.uncertainty_2 = process.uncertainty_2; + cresult.archive_bottle_id = env->NewStringUTF(process.archive_bottle_id.toStdString().c_str()); + } + + //calibration内容获取 + RadionuclideData::CalibrationBlock calibrationBlock; + order = ORDER_CALIBRATION; + variant = message.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + calibrationflag = false; + } + else + { + calibrationBlock = variant.value(); + cresult.date_calibration = env->NewStringUTF(calibrationBlock.date_calibration.toStdString().c_str()); + cresult.time_calibration = env->NewStringUTF(calibrationBlock.time_calibration.toStdString().c_str()); + } + + //g_energy内容获取 + order = ORDER_G_ENERGY; + variant = message.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + g_energyflag = false; + } + else + { + RadionuclideData::G_EnergyBlock g_energyBlock = variant.value(); + allSize["g_energy"] = g_energyBlock.g_energy.size(); + cresult.g_energy = CplusToJava::QVectorD2jobjectArray(g_energyBlock.g_energy, env); + allSize["g_centroid_channel"] = g_energyBlock.centroid_channel.size(); + cresult.g_centroid_channel = CplusToJava::QVectorD2jobjectArray(g_energyBlock.centroid_channel, env); + allSize["g_uncertainty"] = g_energyBlock.uncertainty.size(); + cresult.g_uncertainty = CplusToJava::QVectorD2jobjectArray(g_energyBlock.uncertainty, env); + cresult.g_record_count = g_energyBlock.record_count; + } + + //b_energy内容获取 + order = ORDER_B_ENERGY; + variant = message.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + b_energyflag = false; + } + else + { + RadionuclideData::B_EnergyBlock b_energyBlock = variant.value(); + allSize["b_electron_energy"] = b_energyBlock.electron_energy.size(); + cresult.b_electron_energy = CplusToJava::QVectorD2jobjectArray(b_energyBlock.electron_energy, env); + allSize["b_decay_mode"] = b_energyBlock.decay_mode.size(); + cresult.b_decay_mode = CplusToJava::QVectorQS2jobjectArray(b_energyBlock.decay_mode, env); + allSize["b_channel"] = b_energyBlock.channel.size(); + cresult.b_channel = CplusToJava::QVectorD2jobjectArray(b_energyBlock.channel, env); + allSize["b_uncertainty"] = b_energyBlock.uncertainty.size(); + cresult.b_uncertainty = CplusToJava::QVectorD2jobjectArray(b_energyBlock.uncertainty, env); + cresult.b_record_count = b_energyBlock.record_count; + } + + //g_Resolution内容获取 + order = ORDER_G_RESOLUTION; + variant = message.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + g_Resolutionflag = false; + } + else + { + RadionuclideData::_g_Resolution_Block_ g_resolution = variant.value(); + allSize["g_r_energy"] = g_resolution.g_energy.size(); + cresult.g_r_energy = CplusToJava::QVectorD2jobjectArray(g_resolution.g_energy, env); + allSize["g_r_FWHM"] = g_resolution.FWHM.size(); + cresult.g_r_FWHM = CplusToJava::QVectorD2jobjectArray(g_resolution.FWHM, env); + allSize["g_r_uncertainty"] = g_resolution.uncertainty.size(); + cresult.g_r_uncertainty = CplusToJava::QVectorD2jobjectArray(g_resolution.uncertainty, env); + cresult.g_r_record_count = g_resolution.record_count; + } + + //b_Resolution内容获取 + order = ORDER_B_RESOLUTION; + variant = message.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + b_Resolutionflag = false; + } + else + { + RadionuclideData::_b_Resolution_Block_ b_resolution = variant.value(); + allSize["b_r_electron_energy"] = b_resolution.electron_energy.size(); + cresult.b_r_electron_energy = CplusToJava::QVectorD2jobjectArray(b_resolution.electron_energy, env); + allSize["b_r_FWHM"] = b_resolution.FWHM.size(); + cresult.b_r_FWHM = CplusToJava::QVectorD2jobjectArray(b_resolution.FWHM, env); + allSize["b_r_uncertainty"] = b_resolution.uncertainty.size(); + cresult.b_r_uncertainty = CplusToJava::QVectorD2jobjectArray(b_resolution.uncertainty, env); + cresult.b_r_record_count = b_resolution.record_count; + } + + //g_Efficiency内容获取 + order = ORDER_G_EFFICIENCY; + variant = message.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + g_Efficiencyflag = false; + } + else + { + RadionuclideData::_g_Efficiency_Block_ g_efficiency = variant.value(); + allSize["g_e_energy"] = g_efficiency.g_energy.size(); + cresult.g_e_energy = CplusToJava::QVectorD2jobjectArray(g_efficiency.g_energy, env); + allSize["g_e_efficiency"] = g_efficiency.efficiency.size(); + cresult.g_e_efficiency = CplusToJava::QVectorD2jobjectArray(g_efficiency.efficiency, env); + allSize["g_e_uncertainty"] = g_efficiency.uncertainty.size(); + cresult.g_e_uncertainty = CplusToJava::QVectorD2jobjectArray(g_efficiency.uncertainty, env); + cresult.g_e_record_count = g_efficiency.record_count; + } + + //roi_limits内容获取 + order = ORDER_ROI_LIMITS; + variant = message.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + roi_limitsflag = false; + } + else + { + RadionuclideData::ROI_LimitsBlock roiLimits = variant.value(); + allSize["ROI_number"] = roiLimits.ROI_number.size(); + cresult.ROI_number = CplusToJava::QVectorQS2jobjectArray(roiLimits.ROI_number, env); + allSize["POI_B_x1"] = roiLimits.POI_B_x1.size(); + cresult.POI_B_x1 = CplusToJava::QVectorD2jobjectArray(roiLimits.POI_B_x1, env); + allSize["POI_B_x2"] = roiLimits.POI_B_x2.size(); + cresult.POI_B_x2 = CplusToJava::QVectorD2jobjectArray(roiLimits.POI_B_x2, env); + allSize["POI_G_y1"] = roiLimits.POI_G_y1.size(); + cresult.POI_G_y1 = CplusToJava::QVectorD2jobjectArray(roiLimits.POI_G_y1, env); + allSize["POI_G_y2"] = roiLimits.POI_G_y2.size(); + cresult.POI_G_y2 = CplusToJava::QVectorD2jobjectArray(roiLimits.POI_G_y2, env); + cresult.roi_record_count = roiLimits.record_count; + } + + //b-gEfficiency内容获取 + order = ORDER_B_GEFFICIENCY; + variant = message.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + b_gEfficiencyflag = false; + } + else + { + RadionuclideData::BG_EfficiencyBlock bg_efficiency = variant.value(); + allSize["bg_nuclide_name"] = bg_efficiency.nuclide_name.size(); + cresult.bg_nuclide_name = CplusToJava::QVectorQS2jobjectArray(bg_efficiency.nuclide_name, env); + allSize["bg_ROI_number"] = bg_efficiency.ROI_number.size(); + + //QString转为double（java存库所需） + QVector bg_roi; + for (int i = 0; i < allSize["bg_ROI_number"];i++) + { + bg_roi.push_back(bg_efficiency.ROI_number.at(i).toDouble()); + } + + cresult.bg_ROI_number = CplusToJava::QVectorD2jobjectArray(bg_roi, env); + allSize["bg_efficiency"] = bg_efficiency.bg_efficiency.size(); + cresult.bg_efficiency = CplusToJava::QVectorD2jobjectArray(bg_efficiency.bg_efficiency, env); + allSize["bg_uncertainty"] = bg_efficiency.uncertainty.size(); + cresult.bg_uncertainty = CplusToJava::QVectorD2jobjectArray(bg_efficiency.uncertainty, env); + cresult.bg_record_count = bg_efficiency.record_count; + } + + //ratios内容获取 + order = ORDER_RATIOS; + variant = message.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + ratiosflag = false; + } + else + { + RadionuclideData::RatiosBlock ratios = variant.value(); + allSize["ratio_id"] = ratios.ratio_id.size(); + cresult.ratio_id = CplusToJava::QVectorQS2jobjectArray(ratios.ratio_id, env); + allSize["ROI_num_highter_G_energy_ROI"] = ratios.ROI_num_highter_G_energy_ROI.size(); + cresult.ROI_num_highter_G_energy_ROI = CplusToJava::QVectorQS2jobjectArray(ratios.ROI_num_highter_G_energy_ROI, env); + allSize["ROI_num_lower_G_energy_ROI"] = ratios.ROI_num_lower_G_energy_ROI.size(); + cresult.ROI_num_lower_G_energy_ROI = CplusToJava::QVectorQS2jobjectArray(ratios.ROI_num_lower_G_energy_ROI, env); + allSize["count_ratio"] = ratios.count_ratio.size(); + cresult.count_ratio = CplusToJava::QVectorD2jobjectArray(ratios.count_ratio, env); + allSize["count_ratio_uncertainty"] = ratios.count_ratio_uncertainty.size(); + cresult.count_ratio_uncertainty = CplusToJava::QVectorD2jobjectArray(ratios.count_ratio_uncertainty, env); + cresult.ratio_record_count = ratios.record_count; + } + + //g_Spectrum内容获取 + order = ORDER_G_SPECTRUM; + variant = message.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + g_Spectrumflag = true; + } + else + { + RadionuclideData::G_SpectrumBlock g_spectrum = variant.value(); + + cresult.num_g_channel = g_spectrum.num_g_channel; + cresult.g_energy_span = g_spectrum.g_energy_span; + cresult.g_begin_channel = g_spectrum.begin_channel; + allSize["g_counts"] = g_spectrum.counts.size(); + cresult.g_counts = CplusToJava::QVectorLL2jobjectArray(g_spectrum.counts, env); + } + //b_Spectrum内容获取 + order = ORDER_B_SPECTRUM; + variant = message.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + b_Spectrumflag = false; + } + else + { + RadionuclideData::B_SpectrumBlock b_spectrum = variant.value(); + cresult.num_b_channel = b_spectrum.num_b_channel; + cresult.b_energy_span = b_spectrum.b_energy_span; + cresult.b_begin_channel = b_spectrum.begin_channel; + allSize["b_counts"] = b_spectrum.counts.size(); + cresult.b_counts = CplusToJava::QVectorLL2jobjectArray(b_spectrum.counts, env); + } + + //Histogram内容获取 + order = ORDER_HISTOGRAM; + variant = message.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + Histogramflag = true; + } + else + { + RadionuclideData::HistogramBlock historgram = variant.value(); + cresult.b_channels = historgram.b_channels; + cresult.g_channels = historgram.g_channels; + cresult.b_h_energy_span = historgram.b_energy_span; + cresult.g_h_energy_span = historgram.g_energy_span; + allSize["h_counts"] = historgram.counts.size(); + cresult.h_counts = CplusToJava::QVectorLL2jobjectArray(historgram.counts, env); + } + + //Certificate内容获取 + RadionuclideData::CertificateBlock certificateBlock; + order = ORDER_CERTIFICATE; + variant = message.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + certificateflag = false; + } + else + { + RadionuclideData::CertificateBlock certificate = variant.value(); + cresult.total_source_activity = certificateBlock.total_source_activity; + cresult.assay_date = env->NewStringUTF(certificate.assay_date.toStdString().c_str()); + cresult.assay_time = env->NewStringUTF(certificate.assay_time.toStdString().c_str()); + cresult.units_activity = env->NewStringUTF(certificate.units_activity.toStdString().c_str()); + allSize["nuclide_name"] = certificate.nuclide_name.size(); + cresult.nuclide_name = CplusToJava::QVectorQS2jobjectArray(certificate.nuclide_name, env); + allSize["half_life_time"] = certificate.half_life_time.size(); + cresult.half_life_time = CplusToJava::QVectorQS2jobjectArray(certificate.half_life_time, env); + allSize["time_unit"] = certificate.time_unit.size(); + cresult.time_unit = CplusToJava::QVectorQS2jobjectArray(certificate.time_unit, env); + allSize["activity_nuclide_time_assay"] = certificate.activity_nuclide_time_assay.size(); + cresult.activity_nuclide_time_assay = CplusToJava::QVectorD2jobjectArray(certificate.activity_nuclide_time_assay, env); + allSize["uncertainty"] = certificate.uncertainty.size(); + cresult.uncertainty = CplusToJava::QVectorD2jobjectArray(certificate.uncertainty, env); + allSize["cer_g_energy"] = certificate.g_energy.size(); + cresult.cer_g_energy = CplusToJava::QVectorD2jobjectArray(certificate.g_energy, env); + allSize["g_intensity"] = certificate.g_intensity.size(); + cresult.g_intensity = CplusToJava::QVectorD2jobjectArray(certificate.g_intensity, env); + allSize["electron_decay_mode"] = certificate.electron_decay_mode.size(); + cresult.electron_decay_mode = CplusToJava::QVectorQS2jobjectArray(certificate.electron_decay_mode, env); + allSize["maximum_energy"] = certificate.maximum_energy.size(); + cresult.maximum_energy = CplusToJava::QVectorD2jobjectArray(certificate.maximum_energy, env); + allSize["intensity_b_particle"] = certificate.intensity_b_particle.size(); + cresult.intensity_b_particle = CplusToJava::QVectorD2jobjectArray(certificate.intensity_b_particle, env); + cresult.record_count = certificateBlock.record_count; + } + + //TotalEff block内容获取 + order = ORDER_TOTALEFF; + variant = message.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + totalflag = false; + } + else + { + RadionuclideData::TotaleffBlock totleff = variant.value(); + + allSize["t_g_energy"] = totleff.g_energy.size(); + //double转QString,java存库用 + QVector t_g_energy; + for (int i = 0; i < allSize["t_g_energy"]; i++) + { + t_g_energy.push_back(QString::number(totleff.g_energy.at(i))); + } + + cresult.t_g_energy = CplusToJava::QVectorQS2jobjectArray(t_g_energy, env); + allSize["total_efficiency"] = totleff.total_efficiency.size(); + cresult.total_efficiency = CplusToJava::QVectorD2jobjectArray(totleff.total_efficiency, env); + allSize["t_uncertainty"] = totleff.uncertainty.size(); + cresult.t_uncertainty = CplusToJava::QVectorD2jobjectArray(totleff.uncertainty, env); + cresult.t_record_count = totleff.record_count; + } + + if ((!headerflag) || (!commentflag) || (!sampleflag) || (!certificateflag) || (!acquisitionflag) || (!collectionflag) || (!processflag) + || (!calibrationflag) || (!g_energyflag) || (!b_energyflag) || (!g_Resolutionflag) || (!b_Resolutionflag) || (!g_Efficiencyflag) + || (!roi_limitsflag) || (!b_gEfficiencyflag) || (!ratiosflag) || (!g_Spectrumflag) || (!b_Spectrumflag) || (!Histogramflag) + || (!totalflag)) + { + // **************** printf("THE PHDFile has some blocks can't be read:"); + printf(qfilename.toStdString().c_str()); + // **************** printf("\n"); + } + + //获取Java中的EnergySpectrumStruct类 + jclass energySpectrumStructClass = env->FindClass("Lorg/jeecg/modules/native_jni/struct/EnergySpectrumStruct;"); + + // 创建Java中的EnergySpectrumStruct对象 + jmethodID constructorID = env->GetMethodID(energySpectrumStructClass, "", "()V"); + jobject result = env->NewObject(energySpectrumStructClass, constructorID); + + jfieldID fieldID; + if (headerflag) + { + // 设置成员变量msg_type的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "msg_type", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.msg_type); + + // 设置成员变量msg_id的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "msg_id", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.msg_id); + + // 设置成员变量data_type的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "data_type", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.data_type); + + // 设置成员变量designator的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "designator", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.designator); + + // 设置成员变量site_code的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "site_code", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.site_code); + + // 设置成员变量detector_code的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "detector_code", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.detector_code); + + //设置成员变量system_type的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "system_type", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.system_type); + + //设置成员变量sample_geometry的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "sample_geometry", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.sample_geometry); + + //设置成员变量spectrum_quantity的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "spectrum_quantity", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.spectrum_quantity); + + //设置成员变量sample_ref_id的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "sample_ref_id", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.sample_ref_id); + + //设置成员变量measurement_id的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "measurement_id", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.measurement_id); + + //设置成员变量detector_bk_measurement_id的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "detector_bk_measurement_id", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.detector_bk_measurement_id); + + //设置成员变量gas_bk_measurement_id的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "gas_bk_measurement_id", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.gas_bk_measurement_id); + + //设置成员变量transmit_date的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "transmit_date", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.transmit_date); + + //设置成员变量transmit_time的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "transmit_time", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.transmit_time); + } + + if (commentflag) + { + //设置成员变量comment的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "comment", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.comment); + } + + if (sampleflag) + { + //设置成员变量dimension_1的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "dimension_1", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, cresult.dimension_1); + + //设置成员变量dimension_2的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "dimension_2", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, cresult.dimension_2); + } + + if (acquisitionflag) + { + //设置成员变量acquisition_start_date的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "acquisition_start_date", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.acquisition_start_date); + + //设置成员变量acquisition_start_time的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "acquisition_start_time", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.acquisition_start_time); + + //设置成员变量acquisition_real_time的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "acquisition_real_time", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, cresult.acquisition_real_time); + + //设置成员变量acquisition_live_time的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "acquisition_live_time", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, cresult.acquisition_live_time); + } + + if (collectionflag) + { + //设置成员变量collection_start_date的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "collection_start_date", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.collection_start_date); + + //设置成员变量collection_start_time的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "collection_start_time", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.collection_start_time); + + //设置成员变量collection_stop_date的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "collection_stop_date", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.collection_stop_date); + + //设置成员变量collection_stop_time的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "collection_stop_time", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.collection_stop_time); + + //设置成员变量air_volume的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "air_volume", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, cresult.air_volume); + } + + if (processflag) + { + //设置成员变量sample_volume_of_Xe的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "sample_volume_of_Xe", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, cresult.sample_volume_of_Xe); + + //设置成员变量uncertainty_1的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "uncertainty_1", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, cresult.uncertainty_1); + + //设置成员变量Xe_collection_yield的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "Xe_collection_yield", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, cresult.Xe_collection_yield); + + //设置成员变量uncertainty_2的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "uncertainty_2", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, cresult.uncertainty_2); + + //设置成员变量archive_bottle_id的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "archive_bottle_id", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.archive_bottle_id); + } + + if (calibrationflag) + { + //设置成员变量date_calibration的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "date_calibration", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.date_calibration); + + //设置成员变量time_calibration的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "time_calibration", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.time_calibration); + } + + jobject fieldJobject; + + if (g_energyflag) + { + //设置成员变量g_energy的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "g_energy", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["g_energy"], cresult.g_energy); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量g_centroid_channel的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "g_centroid_channel", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["g_centroid_channel"], cresult.g_centroid_channel); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量g_uncertainty的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "g_uncertainty", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["g_uncertainty"], cresult.g_uncertainty); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量g_record_count的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "g_record_count", SIG_INT); + env->SetIntField(result, fieldID, cresult.g_record_count); + } + + if (b_energyflag) + { + //设置成员变量b_electron_energy的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "b_electron_energy", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["b_electron_energy"], cresult.b_electron_energy); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量b_decay_mode的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "b_decay_mode", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["b_decay_mode"], cresult.b_decay_mode); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量b_channel的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "b_channel", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["b_channel"], cresult.b_channel); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量b_uncertainty的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "b_uncertainty", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["b_uncertainty"], cresult.b_uncertainty); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量b_record_count的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "b_record_count", SIG_INT); + env->SetIntField(result, fieldID, cresult.b_record_count); + } + + if (g_Resolutionflag) + { + //设置成员变量g_r_energy的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "g_r_energy", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["g_r_energy"], cresult.g_r_energy); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量g_r_FWHM的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "g_r_FWHM", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["g_r_FWHM"], cresult.g_r_FWHM); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量g_r_uncertainty的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "g_r_uncertainty", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["g_r_uncertainty"], cresult.g_r_uncertainty); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量g_r_record_count的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "g_r_record_count", SIG_INT); + env->SetIntField(result, fieldID, cresult.g_r_record_count); + } + + if (b_Resolutionflag) + { + //设置成员变量b_r_electron_energy的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "b_r_electron_energy", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["b_r_electron_energy"], cresult.b_r_electron_energy); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量b_r_FWHM的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "b_r_FWHM", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["b_r_FWHM"], cresult.b_r_FWHM); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量b_r_uncertainty的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "b_r_uncertainty", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["b_r_uncertainty"], cresult.b_r_uncertainty); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量g_r_record_count的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "b_r_record_count", SIG_INT); + env->SetIntField(result, fieldID, cresult.b_r_record_count); + } + + if (g_Efficiencyflag) + { + //设置成员变量g_e_energy的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "g_e_energy", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["g_e_energy"], cresult.g_e_energy); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量g_e_efficiency的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "g_e_efficiency", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["g_e_efficiency"], cresult.g_e_efficiency); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量g_e_uncertainty的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "g_e_uncertainty", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["g_e_uncertainty"], cresult.g_e_uncertainty); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量g_e_record_count的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "g_e_record_count", SIG_INT); + env->SetIntField(result, fieldID, cresult.g_e_record_count); + } + + if (roi_limitsflag) + { + //设置成员变量ROI_number的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "ROI_number", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["ROI_number"], cresult.ROI_number); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量POI_B_x1的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "POI_B_x1", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["POI_B_x1"], cresult.POI_B_x1); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量POI_B_x2的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "POI_B_x2", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["POI_B_x2"], cresult.POI_B_x2); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量POI_G_y1的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "POI_G_y1", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["POI_G_y1"], cresult.POI_G_y1); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量POI_G_y2的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "POI_G_y2", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["POI_G_y2"], cresult.POI_G_y2); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量roi_record_count的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "roi_record_count", SIG_INT); + env->SetIntField(result, fieldID, cresult.roi_record_count); + } + + if (b_gEfficiencyflag) + { + //设置成员变量bg_nuclide_name的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "bg_nuclide_name", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["bg_nuclide_name"], cresult.bg_nuclide_name); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量bg_ROI_number的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "bg_ROI_number", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["bg_ROI_number"], cresult.bg_ROI_number); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量bg_efficiency的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "bg_efficiency", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["bg_efficiency"], cresult.bg_efficiency); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量bg_uncertainty的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "bg_uncertainty", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["bg_uncertainty"], cresult.bg_uncertainty); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量bg_record_count的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "bg_record_count", SIG_INT); + env->SetIntField(result, fieldID, cresult.bg_record_count); + } + + if (ratiosflag) + { + //设置成员变量ratio_id的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "ratio_id", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["ratio_id"], cresult.ratio_id); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量ROI_num_highter_G_energy_ROI的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "ROI_num_highter_G_energy_ROI", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["ROI_num_highter_G_energy_ROI"], cresult.ROI_num_highter_G_energy_ROI); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量ROI_num_lower_G_energy_ROI的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "ROI_num_lower_G_energy_ROI", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["ROI_num_lower_G_energy_ROI"], cresult.ROI_num_lower_G_energy_ROI); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量count_ratio的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "count_ratio", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["count_ratio"], cresult.count_ratio); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量count_ratio_uncertainty的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "count_ratio_uncertainty", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["count_ratio_uncertainty"], cresult.count_ratio_uncertainty); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量ratio_record_count的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "ratio_record_count", SIG_INT); + env->SetIntField(result, fieldID, cresult.ratio_record_count); + } + + if (g_Spectrumflag) + { + //设置成员变量num_g_channel的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "num_g_channel", SIG_LONG); + env->SetLongField(result, fieldID, cresult.num_g_channel); + + //设置成员变量g_energy_span的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "g_energy_span", SIG_LONG); + env->SetLongField(result, fieldID, cresult.g_energy_span); + + //设置成员变量g_begin_channel的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "g_begin_channel", SIG_LONG); + env->SetLongField(result, fieldID, cresult.g_begin_channel); + + //设置成员变量g_counts的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "g_counts", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["g_counts"], cresult.g_counts); + env->SetObjectField(result, fieldID, fieldJobject); + } + + if (b_Spectrumflag) + { + //设置成员变量num_b_channel的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "num_b_channel", SIG_LONG); + env->SetLongField(result, fieldID, cresult.num_b_channel); + + //设置成员变量b_energy_span的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "b_energy_span", SIG_LONG); + env->SetLongField(result, fieldID, cresult.b_energy_span); + + //设置成员变量b_begin_channel的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "b_begin_channel", SIG_LONG); + env->SetLongField(result, fieldID, cresult.b_begin_channel); + + //设置成员变量b_counts的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "b_counts", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["b_counts"], cresult.b_counts); + env->SetObjectField(result, fieldID, fieldJobject); + } + + if (Histogramflag) + { + //设置成员变量b_channels的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "b_channels", SIG_LONG); + env->SetLongField(result, fieldID, cresult.b_channels); + + //设置成员变量g_channels的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "g_channels", SIG_LONG); + env->SetLongField(result, fieldID, cresult.g_channels); + + //设置成员变量b_h_energy_span的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "b_h_energy_span", SIG_LONG); + env->SetLongField(result, fieldID, cresult.b_h_energy_span); + + //设置成员变量g_h_energy_span的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "g_h_energy_span", SIG_LONG); + env->SetLongField(result, fieldID, cresult.g_h_energy_span); + + //设置成员变量h_counts的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "h_counts", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["h_counts"], cresult.h_counts); + env->SetObjectField(result, fieldID, fieldJobject); + } + + if (certificateflag) + { + //设置成员变量total_source_activity的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "total_source_activity", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, cresult.total_source_activity); + + //设置成员变量assay_date的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "assay_date", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.assay_date); + + //设置成员变量assay_time的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "assay_time", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.assay_time); + + //设置成员变量units_activity的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "units_activity", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.units_activity); + + //设置成员变量nuclide_name的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "nuclide_name", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["nuclide_name"], cresult.nuclide_name); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量half_life_time的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "half_life_time", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["half_life_time"], cresult.half_life_time); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量time_unit的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "time_unit", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["time_unit"], cresult.time_unit); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量activity_nuclide_time_assay的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "activity_nuclide_time_assay", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["activity_nuclide_time_assay"], cresult.activity_nuclide_time_assay); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量uncertainty的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "uncertainty", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["uncertainty"], cresult.uncertainty); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量cer_g_energy的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "cer_g_energy", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["cer_g_energy"], cresult.cer_g_energy); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量g_intensity的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "g_intensity", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["g_intensity"], cresult.g_intensity); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量electron_decay_mode的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "electron_decay_mode", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["electron_decay_mode"], cresult.electron_decay_mode); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量maximum_energy的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "maximum_energy", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["maximum_energy"], cresult.maximum_energy); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量intensity_b_particle的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "intensity_b_particle", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["intensity_b_particle"], cresult.intensity_b_particle); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量record_count的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "record_count", SIG_INT); + env->SetIntField(result, fieldID, cresult.record_count); + } + + if (totalflag) + { + //设置成员变量t_g_energy的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "t_g_energy", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["t_g_energy"], cresult.t_g_energy); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量total_efficiency的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "total_efficiency", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["total_efficiency"], cresult.total_efficiency); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量t_uncertainty的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "t_uncertainty", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["t_uncertainty"], cresult.t_uncertainty); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量t_record_count的值 + fieldID = env->GetFieldID(energySpectrumStructClass, "t_record_count", SIG_INT); + env->SetIntField(result, fieldID, cresult.t_record_count); + } + + return result; +} + +JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_CalcBgBoundary(JNIEnv* env, jclass, jobject javaStruct) +{ + // 获取Java中的Struct对象 + jclass structClass = env->GetObjectClass(javaStruct); + + //算法输入 + tagBgROILimit roiLimit; + roiLimit.ROI_B_start_x1 = CplusToJava::jobjectArray2QVectorD(env,CplusToJava::GetjobjectArray(env, structClass, javaStruct, "ROI_B_start_x1")); + roiLimit.ROI_B_stop_x2 = CplusToJava::jobjectArray2QVectorD(env, CplusToJava::GetjobjectArray(env, structClass, javaStruct, "ROI_B_stop_x2")); + roiLimit.ROI_G_start_y1 = CplusToJava::jobjectArray2QVectorD(env, CplusToJava::GetjobjectArray(env, structClass, javaStruct, "ROI_G_start_y1")); + roiLimit.ROI_G_stop_y2 = CplusToJava::jobjectArray2QVectorD(env, CplusToJava::GetjobjectArray(env, structClass, javaStruct, "ROI_G_stop_y2")); + + tagBgEC bgec; + bgec.b_e_c.energy = CplusToJava::jobjectArray2QVectorD(env, CplusToJava::GetjobjectArray(env, structClass, javaStruct, "b_energy")); + bgec.b_e_c.channel = CplusToJava::jobjectArray2QVectorD(env, CplusToJava::GetjobjectArray(env, structClass, javaStruct, "b_channel")); + bgec.g_e_c.energy = CplusToJava::jobjectArray2QVectorD(env, CplusToJava::GetjobjectArray(env, structClass, javaStruct, "g_energy")); + bgec.g_e_c.channel = CplusToJava::jobjectArray2QVectorD(env, CplusToJava::GetjobjectArray(env, structClass, javaStruct, "g_channel")); + + tagBgCalibratePara bgpara; + bgpara.b_e_cal = CplusToJava::jobjectArray2QVectorD(env, CplusToJava::GetjobjectArray(env, structClass, javaStruct, "b_e_cal")); + bgpara.g_e_cal = CplusToJava::jobjectArray2QVectorD(env, CplusToJava::GetjobjectArray(env, structClass, javaStruct, "g_e_cal")); + + // 获取成员变量b_e_cal_flag的值 + jfieldID fieldid = env->GetFieldID(structClass, "b_e_cal_flag", SIG_INT); + bgpara.b_e_cal_flag = env->GetIntField(javaStruct, fieldid); + + // 获取成员变量g_e_cal_flag的值 + fieldid = env->GetFieldID(structClass, "g_e_cal_flag", SIG_INT); + bgpara.g_e_cal_flag = env->GetIntField(javaStruct, fieldid); + + //算法计算 + BgBoundary output; + CBgWork bgwork; + bgwork.CalcBgBoundary(roiLimit, bgec, bgpara, output); + + //获取Java中的BgBoundary类 + jclass BgBoundaryStructClass = env->FindClass("Lorg/jeecg/modules/native_jni/struct/BgBoundary;"); + + // 创建Java中的EnergySpectrumStruct对象 + jmethodID constructorID = env->GetMethodID(BgBoundaryStructClass, "", "()V"); + jobject result = env->NewObject(BgBoundaryStructClass, constructorID); + + //设置成员变量ROI_B_Boundary_start的值 + jfieldID fieldID = env->GetFieldID(BgBoundaryStructClass, "ROI_B_Boundary_start", SIG_LIST); + jobjectArray jarray = CplusToJava::QVectorI2jobjectArray(output.ROI_B_Boundary_start, env); + jobject fieldJobject = CplusToJava::Createjobject(env, output.ROI_B_Boundary_start.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量ROI_B_Boundary_stop的值 + fieldID = env->GetFieldID(BgBoundaryStructClass, "ROI_B_Boundary_stop", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(output.ROI_B_Boundary_stop, env); + fieldJobject = CplusToJava::Createjobject(env, output.ROI_B_Boundary_stop.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量ROI_G_Boundary_start的值 + fieldID = env->GetFieldID(BgBoundaryStructClass, "ROI_G_Boundary_start", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(output.ROI_G_Boundary_start, env); + fieldJobject = CplusToJava::Createjobject(env, output.ROI_G_Boundary_start.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量ROI_G_Boundary_stop的值 + fieldID = env->GetFieldID(BgBoundaryStructClass, "ROI_G_Boundary_stop", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(output.ROI_G_Boundary_stop, env); + fieldJobject = CplusToJava::Createjobject(env, output.ROI_G_Boundary_stop.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + return result; +} + +JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_GetFileFittingData(JNIEnv* env, jclass, jobject jwatch_x, jobject jwatch_y) +{ + jobjectArray jawatch_x = CplusToJava::jobject2jobjectArray(env, jwatch_x); + QVector watch_x = CplusToJava::jobjectArray2QVectorD(env, jawatch_x); + + jobjectArray jawatch_y = CplusToJava::jobject2jobjectArray(env, jwatch_y); + QVector watch_y = CplusToJava::jobjectArray2QVectorD(env, jawatch_y); + + QVector fitting_para; + CBgWork::GetFileFittingData(watch_x, watch_y, fitting_para); + jobjectArray jafitting_para = CplusToJava::QVectorD2jobjectArray(fitting_para, env); + jobject jfitting_para = CplusToJava::Createjobject(env, fitting_para.size(), jafitting_para); + return jfitting_para; +} + +JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_GetFileFittingPara(JNIEnv* env, jclass, jobject jwatch_x, jobject jwatch_y) +{ + jobjectArray jawatch_x = CplusToJava::jobject2jobjectArray(env,jwatch_x); + QVector watch_x = CplusToJava::jobjectArray2QVectorD(env, jawatch_x); + + jobjectArray jawatch_y = CplusToJava::jobject2jobjectArray(env, jwatch_y); + QVector watch_y = CplusToJava::jobjectArray2QVectorD(env, jawatch_y); + + QVector fitting_para; + CBgWork::GetFileFittingPara(watch_x, watch_y, fitting_para); + jobjectArray jafitting_para = CplusToJava::QVectorD2jobjectArray(fitting_para,env); + jobject jfitting_para = CplusToJava::Createjobject(env, fitting_para.size(), jafitting_para); + return jfitting_para; +} + +JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_bgAnalyse(JNIEnv* env, jclass, jstring sample, jstring gas, jstring detbgr) +{ + //算法部分 + bool bRet = false; + BgFileI inputFile; + CBgWork bgwork; + bool bFileAnlyseError = false; + QString sampleFile = CplusToJava::jstring2QString(env, sample); + printf(sampleFile.toStdString().c_str()); + // **************** printf("\n"); + QString gasFile = CplusToJava::jstring2QString(env, gas); + printf(gasFile.toStdString().c_str()); + // **************** printf("\n"); + QString detbgrFile = CplusToJava::jstring2QString(env, detbgr); + printf(detbgrFile.toStdString().c_str()); + // **************** printf("\n"); + BgAllGenerate allData; + if (!inputFile.Detbgr.AnalysePHD_File(detbgrFile)) + { + printf("In BgAnalyse,detbgrFile get failed:"); + printf(detbgrFile.toStdString().c_str()); + printf("\n"); + } + else if (!inputFile.gas.AnalysePHD_File(gasFile)) + { + printf("In BgAnalyse,gasFile get failed:"); + printf(gasFile.toStdString().c_str()); + printf("\n"); + } + else if (!inputFile.sample.AnalysePHD_File(sampleFile)) + { + printf("In BgAnalyse,sampleFile get failed:"); + printf(sampleFile.toStdString().c_str()); + printf("\n"); + } + else + { + bgwork.SetBgFile(inputFile); + bRet = bgwork.AutoAnalyse(); + allData = bgwork.GetAllValue(); + } + //获取Java中的BgAnalyseResult类 + jclass structClass = env->FindClass("Lorg/jeecg/modules/native_jni/struct/BgAnalyseResult;"); + + // 创建Java中的BgAnalyseResult对象 + jmethodID constructorID = env->GetMethodID(structClass, "", "()V"); + jobject result = env->NewObject(structClass, constructorID); + + //设置成员变量analyse_flag的值(判断是否成功) + jfieldID fieldID = env->GetFieldID(structClass, "analyse_flag", SIG_BOOL); + env->SetBooleanField(result, fieldID, bRet); + + //printf("set bool success"); + + if (bRet) { + + //设置成员变量MDC_Xe135的值 + jfieldID fieldID = env->GetFieldID(structClass, "MDC_Xe135", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.MDCPara.MDC_Xe135); + + //设置成员变量MDC_Xe131m的值 + fieldID = env->GetFieldID(structClass, "MDC_Xe131m", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.MDCPara.MDC_Xe131m); + + //设置成员变量MDC_Xe133m的值 + fieldID = env->GetFieldID(structClass, "MDC_Xe133m", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.MDCPara.MDC_Xe133m); + + //设置成员变量MDC_Xe133的值 + fieldID = env->GetFieldID(structClass, "MDC_Xe133", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.MDCPara.MDC_Xe133); + + /* + //设置成员变量MDC的值 + fieldID = env->GetFieldID(structClass, "MDC", SIG_LIST); + jobjectArray jarray = CplusToJava::QVectorD2jobjectArray(allData.BgOther.MDCPara.MDC, env); + jobject fieldJobject = CplusToJava::Createjobject(env, allData.BgOther.MDCPara.MDC.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + */ + /* + //设置成员变量MDC_CTS的值 + fieldID = env->GetFieldID(structClass, "MDC_CTS", SIG_LIST); + jobjectArray jarray = CplusToJava::QVectorD2jobjectArray(allData.BgOther.MDCPara.MDC_CTS, env); + jobject fieldJobject = CplusToJava::Createjobject(env, allData.BgOther.MDCPara.MDC_CTS.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + */ + //设置成员变量Xe135_con的值 + fieldID = env->GetFieldID(structClass, "Xe135_con", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.XeConUncer.Xe135_con); + + //设置成员变量Xe135_uncer的值 + fieldID = env->GetFieldID(structClass, "Xe135_uncer", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.XeConUncer.Xe135_uncer); + + //设置成员变量Xe131m_con的值 + fieldID = env->GetFieldID(structClass, "Xe131m_con", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.XeConUncer.Xe131m_con); + + //设置成员变量Xe131m_uncer的值 + fieldID = env->GetFieldID(structClass, "Xe131m_uncer", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.XeConUncer.Xe131m_uncer); + + //设置成员变量Xe133m_con的值 + fieldID = env->GetFieldID(structClass, "Xe133m_con", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.XeConUncer.Xe133m_con); + + //设置成员变量Xe133m_uncer的值 + fieldID = env->GetFieldID(structClass, "Xe133m_uncer", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.XeConUncer.Xe133m_uncer); + + //设置成员变量Xe133_con的值 + fieldID = env->GetFieldID(structClass, "Xe133_con", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.XeConUncer.Xe133_con); + + //设置成员变量Xe133_uncer的值 + fieldID = env->GetFieldID(structClass, "Xe133_uncer", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.XeConUncer.Xe133_uncer); + + // 设置成员变量error_log的值 + QString error_str = "no error."; + jstring jerror_str = env->NewStringUTF(error_str.toStdString().c_str()); + fieldID = env->GetFieldID(structClass, "error_log", SIG_STRING); + env->SetObjectField(result, fieldID, jerror_str); + + //sample + //设置成员变量s_b_fitting_e_c的值 + fieldID = env->GetFieldID(structClass, "s_b_fitting_e_c", SIG_LIST); + jobjectArray jarray = CplusToJava::QVectorD2jobjectArray(allData.BgSample.s_fittingPara.b_fitting_e_c, env); + jobject fieldJobject = CplusToJava::Createjobject(env, allData.BgSample.s_fittingPara.b_fitting_e_c.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量s_b_fitting_type的值 + fieldID = env->GetFieldID(structClass, "s_b_fitting_type", SIG_INT); + env->SetIntField(result, fieldID, allData.BgSample.s_fittingPara.b_fitting_type); + + //设置成员变量s_b_fitting_type_def的值 + QString sfunctiondef = CBgWork::GetFittingDescriptionByType(allData.BgSample.s_fittingPara.b_fitting_type); + jstring sjtemp = env->NewStringUTF(sfunctiondef.toStdString().c_str()); + fieldID = env->GetFieldID(structClass, "s_b_fitting_type_def", SIG_STRING); + env->SetObjectField(result, fieldID, sjtemp); + + //设置成员变量s_g_fitting_e_c的值 + fieldID = env->GetFieldID(structClass, "s_g_fitting_e_c", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgSample.s_fittingPara.g_fitting_e_c, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgSample.s_fittingPara.g_fitting_e_c.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量s_g_fitting_type的值 + fieldID = env->GetFieldID(structClass, "s_g_fitting_type", SIG_INT); + env->SetIntField(result, fieldID, allData.BgSample.s_fittingPara.g_fitting_type); + + //设置成员变量s_g_fitting_type_def的值 + sfunctiondef = CBgWork::GetFittingDescriptionByType(allData.BgSample.s_fittingPara.g_fitting_type); + sjtemp = env->NewStringUTF(sfunctiondef.toStdString().c_str()); + fieldID = env->GetFieldID(structClass, "s_g_fitting_type_def", SIG_STRING); + env->SetObjectField(result, fieldID, sjtemp); + + //设置成员变量s_b_fitting_c_e的值 + fieldID = env->GetFieldID(structClass, "s_b_fitting_c_e", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgSample.s_fittingPara.b_fitting_c_e, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgSample.s_fittingPara.b_fitting_c_e.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量s_g_fitting_c_e的值 + fieldID = env->GetFieldID(structClass, "s_g_fitting_c_e", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgSample.s_fittingPara.g_fitting_c_e, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgSample.s_fittingPara.g_fitting_c_e.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //gas + //设置成员变量g_b_fitting_e_c的值 + fieldID = env->GetFieldID(structClass, "g_b_fitting_e_c", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgGas.g_fittingPara.b_fitting_e_c, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgGas.g_fittingPara.b_fitting_e_c.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量g_b_fitting_type的值 + fieldID = env->GetFieldID(structClass, "g_b_fitting_type", SIG_INT); + env->SetIntField(result, fieldID, allData.BgGas.g_fittingPara.b_fitting_type); + + //设置成员变量g_b_fitting_type_def的值 + QString gfunctiondef = CBgWork::GetFittingDescriptionByType(allData.BgGas.g_fittingPara.b_fitting_type); + jstring gjtemp = env->NewStringUTF(gfunctiondef.toStdString().c_str()); + fieldID = env->GetFieldID(structClass, "g_b_fitting_type_def", SIG_STRING); + env->SetObjectField(result, fieldID, gjtemp); + + //设置成员变量g_g_fitting_e_c的值 + fieldID = env->GetFieldID(structClass, "g_g_fitting_e_c", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgGas.g_fittingPara.g_fitting_e_c, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgGas.g_fittingPara.g_fitting_e_c.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量g_g_fitting_type的值 + fieldID = env->GetFieldID(structClass, "g_g_fitting_type", SIG_INT); + env->SetIntField(result, fieldID, allData.BgGas.g_fittingPara.g_fitting_type); + + //设置成员变量g_g_fitting_type_def的值 + gfunctiondef = CBgWork::GetFittingDescriptionByType(allData.BgGas.g_fittingPara.g_fitting_type); + gjtemp = env->NewStringUTF(gfunctiondef.toStdString().c_str()); + fieldID = env->GetFieldID(structClass, "g_g_fitting_type_def", SIG_STRING); + env->SetObjectField(result, fieldID, gjtemp); + + //设置成员变量g_b_fitting_c_e的值 + fieldID = env->GetFieldID(structClass, "g_b_fitting_c_e", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgGas.g_fittingPara.b_fitting_c_e, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgGas.g_fittingPara.b_fitting_c_e.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量g_g_fitting_c_e的值 + fieldID = env->GetFieldID(structClass, "g_g_fitting_c_e", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgGas.g_fittingPara.g_fitting_c_e, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgGas.g_fittingPara.g_fitting_c_e.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //detbgr + //设置成员变量d_b_fitting_e_c的值 + fieldID = env->GetFieldID(structClass, "d_b_fitting_e_c", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgDetbgr.d_fittingPara.b_fitting_e_c, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgDetbgr.d_fittingPara.b_fitting_e_c.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量d_b_fitting_type的值 + fieldID = env->GetFieldID(structClass, "d_b_fitting_type", SIG_INT); + env->SetIntField(result, fieldID, allData.BgDetbgr.d_fittingPara.b_fitting_type); + + //设置成员变量d_b_fitting_type_def的值 + QString dfunctiondef = CBgWork::GetFittingDescriptionByType(allData.BgDetbgr.d_fittingPara.b_fitting_type); + jstring djtemp = env->NewStringUTF(dfunctiondef.toStdString().c_str()); + fieldID = env->GetFieldID(structClass, "d_b_fitting_type_def", SIG_STRING); + env->SetObjectField(result, fieldID, djtemp); + + //设置成员变量d_g_fitting_e_c的值 + fieldID = env->GetFieldID(structClass, "d_g_fitting_e_c", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgDetbgr.d_fittingPara.g_fitting_e_c, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgDetbgr.d_fittingPara.g_fitting_e_c.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量d_g_fitting_type的值 + fieldID = env->GetFieldID(structClass, "d_g_fitting_type", SIG_INT); + env->SetIntField(result, fieldID, allData.BgDetbgr.d_fittingPara.g_fitting_type); + + //设置成员变量d_g_fitting_type_def的值 + dfunctiondef = CBgWork::GetFittingDescriptionByType(allData.BgDetbgr.d_fittingPara.g_fitting_type); + djtemp = env->NewStringUTF(dfunctiondef.toStdString().c_str()); + fieldID = env->GetFieldID(structClass, "d_g_fitting_type_def", SIG_STRING); + env->SetObjectField(result, fieldID, djtemp); + + //设置成员变量d_b_fitting_c_e的值 + fieldID = env->GetFieldID(structClass, "d_b_fitting_c_e", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgDetbgr.d_fittingPara.b_fitting_c_e, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgDetbgr.d_fittingPara.b_fitting_c_e.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量d_g_fitting_c_e的值 + fieldID = env->GetFieldID(structClass, "d_g_fitting_c_e", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgDetbgr.d_fittingPara.g_fitting_c_e, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgDetbgr.d_fittingPara.g_fitting_c_e.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + int rowsize = allData.BgSample.s_boungdary.ROI_B_Boundary_start.size(); + QVector itemp; + for (int pos = 1; pos <= rowsize; pos++) + { + itemp.append(pos); + } + //设置成员变量S_ROI的值 + fieldID = env->GetFieldID(structClass, "S_ROI", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(itemp, env); + fieldJobject = CplusToJava::Createjobject(env, itemp.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量S_ROI_B_Boundary_start的值 + fieldID = env->GetFieldID(structClass, "S_ROI_B_Boundary_start", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(allData.BgSample.s_boungdary.ROI_B_Boundary_start, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgSample.s_boungdary.ROI_B_Boundary_start.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量S_ROI_B_Boundary_stop的值 + fieldID = env->GetFieldID(structClass, "S_ROI_B_Boundary_stop", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(allData.BgSample.s_boungdary.ROI_B_Boundary_stop, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgSample.s_boungdary.ROI_B_Boundary_stop.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量S_ROI_G_Boundary_start的值 + fieldID = env->GetFieldID(structClass, "S_ROI_G_Boundary_start", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(allData.BgSample.s_boungdary.ROI_G_Boundary_start, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgSample.s_boungdary.ROI_G_Boundary_start.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量S_ROI_G_Boundary_stop的值 + fieldID = env->GetFieldID(structClass, "S_ROI_G_Boundary_stop", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(allData.BgSample.s_boungdary.ROI_G_Boundary_stop, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgSample.s_boungdary.ROI_G_Boundary_stop.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + rowsize = allData.BgGas.g_boungdary.ROI_B_Boundary_start.size(); + itemp.clear(); + for (int pos = 1; pos <= rowsize; pos++) + { + itemp.append(pos); + } + //设置成员变量G_ROI的值 + fieldID = env->GetFieldID(structClass, "G_ROI", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(itemp, env); + fieldJobject = CplusToJava::Createjobject(env, itemp.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量G_ROI_B_Boundary_start的值 + fieldID = env->GetFieldID(structClass, "G_ROI_B_Boundary_start", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(allData.BgGas.g_boungdary.ROI_B_Boundary_start, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgGas.g_boungdary.ROI_B_Boundary_start.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量G_ROI_B_Boundary_stop的值 + fieldID = env->GetFieldID(structClass, "G_ROI_B_Boundary_stop", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(allData.BgGas.g_boungdary.ROI_B_Boundary_stop, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgGas.g_boungdary.ROI_B_Boundary_stop.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量G_ROI_G_Boundary_start的值 + fieldID = env->GetFieldID(structClass, "G_ROI_G_Boundary_start", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(allData.BgGas.g_boungdary.ROI_G_Boundary_start, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgGas.g_boungdary.ROI_G_Boundary_start.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量G_ROI_G_Boundary_stop的值 + fieldID = env->GetFieldID(structClass, "G_ROI_G_Boundary_stop", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(allData.BgGas.g_boungdary.ROI_G_Boundary_stop, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgGas.g_boungdary.ROI_G_Boundary_stop.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + rowsize = allData.BgDetbgr.d_boungdary.ROI_B_Boundary_start.size(); + itemp.clear(); + for (int pos = 1; pos <= rowsize; pos++) + { + itemp.append(pos); + } + //设置成员变量D_ROI的值 + fieldID = env->GetFieldID(structClass, "D_ROI", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(itemp, env); + fieldJobject = CplusToJava::Createjobject(env, itemp.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量D_ROI_B_Boundary_start的值 + fieldID = env->GetFieldID(structClass, "D_ROI_B_Boundary_start", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(allData.BgDetbgr.d_boungdary.ROI_B_Boundary_start, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgDetbgr.d_boungdary.ROI_B_Boundary_start.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量D_ROI_B_Boundary_stop的值 + fieldID = env->GetFieldID(structClass, "D_ROI_B_Boundary_stop", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(allData.BgDetbgr.d_boungdary.ROI_B_Boundary_stop, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgDetbgr.d_boungdary.ROI_B_Boundary_stop.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量D_ROI_G_Boundary_start的值 + fieldID = env->GetFieldID(structClass, "D_ROI_G_Boundary_start", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(allData.BgDetbgr.d_boungdary.ROI_G_Boundary_start, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgDetbgr.d_boungdary.ROI_G_Boundary_start.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量D_ROI_G_Boundary_stop的值 + fieldID = env->GetFieldID(structClass, "D_ROI_G_Boundary_stop", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(allData.BgDetbgr.d_boungdary.ROI_G_Boundary_stop, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgDetbgr.d_boungdary.ROI_G_Boundary_stop.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + int NID_FLAG = 0; + if (allData.BgOther.XeConUncer.Xe131m_con > allData.BgOther.MDCPara.MDC_Xe131m) + { + NID_FLAG = 1; + } + //设置成员变量XE_131m_NID_FLAG的值 + fieldID = env->GetFieldID(structClass, "XE_131m_NID_FLAG", SIG_INT); + env->SetIntField(result, fieldID, NID_FLAG); + + //设置成员变量LC_Xe131m的值 + fieldID = env->GetFieldID(structClass, "LC_Xe131m", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.LCPara.LC_Xe131m); + + NID_FLAG = 0; + if (allData.BgOther.XeConUncer.Xe133_con > allData.BgOther.MDCPara.MDC_Xe133) + { + NID_FLAG = 1; + } + //设置成员变量XE_133_NID_FLAG的值 + fieldID = env->GetFieldID(structClass, "XE_133_NID_FLAG", SIG_INT); + env->SetIntField(result, fieldID, NID_FLAG); + + //设置成员变量LC_Xe133的值 + fieldID = env->GetFieldID(structClass, "LC_Xe133", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.LCPara.LC_Xe133); + + NID_FLAG = 0; + if (allData.BgOther.XeConUncer.Xe133m_con > allData.BgOther.MDCPara.MDC_Xe133m) + { + NID_FLAG = 1; + } + //设置成员变量XE_133m_NID_FLAG的值 + fieldID = env->GetFieldID(structClass, "XE_133m_NID_FLAG", SIG_INT); + env->SetIntField(result, fieldID, NID_FLAG); + + //设置成员变量LC_Xe133m的值 + fieldID = env->GetFieldID(structClass, "LC_Xe133m", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.LCPara.LC_Xe133m); + + NID_FLAG = 0; + if (allData.BgOther.XeConUncer.Xe135_con > allData.BgOther.MDCPara.MDC_Xe135) + { + NID_FLAG = 1; + } + //设置成员变量XE_135_NID_FLAG的值 + fieldID = env->GetFieldID(structClass, "XE_135_NID_FLAG", SIG_INT); + env->SetIntField(result, fieldID, NID_FLAG); + + //设置成员变量LC_Xe135的值 + fieldID = env->GetFieldID(structClass, "LC_Xe135", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.LCPara.LC_Xe135); + + rowsize = allData.BgSample.s_roi_cts.size(); + itemp.clear(); + for (int pos = 1; pos <= rowsize; pos++) + { + itemp.append(pos); + } + //设置成员变量ROI的值 + fieldID = env->GetFieldID(structClass, "ROI", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(itemp, env); + fieldJobject = CplusToJava::Createjobject(env, itemp.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量LC的值 + fieldID = env->GetFieldID(structClass, "LC", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgOther.LCPara.LC, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgOther.LCPara.LC.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量s_roi_cts的值 + fieldID = env->GetFieldID(structClass, "s_roi_cts", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgSample.s_roi_cts, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgSample.s_roi_cts.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量g_roi_cts的值 + fieldID = env->GetFieldID(structClass, "g_roi_cts", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgGas.g_roi_cts, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgGas.g_roi_cts.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量d_roi_cts的值 + fieldID = env->GetFieldID(structClass, "d_roi_cts", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgDetbgr.d_roi_cts, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgDetbgr.d_roi_cts.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量s_deduct_d_cts的值 + fieldID = env->GetFieldID(structClass, "s_deduct_d_cts", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgSample.s_deduct_d_cts, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgSample.s_deduct_d_cts.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量g_deduct_d_cts的值 + fieldID = env->GetFieldID(structClass, "g_deduct_d_cts", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgGas.g_deduct_d_cts, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgGas.g_deduct_d_cts.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + QVector netTemp; + QVector netBq; + netBq.append(0); + netTemp.append(0); + for (int pos = 6; pos < allData.BgOther.ROI_net_coutns.size(); pos += 3) + { + netTemp.append(allData.BgOther.ROI_net_coutns.at(pos)); + netBq.append(qSqrt(allData.BgOther.ROI_net_coutns.at(pos + 1))); + } + //设置成员变量ROI_net_coutns的值 + fieldID = env->GetFieldID(structClass, "ROI_net_coutns", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(netTemp, env); + fieldJobject = CplusToJava::Createjobject(env, netTemp.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量ROI_net_coutns_err的值 + fieldID = env->GetFieldID(structClass, "ROI_net_coutns_err", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(netBq, env); + fieldJobject = CplusToJava::Createjobject(env, netBq.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + QVector concTemp; + QVector concErrTemp; + concTemp.append(0); + concErrTemp.append(0); + for (int pos = 4; pos < allData.BgOther.ROI_con_uncer.size(); pos += 2) + { + concTemp.append(allData.BgOther.ROI_con_uncer.at(pos)); + concErrTemp.append(allData.BgOther.ROI_con_uncer.at(pos + 1)); + } + //设置成员变量ROI_con_uncer的值 + fieldID = env->GetFieldID(structClass, "ROI_con_uncer", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(concTemp, env); + fieldJobject = CplusToJava::Createjobject(env, concTemp.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量ROI_con_uncer_err的值 + fieldID = env->GetFieldID(structClass, "ROI_con_uncer_err", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(concErrTemp, env); + fieldJobject = CplusToJava::Createjobject(env, concErrTemp.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + QVector dNidFlag; + QVector MDCtemp; + dNidFlag.append(0); + MDCtemp.append(0); + for (int pos = 0; pos < allData.BgOther.MDCPara.MDC.size(); pos++) + { + double dTemp = allData.BgOther.MDCPara.MDC.at(pos); + MDCtemp.append(dTemp); + if (pos + 1 < concTemp.size()) + { + if (concTemp.at(pos + 1) > dTemp) + { + dNidFlag.append(1); + } + else + { + dNidFlag.append(0); + } + } + } + //设置成员变量MDC的值 + fieldID = env->GetFieldID(structClass, "MDC", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgOther.MDCPara.MDC, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgOther.MDCPara.MDC.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量dNidFlag的值 + fieldID = env->GetFieldID(structClass, "dNidFlag", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(dNidFlag, env); + fieldJobject = CplusToJava::Createjobject(env, dNidFlag.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量LC_CTS的值 + fieldID = env->GetFieldID(structClass, "LC_CTS", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgOther.LCPara.LC_CTS, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgOther.LCPara.LC_CTS.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + } + else + { + // 设置成员变量error_log的值 + QString error_str = CBgWork::BgAnlyseError(bgwork.GetLastError()); + jstring jerror_str = env->NewStringUTF(error_str.toStdString().c_str()); + fieldID = env->GetFieldID(structClass, "error_log", SIG_STRING); + env->SetObjectField(result, fieldID, jerror_str); + } + + return result; +} + +void exportMDC(JNIEnv *env, jobject& result, BgAllGenerate& allData, jclass& structClass) +{ + //设置成员变量MDC_Xe135的值 + jfieldID fieldID = env->GetFieldID(structClass, "MDC_Xe135", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.MDCPara.MDC_Xe135); + + //设置成员变量MDC_Xe131m的值 + fieldID = env->GetFieldID(structClass, "MDC_Xe131m", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.MDCPara.MDC_Xe131m); + + //设置成员变量MDC_Xe133m的值 + fieldID = env->GetFieldID(structClass, "MDC_Xe133m", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.MDCPara.MDC_Xe133m); + + //设置成员变量MDC_Xe133的值 + fieldID = env->GetFieldID(structClass, "MDC_Xe133", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.MDCPara.MDC_Xe133); + + /* + //设置成员变量MDC的值 + fieldID = env->GetFieldID(structClass, "MDC", SIG_LIST); + jobjectArray jarray = CplusToJava::QVectorD2jobjectArray(allData.BgOther.MDCPara.MDC, env); + jobject fieldJobject = CplusToJava::Createjobject(env, allData.BgOther.MDCPara.MDC.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + */ + /* + //设置成员变量MDC_CTS的值 + fieldID = env->GetFieldID(structClass, "MDC_CTS", SIG_LIST); + jobjectArray jarray = CplusToJava::QVectorD2jobjectArray(allData.BgOther.MDCPara.MDC_CTS, env); + jobject fieldJobject = CplusToJava::Createjobject(env, allData.BgOther.MDCPara.MDC_CTS.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + */ + + //设置成员变量LC_Xe131m的值 + fieldID = env->GetFieldID(structClass, "LC_Xe131m", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.LCPara.LC_Xe131m); + + //设置成员变量LC_Xe133的值 + fieldID = env->GetFieldID(structClass, "LC_Xe133", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.LCPara.LC_Xe133); + + //设置成员变量LC_Xe133m的值 + fieldID = env->GetFieldID(structClass, "LC_Xe133m", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.LCPara.LC_Xe133m); + + //设置成员变量LC_Xe135的值 + fieldID = env->GetFieldID(structClass, "LC_Xe135", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.LCPara.LC_Xe135); + + //设置成员变量LC的值 + fieldID = env->GetFieldID(structClass, "LC", SIG_LIST); + jobjectArray jarray = CplusToJava::QVectorD2jobjectArray(allData.BgOther.LCPara.LC, env); + jobject fieldJobject = CplusToJava::Createjobject(env, allData.BgOther.LCPara.LC.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量LC_CTS的值 + fieldID = env->GetFieldID(structClass, "LC_CTS", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgOther.LCPara.LC_CTS, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgOther.LCPara.LC_CTS.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + int NID_FLAG = 0; + if (allData.BgOther.XeConUncer.Xe131m_con > allData.BgOther.MDCPara.MDC_Xe131m) + { + NID_FLAG = 1; + } + //设置成员变量XE_131m_NID_FLAG的值 + fieldID = env->GetFieldID(structClass, "XE_131m_NID_FLAG", SIG_INT); + env->SetIntField(result, fieldID, NID_FLAG); + + NID_FLAG = 0; + if (allData.BgOther.XeConUncer.Xe133_con > allData.BgOther.MDCPara.MDC_Xe133) + { + NID_FLAG = 1; + } + //设置成员变量XE_133_NID_FLAG的值 + fieldID = env->GetFieldID(structClass, "XE_133_NID_FLAG", SIG_INT); + env->SetIntField(result, fieldID, NID_FLAG); + + NID_FLAG = 0; + if (allData.BgOther.XeConUncer.Xe133m_con > allData.BgOther.MDCPara.MDC_Xe133m) + { + NID_FLAG = 1; + } + //设置成员变量XE_133m_NID_FLAG的值 + fieldID = env->GetFieldID(structClass, "XE_133m_NID_FLAG", SIG_INT); + env->SetIntField(result, fieldID, NID_FLAG); + + NID_FLAG = 0; + if (allData.BgOther.XeConUncer.Xe135_con > allData.BgOther.MDCPara.MDC_Xe135) + { + NID_FLAG = 1; + } + //设置成员变量XE_135_NID_FLAG的值 + fieldID = env->GetFieldID(structClass, "XE_135_NID_FLAG", SIG_INT); + env->SetIntField(result, fieldID, NID_FLAG); +} + +void exportSROIcts(JNIEnv *env, jobject& result, BgAllGenerate& allData, jclass& structClass) +{ + //sample + //设置成员变量s_b_fitting_e_c的值 + jfieldID fieldID = env->GetFieldID(structClass, "s_b_fitting_e_c", SIG_LIST); + jobjectArray jarray = CplusToJava::QVectorD2jobjectArray(allData.BgSample.s_fittingPara.b_fitting_e_c, env); + jobject fieldJobject = CplusToJava::Createjobject(env, allData.BgSample.s_fittingPara.b_fitting_e_c.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量s_b_fitting_type的值 + fieldID = env->GetFieldID(structClass, "s_b_fitting_type", SIG_INT); + env->SetIntField(result, fieldID, allData.BgSample.s_fittingPara.b_fitting_type); + + //设置成员变量s_b_fitting_type_def的值 + QString sfunctiondef = CBgWork::GetFittingDescriptionByType(allData.BgSample.s_fittingPara.b_fitting_type); + jstring sjtemp = env->NewStringUTF(sfunctiondef.toStdString().c_str()); + fieldID = env->GetFieldID(structClass, "s_b_fitting_type_def", SIG_STRING); + env->SetObjectField(result, fieldID, sjtemp); + + //设置成员变量s_g_fitting_e_c的值 + fieldID = env->GetFieldID(structClass, "s_g_fitting_e_c", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgSample.s_fittingPara.g_fitting_e_c, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgSample.s_fittingPara.g_fitting_e_c.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量s_g_fitting_type的值 + fieldID = env->GetFieldID(structClass, "s_g_fitting_type", SIG_INT); + env->SetIntField(result, fieldID, allData.BgSample.s_fittingPara.g_fitting_type); + + //设置成员变量s_g_fitting_type_def的值 + sfunctiondef = CBgWork::GetFittingDescriptionByType(allData.BgSample.s_fittingPara.g_fitting_type); + sjtemp = env->NewStringUTF(sfunctiondef.toStdString().c_str()); + fieldID = env->GetFieldID(structClass, "s_g_fitting_type_def", SIG_STRING); + env->SetObjectField(result, fieldID, sjtemp); + + //设置成员变量s_b_fitting_c_e的值 + fieldID = env->GetFieldID(structClass, "s_b_fitting_c_e", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgSample.s_fittingPara.b_fitting_c_e, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgSample.s_fittingPara.b_fitting_c_e.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量s_g_fitting_c_e的值 + fieldID = env->GetFieldID(structClass, "s_g_fitting_c_e", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgSample.s_fittingPara.g_fitting_c_e, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgSample.s_fittingPara.g_fitting_c_e.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + int rowsize = allData.BgSample.s_roi_cts.size(); + QVector itemp; + itemp.clear(); + for (int pos = 1; pos <= rowsize; pos++) + { + itemp.append(pos); + } + //设置成员变量ROI的值 + fieldID = env->GetFieldID(structClass, "ROI", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(itemp, env); + fieldJobject = CplusToJava::Createjobject(env, itemp.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + + //设置成员变量s_roi_cts的值 + fieldID = env->GetFieldID(structClass, "s_roi_cts", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgSample.s_roi_cts, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgSample.s_roi_cts.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + rowsize = allData.BgSample.s_boungdary.ROI_B_Boundary_start.size(); + itemp.clear(); + for (int pos = 1; pos <= rowsize; pos++) + { + itemp.append(pos); + } + //设置成员变量S_ROI的值 + fieldID = env->GetFieldID(structClass, "S_ROI", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(itemp, env); + fieldJobject = CplusToJava::Createjobject(env, itemp.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量S_ROI_B_Boundary_start的值 + fieldID = env->GetFieldID(structClass, "S_ROI_B_Boundary_start", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(allData.BgSample.s_boungdary.ROI_B_Boundary_start, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgSample.s_boungdary.ROI_B_Boundary_start.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量S_ROI_B_Boundary_stop的值 + fieldID = env->GetFieldID(structClass, "S_ROI_B_Boundary_stop", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(allData.BgSample.s_boungdary.ROI_B_Boundary_stop, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgSample.s_boungdary.ROI_B_Boundary_stop.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量S_ROI_G_Boundary_start的值 + fieldID = env->GetFieldID(structClass, "S_ROI_G_Boundary_start", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(allData.BgSample.s_boungdary.ROI_G_Boundary_start, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgSample.s_boungdary.ROI_G_Boundary_start.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量S_ROI_G_Boundary_stop的值 + fieldID = env->GetFieldID(structClass, "S_ROI_G_Boundary_stop", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(allData.BgSample.s_boungdary.ROI_G_Boundary_stop, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgSample.s_boungdary.ROI_G_Boundary_stop.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); +} + +void exportGROIcts(JNIEnv *env, jobject& result, BgAllGenerate& allData, jclass& structClass) +{ + //gas + //设置成员变量g_b_fitting_e_c的值 + jfieldID fieldID = env->GetFieldID(structClass, "g_b_fitting_e_c", SIG_LIST); + jobjectArray jarray = CplusToJava::QVectorD2jobjectArray(allData.BgGas.g_fittingPara.b_fitting_e_c, env); + jobject fieldJobject = CplusToJava::Createjobject(env, allData.BgGas.g_fittingPara.b_fitting_e_c.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量g_b_fitting_type的值 + fieldID = env->GetFieldID(structClass, "g_b_fitting_type", SIG_INT); + env->SetIntField(result, fieldID, allData.BgGas.g_fittingPara.b_fitting_type); + + //设置成员变量g_b_fitting_type_def的值 + QString gfunctiondef = CBgWork::GetFittingDescriptionByType(allData.BgGas.g_fittingPara.b_fitting_type); + jstring gjtemp = env->NewStringUTF(gfunctiondef.toStdString().c_str()); + fieldID = env->GetFieldID(structClass, "g_b_fitting_type_def", SIG_STRING); + env->SetObjectField(result, fieldID, gjtemp); + + //设置成员变量g_g_fitting_e_c的值 + fieldID = env->GetFieldID(structClass, "g_g_fitting_e_c", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgGas.g_fittingPara.g_fitting_e_c, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgGas.g_fittingPara.g_fitting_e_c.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量g_g_fitting_type的值 + fieldID = env->GetFieldID(structClass, "g_g_fitting_type", SIG_INT); + env->SetIntField(result, fieldID, allData.BgGas.g_fittingPara.g_fitting_type); + + //设置成员变量g_g_fitting_type_def的值 + gfunctiondef = CBgWork::GetFittingDescriptionByType(allData.BgGas.g_fittingPara.g_fitting_type); + gjtemp = env->NewStringUTF(gfunctiondef.toStdString().c_str()); + fieldID = env->GetFieldID(structClass, "g_g_fitting_type_def", SIG_STRING); + env->SetObjectField(result, fieldID, gjtemp); + + //设置成员变量g_b_fitting_c_e的值 + fieldID = env->GetFieldID(structClass, "g_b_fitting_c_e", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgGas.g_fittingPara.b_fitting_c_e, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgGas.g_fittingPara.b_fitting_c_e.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量g_g_fitting_c_e的值 + fieldID = env->GetFieldID(structClass, "g_g_fitting_c_e", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgGas.g_fittingPara.g_fitting_c_e, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgGas.g_fittingPara.g_fitting_c_e.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + int rowsize = allData.BgGas.g_boungdary.ROI_B_Boundary_start.size(); + QVector itemp; + itemp.clear(); + for (int pos = 1; pos <= rowsize; pos++) + { + itemp.append(pos); + } + //设置成员变量G_ROI的值 + fieldID = env->GetFieldID(structClass, "G_ROI", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(itemp, env); + fieldJobject = CplusToJava::Createjobject(env, itemp.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量G_ROI_B_Boundary_start的值 + fieldID = env->GetFieldID(structClass, "G_ROI_B_Boundary_start", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(allData.BgGas.g_boungdary.ROI_B_Boundary_start, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgGas.g_boungdary.ROI_B_Boundary_start.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量G_ROI_B_Boundary_stop的值 + fieldID = env->GetFieldID(structClass, "G_ROI_B_Boundary_stop", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(allData.BgGas.g_boungdary.ROI_B_Boundary_stop, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgGas.g_boungdary.ROI_B_Boundary_stop.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量G_ROI_G_Boundary_start的值 + fieldID = env->GetFieldID(structClass, "G_ROI_G_Boundary_start", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(allData.BgGas.g_boungdary.ROI_G_Boundary_start, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgGas.g_boungdary.ROI_G_Boundary_start.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量G_ROI_G_Boundary_stop的值 + fieldID = env->GetFieldID(structClass, "G_ROI_G_Boundary_stop", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(allData.BgGas.g_boungdary.ROI_G_Boundary_stop, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgGas.g_boungdary.ROI_G_Boundary_stop.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量g_roi_cts的值 + fieldID = env->GetFieldID(structClass, "g_roi_cts", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgGas.g_roi_cts, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgGas.g_roi_cts.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); +} + +void exportDROIcts(JNIEnv *env, jobject& result, BgAllGenerate& allData, jclass& structClass) +{ + //detbgr + //设置成员变量d_b_fitting_e_c的值 + jfieldID fieldID = env->GetFieldID(structClass, "d_b_fitting_e_c", SIG_LIST); + jobjectArray jarray = CplusToJava::QVectorD2jobjectArray(allData.BgDetbgr.d_fittingPara.b_fitting_e_c, env); + jobject fieldJobject = CplusToJava::Createjobject(env, allData.BgDetbgr.d_fittingPara.b_fitting_e_c.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量d_b_fitting_type的值 + fieldID = env->GetFieldID(structClass, "d_b_fitting_type", SIG_INT); + env->SetIntField(result, fieldID, allData.BgDetbgr.d_fittingPara.b_fitting_type); + + //设置成员变量d_b_fitting_type_def的值 + QString dfunctiondef = CBgWork::GetFittingDescriptionByType(allData.BgDetbgr.d_fittingPara.b_fitting_type); + jstring djtemp = env->NewStringUTF(dfunctiondef.toStdString().c_str()); + fieldID = env->GetFieldID(structClass, "d_b_fitting_type_def", SIG_STRING); + env->SetObjectField(result, fieldID, djtemp); + + //设置成员变量d_g_fitting_e_c的值 + fieldID = env->GetFieldID(structClass, "d_g_fitting_e_c", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgDetbgr.d_fittingPara.g_fitting_e_c, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgDetbgr.d_fittingPara.g_fitting_e_c.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量d_g_fitting_type的值 + fieldID = env->GetFieldID(structClass, "d_g_fitting_type", SIG_INT); + env->SetIntField(result, fieldID, allData.BgDetbgr.d_fittingPara.g_fitting_type); + + //设置成员变量d_g_fitting_type_def的值 + dfunctiondef = CBgWork::GetFittingDescriptionByType(allData.BgDetbgr.d_fittingPara.g_fitting_type); + djtemp = env->NewStringUTF(dfunctiondef.toStdString().c_str()); + fieldID = env->GetFieldID(structClass, "d_g_fitting_type_def", SIG_STRING); + env->SetObjectField(result, fieldID, djtemp); + + //设置成员变量d_b_fitting_c_e的值 + fieldID = env->GetFieldID(structClass, "d_b_fitting_c_e", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgDetbgr.d_fittingPara.b_fitting_c_e, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgDetbgr.d_fittingPara.b_fitting_c_e.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量d_g_fitting_c_e的值 + fieldID = env->GetFieldID(structClass, "d_g_fitting_c_e", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgDetbgr.d_fittingPara.g_fitting_c_e, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgDetbgr.d_fittingPara.g_fitting_c_e.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + + int rowsize = allData.BgDetbgr.d_boungdary.ROI_B_Boundary_start.size(); + QVector itemp; + itemp.clear(); + for (int pos = 1; pos <= rowsize; pos++) + { + itemp.append(pos); + } + //设置成员变量D_ROI的值 + fieldID = env->GetFieldID(structClass, "D_ROI", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(itemp, env); + fieldJobject = CplusToJava::Createjobject(env, itemp.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量D_ROI_B_Boundary_start的值 + fieldID = env->GetFieldID(structClass, "D_ROI_B_Boundary_start", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(allData.BgDetbgr.d_boungdary.ROI_B_Boundary_start, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgDetbgr.d_boungdary.ROI_B_Boundary_start.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量D_ROI_B_Boundary_stop的值 + fieldID = env->GetFieldID(structClass, "D_ROI_B_Boundary_stop", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(allData.BgDetbgr.d_boungdary.ROI_B_Boundary_stop, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgDetbgr.d_boungdary.ROI_B_Boundary_stop.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量D_ROI_G_Boundary_start的值 + fieldID = env->GetFieldID(structClass, "D_ROI_G_Boundary_start", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(allData.BgDetbgr.d_boungdary.ROI_G_Boundary_start, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgDetbgr.d_boungdary.ROI_G_Boundary_start.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量D_ROI_G_Boundary_stop的值 + fieldID = env->GetFieldID(structClass, "D_ROI_G_Boundary_stop", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(allData.BgDetbgr.d_boungdary.ROI_G_Boundary_stop, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgDetbgr.d_boungdary.ROI_G_Boundary_stop.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量d_roi_cts的值 + fieldID = env->GetFieldID(structClass, "d_roi_cts", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgDetbgr.d_roi_cts, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgDetbgr.d_roi_cts.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); +} + +void exportSDetuctDcts(JNIEnv *env, jobject& result, BgAllGenerate& allData, jclass& structClass) +{ + +} + +void exportGDetuctDcts(JNIEnv *env, jobject& result, BgAllGenerate& allData, jclass& structClass) +{ + //设置成员变量g_deduct_d_cts的值 + jfieldID fieldID = env->GetFieldID(structClass, "g_deduct_d_cts", SIG_LIST); + jobjectArray jarray = CplusToJava::QVectorD2jobjectArray(allData.BgGas.g_deduct_d_cts, env); + jobject fieldJobject = CplusToJava::Createjobject(env, allData.BgGas.g_deduct_d_cts.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); +} + +void exportExtractNetCounts(JNIEnv *env, jobject& result, BgAllGenerate& allData, jclass& structClass) +{ + //设置成员变量s_deduct_d_cts的值 + jfieldID fieldID = env->GetFieldID(structClass, "s_deduct_d_cts", SIG_LIST); + jobjectArray jarray = CplusToJava::QVectorD2jobjectArray(allData.BgSample.s_deduct_d_cts, env); + jobject fieldJobject = CplusToJava::Createjobject(env, allData.BgSample.s_deduct_d_cts.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + QVector netTemp; + QVector netBq; + netBq.append(0); + netTemp.append(0); + for (int pos = 6; pos < allData.BgOther.ROI_net_coutns.size(); pos += 3) + { + netTemp.append(allData.BgOther.ROI_net_coutns.at(pos)); + netBq.append(qSqrt(allData.BgOther.ROI_net_coutns.at(pos + 1))); + } + //设置成员变量ROI_net_coutns的值 + fieldID = env->GetFieldID(structClass, "ROI_net_coutns", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(netTemp, env); + fieldJobject = CplusToJava::Createjobject(env, netTemp.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量ROI_net_coutns_err的值 + fieldID = env->GetFieldID(structClass, "ROI_net_coutns_err", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(netBq, env); + fieldJobject = CplusToJava::Createjobject(env, netBq.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); +} + +void exportCalcRoiConUncer(JNIEnv *env, jobject& result, BgAllGenerate& allData, jclass& structClass) +{ + + QVector concTemp; + QVector concErrTemp; + concTemp.append(0); + concErrTemp.append(0); + for (int pos = 4; pos < allData.BgOther.ROI_con_uncer.size(); pos += 2) + { + concTemp.append(allData.BgOther.ROI_con_uncer.at(pos)); + concErrTemp.append(allData.BgOther.ROI_con_uncer.at(pos + 1)); + } + //设置成员变量ROI_con_uncer的值 + jfieldID fieldID = env->GetFieldID(structClass, "ROI_con_uncer", SIG_LIST); + jobjectArray jarray = CplusToJava::QVectorD2jobjectArray(concTemp, env); + jobject fieldJobject = CplusToJava::Createjobject(env, concTemp.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + QVector dNidFlag; + QVector MDCtemp; + dNidFlag.append(0); + MDCtemp.append(0); + for (int pos = 0; pos < allData.BgOther.MDCPara.MDC.size(); pos++) + { + double dTemp = allData.BgOther.MDCPara.MDC.at(pos); + MDCtemp.append(dTemp); + if (pos + 1 < concTemp.size()) + { + if (concTemp.at(pos + 1) > dTemp) + { + dNidFlag.append(1); + } + else + { + dNidFlag.append(0); + } + } + } + //设置成员变量MDC的值 + fieldID = env->GetFieldID(structClass, "MDC", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(allData.BgOther.MDCPara.MDC, env); + fieldJobject = CplusToJava::Createjobject(env, allData.BgOther.MDCPara.MDC.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量dNidFlag的值 + fieldID = env->GetFieldID(structClass, "dNidFlag", SIG_LIST); + jarray = CplusToJava::QVectorI2jobjectArray(dNidFlag, env); + fieldJobject = CplusToJava::Createjobject(env, dNidFlag.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量ROI_con_uncer_err的值 + fieldID = env->GetFieldID(structClass, "ROI_con_uncer_err", SIG_LIST); + jarray = CplusToJava::QVectorD2jobjectArray(concErrTemp, env); + fieldJobject = CplusToJava::Createjobject(env, concErrTemp.size(), jarray); + env->SetObjectField(result, fieldID, fieldJobject); +} + +void exportCalcXeConUncer(JNIEnv *env, jobject& result, BgAllGenerate& allData, jclass& structClass) +{ + //设置成员变量Xe135_con的值 + jfieldID fieldID = env->GetFieldID(structClass, "Xe135_con", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.XeConUncer.Xe135_con); + + //设置成员变量Xe135_uncer的值 + fieldID = env->GetFieldID(structClass, "Xe135_uncer", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.XeConUncer.Xe135_uncer); + + //设置成员变量Xe131m_con的值 + fieldID = env->GetFieldID(structClass, "Xe131m_con", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.XeConUncer.Xe131m_con); + + //设置成员变量Xe131m_uncer的值 + fieldID = env->GetFieldID(structClass, "Xe131m_uncer", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.XeConUncer.Xe131m_uncer); + + //设置成员变量Xe133m_con的值 + fieldID = env->GetFieldID(structClass, "Xe133m_con", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.XeConUncer.Xe133m_con); + + //设置成员变量Xe133m_uncer的值 + fieldID = env->GetFieldID(structClass, "Xe133m_uncer", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.XeConUncer.Xe133m_uncer); + + //设置成员变量Xe133_con的值 + fieldID = env->GetFieldID(structClass, "Xe133_con", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.XeConUncer.Xe133_con); + + //设置成员变量Xe133_uncer的值 + fieldID = env->GetFieldID(structClass, "Xe133_uncer", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, allData.BgOther.XeConUncer.Xe133_uncer); + + +} + +JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_bgReAnalyse(JNIEnv *env, jclass, jstring sample, jstring gas, jstring detbgr, jobject para) +{ + //算法部分 + bool bRet = false; + BgFileI inputFile; + CBgWork bgwork; + bool bFileAnlyseError = false; + QString sampleFile = CplusToJava::jstring2QString(env, sample); + printf("sample:%s\n", sampleFile.toStdString().c_str()); + // **************** printf("\n"); + QString gasFile = CplusToJava::jstring2QString(env, gas); + printf("gas:%s\n", gasFile.toStdString().c_str()); + // **************** printf("\n"); + QString detbgrFile = CplusToJava::jstring2QString(env, detbgr); + printf("detbgr:%s\n", detbgrFile.toStdString().c_str()); + // **************** printf("\n"); + BgAllGenerate allData; + if (!inputFile.Detbgr.AnalysePHD_File(detbgrFile)) + { + printf("In BgAnalyse,detbgrFile get failed:"); + printf(detbgrFile.toStdString().c_str()); + printf("\n"); + } + else if (!inputFile.gas.AnalysePHD_File(gasFile)) + { + printf("In BgAnalyse,gasFile get failed:"); + printf(gasFile.toStdString().c_str()); + printf("\n"); + } + else if (!inputFile.sample.AnalysePHD_File(sampleFile)) + { + printf("In BgAnalyse,sampleFile get failed:"); + printf(sampleFile.toStdString().c_str()); + printf("\n"); + } + else + { + bgwork.SetBgFile(inputFile); + + // 获取Java中的Struct对象 + jclass structClass = env->GetObjectClass(para); + + BgCalibratePara bgpara; + bgpara.b_e_cal = CplusToJava::jobjectArray2QVectorD(env, CplusToJava::GetjobjectArray(env, structClass, para, "b_e_cal")); + bgpara.g_e_cal = CplusToJava::jobjectArray2QVectorD(env, CplusToJava::GetjobjectArray(env, structClass, para, "g_e_cal")); + + // 获取成员变量b_e_cal_flag的值 + jfieldID fieldid = env->GetFieldID(structClass, "b_e_cal_flag", SIG_INT); + bgpara.b_e_cal_flag = env->GetIntField(para, fieldid); + + // 获取成员变量g_e_cal_flag的值 + fieldid = env->GetFieldID(structClass, "g_e_cal_flag", SIG_INT); + bgpara.g_e_cal_flag = env->GetIntField(para, fieldid); + + fieldid = env->GetFieldID(structClass, "bApplyNewCalicSample", SIG_BOOL); + bgpara.bApplyNewCalicSample = env->GetBooleanField(para, fieldid); // 界面交互新刻度应用 + + fieldid = env->GetFieldID(structClass, "bApplyNewCalicDetBg", SIG_BOOL); + bgpara.bApplyNewCalicDetBg = env->GetBooleanField(para, fieldid); + + fieldid = env->GetFieldID(structClass, "bApplyNewCalicGasBg", SIG_BOOL); + bgpara.bApplyNewCalicGasBg = env->GetBooleanField(para, fieldid); + + fieldid = env->GetFieldID(structClass, "bApplyNewCalicQc", SIG_BOOL); + bgpara.bApplyNewCalicQc = env->GetBooleanField(para, fieldid); + + QString strbe = ""; + for (int i = 0; i < bgpara.b_e_cal.size(); i++) + { + if (strbe != "") + strbe += ","; + strbe += QString::number(bgpara.b_e_cal.at(i)); + } + QString strGe = ""; + for (int i = 0; i < bgpara.g_e_cal.size(); i++) + { + if (strGe != "") + strGe += ","; + strGe += QString::number(bgpara.g_e_cal.at(i)); + } + + printf("b_e_cal:%s\n", strbe.toStdString().c_str()); + printf("g_e_cal:%s\n", strGe.toStdString().c_str()); + + printf("b_e_cal_flag:%d,g_e_cal_flag:%d\n", bgpara.b_e_cal_flag, bgpara.g_e_cal_flag); + printf("bApplyNewCalicSample:%d\n", bgpara.bApplyNewCalicSample); + printf("bApplyNewCalicDetBg:%d", bgpara.bApplyNewCalicDetBg); + printf("bApplyNewCalicGasBg:%d\n", bgpara.bApplyNewCalicGasBg); + printf("bApplyNewCalicQc:%d\n", bgpara.bApplyNewCalicQc); + + bRet = bgwork.MutialAnalyse(bgpara); + + //bRet = bgwork.AutoAnalyse(); + allData = bgwork.GetAllValue(); + } + //获取Java中的BgAnalyseResult类 + jclass structClass = env->FindClass("Lorg/jeecg/modules/native_jni/struct/BgAnalyseResult;"); + + // 创建Java中的BgAnalyseResult对象 + jmethodID constructorID = env->GetMethodID(structClass, "", "()V"); + jobject result = env->NewObject(structClass, constructorID); + + //设置成员变量analyse_flag的值(判断是否成功) + jfieldID fieldID = env->GetFieldID(structClass, "analyse_flag", SIG_BOOL); + env->SetBooleanField(result, fieldID, bRet); + + //// **************** printf("set bool success"); + + if (bRet) { + // 设置成员变量error_log的值 + QString error_str = "no error."; + jstring jerror_str = env->NewStringUTF(error_str.toStdString().c_str()); + fieldID = env->GetFieldID(structClass, "error_log", SIG_STRING); + env->SetObjectField(result, fieldID, jerror_str); + + exportSROIcts(env, result, allData, structClass); + exportGROIcts(env, result, allData, structClass); + exportDROIcts(env, result, allData, structClass); + exportSDetuctDcts(env, result, allData, structClass); + exportGDetuctDcts(env, result, allData, structClass); + exportExtractNetCounts(env, result, allData, structClass); + exportCalcRoiConUncer(env, result, allData, structClass); + exportCalcXeConUncer(env, result, allData, structClass); + exportMDC(env, result, allData, structClass); + + } + else + { + for (BgErrorType type : {E_SAMPLE_ROI_CTS, E_GAS_ROI_CTS, E_DETA_ROI_CTS, E_S_DETUCT_D_CTS, E_NET_COUNTS, E_ROI_CON_UNCER, E_XE_CON_UNCER, E_MDC}) + { + if (type == bgwork.GetLastError()) break; + switch (type) + { + case E_SAMPLE_ROI_CTS: + exportSROIcts(env, result, allData, structClass); + break; + case E_GAS_ROI_CTS: + exportGROIcts(env, result, allData, structClass); + break; + case E_DETA_ROI_CTS: + exportDROIcts(env, result, allData, structClass); + break; + case E_S_DETUCT_D_CTS: + exportSDetuctDcts(env, result, allData, structClass); + break; + case E_G_DETUCT_D_CTS: + exportGDetuctDcts(env, result, allData, structClass); + break; + case E_NET_COUNTS: + exportExtractNetCounts(env, result, allData, structClass); + break; + case E_ROI_CON_UNCER: + exportCalcRoiConUncer(env, result, allData, structClass); + break; + case E_XE_CON_UNCER: + exportCalcXeConUncer(env, result, allData, structClass); + break; + case E_MDC: + exportMDC(env, result, allData, structClass); + break; + default: + break; + } + } + // 设置成员变量error_log的值 + QString error_str = CBgWork::BgAnlyseError(bgwork.GetLastError()); + jstring jerror_str = env->NewStringUTF(error_str.toStdString().c_str()); + fieldID = env->GetFieldID(structClass, "error_log", SIG_STRING); + env->SetObjectField(result, fieldID, jerror_str); + } + + return result; +} + +JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_getAlertSourceData(JNIEnv* env, jclass, jstring path) +{ + //路径转换 + QString alertFile = CplusToJava::jstring2QString(env, path); + + //解析 + AlertMessage alertmes; + bool readflag = alertmes.AnalyseFile(alertFile); + if (!readflag) + { + printf("THE AlertFile get failed:"); + printf(alertFile.toStdString().c_str()); + printf("\n"); + } + + AlertData::AlertsInfo alertresult = alertmes.GetAlertsInfo(); + + //获取Java中的AlertSpectrumStruct类 + jclass structClass = env->FindClass("Lorg/jeecg/modules/native_jni/struct/AlertSpectrumStruct;"); + + // 创建Java中的BgAnalyseResult对象 + jmethodID constructorID = env->GetMethodID(structClass, "", "()V"); + jobject result = env->NewObject(structClass, constructorID); + + //设置成员变量station_code的值 + jfieldID fieldID = env->GetFieldID(structClass, "station_code", SIG_STRING); + jstring jstation_code = env->NewStringUTF(alertresult.station_code.toStdString().c_str()); + env->SetObjectField(result, fieldID, jstation_code); + + //设置成员变量alert_type的值 + fieldID = env->GetFieldID(structClass, "alert_type", SIG_STRING); + jstring jalert_type = env->NewStringUTF(alertresult.alert_type.toStdString().c_str()); + env->SetObjectField(result, fieldID, jalert_type); + + //设置成员变量date的值 + fieldID = env->GetFieldID(structClass, "date", SIG_STRING); + jstring jdate = env->NewStringUTF(alertresult.date.toStdString().c_str()); + env->SetObjectField(result, fieldID, jdate); + + //设置成员变量time的值 + fieldID = env->GetFieldID(structClass, "time", SIG_STRING); + jstring jtime = env->NewStringUTF(alertresult.time.toStdString().c_str()); + env->SetObjectField(result, fieldID, jtime); + + //设置成员变量desc的值 + fieldID = env->GetFieldID(structClass, "desc", SIG_STRING); + jstring jdesc = env->NewStringUTF(alertresult.desc.toStdString().c_str()); + env->SetObjectField(result, fieldID, jdesc); + + return result; +} + +JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_getMetSourceData(JNIEnv* env, jclass, jstring path) +{ + //路径转换 + QString metFile = CplusToJava::jstring2QString(env, path); + + //文件头单独读取台站 + MeteorologicalMessage metData; + bool readflag = metData.AnalyseFile(metFile); + + if (!readflag) + { + printf("THE MetFile get failed:"); + printf(metFile.toStdString().c_str()); + printf("\n"); + } + + QString sta_code = metData.GetMessageInfo().msg_src_code; + QList listdata = metData.GetMetDatas(); + jstring station_code = env->NewStringUTF(sta_code.toStdString().c_str()); + //循环次数及record_count + int arraySize = listdata.size(); + + //用于接收结构体各项 + QVector vec_met_start_date; + QVector vec_met_start_time; + QVector vec_met_end_date; + QVector vec_met_end_time; + QVector vec_average_outside_temperature; + QVector vec_average_wind_direction; + QVector vec_average_wind_speed; + QVector vec_average_barometric_reading; + QVector vec_humidity; + QVector vec_rainfall; + for (int i = 0; i < arraySize; i++) { + MetData::MetDataItem temp = listdata[i]; + vec_met_start_date.push_back(temp.met_start_date); + vec_met_start_time.push_back(temp.met_start_time); + vec_met_end_date.push_back(temp.met_end_date); + vec_met_end_time.push_back(temp.met_end_time); + vec_average_outside_temperature.push_back(temp.average_outside_temperature); + vec_average_wind_direction.push_back(temp.average_wind_direction); + vec_average_wind_speed.push_back(temp.average_wind_speed); + vec_average_barometric_reading.push_back(temp.average_barometric_reading); + vec_humidity.push_back(temp.humidity); + vec_rainfall.push_back(temp.rainfall); + } + jobjectArray jmet_start_date = CplusToJava::QVectorQS2jobjectArray(vec_met_start_date, env); + jobjectArray jmet_start_time = CplusToJava::QVectorQS2jobjectArray(vec_met_start_time, env); + jobjectArray jmet_end_date = CplusToJava::QVectorQS2jobjectArray(vec_met_end_date, env); + jobjectArray jmet_end_time = CplusToJava::QVectorQS2jobjectArray(vec_met_end_time, env); + jobjectArray javerage_outside_temperature = CplusToJava::QVectorD2jobjectArray(vec_average_outside_temperature, env); + jobjectArray javerage_wind_direction = CplusToJava::QVectorD2jobjectArray(vec_average_wind_direction, env); + jobjectArray javerage_wind_speed = CplusToJava::QVectorD2jobjectArray(vec_average_wind_speed, env); + jobjectArray javerage_barometric_reading = CplusToJava::QVectorD2jobjectArray(vec_average_barometric_reading, env); + jobjectArray jhumidity = CplusToJava::QVectorD2jobjectArray(vec_humidity, env); + jobjectArray jrainfall = CplusToJava::QVectorD2jobjectArray(vec_rainfall, env); + + //获取Java中的MetSpectrumStruct类 + jclass MetSpectrumStruct = env->FindClass("Lorg/jeecg/modules/native_jni/struct/MetSpectrumStruct;"); + + // 创建Java中的MetSpectrumStruct对象 + jmethodID constructorID = env->GetMethodID(MetSpectrumStruct, "", "()V"); + jobject result = env->NewObject(MetSpectrumStruct, constructorID); + + //设置成员变量met_start_date的值 + jfieldID fieldID = env->GetFieldID(MetSpectrumStruct, "met_start_date", SIG_LIST); + jobject fieldJobject = CplusToJava::Createjobject(env, arraySize, jmet_start_date); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量met_start_time的值 + fieldID = env->GetFieldID(MetSpectrumStruct, "met_start_time", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, arraySize, jmet_start_time); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量met_end_date的值 + fieldID = env->GetFieldID(MetSpectrumStruct, "met_end_date", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, arraySize, jmet_end_date); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量met_end_time的值 + fieldID = env->GetFieldID(MetSpectrumStruct, "met_end_time", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, arraySize, jmet_end_time); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量average_outside_temperature的值 + fieldID = env->GetFieldID(MetSpectrumStruct, "average_outside_temperature", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, arraySize, javerage_outside_temperature); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量average_wind_direction的值 + fieldID = env->GetFieldID(MetSpectrumStruct, "average_wind_direction", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, arraySize, javerage_wind_direction); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量average_wind_speed的值 + fieldID = env->GetFieldID(MetSpectrumStruct, "average_wind_speed", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, arraySize, javerage_wind_speed); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量average_barometric_reading的值 + fieldID = env->GetFieldID(MetSpectrumStruct, "average_barometric_reading", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, arraySize, javerage_barometric_reading); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量humidity的值 + fieldID = env->GetFieldID(MetSpectrumStruct, "humidity", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, arraySize, jhumidity); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量rainfall的值 + fieldID = env->GetFieldID(MetSpectrumStruct, "rainfall", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, arraySize, jrainfall); + env->SetObjectField(result, fieldID, fieldJobject); + + // 设置成员变量station_code的值 + fieldID = env->GetFieldID(MetSpectrumStruct, "station_code", SIG_STRING); + env->SetObjectField(result, fieldID, station_code); + + //设置成员变量record_count的值 + fieldID = env->GetFieldID(MetSpectrumStruct, "record_count", SIG_INT); + env->SetIntField(result, fieldID, arraySize); + + return result; +} + +JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_getSOHSourceData(JNIEnv* env, jclass, jstring path) +{ + //路径转换 + QString sohFile = CplusToJava::jstring2QString(env, path); + + //解析文件 + StateOfHealthMessage sohfile; + bool readflag = sohfile.AnalyseFile(sohFile); + if (!readflag) + { + printf("THE SOHFile get failed:"); + printf(sohFile.toStdString().c_str()); + printf("\n"); + } + + //区块名 + QString header = "#Header"; + QString airflow = "#AirSamplerFlow"; + QString airenv = "#AirSamplerEnv"; + QString det = "#DetEnv"; + QString nimbin = "#NIMBIN"; + QString power = "#PowerSupply"; + QString equip = "#EquipStatus"; + QString tamper = "#TamperEnv"; + QString process = "#ProcessSensors"; + QString chromato = "#Chromatogram"; + + //各数据块存在标识 + bool headerflag = true; + bool airflowflag = true; + bool airenvflag = true; + bool detflag = true; + bool nimbinflag = true; + bool powerflag = true; + bool equipflag = true; + bool tamperflag = true; + bool processflag = true; + bool chromatoflag = true; + + //创建结构体对象并填充内容 + SOHFileResult cresult; + + //接收QVector的大小 + QMap allSize; + + //header内容获取 + RMSSOHData::HeaderBlock headerBlock; + QString order = header; + QVariant variant = sohfile.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + headerflag = false; + } + else + { + headerBlock = variant.value(); + cresult.designator = env->NewStringUTF(headerBlock.designator.toStdString().c_str()); + cresult.station_code = env->NewStringUTF(headerBlock.station_code.toStdString().c_str()); + cresult.detector_code = env->NewStringUTF(headerBlock.detector_code.toStdString().c_str()); + cresult.start_date = env->NewStringUTF(headerBlock.start_date.toStdString().c_str()); + cresult.start_time = env->NewStringUTF(headerBlock.start_time.toStdString().c_str()); + cresult.end_date = env->NewStringUTF(headerBlock.end_date.toStdString().c_str()); + cresult.end_time = env->NewStringUTF(headerBlock.end_time.toStdString().c_str()); + cresult.transmit_date = env->NewStringUTF(headerBlock.transmit_date.toStdString().c_str()); + cresult.transmit_time = env->NewStringUTF(headerBlock.transmit_time.toStdString().c_str()); + + printf( headerBlock.station_code.toStdString().c_str()); + } + + //AirSamplerFlowBlock内容获取 + RMSSOHData::AirSamplerFlowBlock airflowBlock; + order = airflow; + variant = sohfile.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + airflowflag = false; + } + else + { + airflowBlock = variant.value(); + allSize["average_flow_rate"] = airflowBlock.average_flow_rate.size(); + cresult.average_flow_rate = CplusToJava::QVectorD2jobjectArray(airflowBlock.average_flow_rate, env); + allSize["flow_rate_standard_deviation"] = airflowBlock.flow_rate_standard_deviation.size(); + cresult.flow_rate_standard_deviation = CplusToJava::QVectorD2jobjectArray(airflowBlock.flow_rate_standard_deviation, env); + allSize["af_start_date"] = airflowBlock.start_date.size(); + cresult.af_start_date = CplusToJava::QVectorQS2jobjectArray(airflowBlock.start_date, env); + allSize["af_start_time"] = airflowBlock.start_time.size(); + cresult.af_start_time = CplusToJava::QVectorQS2jobjectArray(airflowBlock.start_time, env); + allSize["af_interval_duration"] = airflowBlock.interval_duration.size(); + cresult.af_interval_duration = CplusToJava::QVectorL2jobjectArray(airflowBlock.interval_duration, env); + cresult.af_record_count = airflowBlock.record_count; + } + + //AirSamplerEnvBlock内容获取 + RMSSOHData::AirSamplerEnvBlock airenvBlock; + order = airenv; + variant = sohfile.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + airenvflag = false; + } + else + { + airenvBlock = variant.value(); + allSize["temperature"] = airenvBlock.temperature.size(); + cresult.temperature = CplusToJava::QVectorD2jobjectArray(airenvBlock.temperature, env); + allSize["pressure"] = airenvBlock.pressure.size(); + cresult.pressure = CplusToJava::QVectorD2jobjectArray(airenvBlock.pressure, env); + allSize["ae_date"] = airenvBlock.date.size(); + cresult.ae_date = CplusToJava::QVectorQS2jobjectArray(airenvBlock.date, env); + allSize["ae_time"] = airenvBlock.time.size(); + cresult.ae_time = CplusToJava::QVectorQS2jobjectArray(airenvBlock.time, env); + allSize["ae_interval_duration"] = airenvBlock.interval_duration.size(); + cresult.ae_interval_duration = CplusToJava::QVectorL2jobjectArray(airenvBlock.interval_duration, env); + cresult.ae_record_count = airenvBlock.record_count; + } + + //Det Env block内容获取 + RMSSOHData::DetEnvBlock detBlock; + order = det; + variant = sohfile.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + detflag = false; + } + else + { + detBlock = variant.value(); + allSize["room_temperature"] = detBlock.room_temperature.size(); + cresult.room_temperature = CplusToJava::QVectorD2jobjectArray(detBlock.room_temperature, env); + allSize["detector_shield_status"] = detBlock.detector_shield_status.size(); + cresult.detector_shield_status = CplusToJava::QVectorQS2jobjectArray(detBlock.detector_shield_status, env); + allSize["humidity"] = detBlock.humidity.size(); + cresult.humidity = CplusToJava::QVectorS2jobjectArray(detBlock.humidity, env); + allSize["d_voltage"] = detBlock.voltage.size(); + cresult.d_voltage = CplusToJava::QVectorL2jobjectArray(detBlock.voltage, env); + allSize["crystal_temperature"] = detBlock.crystal_temperature.size(); + cresult.crystal_temperature = CplusToJava::QVectorL2jobjectArray(detBlock.crystal_temperature, env); + allSize["electric_cooler_status"] = detBlock.electric_cooler_status.size(); + cresult.electric_cooler_status = CplusToJava::QVectorQS2jobjectArray(detBlock.electric_cooler_status, env); + allSize["fill_fraction"] = detBlock.fill_fraction.size(); + cresult.fill_fraction = CplusToJava::QVectorD2jobjectArray(detBlock.fill_fraction, env); + allSize["leakage"] = detBlock.leakage.size(); + cresult.leakage = CplusToJava::QVectorD2jobjectArray(detBlock.leakage, env); + allSize["d_date"] = detBlock.date.size(); + cresult.d_date = CplusToJava::QVectorQS2jobjectArray(detBlock.date, env); + allSize["d_time"] = detBlock.time.size(); + cresult.d_time = CplusToJava::QVectorQS2jobjectArray(detBlock.time, env); + allSize["d_interval_duration"] = detBlock.interval_duration.size(); + cresult.d_interval_duration = CplusToJava::QVectorL2jobjectArray(detBlock.interval_duration, env); + cresult.d_record_count = detBlock.record_count; + } + + //NIMBIN block内容获取 + RMSSOHData::NIMBIN_Block nimbinBlock; + order = nimbin; + variant = sohfile.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + nimbinflag = false; + } + else + { + nimbinBlock = variant.value(); + allSize["flag"] = nimbinBlock.flag.size(); + cresult.flag = CplusToJava::QVectorQS2jobjectArray(nimbinBlock.flag, env); + allSize["n_voltage"] = nimbinBlock.voltage.size(); + cresult.n_voltage = CplusToJava::QVectorS2jobjectArray(nimbinBlock.voltage, env); + allSize["n_date"] = nimbinBlock.date.size(); + cresult.n_date = CplusToJava::QVectorQS2jobjectArray(nimbinBlock.date, env); + allSize["n_time"] = nimbinBlock.time.size(); + cresult.n_time = CplusToJava::QVectorQS2jobjectArray(nimbinBlock.time, env); + allSize["n_interval_duration"] = nimbinBlock.interval_duration.size(); + cresult.n_interval_duration = CplusToJava::QVectorL2jobjectArray(nimbinBlock.interval_duration, env); + cresult.n_record_count = airenvBlock.record_count; + } + + //Power Supply block内容获取 + RMSSOHData::PowerSupplyBlock powerBlock; + order = power; + variant = sohfile.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + powerflag = false; + } + else + { + powerBlock = variant.value(); + allSize["MAIN"] = powerBlock.MAIN.size(); + cresult.MAIN = CplusToJava::QVectorQS2jobjectArray(powerBlock.MAIN, env); + allSize["main_power_status"] = powerBlock.main_power_status.size(); + cresult.main_power_status = CplusToJava::QVectorQS2jobjectArray(powerBlock.main_power_status, env); + allSize["AUX"] = powerBlock.AUX.size(); + cresult.AUX = CplusToJava::QVectorQS2jobjectArray(powerBlock.AUX, env); + allSize["aux_power_status"] = powerBlock.aux_power_status.size(); + cresult.aux_power_status = CplusToJava::QVectorQS2jobjectArray(powerBlock.aux_power_status, env); + allSize["UPS"] = powerBlock.UPS.size(); + cresult.UPS = CplusToJava::QVectorQS2jobjectArray(powerBlock.UPS, env); + allSize["ups_status"] = powerBlock.ups_status.size(); + cresult.ups_status = CplusToJava::QVectorQS2jobjectArray(powerBlock.ups_status, env); + allSize["p_date"] = powerBlock.date.size(); + cresult.p_date = CplusToJava::QVectorQS2jobjectArray(powerBlock.date, env); + allSize["p_time"] = powerBlock.time.size(); + cresult.p_time = CplusToJava::QVectorQS2jobjectArray(powerBlock.time, env); + allSize["p_interval_duration"] = powerBlock.interval_duration.size(); + cresult.p_interval_duration = CplusToJava::QVectorL2jobjectArray(powerBlock.interval_duration, env); + cresult.p_record_count = powerBlock.record_count; + } + + //Equip Status block内容获取 + RMSSOHData::EquipStatusBlock equipBlock; + order = equip; + variant = sohfile.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + equipflag = false; + } + else + { + equipBlock = variant.value(); + allSize["C_value"] = equipBlock.C_value.size(); + cresult.C_value = CplusToJava::QVectorQS2jobjectArray(equipBlock.C_value, env); + allSize["P_value"] = equipBlock.P_value.size(); + cresult.P_value = CplusToJava::QVectorQS2jobjectArray(equipBlock.P_value, env); + allSize["A_value"] = equipBlock.A_value.size(); + cresult.A_value = CplusToJava::QVectorQS2jobjectArray(equipBlock.A_value, env); + allSize["e_date"] = equipBlock.date.size(); + cresult.e_date = CplusToJava::QVectorQS2jobjectArray(equipBlock.date, env); + allSize["e_time"] = equipBlock.time.size(); + cresult.e_time = CplusToJava::QVectorQS2jobjectArray(equipBlock.time, env); + allSize["e_interval_duration"] = equipBlock.interval_duration.size(); + cresult.e_interval_duration = CplusToJava::QVectorL2jobjectArray(equipBlock.interval_duration, env); + cresult.e_record_count = equipBlock.record_count; + } + + //Tamper Env block内容获取 + RMSSOHData::TamperEnvBlock tamperBlock; + order = tamper; + variant = sohfile.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + tamperflag = false; + } + else + { + tamperBlock = variant.value(); + allSize["tamper_sensor_name"] = tamperBlock.tamper_sensor_name.size(); + cresult.tamper_sensor_name = CplusToJava::QVectorQS2jobjectArray(tamperBlock.tamper_sensor_name, env); + allSize["tamper_sensor_status"] = tamperBlock.tamper_sensor_status.size(); + cresult.tamper_sensor_status = CplusToJava::QVectorQS2jobjectArray(tamperBlock.tamper_sensor_status, env); + allSize["t_date"] = tamperBlock.date.size(); + cresult.t_date = CplusToJava::QVectorQS2jobjectArray(tamperBlock.date, env); + allSize["t_time"] = tamperBlock.time.size(); + cresult.t_time = CplusToJava::QVectorQS2jobjectArray(tamperBlock.time, env); + allSize["t_interval_duration"] = tamperBlock.interval_duration.size(); + cresult.t_interval_duration = CplusToJava::QVectorL2jobjectArray(tamperBlock.interval_duration, env); + cresult.t_record_count = tamperBlock.record_count; + } + + //Process Sensors block内容获取 + RMSSOHData::ProcessSensorsBlock processBlock; + order = process; + variant = sohfile.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + processflag = false; + } + else + { + processBlock = variant.value(); + allSize["sensor_type"] = processBlock.sensor_type.size(); + cresult.sensor_type = CplusToJava::QVectorQS2jobjectArray(processBlock.sensor_type, env); + allSize["sensor_name"] = processBlock.sensor_name.size(); + cresult.sensor_name = CplusToJava::QVectorQS2jobjectArray(processBlock.sensor_name, env); + allSize["sensor_reading"] = processBlock.sensor_reading.size(); + cresult.sensor_reading = CplusToJava::QVectorD2jobjectArray(processBlock.sensor_reading, env); + allSize["ps_date"] = processBlock.date.size(); + cresult.ps_date = CplusToJava::QVectorQS2jobjectArray(processBlock.date, env); + allSize["ps_time"] = processBlock.time.size(); + cresult.ps_time = CplusToJava::QVectorQS2jobjectArray(processBlock.time, env); + allSize["ps_duration"] = processBlock.duration.size(); + cresult.ps_duration = CplusToJava::QVectorL2jobjectArray(processBlock.duration, env); + cresult.ps_record_count = processBlock.record_count; + } + + //Chromatogram block内容获取 + RMSSOHData::ChromatogramBlock chromatoBlock; + order = chromato; + variant = sohfile.GetBlockData(order); + if (!variant.isValid()) + { + printf((order.toStdString() + " get failed\n").c_str()); + chromatoflag = false; + } + else + { + chromatoBlock = variant.value(); + cresult.srid = env->NewStringUTF(chromatoBlock.srid.toStdString().c_str()); + allSize["interval_number"] = chromatoBlock.interval_number.size(); + cresult.interval_number = CplusToJava::QVectorL2jobjectArray(chromatoBlock.interval_number, env); + allSize["interval_start_channel"] = chromatoBlock.interval_start_channel.size(); + cresult.interval_start_channel = CplusToJava::QVectorL2jobjectArray(chromatoBlock.interval_start_channel, env); + allSize["c_duration"] = chromatoBlock.duration.size(); + cresult.c_duration = CplusToJava::QVectorD2jobjectArray(chromatoBlock.duration, env); + allSize["detector_response"] = chromatoBlock.detector_response.size(); + cresult.detector_response = CplusToJava::QVectorL2jobjectArray(chromatoBlock.detector_response, env); + cresult.interval_record_count = chromatoBlock.interval_record_count; + cresult.total_number = chromatoBlock.total_number; + } + + //获取Java中的SOHSpectrumStruct类 + jclass SOHSpectrumStruct = env->FindClass("Lorg/jeecg/modules/native_jni/struct/SOHSpectrumStruct;"); + + // 创建Java中的SOHSpectrumStruct对象 + jmethodID constructorID = env->GetMethodID(SOHSpectrumStruct, "", "()V"); + jobject result = env->NewObject(SOHSpectrumStruct, constructorID); + + jfieldID fieldID; + if (headerflag) + { + // 设置成员变量station_code的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "station_code", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.station_code); + + // 设置成员变量detector_code的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "detector_code", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.detector_code); + + + // 设置成员变量start_date的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "start_date", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.start_date); + + // 设置成员变量start_time的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "start_time", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.start_time); + + /* + // 设置成员变量designator的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "designator", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.designator); + + // 设置成员变量end_date的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "end_date", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.end_date); + + //设置成员变量end_time的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "end_time", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.end_time); + + + //设置成员变量transmit_date的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "transmit_date", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.transmit_date); + + //设置成员变量transmit_time的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "transmit_time", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.transmit_time); + */ + } + + jobject fieldJobject; + if (airflowflag) + { + //设置成员变量average_flow_rate的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "average_flow_rate", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["average_flow_rate"], cresult.average_flow_rate); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量flow_rate_standard_deviation的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "flow_rate_standard_deviation", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["flow_rate_standard_deviation"], cresult.flow_rate_standard_deviation); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量af_start_date的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "af_start_date", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["af_start_date"], cresult.af_start_date); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量af_start_time的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "af_start_time", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["af_start_time"], cresult.af_start_time); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量af_interval_duration的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "af_interval_duration", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["af_interval_duration"], cresult.af_interval_duration); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量af_record_count的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "af_record_count", SIG_INT); + env->SetIntField(result, fieldID, cresult.af_record_count); + } + /* + if (airenvflag) + { + //设置成员变量temperature的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "temperature", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["temperature"], cresult.temperature); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量pressure的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "pressure", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["pressure"], cresult.pressure); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量ae_date的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "ae_date", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["ae_date"], cresult.ae_date); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量ae_time的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "ae_time", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["ae_time"], cresult.ae_time); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量ae_interval_duration的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "ae_interval_duration", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["ae_interval_duration"], cresult.ae_interval_duration); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量ae_record_count的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "ae_record_count", SIG_INT); + env->SetIntField(result, fieldID, cresult.ae_record_count); + } + + if (detflag) + { + //设置成员变量room_temperature的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "room_temperature", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["room_temperature"], cresult.room_temperature); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量detector_shield_status的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "detector_shield_status", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["detector_shield_status"], cresult.detector_shield_status); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量humidity的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "humidity", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["humidity"], cresult.humidity); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量d_voltage的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "d_voltage", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["d_voltage"], cresult.d_voltage); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量crystal_temperature的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "crystal_temperature", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["crystal_temperature"], cresult.crystal_temperature); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量electric_cooler_status的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "electric_cooler_status", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["electric_cooler_status"], cresult.electric_cooler_status); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量fill_fraction的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "fill_fraction", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["fill_fraction"], cresult.fill_fraction); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量leakage的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "leakage", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["leakage"], cresult.leakage); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量d_date的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "d_date", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["d_date"], cresult.d_date); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量d_time的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "d_time", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["d_time"], cresult.d_time); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量d_interval_duration的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "d_interval_duration", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["d_interval_duration"], cresult.d_interval_duration); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量d_record_count的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "d_record_count", SIG_INT); + env->SetIntField(result, fieldID, cresult.d_record_count); + } + + if (nimbinflag) + { + //设置成员变量flag的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "flag", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["flag"], cresult.flag); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量n_voltage的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "n_voltage", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["n_voltage"], cresult.n_voltage); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量n_date的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "n_date", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["n_date"], cresult.n_date); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量n_time的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "n_time", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["n_time"], cresult.n_time); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量n_interval_duration的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "n_interval_duration", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["n_interval_duration"], cresult.n_interval_duration); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量n_record_count的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "n_record_count", SIG_INT); + env->SetIntField(result, fieldID, cresult.n_record_count); + } + + if (powerflag) + { + //设置成员变量MAIN的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "MAIN", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["MAIN"], cresult.MAIN); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量main_power_status的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "main_power_status", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["main_power_status"], cresult.main_power_status); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量AUX的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "AUX", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["AUX"], cresult.AUX); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量aux_power_status的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "aux_power_status", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["aux_power_status"], cresult.aux_power_status); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量UPS的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "UPS", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["UPS"], cresult.UPS); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量ups_status的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "ups_status", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["ups_status"], cresult.ups_status); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量p_date的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "p_date", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["p_date"], cresult.p_date); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量p_time的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "p_time", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["p_time"], cresult.p_time); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量p_interval_duration的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "p_interval_duration", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["p_interval_duration"], cresult.p_interval_duration); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量p_record_count的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "p_record_count", SIG_INT); + env->SetIntField(result, fieldID, cresult.p_record_count); + } + + if (equipflag) + { + //设置成员变量C_value的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "C_value", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["C_value"], cresult.C_value); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量P_value的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "P_value", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["P_value"], cresult.P_value); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量A_value的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "A_value", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["A_value"], cresult.A_value); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量e_date的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "e_date", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["e_date"], cresult.e_date); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量e_time的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "e_time", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["e_time"], cresult.e_time); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量e_interval_duration的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "e_interval_duration", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["e_interval_duration"], cresult.e_interval_duration); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量e_record_count的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "e_record_count", SIG_INT); + env->SetIntField(result, fieldID, cresult.e_record_count); + } + + if (tamperflag) + { + //设置成员变量tamper_sensor_name的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "tamper_sensor_name", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["tamper_sensor_name"], cresult.tamper_sensor_name); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量tamper_sensor_status的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "tamper_sensor_status", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["tamper_sensor_status"], cresult.tamper_sensor_status); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量t_date的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "t_date", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["t_date"], cresult.t_date); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量t_time的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "t_time", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["t_time"], cresult.t_time); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量t_interval_duration的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "t_interval_duration", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["t_interval_duration"], cresult.t_interval_duration); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量t_record_count的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "t_record_count", SIG_INT); + env->SetIntField(result, fieldID, cresult.t_record_count); + } + + if (processflag) + { + //设置成员变量sensor_type的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "sensor_type", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["sensor_type"], cresult.sensor_type); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量sensor_name的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "sensor_name", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["sensor_name"], cresult.sensor_name); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量sensor_reading的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "sensor_reading", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["sensor_reading"], cresult.sensor_reading); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量ps_date的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "ps_date", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["ps_date"], cresult.ps_date); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量ps_time的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "ps_time", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["ps_time"], cresult.ps_time); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量ps_duration的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "ps_duration", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["ps_duration"], cresult.ps_duration); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量ps_record_count的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "ps_record_count", SIG_INT); + env->SetIntField(result, fieldID, cresult.ps_record_count); + } + + if (chromatoflag) + { + // 设置成员变量srid的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "srid", SIG_STRING); + env->SetObjectField(result, fieldID, cresult.srid); + + //设置成员变量interval_number的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "interval_number", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["interval_number"], cresult.interval_number); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量interval_start_channel的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "interval_start_channel", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["interval_start_channel"], cresult.interval_start_channel); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量c_duration的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "c_duration", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["c_duration"], cresult.c_duration); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量detector_response的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "detector_response", SIG_LIST); + fieldJobject = CplusToJava::Createjobject(env, allSize["detector_response"], cresult.detector_response); + env->SetObjectField(result, fieldID, fieldJobject); + + //设置成员变量interval_record_count的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "interval_record_count", SIG_INT); + env->SetIntField(result, fieldID, cresult.interval_record_count); + + //设置成员变量total_number的值 + fieldID = env->GetFieldID(SOHSpectrumStruct, "total_number", SIG_LONG); + env->SetLongField(result, fieldID, cresult.total_number); + } + */ + + return result; +} + +JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_GetFittingPara(JNIEnv *env, jclass, jobject jwatch_x, jobject jwatch_y, jstring fittype) +{ + jobjectArray jawatch_x = CplusToJava::jobject2jobjectArray(env, jwatch_x); + QVector watch_x = CplusToJava::jobjectArray2QVectorD(env, jawatch_x); + + jobjectArray jawatch_y = CplusToJava::jobject2jobjectArray(env, jwatch_y); + QVector watch_y = CplusToJava::jobjectArray2QVectorD(env, jawatch_y); + + QString strFit = CplusToJava::jstring2QString(env, fittype); + + FitType fType; + QStringList typeList = { "_default","liner","poly2","poly3",",gauss" }; + for (int i = 0; i < typeList.size(); i++) + { + if (typeList.at(i) == strFit) + { + fType = (FitType)i; + break; + } + } + + QVector fittingPara; + CBgWork::GetFittingPara(watch_x, watch_y, fType, fittingPara); + jobjectArray jafitting_para = CplusToJava::QVectorD2jobjectArray(fittingPara, env); + jobject jfitting_para = CplusToJava::Createjobject(env, fittingPara.size(), jafitting_para); + return jfitting_para; +} + +JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_GetFittingData(JNIEnv *env, jclass, jobject jwatch, jstring fittype, jobject jfittingPara) +{ + jobjectArray jawatch = CplusToJava::jobject2jobjectArray(env, jwatch); + QVector watch = CplusToJava::jobjectArray2QVectorD(env, jawatch); + + jobjectArray fittingPara = CplusToJava::jobject2jobjectArray(env, jfittingPara); + QVector vecFittingPara = CplusToJava::jobjectArray2QVectorD(env, fittingPara); + + QString strFit = CplusToJava::jstring2QString(env, fittype); + + FitType fType; + QStringList typeList = { "_default","liner","poly2","poly3",",gauss" }; + for (int i = 0; i < typeList.size(); i++) + { + if (typeList.at(i) == strFit) + { + fType = (FitType)i; + break; + } + } + + QVector rData; + CBgWork::GetFittingData(watch, fType, vecFittingPara, rData); + jobjectArray jrDataArr = CplusToJava::QVectorD2jobjectArray(rData, env); + jobject jrDataObj = CplusToJava::Createjobject(env, rData.size(), jrDataArr); + return jrDataObj; +} + +JNIEXPORT void JNICALL test_bate() +{ + + QVector watch_x = {76.22, 92.209, 108.102, 123.901, 139.606, 155.221, 170.746, 186.182, 201.532, 216.797, 231.979, 247.077, 262.095, 277.033, 291.893, 306.675, 321.381, 336.012, 350.569, 365.054, 379.467, 393.809}; + + QVector watch_y = {25.0084, 31.0752, 37.0466, 42.9244, 48.7102, 54.4057, 60.0123, 65.5316, 70.965, 76.3141, 81.5801, 86.7644, 91.8684, 96.8932, 101.84, 106.711, 111.506, 116.226, 120.874, 125.45, 129.954, 134.389}; + + QVector fitting_para; + CBgWork::GetFileFittingPara(watch_x, watch_y, fitting_para); + + + printf(" ## test_bate"); +// bool bRet = false; +// BgFileI inputFile; +// CBgWork bgwork; +// bool bFileAnlyseError = false; +// QString sampleFile = "E:\\AWork\\QINGH\\betaReAnalyse\\AUX09_009-20231107_0333_S_FULL_40192.4.PHD"; +// printf(sampleFile.toStdString().c_str()); +// // **************** printf("\n"); +// QString gasFile = "E:\\AWork\\QINGH\\betaReAnalyse\\AUX09_009-20231106_1533_G_FULL_40188.3.PHD"; +// printf(gasFile.toStdString().c_str()); +// // **************** printf("\n"); +// QString detbgrFile = "E:\\AWork\\QINGH\\betaReAnalyse\\AUX09_009-20220325_0409_D_FULL_259518.PHD"; +// printf(detbgrFile.toStdString().c_str()); +// // **************** printf("\n"); +// BgAllGenerate allData; +// if (!inputFile.Detbgr.AnalysePHD_File(detbgrFile)) +// { +// printf("In BgAnalyse,detbgrFile get failed:"); +// printf(detbgrFile.toStdString().c_str()); +// printf("\n"); +// } +// else if (!inputFile.gas.AnalysePHD_File(gasFile)) +// { +// printf("In BgAnalyse,gasFile get failed:"); +// printf(gasFile.toStdString().c_str()); +// printf("\n"); +// } +// else if (!inputFile.sample.AnalysePHD_File(sampleFile)) +// { +// printf("In BgAnalyse,sampleFile get failed:"); +// printf(sampleFile.toStdString().c_str()); +// printf("\n"); +// } +// else +// { +// bgwork.SetBgFile(inputFile); + +// BgCalibratePara bgpara; +// bgpara.b_e_cal;// = CplusToJava::jobjectArray2QVectorD(env, CplusToJava::GetjobjectArray(env, structClass, para, "b_e_cal")); +// bgpara.g_e_cal = { -9.825890591564047,1.1141181619726583,-0.0011411816197261363 };// = CplusToJava::jobjectArray2QVectorD(env, CplusToJava::GetjobjectArray(env, structClass, para, "g_e_cal")); + +// bgpara.b_e_cal_flag = 2;// env->GetIntField(para, fieldid); +// bgpara.g_e_cal_flag = 2;// env->GetIntField(para, fieldid); + +// bgpara.bApplyNewCalicSample = true;// env->GetIntField(para, fieldid); // 界面交互新刻度应用 +// bgpara.bApplyNewCalicDetBg = false;// env->GetIntField(para, fieldid); +// bgpara.bApplyNewCalicGasBg = false; //env->GetIntField(para, fieldid); +// bgpara.bApplyNewCalicQc = false; //env->GetIntField(para, fieldid); + +// bRet = bgwork.MutialAnalyse(bgpara); + +// allData = bgwork.GetAllValue(); +// } + +// QString qfilename = "C:/TempData/DEP33_004-20231109_1002_S.PHD"; +// //文件解析 +// RadionuclideMessage message; +// bool readflag = message.AnalysePHD_File(qfilename); + +// if (!readflag) +// { +// printf("THE PHDfile get failed:"); +// printf(qfilename.toStdString().c_str()); +// printf("\n"); +// } + +// QString order = ORDER_G_SPECTRUM; +// QVariant variant = message.GetBlockData(order); +// if (!variant.isValid()) +// { +// printf((order.toStdString() + " get failed\n").c_str()); +// } +// else +// { +// RadionuclideData::G_SpectrumBlock g_spectrum = variant.value(); +//// allSize["g_counts"] = g_spectrum.counts.size(); +// for(int i = 0; i < g_spectrum.counts.size(); i++) +// { +// printf("%ld\n", g_spectrum.counts[i]); +// } +// } +// +// //各数据块存在标识 +// bool headerflag = true; +// bool commentflag = true; +// bool sampleflag = true; +// bool certificateflag = true; +// bool acquisitionflag = true; +// bool collectionflag = true; +// bool processflag = true; +// bool calibrationflag = true; +// bool g_energyflag = true; +// bool b_energyflag = true; +// bool g_Resolutionflag = true; +// bool b_Resolutionflag = true; +// bool g_Efficiencyflag = true; +// bool roi_limitsflag = true; +// bool b_gEfficiencyflag = true; +// bool ratiosflag = true; +// bool g_Spectrumflag = true; +// bool b_Spectrumflag = true; +// bool Histogramflag = true; +// bool totalflag = true; +// +// //header内容获取 +// RadionuclideData::HeaderBlock headerBlock; +// QString order = ORDER_HEADER; +// QVariant variant = message.GetBlockData(order); +// if (!variant.isValid()) +// { +// printf((order.toStdString() + " get failed\n").c_str()); +// headerflag = false; +// } +// +// //comment内容获取 +// order = ORDER_COMMENT; +// variant = message.GetBlockData(order); +// if (!variant.isValid()) +// { +// printf((order.toStdString() + " get failed\n").c_str()); +// commentflag = false; +// } +// +// //sample内容获取 +// RadionuclideData::SampleBlock sampleBlock; +// order = ORDER_SAMPLE; +// variant = message.GetBlockData(order); +// if (!variant.isValid()) +// { +// printf((order.toStdString() + " get failed\n").c_str()); +// sampleflag = false; +// } +// +// //acquisition内容获取 +// RadionuclideData::AcquisitionBlock acquisitionBlock; +// order = ORDER_ACQUISITION; +// variant = message.GetBlockData(order); +// if (!variant.isValid()) +// { +// printf((order.toStdString() + " get failed\n").c_str()); +// acquisitionflag = false; +// } +// +// //collection内容获取 +// RadionuclideData::CollectionBlock collectionBlock; +// order = ORDER_COLLECTION; +// variant = message.GetBlockData(order); +// if (!variant.isValid()) +// { +// printf((order.toStdString() + " get failed\n").c_str()); +// collectionflag = false; +// } +// +// //process内容获取 +// RadionuclideData::ProcessingBlock process; +// order = ORDER_PROCESSING; +// variant = message.GetBlockData(order); +// if (!variant.isValid()) +// { +// printf((order.toStdString() + " get failed\n").c_str()); +// processflag = false; +// } +// +// +// //calibration内容获取 +// RadionuclideData::CalibrationBlock calibrationBlock; +// order = ORDER_CALIBRATION; +// variant = message.GetBlockData(order); +// if (!variant.isValid()) +// { +// printf((order.toStdString() + " get failed\n").c_str()); +// calibrationflag = false; +// } +// +// //g_energy内容获取 +// order = ORDER_G_ENERGY; +// variant = message.GetBlockData(order); +// if (!variant.isValid()) +// { +// printf((order.toStdString() + " get failed\n").c_str()); +// g_energyflag = false; +// } +// +// +// //b_energy内容获取 +// order = ORDER_B_ENERGY; +// variant = message.GetBlockData(order); +// if (!variant.isValid()) +// { +// printf((order.toStdString() + " get failed\n").c_str()); +// b_energyflag = false; +// } +// +// +// //g_Resolution内容获取 +// order = ORDER_G_RESOLUTION; +// variant = message.GetBlockData(order); +// if (!variant.isValid()) +// { +// printf((order.toStdString() + " get failed\n").c_str()); +// g_Resolutionflag = false; +// } +// +// +// //b_Resolution内容获取 +// order = ORDER_B_RESOLUTION; +// variant = message.GetBlockData(order); +// if (!variant.isValid()) +// { +// printf((order.toStdString() + " get failed\n").c_str()); +// b_Resolutionflag = false; +// } +// +// +// //g_Efficiency内容获取 +// order = ORDER_G_EFFICIENCY; +// variant = message.GetBlockData(order); +// if (!variant.isValid()) +// { +// printf((order.toStdString() + " get failed\n").c_str()); +// g_Efficiencyflag = false; +// } +// +// +// //roi_limits内容获取 +// order = ORDER_ROI_LIMITS; +// variant = message.GetBlockData(order); +// if (!variant.isValid()) +// { +// printf((order.toStdString() + " get failed\n").c_str()); +// roi_limitsflag = false; +// } +// +// //b-gEfficiency内容获取 +// order = ORDER_B_GEFFICIENCY; +// variant = message.GetBlockData(order); +// if (!variant.isValid()) +// { +// printf((order.toStdString() + " get failed\n").c_str()); +// b_gEfficiencyflag = false; +// } +// +// //ratios内容获取 +// order = ORDER_RATIOS; +// variant = message.GetBlockData(order); +// if (!variant.isValid()) +// { +// printf((order.toStdString() + " get failed\n").c_str()); +// ratiosflag = false; +// } +// +// //g_Spectrum内容获取 +// order = ORDER_G_SPECTRUM; +// variant = message.GetBlockData(order); +// if (!variant.isValid()) +// { +// printf((order.toStdString() + " get failed\n").c_str()); +// g_Spectrumflag = true; +// } +// +// //b_Spectrum内容获取 +// order = ORDER_B_SPECTRUM; +// variant = message.GetBlockData(order); +// if (!variant.isValid()) +// { +// printf((order.toStdString() + " get failed\n").c_str()); +// b_Spectrumflag = false; +// } +// +// //Histogram内容获取 +// order = ORDER_HISTOGRAM; +// variant = message.GetBlockData(order); +// if (!variant.isValid()) +// { +// printf((order.toStdString() + " get failed\n").c_str()); +// Histogramflag = true; +// } +// +// //Certificate内容获取 +// RadionuclideData::CertificateBlock certificateBlock; +// order = ORDER_CERTIFICATE; +// variant = message.GetBlockData(order); +// if (!variant.isValid()) +// { +// printf((order.toStdString() + " get failed\n").c_str()); +// certificateflag = false; +// } +// +// //TotalEff block内容获取 +// order = ORDER_TOTALEFF; +// variant = message.GetBlockData(order); +// if (!variant.isValid()) +// { +// printf((order.toStdString() + " get failed\n").c_str()); +// totalflag = false; +// } + +} + +/* +JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_BetaGammaSpectrumAnalyzeFunc(JNIEnv* env, jclass, jobject jspectrum_group) +{ + // 获取Java中的Struct对象 + jclass structClass = env->GetObjectClass(jspectrum_group); + + QString SampleSpectrumFile = CplusToJava::getStructString(env, structClass, jspectrum_group, "SampleSpectrumFile"); + QString GasBgSpectrumFile = CplusToJava::getStructString(env, structClass, jspectrum_group, "GasBgSpectrumFile"); + QString DetBgSpectrumFile = CplusToJava::getStructString(env, structClass, jspectrum_group, "DetBgSpectrumFile"); + QVector b_c2e = CplusToJava::jobjectArray2QVectorD(env, CplusToJava::GetjobjectArray(env, structClass, jspectrum_group, "b_c2e")); + QVector g_c2e = CplusToJava::jobjectArray2QVectorD(env, CplusToJava::GetjobjectArray(env, structClass, jspectrum_group, "g_c2e")); + + // 获取成员变量BgCalPara的值//?待修改 + jfieldID nextfieldID = env->GetFieldID(structClass, "BgCalPara", "Lorg/jeecg/modules/entity/vo/SpectrumGroup;"); + jobject nextObject = env->GetObjectField(jspectrum_group, nextfieldID); + jclass nextclass = env->GetObjectClass(nextObject); + + // 获取成员变量b_e_cal_flag的值 + jfieldID fieldID = env->GetFieldID(nextclass, "b_e_cal_flag", SIG_INT); + jint b_e_cal_flag = env->GetIntField(nextObject, fieldID); + + // 获取成员变量g_e_cal_flag的值 + fieldID = env->GetFieldID(nextclass, "g_e_cal_flag", SIG_INT); + jint g_e_cal_flag = env->GetIntField(nextObject, fieldID); + + // 获取成员变量bApplyNewCalicSample的值 + fieldID = env->GetFieldID(nextclass, "bApplyNewCalicSample", SIG_BOOL); + bool bApplyNewCalicSample = env->GetBooleanField(nextObject, fieldID); + + // 获取成员变量bApplyNewCalicDetBg的值 + fieldID = env->GetFieldID(nextclass, "bApplyNewCalicDetBg", SIG_BOOL); + bool bApplyNewCalicDetBg = env->GetBooleanField(nextObject, fieldID); + + // 获取成员变量bApplyNewCalicGasBg的值 + fieldID = env->GetFieldID(nextclass, "bApplyNewCalicGasBg", SIG_BOOL); + bool bApplyNewCalicGasBg = env->GetBooleanField(nextObject, fieldID); + + // 获取成员变量bApplyNewCalicQc的值 + fieldID = env->GetFieldID(nextclass, "bApplyNewCalicQc", SIG_BOOL); + bool bApplyNewCalicQc = env->GetBooleanField(nextObject, fieldID); + + QVector b_e_cal = CplusToJava::jobjectArray2QVectorD(env, CplusToJava::GetjobjectArray(env, nextclass, nextObject, "b_e_cal")); + QVector g_e_cal = CplusToJava::jobjectArray2QVectorD(env, CplusToJava::GetjobjectArray(env, nextclass, nextObject, "g_e_cal")); + + BetaGammaAnalyze::SpectrumGroup spectrum_group; + + spectrum_group.SampleSpectrumFile = SampleSpectrumFile; + spectrum_group.GasBgSpectrumFile = GasBgSpectrumFile; + spectrum_group.DetBgSpectrumFile = DetBgSpectrumFile; + spectrum_group.b_c2e = b_c2e; + spectrum_group.g_c2e = g_c2e; + spectrum_group.BgCalPara.b_e_cal = b_e_cal; + spectrum_group.BgCalPara.g_e_cal = g_e_cal; + spectrum_group.BgCalPara.b_e_cal_flag = b_e_cal_flag; + spectrum_group.BgCalPara.g_e_cal_flag = g_e_cal_flag; + spectrum_group.BgCalPara.bApplyNewCalicSample = bApplyNewCalicSample; + spectrum_group.BgCalPara.bApplyNewCalicDetBg = bApplyNewCalicDetBg; + spectrum_group.BgCalPara.bApplyNewCalicGasBg = bApplyNewCalicGasBg; + spectrum_group.BgCalPara.bApplyNewCalicQc = bApplyNewCalicQc; + + BetaGammaAnalyze::BetaGammaSpectrumAnalyze::BetaGammaSpectrumAnalyzeFunc(spectrum_group); + + //获取Java中的BgAnalyseResultStruct类 + jclass BgAnalyseResultStruct = env->FindClass("Lorg/jeecg/modules/native_jni/struct/BgAnalyseResult;"); + + // 创建Java中的BgAnalyseResultStruct对象 + jmethodID methodID = env->GetMethodID(BgAnalyseResultStruct, "", "()V"); + jobject result = env->NewObject(BgAnalyseResultStruct, methodID); + + return result; +} +*/ diff --git a/org_jeecg_modules_native_jni_EnergySpectrumHandler.h b/org_jeecg_modules_native_jni_EnergySpectrumHandler.h new file mode 100644 index 0000000..ca0d863 --- /dev/null +++ b/org_jeecg_modules_native_jni_EnergySpectrumHandler.h @@ -0,0 +1,116 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class org_jeecg_modules_native_jni_EnergySpectrumHandler */ + +#ifndef _Included_org_jeecg_modules_native_jni_EnergySpectrumHandler +#define _Included_org_jeecg_modules_native_jni_EnergySpectrumHandler + + + +#ifdef __cplusplus +extern "C" { +#endif + /* + * Class: org_jeecg_modules_native_jni_EnergySpectrumHandler + * Method: getSourceData + * Signature: (Ljava/lang/String;)Lorg/jeecg/modules/native_jni/struct/EnergySpectrumStruct; + */ + //解析文件 + JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_getSourceData + (JNIEnv*, jclass, jstring); + /* + * Class: org_jeecg_modules_native_jni_EnergySpectrumHandler + * Method: CalcBgBoundary + * Signature: (Lorg/jeecg/modules/native_jni/struct/CalcBgBoundaryParam;)Lorg/jeecg/modules/native_jni/struct/BgBoundary; + */ + JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_CalcBgBoundary + (JNIEnv*, jclass, jobject); + + /* + * Class: org_jeecg_modules_native_jni_EnergySpectrumHandler + * Method: GetFileFittingPara + * Signature: (Ljava/util/List;Ljava/util/List;)Ljava/util/List; + */ + JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_GetFileFittingPara + (JNIEnv*, jclass, jobject, jobject); + + /* + * Class: org_jeecg_modules_native_jni_EnergySpectrumHandler + * Method: GetFileFittingData + * Signature: (Ljava/util/List;Ljava/util/List;)Ljava/util/List; + */ + JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_GetFileFittingData + (JNIEnv*, jclass, jobject, jobject); + + /* + * Class: org_jeecg_modules_native_jni_EnergySpectrumHandler + * Method: bgAnalyse + * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Lorg/jeecg/modules/native_jni/struct/BgAnalyseResult; + */ + JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_bgAnalyse + (JNIEnv*, jclass, jstring sample, jstring gas, jstring detbgr); + + /* + * Class: org_jeecg_modules_native_jni_EnergySpectrumHandler + * Method: bgReAnalyse + * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lorg/jeecg/modules/entity/vo/BgCalibratePara;)Lorg/jeecg/modules/native_jni/struct/BgAnalyseResult; + */ + JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_bgReAnalyse + (JNIEnv *, jclass, jstring, jstring, jstring, jobject); + + /* + * Class: org_jeecg_modules_native_jni_EnergySpectrumHandler + * Method: getAlertSourceData + * Signature: (Ljava/lang/String;)Lorg/jeecg/modules/native_jni/struct/AlertSpectrumStruct; + */ + JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_getAlertSourceData + (JNIEnv*, jclass, jstring); + + /* + * Class: org_jeecg_modules_native_jni_EnergySpectrumHandler + * Method: getMetSourceData + * Signature: (Ljava/lang/String;)Ljava/util/List; + */ + JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_getMetSourceData + (JNIEnv*, jclass, jstring); + + /* + * Class: org_jeecg_modules_native_jni_EnergySpectrumHandler + * Method: getSOHSourceData + * Signature: (Ljava/lang/String;)Lorg/jeecg/modules/native_jni/struct/SOHSpectrumStruct; + */ + JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_getSOHSourceData + (JNIEnv*, jclass, jstring); + + /* + * Class: org_jeecg_modules_native_jni_EnergySpectrumHandler + * Method: GetFittingPara + * Signature: (Ljava/util/List;Ljava/util/List;Ljava/lang/String;)Ljava/util/List; + */ + JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_GetFittingPara + (JNIEnv *, jclass, jobject, jobject, jstring); + + /* + * Class: org_jeecg_modules_native_jni_EnergySpectrumHandler + * Method: GetFittingData + * Signature: (Ljava/util/List;Ljava/lang/String;Ljava/util/List;)Ljava/util/List; + */ + JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_GetFittingData + (JNIEnv *, jclass, jobject, jstring, jobject); + + JNIEXPORT void JNICALL test_bate(); + /* + * Class: org_jeecg_modules_native_jni_EnergySpectrumHandler + * Method: BetaGammaSpectrumAnalyzeFunc + * Signature: (Lorg/jeecg/modules/entity/vo/SpectrumGroup;)Lorg/jeecg/modules/native_jni/struct/BgAnalyseResult; + *//* + JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_BetaGammaSpectrumAnalyzeFunc + (JNIEnv*, jclass, jobject);*/ + +#ifdef __cplusplus +} + + + +#endif +#endif