commit 2434b2a176f6b11aff0adda11ac9c7fe544ff061 Author: wanglong <1553009806@qq.com> Date: Tue Jun 4 15:27:02 2024 +0800 Initial commit on main branch 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