diff --git a/CplusToJava.cpp b/CplusToJava.cpp index 1932fd3..ae344c5 100644 --- a/CplusToJava.cpp +++ b/CplusToJava.cpp @@ -101,6 +101,25 @@ jobject CplusToJava::Createjobject(JNIEnv* env, jint esize, jobjectArray array) return arrayList; } +jobject CplusToJava::Create2Djobject(JNIEnv *env, jint esize, jobjectArray array, jint row, jint col) +{ + jclass byteArrayClass = env->FindClass("[J"); + jobjectArray result = env->NewObjectArray(row, byteArrayClass, NULL); + for (int r = 0; r < row; r++) { + jlongArray innerArray = env->NewLongArray(col); + jlong longArray[col]; + for (int c = 0; c < col; c++) { + jint pos = r * col + c; + jobject element = env->GetObjectArrayElement(array, pos); + jlong v = env->CallLongMethod(element, env->GetMethodID(env->FindClass("java/lang/Long"), "longValue", "()J")); + longArray[c] = v; + } + env->SetLongArrayRegion(innerArray, 0, col, longArray); + env->SetObjectArrayElement(result, r, innerArray); + } + return result; +} + jobjectArray CplusToJava::jobject2jobjectArray(JNIEnv* env, jobject array) { jclass listClass = env->FindClass("java/util/List"); diff --git a/CplusToJava.h b/CplusToJava.h index d9c2af5..58adb2e 100644 --- a/CplusToJava.h +++ b/CplusToJava.h @@ -4,13 +4,14 @@ #include //变量名与java中sig对应 -#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" +#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" +#define SIG_LONG_ARRAY "[[J" enum BindType { BIND_NONE, BIND_STRING, BIND_CHAR, BIND_DOUBLE, BIND_INT }; @@ -370,6 +371,8 @@ public: static jobjectArray QVectorS2jobjectArray(QVector vec, JNIEnv* env); //生成jobject static jobject Createjobject(JNIEnv* env, jint esize, jobjectArray array); + //生成2djobject + static jobject Create2Djobject(JNIEnv* env, jint esize, jobjectArray array, jint row, jint col); //jobject转换为jobjectArray static jobjectArray jobject2jobjectArray(JNIEnv* env, jobject array); //将jobjectArray转换为QVector diff --git a/DataManager_Define.h b/DataManager_Define.h index 19bffe3..5843833 100644 --- a/DataManager_Define.h +++ b/DataManager_Define.h @@ -35,6 +35,8 @@ #define ORDER_CALIBRATION QLatin1String("#Calibration") #define ORDER_CERTIFICATE QLatin1String("#Certificate") #define ORDER_GPS QLatin1String("#GPS") +#define ORDER_BSELF QLatin1String("#b_self_Attenuation") +#define ORDER_NB_GEFFICIENCY QLatin1String("#b_Efficiency") #define ORDER_STOP QLatin1String("STOP") #define ORDER_BEGIN QLatin1String("BEGIN") #define DATATYPE_QCPHD QLatin1String("QCPHD") @@ -506,6 +508,36 @@ namespace RadionuclideData double lat; // 绾害 } GpsBlock, *PtGpsBlock; + + typedef struct _N_BG_Efficiency_Block_ + { + /* b-gEfficiency Block */ + QVector nuclide_name; // nuclide name + QVector bg_efficiency; // 尾-纬 coincidence efficiency (counts in ROI/尾-纬 pair emitted) + QVector uncertainty; // uncertainty (counts in ROI/尾-纬 pair emitted) + int record_count; + } + NBG_EfficiencyBlock, *PtNBG_EfficiencyBlock; + + typedef struct _b_self_Attenuation_block_ + { + /* b_self_Attenuation Block */ + QVector devNames; + QVector> xenon; + QVector> nitrogen; + } + BSelfAttenuationBlock, *PtBSelfAttenuationBlock; + typedef struct _n_g_Efficiency_Block_ + { + /* g_Efficiency Block */ + QVector dev_name; + QVector g_energy; // 纬 -energy (keV) + QVector efficiency; // efficiency (counts in peak/photon emitted) + QVector uncertainty; // uncertainty (counts in peak/photon emitted) + int record_count; + } + n_G_EfficiencyBlock, *Pt_n_G_EfficiencyBlock; + } Q_DECLARE_METATYPE(RadionuclideData::HeaderBlock) Q_DECLARE_METATYPE(RadionuclideData::AcquisitionBlock) @@ -526,6 +558,9 @@ Q_DECLARE_METATYPE(RadionuclideData::G_SpectrumBlock) Q_DECLARE_METATYPE(RadionuclideData::B_SpectrumBlock) Q_DECLARE_METATYPE(RadionuclideData::HistogramBlock) Q_DECLARE_METATYPE(RadionuclideData::CertificateBlock) +Q_DECLARE_METATYPE(RadionuclideData::NBG_EfficiencyBlock) +Q_DECLARE_METATYPE(RadionuclideData::BSelfAttenuationBlock) +Q_DECLARE_METATYPE(RadionuclideData::n_G_EfficiencyBlock) Q_DECLARE_METATYPE(RadionuclideData::GpsBlock) namespace MetData diff --git a/RadionuclideMessage.cpp b/RadionuclideMessage.cpp index 8575074..285d096 100644 --- a/RadionuclideMessage.cpp +++ b/RadionuclideMessage.cpp @@ -2,6 +2,7 @@ #include #include #include +#include #define SECOND 1 #define HOUR 3600 @@ -116,6 +117,8 @@ void RadionuclideMessage::InitBlockFlagInfo() block_flag.append(QLatin1String("BEGIN")); // [ BEGIN ] block_flag.append(QLatin1String("#Spectrum")); // [ 22 ] block_flag.append(QLatin1String("#GPS")); // [ 23 ] + block_flag.append(QLatin1String("#b_self_Attenuation")); // [ 24 ] + block_flag.append(QLatin1String("#b_Efficiency")); // [ 25 ] } bool RadionuclideMessage::AnalyseMessgeBody(QTextStream &content) @@ -225,6 +228,14 @@ bool RadionuclideMessage::AnalyseMessgeBody(QTextStream &content) { bRet &= Analyse_Gps_Block(content, line); } + else if ( 0==line.compare(block_flag.at(24)) && bRet) + { + bRet &= Analyse_b_self_Attenuation_Block(content, line); + } + else if ( 0==line.compare(block_flag.at(25)) && bRet) + { + bRet &= Analyse_b_Efficiency_Block(content, line); + } else { // 鏁版嵁閿欒锛屾暟鎹湁鏁 bIsValid = false; @@ -261,6 +272,7 @@ bool RadionuclideMessage::Analyse_Header_Block(QTextStream& content, QString& ne content >> Header.sample_ref_id; content.readLine(); + m_system_type = Header.system_type; const MessageInfo& msg = AbstractSpectrumDataMessage::GetMessageInfo(); if ( msg.verify_srid ) { @@ -513,6 +525,36 @@ bool RadionuclideMessage::Analyse_b_Resolution_Block(QTextStream& content, QStri bool RadionuclideMessage::Analyse_g_Efficiency_Block(QTextStream& content, QString& nextBlock) { + if(m_system_type == 'C') + { + n_G_EfficiencyBlock g_eff; + 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; + QString name; + QTextStream line_content(&nextBlock); + line_content >> name >> g_energy >> efficiency >> uncertainty; + g_eff.dev_name.push_back(name); + g_eff.g_energy << g_energy; + g_eff.efficiency << efficiency; + g_eff.uncertainty << uncertainty; + + ++ row_count; + nextBlock = content.readLine(); + temp_line = nextBlock.simplified(); + if (line_content.status()==QTextStream::ReadCorruptData) + { + return false; + } + } + g_eff.record_count = row_count; + radionuclide_msg_data.insert(block_flag.at(10), QVariant::fromValue(g_eff)); + + return (content.status()==QTextStream::Ok)?true:false; + } G_EfficiencyBlock g_Efficiency; int row_count = 0; nextBlock = content.readLine(); @@ -956,6 +998,74 @@ bool RadionuclideMessage::Analyse_Gps_Block(QTextStream &content, QString &nextB content.readLine(); return (content.status()==QTextStream::Ok)?true:false; } + +bool RadionuclideMessage::Analyse_b_self_Attenuation_Block(QTextStream &content, QString &nextBlock) +{ + BSelfAttenuationBlock bsel; + + QString buffer; + + buffer = content.readLine(); + while(buffer.at(0) != '#') + { + std::stringstream ss(buffer.toStdString()); + std::string name; + std::array data1, data2; + ss >> name; + for(int i = 0; i < 3; i++) + { + ss >> data1[i]; + } + + for(int i = 0; i < 3; i++) + { + ss >> data2[i]; + } + bsel.devNames.push_back(QString::fromStdString(name)); + bsel.xenon.push_back(data1); + bsel.nitrogen.push_back(data2); + + buffer = content.readLine(); + }; + + radionuclide_msg_data.insert(block_flag.at(24), QVariant::fromValue(bsel)); + + nextBlock = buffer; +// content.readLine(); + return (content.status()==QTextStream::Ok)?true:false; +} + +bool RadionuclideMessage::Analyse_b_Efficiency_Block(QTextStream &content, QString &nextBlock) +{ + NBG_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; + double bg_efficiency, uncertainty; + QTextStream line_content(&nextBlock); + line_content >> nuclide_name >> bg_efficiency >> uncertainty; + + bg_Efficiency.nuclide_name << nuclide_name; + 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(25), QVariant::fromValue(bg_Efficiency)); + return (content.status()==QTextStream::Ok)?true:false; +} + bool RadionuclideMessage::Verity_SampleReferenceId(QString srid) { bool bRet = true; diff --git a/RadionuclideMessage.h b/RadionuclideMessage.h index f189202..0f7f34d 100644 --- a/RadionuclideMessage.h +++ b/RadionuclideMessage.h @@ -46,6 +46,8 @@ private: bool Analyse_Calibration_Block(QTextStream& content, QString& nextBlock); bool Analyse_Certificate_Block(QTextStream& content, QString& nextBlock); bool Analyse_Gps_Block(QTextStream& content, QString& nextBlock); + bool Analyse_b_self_Attenuation_Block(QTextStream& content, QString& nextBlock); + bool Analyse_b_Efficiency_Block(QTextStream& content, QString& nextBlock); bool Verity_SampleReferenceId(QString srid); private: @@ -53,6 +55,7 @@ private: QStringList block_flag; QVariantMap radionuclide_msg_data; // 鍥犺В鏋愮殑鏁版嵁鐨勭粨鏋勪笉鍚岋紝璇峰叾缁熶竴瀛樺偍鑷砆VariantMap瀹瑰櫒涓 RadionuclideData::AnalyseDataType analyse_data_type; + QString m_system_type = ""; }; #endif // RADIONUCLIDEMESSAGE_H diff --git a/ReadPHDFile.pro.user b/ReadPHDFile.pro.user index 8eabdd3..ab01799 100644 --- a/ReadPHDFile.pro.user +++ b/ReadPHDFile.pro.user @@ -1,6 +1,6 @@ - + EnvironmentId diff --git a/org_jeecg_modules_native_jni_EnergySpectrumHandler.cpp b/org_jeecg_modules_native_jni_EnergySpectrumHandler.cpp index 23207e9..c509ee6 100644 --- a/org_jeecg_modules_native_jni_EnergySpectrumHandler.cpp +++ b/org_jeecg_modules_native_jni_EnergySpectrumHandler.cpp @@ -8,6 +8,10 @@ #include "AlertMessage.h" #include "MeteorologicalMessage.h" #include "StateOfHealthMessage.h" +#include +#include +#include +#include JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_getSourceData(JNIEnv* env, jclass obj, jstring PHDfile) { @@ -28,7 +32,7 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl if (!readflag) { // **************** printf("THE PHDfile get failed:"); - printf(qfilename.toStdString().c_str()); +// printf(qfilename.toStdString().c_str()); // **************** printf("\n"); } @@ -71,12 +75,12 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl variant = message.GetBlockData(order); if (!variant.isValid()) { - printf((order.toStdString() + " get failed\n").c_str()); +// printf((order.toStdString() + " get failed\n").c_str()); headerflag = false; } else { - headerBlock = variant.value(); + 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()); @@ -96,7 +100,7 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl variant = message.GetBlockData(order); if (!variant.isValid()) { - printf((order.toStdString() + " get failed\n").c_str()); +// printf((order.toStdString() + " get failed\n").c_str()); commentflag = false; } else @@ -121,7 +125,7 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl variant = message.GetBlockData(order); if (!variant.isValid()) { - printf((order.toStdString() + " get failed\n").c_str()); +// printf((order.toStdString() + " get failed\n").c_str()); sampleflag = false; } else @@ -137,7 +141,7 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl variant = message.GetBlockData(order); if (!variant.isValid()) { - printf((order.toStdString() + " get failed\n").c_str()); +// printf((order.toStdString() + " get failed\n").c_str()); acquisitionflag = false; } else @@ -155,7 +159,7 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl variant = message.GetBlockData(order); if (!variant.isValid()) { - printf((order.toStdString() + " get failed\n").c_str()); +// printf((order.toStdString() + " get failed\n").c_str()); collectionflag = false; } else @@ -174,7 +178,7 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl variant = message.GetBlockData(order); if (!variant.isValid()) { - printf((order.toStdString() + " get failed\n").c_str()); +// printf((order.toStdString() + " get failed\n").c_str()); processflag = false; } else @@ -193,7 +197,7 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl variant = message.GetBlockData(order); if (!variant.isValid()) { - printf((order.toStdString() + " get failed\n").c_str()); +// printf((order.toStdString() + " get failed\n").c_str()); calibrationflag = false; } else @@ -208,11 +212,11 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl variant = message.GetBlockData(order); if (!variant.isValid()) { - printf((order.toStdString() + " get failed\n").c_str()); +// 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); @@ -228,7 +232,7 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl variant = message.GetBlockData(order); if (!variant.isValid()) { - printf((order.toStdString() + " get failed\n").c_str()); +// printf((order.toStdString() + " get failed\n").c_str()); b_energyflag = false; } else @@ -250,7 +254,7 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl variant = message.GetBlockData(order); if (!variant.isValid()) { - printf((order.toStdString() + " get failed\n").c_str()); +// printf((order.toStdString() + " get failed\n").c_str()); g_Resolutionflag = false; } else @@ -270,7 +274,7 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl variant = message.GetBlockData(order); if (!variant.isValid()) { - printf((order.toStdString() + " get failed\n").c_str()); +// printf((order.toStdString() + " get failed\n").c_str()); b_Resolutionflag = false; } else @@ -290,7 +294,7 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl variant = message.GetBlockData(order); if (!variant.isValid()) { - printf((order.toStdString() + " get failed\n").c_str()); +// printf((order.toStdString() + " get failed\n").c_str()); g_Efficiencyflag = false; } else @@ -310,7 +314,7 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl variant = message.GetBlockData(order); if (!variant.isValid()) { - printf((order.toStdString() + " get failed\n").c_str()); +// printf((order.toStdString() + " get failed\n").c_str()); roi_limitsflag = false; } else @@ -334,7 +338,7 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl variant = message.GetBlockData(order); if (!variant.isValid()) { - printf((order.toStdString() + " get failed\n").c_str()); +// printf((order.toStdString() + " get failed\n").c_str()); b_gEfficiencyflag = false; } else @@ -364,7 +368,7 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl variant = message.GetBlockData(order); if (!variant.isValid()) { - printf((order.toStdString() + " get failed\n").c_str()); +// printf((order.toStdString() + " get failed\n").c_str()); ratiosflag = false; } else @@ -388,7 +392,7 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl variant = message.GetBlockData(order); if (!variant.isValid()) { - printf((order.toStdString() + " get failed\n").c_str()); +// printf((order.toStdString() + " get failed\n").c_str()); g_Spectrumflag = true; } else @@ -406,7 +410,7 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl variant = message.GetBlockData(order); if (!variant.isValid()) { - printf((order.toStdString() + " get failed\n").c_str()); +// printf((order.toStdString() + " get failed\n").c_str()); b_Spectrumflag = false; } else @@ -419,24 +423,24 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl 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); - } +// //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; @@ -444,7 +448,7 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl variant = message.GetBlockData(order); if (!variant.isValid()) { - printf((order.toStdString() + " get failed\n").c_str()); +// printf((order.toStdString() + " get failed\n").c_str()); certificateflag = false; } else @@ -482,7 +486,7 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl variant = message.GetBlockData(order); if (!variant.isValid()) { - printf((order.toStdString() + " get failed\n").c_str()); +// printf((order.toStdString() + " get failed\n").c_str()); totalflag = false; } else @@ -510,7 +514,7 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl variant = message.GetBlockData(order); if (!variant.isValid()) { - printf((order.toStdString() + " get failed\n").c_str()); +// printf((order.toStdString() + " get failed\n").c_str()); gpsflag = false; } else @@ -526,7 +530,7 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl || (!totalflag)) { // **************** printf("THE PHDFile has some blocks can't be read:"); - printf(qfilename.toStdString().c_str()); +// printf(qfilename.toStdString().c_str()); // **************** printf("\n"); } @@ -537,6 +541,7 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl jmethodID constructorID = env->GetMethodID(energySpectrumStructClass, "", "()V"); jobject result = env->NewObject(energySpectrumStructClass, constructorID); + jobject fieldJobject; jfieldID fieldID; if (headerflag) { @@ -694,8 +699,6 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl fieldID = env->GetFieldID(energySpectrumStructClass, "time_calibration", SIG_STRING); env->SetObjectField(result, fieldID, cresult.time_calibration); } - - jobject fieldJobject; if (g_energyflag) { @@ -943,6 +946,1078 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl 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); + +// //璁剧疆鎴愬憳鍙橀噺h_counts_arr鐨勫 +// fieldID = env->GetFieldID(energySpectrumStructClass, "h_count_arr", SIG_LONG_ARRAY); +// fieldJobject = CplusToJava::Create2Djobject(env, allSize["g_counts"], cresult.h_counts,cresult.g_channels, cresult.b_channels); +// 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); + } + + if(gpsflag) + { + //璁剧疆鎴愬憳鍙橀噺缁忓害鍜岀含搴︾殑鍊 + fieldID = env->GetFieldID(energySpectrumStructClass, "lon", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, cresult.lon); + + fieldID = env->GetFieldID(energySpectrumStructClass, "lat", SIG_DOUBLE); + env->SetDoubleField(result, fieldID, cresult.lat); + } + + return result; +} + +JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_getSourceDataNotHis(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; + bool gpsflag = 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锛坖ava瀛樺簱鎵闇锛 + 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杞琎String,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; + } + + //GPS block鍐呭鑾峰彇 + order = ORDER_GPS; + variant = message.GetBlockData(order); + if (!variant.isValid()) + { +// printf((order.toStdString() + " get failed\n").c_str()); + gpsflag = false; + } + else + { + RadionuclideData::GpsBlock gps = variant.value(); + cresult.lat = gps.lat; + cresult.lon = gps.lon; + } + + 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); + + jobject fieldJobject; + 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); + } + + + + 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); + } + printf("aaaaaaaaaaaa %d\n", Histogramflag ? 1 : 2); if (Histogramflag) { //璁剧疆鎴愬憳鍙橀噺b_channels鐨勫 @@ -962,8 +2037,11 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl 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); +// fieldID = env->GetFieldID(energySpectrumStructClass, "h_counts", SIG_LIST); +// fieldJobject = CplusToJava::Createjobject(env, allSize["h_counts"], cresult.h_counts); +// env->SetObjectField(result, fieldID, fieldJobject); + fieldID = env->GetFieldID(energySpectrumStructClass, "h_count_arr", SIG_LONG_ARRAY); + fieldJobject = CplusToJava::Create2Djobject(env, allSize["g_counts"], cresult.h_counts,cresult.g_channels, cresult.b_channels); env->SetObjectField(result, fieldID, fieldJobject); } @@ -1079,7 +2157,6 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl { // 鑾峰彇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")); @@ -1105,6 +2182,7 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl fieldid = env->GetFieldID(structClass, "g_e_cal_flag", SIG_INT); bgpara.g_e_cal_flag = env->GetIntField(javaStruct, fieldid); + //绠楁硶璁＄畻 BgBoundary output; CBgWork bgwork; @@ -1140,7 +2218,6 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl 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; } @@ -3771,3 +4848,173 @@ JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandl return result; } */ + +jstring Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_selfBgAnalyse(JNIEnv *env, jclass, jstring phdFile, jstring json) +{ + QString phdPath = CplusToJava::jstring2QString(env, phdFile); + //鏂囦欢瑙ｆ瀽 + RadionuclideMessage message; + bool readflag = message.AnalysePHD_File(phdPath); + + if (!readflag) + { + // **************** printf("THE PHDfile get failed:"); + printf("load file error : %s! \n",phdPath.toStdString().c_str()); + return jstring(); + // **************** printf("\n"); + } + + QString order; + QVariant variant; + + /***************瑙ｆ瀽phd鏂囦欢*******************/ + //comment鍐呭鑾峰彇 + RadionuclideData::CollectionBlock collectionBlock; + order = ORDER_COLLECTION; + variant = message.GetBlockData(order); + if (variant.isValid()) + { + collectionBlock = variant.value(); + } + + RadionuclideData::AcquisitionBlock acq; + order = ORDER_ACQUISITION; + variant = message.GetBlockData(order); + if (variant.isValid()) + { + acq = variant.value(); + } + + QDateTime collectStart = QDateTime::fromString(collectionBlock.collection_start_date + " " + collectionBlock.collection_start_time, QString(DATATIME_FORMAT)); + QDateTime collectStop = QDateTime::fromString(collectionBlock.collection_stop_date + " " + collectionBlock.collection_stop_time, QString(DATATIME_FORMAT)); + QDateTime acqStart = QDateTime::fromString(acq.acquisition_start_date + " " + acq.acquisition_start_time, QString(DATATIME_FORMAT)); + double tc = collectStart.secsTo(collectStop); // 閲囨牱鏃堕棿 + double tp = collectStop.secsTo(acqStart); // 琛板彉鏃堕棿 + double tr = acq.acquisition_real_time; // 鑳借氨鑾峰彇瀹炴椂闂 + double tl = acq.acquisition_live_time; // 鑳借氨鑾峰彇娲绘椂闂 + + //header鍐呭鑾峰彇 + RadionuclideData::HeaderBlock headerBlock; + order = ORDER_HEADER; + variant = message.GetBlockData(order); + if (variant.isValid()) + { + headerBlock = variant.value(); + } + + RadionuclideData::ProcessingBlock process; + order = ORDER_PROCESSING; + variant = message.GetBlockData(order); + if (variant.isValid()) + { + process = variant.value(); + } + + RadionuclideData::BSelfAttenuationBlock bsel; + order = ORDER_BSELF; + variant = message.GetBlockData(order); + if (variant.isValid()) + { + bsel = variant.value(); + } + + RadionuclideData::NBG_EfficiencyBlock ngBeff; + order = ORDER_NB_GEFFICIENCY; + QVariant beff = message.GetBlockData(order); + if(!beff.isNull() && headerBlock.system_type == 'C') + { + ngBeff = beff.value(); + } + + RadionuclideData::n_G_EfficiencyBlock ngeff; + order = ORDER_G_EFFICIENCY; + QVariant g_effi = message.GetBlockData(order); + if(!g_effi.isNull()) + { + if(headerBlock.system_type == 'C') + { + ngeff = g_effi.value(); + } + } + /***************瑙ｆ瀽json鍙傛暟*******************/ + QString jsonStr = CplusToJava::jstring2QString(env, json); + QJsonDocument doc; + doc = QJsonDocument::fromJson(jsonStr.toUtf8()); + QJsonObject inObj = doc.object(); + /***************寮濮嬭绠*******************/ + QJsonArray data; + for(int i = 0; i < bsel.devNames.size(); i++) + { + QString name = bsel.devNames[i]; + + std::array self = bsel.xenon[i]; + std::array self2 = bsel.nitrogen[i]; + + double vxe, vn2; + vxe = process.sample_volume_of_Xe; + vn2 = process.Xe_collection_yield; + + QJsonObject factorObj = inObj[name].toObject(); + + double halfLife = factorObj["halflife"].toString().toDouble() * (24 * 60 * 60); + double sendOdds = factorObj["yield"].toString().toDouble() / 100.0; + double area = factorObj["area"].toString().toDouble(); + + double bgeff, geff; + double f; + double fxe = self[0] - self[1] * vxe + self[2] * pow(10, -5) * pow(vxe,2); + double fn2 = self2[0] - self2[0] * vn2 + self2[2] * pow(10, -4) * pow(vn2, 2); + f = fxe * fn2; + + for(int i2 = 0; i2 < ngBeff.nuclide_name.size(); i2++) + { + if(ngBeff.nuclide_name[i2].compare(name) == 0) + { + bgeff = ngBeff.bg_efficiency[i2]; + break; + } + } + + for(int i2 = 0; i2 < ngeff.dev_name.size(); i2++) + { + if(ngeff.dev_name[i2].compare(name) == 0) + { + geff = ngeff.efficiency[i2]; + break; + } + } + + double e = exp(1.0); // 璁＄畻e鐨勫 + double ln2 = log(2); + double T = (halfLife); + double lambda = ln2 / T; + double kc = lambda * tr / (1 - pow(e, -(lambda * tr))); + double a_up = (area / f); + double a_low = (tl * bgeff * geff * sendOdds); + double a = (a_up / a_low) * kc; + double ac_mi = lambda * tp; + double ac_e = pow(e, ac_mi); + double ac_kc = (lambda * tc) / (1 - pow(e, -(lambda * tc))); + double ac = (1000 * a / (vxe / 0.087)) * ac_e * ac_kc; + + double cBaseLine = factorObj["baseline"].toString().toDouble(); + double ld = 2.71 + 4.65 * sqrt(cBaseLine); + double mda = (ld / a_low) * kc; + double mdc = (1000 * mda / (vxe / 0.087)) * ac_e * ac_kc; + + QJsonObject obj; + obj["nuclideName"] = name; + obj["conc"] = ac; + obj["mda"] = mda; + obj["mdc"] = mdc; + obj["concErr"] = a * 0.15; + data.push_back(obj); + } + + QJsonDocument document; + document.setArray(data); + QByteArray simpbyte_array = document.toJson(QJsonDocument::Compact); + QString simpjson_str(simpbyte_array); + jstring jresult = env->NewStringUTF(simpjson_str.toStdString().c_str()); + return jresult; +} diff --git a/org_jeecg_modules_native_jni_EnergySpectrumHandler.h b/org_jeecg_modules_native_jni_EnergySpectrumHandler.h index ca0d863..a85dcd8 100644 --- a/org_jeecg_modules_native_jni_EnergySpectrumHandler.h +++ b/org_jeecg_modules_native_jni_EnergySpectrumHandler.h @@ -18,6 +18,14 @@ extern "C" { //瑙ｆ瀽鏂囦欢 JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_getSourceData (JNIEnv*, jclass, jstring); + + /* + * Class: org_jeecg_modules_native_jni_EnergySpectrumHandler + * Method: getSourceData_test + * Signature: (Ljava/lang/String;)Ljava/lang/String; + */ + JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_getSourceDataNotHis + (JNIEnv* env, jclass obj, jstring PHDfile); /* * Class: org_jeecg_modules_native_jni_EnergySpectrumHandler * Method: CalcBgBoundary @@ -107,6 +115,8 @@ extern "C" { JNIEXPORT jobject JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_BetaGammaSpectrumAnalyzeFunc (JNIEnv*, jclass, jobject);*/ + JNIEXPORT jstring JNICALL Java_org_jeecg_modules_native_1jni_EnergySpectrumHandler_selfBgAnalyse + (JNIEnv *, jclass, jstring, jstring); #ifdef __cplusplus }