1310 lines
58 KiB
C++
1310 lines
58 KiB
C++
#include "MeasureAnalysisProjectModel.h"
|
|
#include "AnalysisTypeDefine.h"
|
|
#include "GlobalDefine.h"
|
|
#include <QFile>
|
|
#include <QDir>
|
|
#include <QJsonDocument>
|
|
#include <QJsonObject>
|
|
#include "DataProcessWorkPool.h"
|
|
|
|
|
|
MeasureAnalysisProjectModel::~MeasureAnalysisProjectModel()
|
|
{
|
|
LOG_DEBUG(QStringLiteral(u"%1数据模型析构.").arg(this->GetProjectName()));
|
|
}
|
|
|
|
void MeasureAnalysisProjectModel::SetProjectDir(const QString& project_dir)
|
|
{
|
|
this->_project_dir = project_dir;
|
|
}
|
|
|
|
void MeasureAnalysisProjectModel::SetProjectName(const QString& project_name)
|
|
{
|
|
this->_project_name = project_name;
|
|
}
|
|
|
|
void MeasureAnalysisProjectModel::SetSpectrumType(MeasureAnalysisProjectModel::SpectrumType spec_type)
|
|
{
|
|
this->_spec_type = spec_type;
|
|
}
|
|
|
|
void MeasureAnalysisProjectModel::SetIsStdSource(bool is_std_source)
|
|
{
|
|
this->_is_std_source = is_std_source;
|
|
}
|
|
|
|
void MeasureAnalysisProjectModel::SetDescriptionInfo(const QString& description_info)
|
|
{
|
|
this->_description_info = description_info;
|
|
}
|
|
|
|
void MeasureAnalysisProjectModel::SetMeasurePresetTime(ulong measure_preset_time)
|
|
{
|
|
this->_measure_preset_time = measure_preset_time;
|
|
}
|
|
|
|
void MeasureAnalysisProjectModel::SetConformTimeWin(uint conform_time_win)
|
|
{
|
|
this->_conform_time_win = conform_time_win;
|
|
}
|
|
|
|
void MeasureAnalysisProjectModel::SetIsMeasureComplete(bool is_measure_complete)
|
|
{
|
|
this->_is_measure_complete = is_measure_complete;
|
|
}
|
|
|
|
void MeasureAnalysisProjectModel::SetMeasureDeviceParamsCfgFilename(const QString& filename)
|
|
{
|
|
this->_measure_device_params_cfg_filename = filename;
|
|
}
|
|
|
|
void MeasureAnalysisProjectModel::SetEnergyScaleFilename(const QString& filename)
|
|
{
|
|
this->_energy_scale_filename = filename;
|
|
}
|
|
|
|
void MeasureAnalysisProjectModel::SetEfficiencyScaleFilename(const QString& filename)
|
|
{
|
|
this->_efficiency_scale_filename = filename;
|
|
}
|
|
|
|
void MeasureAnalysisProjectModel::SetAllChannelParticleDataFilename(const QString& filename)
|
|
{
|
|
this->_all_channel_particle_data_filename = filename;
|
|
}
|
|
|
|
// void MeasureAnalysisProjectModel::SetChannelParticleDataFilename(uint channel, const QString& filename)
|
|
// {
|
|
// this->_channel_particle_data_filename_list[channel] = filename;
|
|
// }
|
|
|
|
void MeasureAnalysisProjectModel::SetChannelAddressCountDataFilename(uint channel, const QString& filename)
|
|
{
|
|
this->_channel_address_count_data_filename_list[channel] = filename;
|
|
}
|
|
|
|
// void MeasureAnalysisProjectModel::SetAllChannelParticleTotalCountDataFilename(const QString& filename)
|
|
// {
|
|
// this->_all_channel_particle_total_count_data_filename = filename;
|
|
// }
|
|
|
|
void MeasureAnalysisProjectModel::SetChannelEnergyCountDataFilename(uint channel, const QString& filename)
|
|
{
|
|
this->_channel_energy_count_data_filename_list[channel] = filename;
|
|
}
|
|
|
|
void MeasureAnalysisProjectModel::SetAllChannelEnergyTotalCountDataFilename(const QString& filename)
|
|
{
|
|
this->_all_channel_energy_total_count_data_filename = filename;
|
|
}
|
|
|
|
void MeasureAnalysisProjectModel::SetParticleEnergyDataFilename(const QString &filename)
|
|
{
|
|
this->_particle_energy_data_filename = filename;
|
|
}
|
|
|
|
void MeasureAnalysisProjectModel::SetTimeWinConformParticleData(uint time_win, uint conform_particle_count, const QString& filename)
|
|
{
|
|
this->_time_win_conform_particle_data[time_win][conform_particle_count] = filename;
|
|
}
|
|
|
|
void MeasureAnalysisProjectModel::SetTimeWinConformEnergyData(uint time_win, uint conform_particle_count, const QString& filename)
|
|
{
|
|
this->_time_win_conform_energy_data[time_win][conform_particle_count] = filename;
|
|
}
|
|
|
|
void MeasureAnalysisProjectModel::SetAntiConformParticleData(uint time_win, const QString &filename)
|
|
{
|
|
this->_anti_conform_particle_data[time_win] = filename;
|
|
}
|
|
|
|
void MeasureAnalysisProjectModel::SetAntiConformEnergyData(uint time_win, const QString &filename)
|
|
{
|
|
this->_anti_conform_energy_data[time_win] = filename;
|
|
}
|
|
|
|
void MeasureAnalysisProjectModel::SetAnalysisCustomData(AnalysisType analysis_type, const QString &data_item_name, const QString &data_filename)
|
|
{
|
|
this->_analysis_custom_data_set[analysis_type][data_item_name] = data_filename;
|
|
}
|
|
|
|
const QString& MeasureAnalysisProjectModel::GetProjectDir() const
|
|
{
|
|
return this->_project_dir;
|
|
}
|
|
|
|
const QString& MeasureAnalysisProjectModel::GetProjectName() const
|
|
{
|
|
return this->_project_name;
|
|
}
|
|
|
|
MeasureAnalysisProjectModel::SpectrumType MeasureAnalysisProjectModel::GetSpectrumType() const
|
|
{
|
|
return this->_spec_type;
|
|
}
|
|
|
|
bool MeasureAnalysisProjectModel::GetIsStdSource() const
|
|
{
|
|
return this->_is_std_source;
|
|
}
|
|
|
|
const QString& MeasureAnalysisProjectModel::GetDescriptionInfo() const
|
|
{
|
|
return this->_description_info;
|
|
}
|
|
|
|
ulong MeasureAnalysisProjectModel::GetMeasurePresetTime() const
|
|
{
|
|
return this->_measure_preset_time;
|
|
}
|
|
|
|
uint MeasureAnalysisProjectModel::GetConformTimeWin() const
|
|
{
|
|
return this->_conform_time_win;
|
|
}
|
|
|
|
bool MeasureAnalysisProjectModel::GetIsMeasureComplete() const
|
|
{
|
|
return this->_is_measure_complete;
|
|
}
|
|
|
|
const QString& MeasureAnalysisProjectModel::GetMeasureDeviceParamsCfgFilename() const
|
|
{
|
|
return this->_measure_device_params_cfg_filename;
|
|
}
|
|
|
|
const QString& MeasureAnalysisProjectModel::GetEnergyScaleFilename() const
|
|
{
|
|
return this->_energy_scale_filename;
|
|
}
|
|
|
|
const QString& MeasureAnalysisProjectModel::GetEfficiencyScaleFilename() const
|
|
{
|
|
return this->_efficiency_scale_filename;
|
|
}
|
|
|
|
const QString& MeasureAnalysisProjectModel::GetAllChannelParticleDataFilename() const
|
|
{
|
|
return this->_all_channel_particle_data_filename;
|
|
}
|
|
|
|
// const QMap<uint, QString>& MeasureAnalysisProjectModel::GetChannelParticleDataFilenameList() const
|
|
// {
|
|
// return this->_channel_particle_data_filename_list;
|
|
// }
|
|
|
|
// const QString& MeasureAnalysisProjectModel::GetChannelParticleDataFilename(uint channel) const
|
|
// {
|
|
// return QString(this->_channel_particle_data_filename_list[channel]);
|
|
// }
|
|
|
|
const QMap<uint, QString>& MeasureAnalysisProjectModel::GetChannelAddressCountDataFilenameList() const
|
|
{
|
|
return this->_channel_address_count_data_filename_list;
|
|
}
|
|
|
|
const QString MeasureAnalysisProjectModel::GetChannelAddressCountDataFilename(uint channel) const
|
|
{
|
|
QString file_name;
|
|
if ( this->_channel_address_count_data_filename_list.contains(channel) ) {
|
|
file_name = this->_channel_address_count_data_filename_list[channel];
|
|
}
|
|
return file_name;
|
|
}
|
|
|
|
// const QString& MeasureAnalysisProjectModel::GetAllChannelParticleTotalCountDataFilename() const
|
|
// {
|
|
// return this->_all_channel_particle_total_count_data_filename;
|
|
// }
|
|
|
|
const QMap<uint, QString>& MeasureAnalysisProjectModel::GetChannelEnergyCountDataFilenameList() const
|
|
{
|
|
return this->_channel_energy_count_data_filename_list;
|
|
}
|
|
|
|
const QString MeasureAnalysisProjectModel::GetChannelEnergyCountDataFilename(uint channel) const
|
|
{
|
|
QString file_name;
|
|
if ( this->_channel_energy_count_data_filename_list.contains(channel) ) {
|
|
file_name = this->_channel_energy_count_data_filename_list[channel];
|
|
}
|
|
return file_name;
|
|
}
|
|
|
|
const QString& MeasureAnalysisProjectModel::GetAllChannelEnergyTotalCountDataFilename() const
|
|
{
|
|
return this->_all_channel_energy_total_count_data_filename;
|
|
}
|
|
|
|
const QString MeasureAnalysisProjectModel::GetParticleEnergyDataFilename() const
|
|
{
|
|
return this->_particle_energy_data_filename;
|
|
}
|
|
|
|
const QMap<uint, QMap<uint, QString> > MeasureAnalysisProjectModel::GetConformParticleDataFilenameList() const
|
|
{
|
|
return this->_time_win_conform_particle_data;
|
|
}
|
|
|
|
const QMap<uint, QString> MeasureAnalysisProjectModel::GetTimeWinConformParticleDataFilenameList(uint time_win) const
|
|
{
|
|
QMap<uint, QString> conform_particle_data;
|
|
if ( this->_time_win_conform_particle_data.contains(time_win) ) {
|
|
conform_particle_data = this->_time_win_conform_particle_data[time_win];
|
|
}
|
|
return conform_particle_data;
|
|
}
|
|
|
|
const QMap<uint, QMap<uint, QString> > MeasureAnalysisProjectModel::GetConformParticleEnergyDataFilenameList() const
|
|
{
|
|
return this->_time_win_conform_energy_data;
|
|
}
|
|
|
|
const QMap<uint, QString> MeasureAnalysisProjectModel::GetTimeWinConformEnergyDataFilenameList(uint time_win) const
|
|
{
|
|
QMap<uint, QString> conform_energy_data;
|
|
if ( this->_time_win_conform_energy_data.contains(time_win) ) {
|
|
conform_energy_data = this->_time_win_conform_energy_data[time_win];
|
|
}
|
|
return conform_energy_data;
|
|
}
|
|
|
|
const QMap<uint, QString> &MeasureAnalysisProjectModel::GetAntiConformParticleData()
|
|
{
|
|
return _anti_conform_particle_data;
|
|
}
|
|
|
|
const QString &MeasureAnalysisProjectModel::GetAntiConformParticleData(uint time_win)
|
|
{
|
|
return _anti_conform_particle_data.value(time_win);
|
|
}
|
|
|
|
const QMap<uint, QString> &MeasureAnalysisProjectModel::GetAntiConformEnergyData()
|
|
{
|
|
return _anti_conform_energy_data;
|
|
}
|
|
|
|
const QString &MeasureAnalysisProjectModel::GetAntiConformEnergyData(uint time_win)
|
|
{
|
|
return _anti_conform_energy_data.value(time_win);
|
|
}
|
|
|
|
const QString MeasureAnalysisProjectModel::GetAnalysisCustomData(AnalysisType analysis_type, const QString &data_item_name)
|
|
{
|
|
return this->_analysis_custom_data_set.value(analysis_type).value(data_item_name);
|
|
}
|
|
|
|
void MeasureAnalysisProjectModel::SetDeviceGuid(const QString &device_guid)
|
|
{
|
|
this->_device_guid = device_guid;
|
|
}
|
|
|
|
const QString &MeasureAnalysisProjectModel::GetDeviceGuid() const
|
|
{
|
|
return this->_device_guid;
|
|
}
|
|
|
|
void MeasureAnalysisProjectModel::SetStartTime(const QString &start_time)
|
|
{
|
|
this->_start_time = start_time;
|
|
}
|
|
|
|
const QString &MeasureAnalysisProjectModel::GetStartTime() const
|
|
{
|
|
return this->_start_time;
|
|
}
|
|
|
|
void MeasureAnalysisProjectModel::SetEndTime(const QString &end_time)
|
|
{
|
|
this->_end_time = end_time;
|
|
}
|
|
|
|
const QString &MeasureAnalysisProjectModel::GetEndTime() const
|
|
{
|
|
return this->_end_time;
|
|
}
|
|
|
|
void MeasureAnalysisProjectModel::SetGvfFilename(const QString &gvf_filename)
|
|
{
|
|
this->_gvf_filename = gvf_filename;
|
|
}
|
|
|
|
const QString &MeasureAnalysisProjectModel::GetGvfFilename() const
|
|
{
|
|
return this->_gvf_filename;
|
|
}
|
|
|
|
bool MeasureAnalysisProjectModel::LoadProjectModel(const QString& project_filename)
|
|
{
|
|
QVariantMap model_data;
|
|
if (!project_filename.isEmpty()) {
|
|
this->_project_filename = project_filename;
|
|
QFileInfo project_fileinfo(project_filename);
|
|
this->_project_dir = project_fileinfo.absoluteDir().absolutePath();
|
|
QFile json_file(this->_project_filename);
|
|
if (!json_file.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
|
return false;
|
|
}
|
|
QJsonDocument json_doc = QJsonDocument::fromJson(json_file.readAll());
|
|
json_file.close();
|
|
if (json_doc.isNull())
|
|
return false;
|
|
if (!json_doc.isObject())
|
|
return false;
|
|
model_data = json_doc.object().toVariantMap();
|
|
}
|
|
|
|
auto ProjectAbsFilename = [this](const QString& project_relative_filename){
|
|
QString project_abs_filename;
|
|
if ( !project_relative_filename.isEmpty() ) {
|
|
QDir project_dir(this->_project_dir);
|
|
project_abs_filename = project_dir.filePath(project_relative_filename);
|
|
QFileInfo file_info(project_abs_filename);
|
|
if ( !file_info.exists() ) {
|
|
project_abs_filename.clear();
|
|
}
|
|
}
|
|
return project_abs_filename;
|
|
};
|
|
if (!model_data.contains("ProjectName"))
|
|
return false;
|
|
this->_project_name = model_data["ProjectName"].toString();
|
|
if (!model_data.contains("SpectrumType"))
|
|
return false;
|
|
this->_spec_type = SpectrumType(model_data["SpectrumType"].toInt());
|
|
if (!model_data.contains("IsStandardSource"))
|
|
return false;
|
|
this->_is_std_source = model_data["IsStandardSource"].toBool();
|
|
if (!model_data.contains("DescriptionInfo"))
|
|
return false;
|
|
this->_description_info = model_data["DescriptionInfo"].toString();
|
|
if (!model_data.contains("MeasurePresetTime"))
|
|
return false;
|
|
this->_measure_preset_time = model_data["MeasurePresetTime"].toInt();
|
|
if (!model_data.contains("IsMeasureComplete"))
|
|
return false;
|
|
this->_is_measure_complete = model_data["IsMeasureComplete"].toBool();
|
|
if (!model_data.contains("ConformTimeWin"))
|
|
return false;
|
|
this->_conform_time_win = model_data["ConformTimeWin"].toInt();
|
|
|
|
this->_measure_device_params_cfg_filename = ProjectAbsFilename(model_data["MeasureDeviceParamsCfgFilename"].toString());
|
|
this->_energy_scale_filename = ProjectAbsFilename(model_data["EnergyScaleFilename"].toString());
|
|
this->_efficiency_scale_filename = ProjectAbsFilename(model_data["EfficiencyScaleFilename"].toString());
|
|
this->_all_channel_particle_data_filename = ProjectAbsFilename(model_data["AllChannelParticleDataFilename"].toString());
|
|
|
|
const auto& address_count_data_filename_list = model_data["ChannelAddressCountDataFilenameList"].toMap();
|
|
for (auto it = address_count_data_filename_list.constBegin(); it!=address_count_data_filename_list.constEnd(); ++it) {
|
|
uint channel_num = it.key().toUInt();
|
|
this->_channel_address_count_data_filename_list[channel_num] = ProjectAbsFilename(it.value().toString());
|
|
}
|
|
|
|
const auto& energy_count_data_filename_list = model_data["ChannelEnergyCountDataFilenameList"].toMap();
|
|
for (auto it = energy_count_data_filename_list.constBegin(); it!=energy_count_data_filename_list.constEnd(); ++it) {
|
|
uint channel_num = it.key().toUInt();
|
|
this->_channel_energy_count_data_filename_list[channel_num] = ProjectAbsFilename(it.value().toString());
|
|
}
|
|
|
|
this->_all_channel_energy_total_count_data_filename = ProjectAbsFilename(model_data["AllChannelEnergyTotalCountDataFilename"].toString());
|
|
|
|
this->_particle_energy_data_filename = ProjectAbsFilename(model_data["ParticleEnergyDataFilename"].toString());
|
|
|
|
const auto& time_win_conform_particle_data = model_data["TimeWinConformParticleData"].toMap();
|
|
for (auto it1 = time_win_conform_particle_data.constBegin(); it1!=time_win_conform_particle_data.constEnd(); ++it1) {
|
|
uint time_win = it1.key().toUInt();
|
|
QMap<uint, QString> conform_particle_data;
|
|
const auto& conform_particle_data_list = it1.value().toMap();
|
|
for (auto it2 = conform_particle_data_list.constBegin(); it2!=conform_particle_data_list.constEnd(); ++it2) {
|
|
uint particle_count = it2.key().toUInt();
|
|
conform_particle_data[particle_count] = ProjectAbsFilename(it2.value().toString());
|
|
}
|
|
this->_time_win_conform_particle_data[time_win] = conform_particle_data;
|
|
}
|
|
|
|
const auto& time_win_conform_energy_data = model_data["TimeWinConformEnergyData"].toMap();
|
|
for (auto it1 = time_win_conform_energy_data.constBegin(); it1!=time_win_conform_energy_data.constEnd(); ++it1) {
|
|
uint time_win = it1.key().toUInt();
|
|
QMap<uint, QString> conform_energy_data;
|
|
const auto& conform_energy_data_list = it1.value().toMap();
|
|
for (auto it2 = conform_energy_data_list.constBegin(); it2!=conform_energy_data_list.constEnd(); ++it2) {
|
|
uint particle_count = it2.key().toUInt();
|
|
conform_energy_data[particle_count] = ProjectAbsFilename(it2.value().toString());
|
|
}
|
|
this->_time_win_conform_energy_data[time_win] = conform_energy_data;
|
|
}
|
|
|
|
const auto& anti_conform_particle_data = model_data["AntiConformParticleData"].toMap();
|
|
for (auto it = anti_conform_particle_data.constBegin(); it!=anti_conform_particle_data.constEnd(); ++it) {
|
|
this->_anti_conform_particle_data[it.key().toUInt()] = ProjectAbsFilename(it.value().toString());
|
|
}
|
|
|
|
const auto& anti_conform_energy_data = model_data["AntiConformEnergyData"].toMap();
|
|
for (auto it = anti_conform_energy_data.constBegin(); it!=anti_conform_energy_data.constEnd(); ++it) {
|
|
this->_anti_conform_energy_data[it.key().toUInt()] = ProjectAbsFilename(it.value().toString());
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool MeasureAnalysisProjectModel::SaveProjectModel()
|
|
{
|
|
_save_mutex.lock();
|
|
auto ProjectRelativeFilename = [this](const QString& abs_filename) {
|
|
QString project_relative_filename;
|
|
if ( !abs_filename.isEmpty() ) {
|
|
QFileInfo file_info(abs_filename);
|
|
if ( file_info.exists() ) {
|
|
QDir project_dir(_project_dir);
|
|
QString project_dir_path = project_dir.absolutePath() + "/";
|
|
QString project_abs_filename = file_info.absoluteFilePath();
|
|
project_relative_filename = project_abs_filename.remove(project_dir_path);
|
|
}
|
|
}
|
|
return project_relative_filename;
|
|
};
|
|
if (this->_project_filename.isEmpty()) {
|
|
this->_project_filename = QDir(this->_project_dir).filePath(this->_project_name + QString(".msproject"));;
|
|
}
|
|
// 将项目模型转换为json对象
|
|
QVariantMap project_json_obj_map;
|
|
project_json_obj_map["ProjectName"] = this->_project_name;
|
|
project_json_obj_map["SpectrumType"] = this->_spec_type;
|
|
project_json_obj_map["IsStandardSource"] = this->_is_std_source;
|
|
project_json_obj_map["DescriptionInfo"] = this->_description_info;
|
|
project_json_obj_map["MeasurePresetTime"] = int(this->_measure_preset_time);
|
|
project_json_obj_map["IsMeasureComplete"] = this->_is_measure_complete;
|
|
project_json_obj_map["ConformTimeWin"] = this->_conform_time_win;
|
|
project_json_obj_map["MeasureDeviceParamsCfgFilename"] = ProjectRelativeFilename(this->_measure_device_params_cfg_filename);
|
|
project_json_obj_map["EnergyScaleFilename"] = ProjectRelativeFilename(this->_energy_scale_filename);
|
|
project_json_obj_map["EfficiencyScaleFilename"] = ProjectRelativeFilename(this->_efficiency_scale_filename);
|
|
project_json_obj_map["AllChannelParticleDataFilename"] = ProjectRelativeFilename(this->_all_channel_particle_data_filename);
|
|
project_json_obj_map["ParticleEnergyDataFilename"] = ProjectRelativeFilename(this->_particle_energy_data_filename);
|
|
|
|
QVariantMap channel_address_count_data_filename_list;
|
|
for (auto it = this->_channel_address_count_data_filename_list.constBegin(); it != this->_channel_address_count_data_filename_list.constEnd(); ++it) {
|
|
channel_address_count_data_filename_list[QString::number(it.key())] = ProjectRelativeFilename(it.value());
|
|
}
|
|
project_json_obj_map["ChannelAddressCountDataFilenameList"] = channel_address_count_data_filename_list;
|
|
|
|
QVariantMap channel_energy_count_data_filename_list;
|
|
for (auto it = this->_channel_energy_count_data_filename_list.constBegin(); it != this->_channel_energy_count_data_filename_list.constEnd(); ++it) {
|
|
channel_energy_count_data_filename_list[QString::number(it.key())] = ProjectRelativeFilename(it.value());
|
|
}
|
|
project_json_obj_map["ChannelEnergyCountDataFilenameList"] = channel_energy_count_data_filename_list;
|
|
project_json_obj_map["AllChannelEnergyTotalCountDataFilename"] = ProjectRelativeFilename(this->_all_channel_energy_total_count_data_filename);
|
|
|
|
QVariantMap time_win_conform_particle_data;
|
|
for (auto it1 = this->_time_win_conform_particle_data.constBegin(); it1 != this->_time_win_conform_particle_data.constEnd(); ++it1) {
|
|
QVariantMap conform_particle_data;
|
|
for (auto it2 = it1.value().constBegin(); it2 != it1.value().constEnd(); ++it2) {
|
|
conform_particle_data[QString::number(it2.key())] = ProjectRelativeFilename(it2.value());
|
|
}
|
|
time_win_conform_particle_data[QString::number(it1.key())] = conform_particle_data;
|
|
}
|
|
project_json_obj_map["TimeWinConformParticleData"] = time_win_conform_particle_data;
|
|
|
|
QVariantMap time_win_conform_energy_data;
|
|
for (auto it1 = this->_time_win_conform_energy_data.constBegin(); it1 != this->_time_win_conform_energy_data.constEnd(); ++it1) {
|
|
QVariantMap conform_energy_data;
|
|
for (auto it2 = it1.value().constBegin(); it2 != it1.value().constEnd(); ++it2) {
|
|
conform_energy_data[QString::number(it2.key())] = ProjectRelativeFilename(it2.value());
|
|
}
|
|
time_win_conform_energy_data[QString::number(it1.key())] = conform_energy_data;
|
|
}
|
|
project_json_obj_map["TimeWinConformEnergyData"] = time_win_conform_energy_data;
|
|
|
|
QVariantMap anti_conform_particle_data;
|
|
for (auto it = this->_anti_conform_particle_data.constBegin(); it != this->_anti_conform_particle_data.constEnd(); ++it) {
|
|
anti_conform_particle_data[QString::number(it.key())] = ProjectRelativeFilename(it.value());
|
|
}
|
|
project_json_obj_map["AntiConformParticleData"] = anti_conform_particle_data;
|
|
|
|
QVariantMap anti_conform_energy_data;
|
|
for (auto it = this->_anti_conform_energy_data.constBegin(); it != this->_anti_conform_energy_data.constEnd(); ++it) {
|
|
anti_conform_energy_data[QString::number(it.key())] = ProjectRelativeFilename(it.value());
|
|
}
|
|
project_json_obj_map["AntiConformEnergyData"] = anti_conform_energy_data;
|
|
|
|
// 将项目模型保存到json文件
|
|
QJsonDocument json_doc = QJsonDocument::fromVariant(project_json_obj_map);
|
|
QFile json_file(this->_project_filename);
|
|
if (!json_file.open(QIODevice::WriteOnly | QIODevice::Text)) {
|
|
return false;
|
|
}
|
|
json_file.write(json_doc.toJson());
|
|
json_file.close();
|
|
|
|
_save_mutex.unlock();
|
|
return true;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
/* MeasureAnalysisProjectModelList */
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
enum ColumnType {
|
|
NameColumn,
|
|
StatusColumn
|
|
};
|
|
|
|
MeasureAnalysisProjectModelList* MeasureAnalysisProjectModelList::_s_instance { nullptr };
|
|
|
|
MeasureAnalysisProjectModelList* MeasureAnalysisProjectModelList::Instance()
|
|
{
|
|
if (!_s_instance) {
|
|
_s_instance = new MeasureAnalysisProjectModelList();
|
|
}
|
|
return _s_instance;
|
|
}
|
|
|
|
MeasureAnalysisProjectModelList::~MeasureAnalysisProjectModelList()
|
|
{
|
|
const auto& models_list = _project_models.values();
|
|
for (auto it=models_list.constBegin(); it!=models_list.constEnd(); ++it) {
|
|
auto& model = *it;
|
|
model->SaveProjectModel();
|
|
}
|
|
}
|
|
|
|
bool MeasureAnalysisProjectModelList::AddProjectModel(MeasureAnalysisProjectModel* model, bool save)
|
|
{
|
|
bool ok = true;
|
|
const QString& project_name = model->GetProjectName();
|
|
if (!_project_models.contains(project_name)) {
|
|
_project_models[project_name] = model;
|
|
intiProjectNodeStruce(model);
|
|
if (save) {
|
|
this->SetCurrentProjectModel(project_name);
|
|
model->SaveProjectModel();
|
|
}
|
|
} else {
|
|
delete model;
|
|
ok &= false;
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
bool MeasureAnalysisProjectModelList::RmProjectModel(const QString& project_name)
|
|
{
|
|
if (!_project_node_items.contains(project_name)) {
|
|
return false;
|
|
}
|
|
const QMap<QString, QStandardItem*> item_nodes = _project_node_items[project_name];
|
|
if (!item_nodes.contains(project_name) ) {
|
|
return false;
|
|
}
|
|
QStandardItem* project_item = item_nodes[project_name];
|
|
if (project_item) {
|
|
if (!this->RemoveNode(project_item)) {
|
|
return false;
|
|
}
|
|
}
|
|
emit removedProjectModel(project_name);
|
|
if (_project_models.contains(project_name)) {
|
|
delete _project_models[project_name];
|
|
_project_models.remove(project_name);
|
|
}
|
|
const auto& project_model = _project_models.first();
|
|
if (project_model) {
|
|
const QString& project_name = project_model->GetProjectName();
|
|
SetCurrentProjectModel(project_name);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
MeasureAnalysisProjectModel* MeasureAnalysisProjectModelList::GetProjectModel(const QString& project_name)
|
|
{
|
|
if (_project_models.contains(project_name)) {
|
|
return _project_models[project_name];
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
MeasureAnalysisProjectModel* MeasureAnalysisProjectModelList::GetCurrentProjectModel()
|
|
{
|
|
return _current_project_model;
|
|
}
|
|
|
|
QList<MeasureAnalysisProjectModel *> MeasureAnalysisProjectModelList::GetProjectModels()
|
|
{
|
|
return _project_models.values();
|
|
}
|
|
|
|
void MeasureAnalysisProjectModelList::SetCurrentProjectModel(const QString& project_name)
|
|
{
|
|
if (_project_models.contains(project_name)) {
|
|
_current_project_model = _project_models[project_name];
|
|
|
|
for (auto it = _project_node_items.constBegin(); it!=_project_node_items.constEnd(); ++it) {
|
|
const QString& temp_project_name = it.key();
|
|
const QMap<QString, QStandardItem*> item_nodes = it.value();
|
|
if ( item_nodes.contains(temp_project_name) ) {
|
|
QStandardItem* project_item = item_nodes[temp_project_name];
|
|
if (project_item) {
|
|
QFont font = project_item->font();
|
|
if ( it.key() == project_name ) {
|
|
font.setBold(true);
|
|
} else {
|
|
font.setBold(false);
|
|
}
|
|
project_item->setFont(font);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
MeasureAnalysisProjectModelList::MeasureAnalysisProjectModelList(QObject* parent)
|
|
: QStandardItemModel(parent)
|
|
, _current_project_model(nullptr)
|
|
{
|
|
setColumnCount(2);
|
|
setHeaderData(NameColumn, Qt::Horizontal, QStringLiteral(u"项名"));
|
|
setHeaderData(StatusColumn, Qt::Horizontal, QStringLiteral(u"状态"));
|
|
}
|
|
|
|
QStandardItem* MeasureAnalysisProjectModelList::GetItemFromIndex(const QModelIndex& index) const
|
|
{
|
|
QModelIndex name_index = index.sibling(index.row(), NameColumn);
|
|
return itemFromIndex(name_index);
|
|
}
|
|
|
|
QStandardItem* MeasureAnalysisProjectModelList::AddChildNode(
|
|
QStandardItem* parent_item, const QString& node_name, const QString& status_text,
|
|
const QVariant& user_data, bool is_fixed, bool state_ok)
|
|
{
|
|
if (!parent_item)
|
|
return nullptr;
|
|
|
|
QStandardItem* name_item = new QStandardItem(node_name);
|
|
name_item->setData(user_data, NodeType);
|
|
name_item->setData(is_fixed, Fixed);
|
|
QStandardItem* status_item = new QStandardItem(status_text);
|
|
status_item->setData(state_ok, Qt::UserRole);
|
|
if (state_ok) {
|
|
name_item->setForeground(Qt::black);
|
|
status_item->setForeground(Qt::black);
|
|
} else {
|
|
name_item->setForeground(Qt::gray);
|
|
status_item->setForeground(Qt::gray);
|
|
}
|
|
QList<QStandardItem*> row_items;
|
|
row_items << name_item << status_item;
|
|
parent_item->appendRow(row_items);
|
|
|
|
return name_item;
|
|
}
|
|
|
|
bool MeasureAnalysisProjectModelList::RemoveNode(QStandardItem* item)
|
|
{
|
|
if (!item)
|
|
return false;
|
|
if (item->column() == NameColumn && item->data(Fixed).toBool())
|
|
return false;
|
|
const QString& project_name = item->data(ProjectName).toString();
|
|
if (AnalysisType::Project == item->data(NodeType).value<AnalysisType>()) {
|
|
QStandardItem* root_item = invisibleRootItem();
|
|
root_item->removeRow(item->row());
|
|
_project_node_items.remove(project_name);
|
|
} else {
|
|
QStandardItem* parent_item = item->parent();
|
|
if (!parent_item) {
|
|
return false;
|
|
}
|
|
parent_item->removeRow(item->row());
|
|
const QString& node_name = item->text();
|
|
if (_project_node_items.contains(project_name)) {
|
|
if (_project_node_items[project_name].contains(node_name)) {
|
|
_project_node_items[project_name].remove(node_name);
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void MeasureAnalysisProjectModelList::SetNodeUserData(QStandardItem* item, const QVariant& data)
|
|
{
|
|
if (item && item->column() == NameColumn)
|
|
item->setData(data, NodeType);
|
|
}
|
|
|
|
QVariant MeasureAnalysisProjectModelList::GetNodeUserData(QStandardItem* item, UserDataType data_type) const
|
|
{
|
|
return (item && item->column() == NameColumn) ? item->data(data_type) : QVariant();
|
|
}
|
|
|
|
void MeasureAnalysisProjectModelList::SetNodeStatus(QStandardItem* item, const QString& status, bool state_ok)
|
|
{
|
|
if (!item || item->column() != NameColumn)
|
|
return;
|
|
QStandardItem* status_item = item->parent()
|
|
? item->parent()->child(item->row(), StatusColumn)
|
|
: invisibleRootItem()->child(item->row(), StatusColumn);
|
|
if (status_item) {
|
|
status_item->setText(status);
|
|
status_item->setData(state_ok, Qt::UserRole);
|
|
if (state_ok) {
|
|
item->setForeground(Qt::black);
|
|
status_item->setForeground(Qt::black);
|
|
} else {
|
|
item->setForeground(Qt::gray);
|
|
status_item->setForeground(Qt::gray);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool MeasureAnalysisProjectModelList::GetNodeStatus(QStandardItem* item) const
|
|
{
|
|
if (!item || item->column() != NameColumn)
|
|
return false;
|
|
QStandardItem* status_item = item->parent()
|
|
? item->parent()->child(item->row(), StatusColumn)
|
|
: invisibleRootItem()->child(item->row(), StatusColumn);
|
|
if ( !status_item )
|
|
return false;
|
|
return status_item->data(Qt::UserRole).toBool();
|
|
}
|
|
|
|
void MeasureAnalysisProjectModelList::ApplyEnergyScale(const QString &project_name)
|
|
{
|
|
if (this->_project_models.contains(project_name)) {
|
|
auto pro_model = this->_project_models[project_name];
|
|
const QString& energy_scale_filename = pro_model->GetEnergyScaleFilename();
|
|
bool status_ok = false;
|
|
QString status = QStringLiteral(u"未配置");
|
|
if (!energy_scale_filename.isEmpty()) {
|
|
status_ok = true;
|
|
status = QStringLiteral(u"已配置");
|
|
auto& node_map = this->_project_node_items[project_name];
|
|
const QString& energy_scale_item_name = QStringLiteral(u"能量刻度");
|
|
if (node_map.contains(energy_scale_item_name)) {
|
|
auto energy_scale_item = node_map[energy_scale_item_name];
|
|
this->SetNodeStatus(energy_scale_item, status, status_ok);
|
|
}
|
|
pro_model->SaveProjectModel();
|
|
|
|
auto apply_erergy_scale_fit_task = new DataProcessWorkPool::EnergyScaleParticleDataTask;
|
|
apply_erergy_scale_fit_task->SetFinishedNotifier(this, "onEnergyScaleParticleDataFinished", project_name);
|
|
apply_erergy_scale_fit_task->StartTask();
|
|
|
|
auto energy_count_process_task = new DataProcessWorkPool::EnergyCountProcessTask;
|
|
energy_count_process_task->SetFinishedNotifier(this, "onEnergyCountProcessFinished", project_name);
|
|
energy_count_process_task->StartTask();
|
|
|
|
auto coincidence_process_task = new DataProcessWorkPool::EnergyScaleCoincidenceDataTask;
|
|
coincidence_process_task->SetFinishedNotifier(this, "onEnergyScaleCoincidenceDataFinished", project_name);
|
|
coincidence_process_task->StartTask();
|
|
|
|
auto anti_coincidence_process_task = new DataProcessWorkPool::EnergyScaleaAntiCoincidenceDataTask;
|
|
anti_coincidence_process_task->SetFinishedNotifier(this, "onEnergyScaleAntiCoincidenceDataFinished", project_name);
|
|
anti_coincidence_process_task->StartTask();
|
|
}
|
|
}
|
|
}
|
|
|
|
void MeasureAnalysisProjectModelList::onDeviceConfigParamsFinished(bool ok, const QString &project_name, const QVariant &data)
|
|
{
|
|
Q_UNUSED(data);
|
|
if ( !ok )
|
|
return;
|
|
if (this->_project_models.contains(project_name)) {
|
|
auto pro_model = this->_project_models[project_name];
|
|
const QString& device_filename = pro_model->GetMeasureDeviceParamsCfgFilename();
|
|
bool status_ok = false;
|
|
QString status = QStringLiteral(u"未配置");
|
|
if (!device_filename.isEmpty()) {
|
|
status_ok = true;
|
|
status = QStringLiteral(u"已配置");
|
|
}
|
|
auto& node_map = this->_project_node_items[project_name];
|
|
const QString& device_config_params_item_name = QStringLiteral(u"设备配置参数");
|
|
if (node_map.contains(device_config_params_item_name)) {
|
|
auto device_config_params_item = node_map[device_config_params_item_name];
|
|
this->SetNodeStatus(device_config_params_item, status, status_ok);
|
|
}
|
|
}
|
|
}
|
|
|
|
void MeasureAnalysisProjectModelList::onChannelAddressCountProcessFinished(bool ok, const QString& project_name, const QVariant &data)
|
|
{
|
|
Q_UNUSED(data);
|
|
if ( !ok )
|
|
return;
|
|
if (this->_project_models.contains(project_name)) {
|
|
auto pro_model = this->_project_models[project_name];
|
|
const QMap<uint, QString>& filename_list = pro_model->GetChannelAddressCountDataFilenameList();
|
|
bool status_ok = false;
|
|
QString status = QStringLiteral(u"无效");
|
|
if (!filename_list.isEmpty()) {
|
|
status_ok = true;
|
|
status = QStringLiteral(u"有效");
|
|
}
|
|
auto& node_map = this->_project_node_items[project_name];
|
|
const QString& adrr_count_item_name = QStringLiteral(u"道址计数");
|
|
if (node_map.contains(adrr_count_item_name)) {
|
|
auto adrr_count_item = node_map[adrr_count_item_name];
|
|
this->SetNodeStatus(adrr_count_item, status, status_ok);
|
|
for (auto it = filename_list.begin(); it != filename_list.end(); ++it) {
|
|
uint ch_num = it.key();
|
|
QString item_name = QStringLiteral(u"通道%1道址计数").arg(ch_num);
|
|
const QVariant& analys_type = QVariant::fromValue(AnalysisType::AddressCountData);
|
|
QStandardItem* node_item = AddChildNode(adrr_count_item, item_name, status, analys_type, true, status_ok);
|
|
node_item->setData(project_name, ProjectName);
|
|
node_item->setData(ch_num, ChannelNum);
|
|
node_map[item_name] = node_item;
|
|
}
|
|
}
|
|
const QString& adrr_count_spec_item_name = QStringLiteral(u"道址计数谱");
|
|
if (node_map.contains(adrr_count_spec_item_name)) {
|
|
auto adrr_count_spec_item = node_map[adrr_count_spec_item_name];
|
|
this->SetNodeStatus(adrr_count_spec_item, status, status_ok);
|
|
}
|
|
pro_model->SaveProjectModel();
|
|
}
|
|
}
|
|
|
|
void MeasureAnalysisProjectModelList::onEnergyScaleParticleDataFinished(bool ok, const QString &project_name, const QVariant &data)
|
|
{
|
|
Q_UNUSED(data);
|
|
if ( !ok )
|
|
return;
|
|
if (this->_project_models.contains(project_name)) {
|
|
auto pro_model = this->_project_models[project_name];
|
|
auto& node_map = this->_project_node_items[project_name];
|
|
bool status_ok = false;
|
|
QString status = QStringLiteral(u"无效");
|
|
const QString& particle_energy_data_filename = pro_model->GetParticleEnergyDataFilename();
|
|
if (!particle_energy_data_filename.isEmpty()) {
|
|
status_ok = true;
|
|
status = QStringLiteral(u"有效");
|
|
const QString& particle_energy_item_name = QStringLiteral(u"粒子能量数据");
|
|
if (node_map.contains(particle_energy_item_name)) {
|
|
auto energy_total_count_spec_item = node_map[particle_energy_item_name];
|
|
this->SetNodeStatus(energy_total_count_spec_item, status, status_ok);
|
|
}
|
|
const QString& count_rate_analysis_item_name = QStringLiteral(u"计数率分析");
|
|
if (node_map.contains(count_rate_analysis_item_name)) {
|
|
auto energy_total_count_spec_item = node_map[count_rate_analysis_item_name];
|
|
this->SetNodeStatus(energy_total_count_spec_item, status, status_ok);
|
|
}
|
|
const QString& peak_fit_analysis_item_name = QStringLiteral(u"峰拟合分析");
|
|
if (node_map.contains(peak_fit_analysis_item_name)) {
|
|
auto energy_total_count_spec_item = node_map[peak_fit_analysis_item_name];
|
|
this->SetNodeStatus(energy_total_count_spec_item, status, status_ok);
|
|
}
|
|
const QString& nuclide_analysis_item_name = QStringLiteral(u"核素分析");
|
|
if (node_map.contains(nuclide_analysis_item_name)) {
|
|
auto energy_total_count_spec_item = node_map[nuclide_analysis_item_name];
|
|
this->SetNodeStatus(energy_total_count_spec_item, status, status_ok);
|
|
}
|
|
const QString& particle_in_time_analysis_item_name = QStringLiteral(u"粒子入射时间分析");
|
|
if (node_map.contains(particle_in_time_analysis_item_name)) {
|
|
auto energy_total_count_spec_item = node_map[particle_in_time_analysis_item_name];
|
|
this->SetNodeStatus(energy_total_count_spec_item, status, status_ok);
|
|
}
|
|
}
|
|
pro_model->SaveProjectModel();
|
|
}
|
|
}
|
|
|
|
void MeasureAnalysisProjectModelList::onEnergyCountProcessFinished(bool ok, const QString &project_name, const QVariant &data)
|
|
{
|
|
Q_UNUSED(data);
|
|
if ( !ok )
|
|
return;
|
|
if (this->_project_models.contains(project_name)) {
|
|
auto pro_model = this->_project_models[project_name];
|
|
auto& node_map = this->_project_node_items[project_name];
|
|
bool status_ok = false;
|
|
QString status = QStringLiteral(u"无效");
|
|
const QString& energy_total_count_filename = pro_model->GetAllChannelEnergyTotalCountDataFilename();
|
|
if (!energy_total_count_filename.isEmpty()) {
|
|
status_ok = true;
|
|
status = QStringLiteral(u"有效");
|
|
const QString& energy_total_count_item_name = QStringLiteral(u"能量计数");
|
|
if (node_map.contains(energy_total_count_item_name)) {
|
|
auto energy_total_count_item = node_map[energy_total_count_item_name];
|
|
this->SetNodeStatus(energy_total_count_item, status, status_ok);
|
|
const QMap<uint, QString>& channel_energy_count_filename_list = pro_model->GetChannelEnergyCountDataFilenameList();
|
|
for (auto it = channel_energy_count_filename_list.constBegin(); it != channel_energy_count_filename_list.constEnd(); ++it) {
|
|
uint ch_num = it.key();
|
|
QString item_name = QStringLiteral(u"通道%1能量计数").arg(ch_num);
|
|
if ( !node_map.contains(item_name) ) {
|
|
const QVariant& analys_type = QVariant::fromValue(AnalysisType::EnergyCountData);
|
|
QStandardItem* node_item = AddChildNode(energy_total_count_item, item_name, status, analys_type, true, status_ok);
|
|
node_item->setData(project_name, ProjectName);
|
|
node_item->setData(ch_num, ChannelNum);
|
|
node_map[item_name] = node_item;
|
|
} else {
|
|
auto ch_energy_count_item = node_map[item_name];
|
|
this->SetNodeStatus(ch_energy_count_item, status, status_ok);
|
|
}
|
|
}
|
|
const auto& ch_energy_count_data_list = pro_model->GetChannelEnergyCountDataFilenameList();
|
|
if (!ch_energy_count_data_list.isEmpty()) {
|
|
const QString& adrr_count_spec_item_name = QStringLiteral(u"能量计数谱");
|
|
if (node_map.contains(adrr_count_spec_item_name)) {
|
|
auto adrr_count_spec_item = node_map[adrr_count_spec_item_name];
|
|
this->SetNodeStatus(adrr_count_spec_item, status, status_ok);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
pro_model->SaveProjectModel();
|
|
}
|
|
}
|
|
|
|
void MeasureAnalysisProjectModelList::onCoincidenceProcessFinished(bool ok, const QString &project_name, const QVariant &data)
|
|
{
|
|
Q_UNUSED(data);
|
|
if ( !ok )
|
|
return;
|
|
if (this->_project_models.contains(project_name)) {
|
|
auto pro_model = this->_project_models[project_name];
|
|
pro_model->SaveProjectModel();
|
|
}
|
|
}
|
|
|
|
void MeasureAnalysisProjectModelList::onEnergyScaleCoincidenceDataFinished(bool ok, const QString &project_name, const QVariant &data)
|
|
{
|
|
Q_UNUSED(data);
|
|
if ( !ok )
|
|
return;
|
|
if (this->_project_models.contains(project_name)) {
|
|
auto pro_model = this->_project_models[project_name];
|
|
auto& node_map = this->_project_node_items[project_name];
|
|
bool status_ok = false;
|
|
QString status = QStringLiteral(u"无效");
|
|
auto time_win_file_name_set = pro_model->GetConformParticleEnergyDataFilenameList();
|
|
if (!time_win_file_name_set.isEmpty()) {
|
|
status_ok = true;
|
|
status = QStringLiteral(u"有效");
|
|
QString item_name = QStringLiteral(u"符合粒子能量数据");
|
|
QStandardItem* conform_energy_data_item = nullptr;
|
|
if (node_map.contains(item_name)) {
|
|
conform_energy_data_item = node_map[item_name];
|
|
this->SetNodeStatus(conform_energy_data_item, status, status_ok);
|
|
}
|
|
for (int conform_time_win : time_win_file_name_set.keys()) {
|
|
const auto& conform_energy_data_filename_list = pro_model->GetTimeWinConformEnergyDataFilenameList(conform_time_win);
|
|
for (auto it = conform_energy_data_filename_list.constBegin(); it!=conform_energy_data_filename_list.constEnd(); ++it) {
|
|
int order = it.key();
|
|
if (conform_energy_data_item) {
|
|
QString item_name = QStringLiteral(u"%1个粒子符合[%2ns]").arg(order).arg(conform_time_win);
|
|
if ( !node_map.contains(item_name) ) {
|
|
const QVariant& analys_type = QVariant::fromValue(AnalysisType::CoincidenceParticleEnergyData);
|
|
QStandardItem* node_item = AddChildNode(conform_energy_data_item, item_name, status, analys_type, true, status_ok);
|
|
node_item->setData(project_name, ProjectName);
|
|
QVariantList conform_info { conform_time_win, order };
|
|
node_item->setData(conform_info, ConformInfo);
|
|
node_map[item_name] = node_item;
|
|
} else {
|
|
auto ch_energy_count_item = node_map[item_name];
|
|
this->SetNodeStatus(ch_energy_count_item, status, status_ok);
|
|
}
|
|
}
|
|
if (!conform_energy_data_filename_list.isEmpty()) {
|
|
item_name = QStringLiteral(u"符合能谱[%1ns]").arg(conform_time_win);
|
|
if (node_map.contains(item_name)) {
|
|
auto energy_total_count_spec_item = node_map[item_name];
|
|
this->SetNodeStatus(energy_total_count_spec_item, status, status_ok);
|
|
}
|
|
item_name = QStringLiteral(u"二维符合能谱[%1ns]").arg(conform_time_win);
|
|
if (node_map.contains(item_name)) {
|
|
auto energy_total_count_spec_item = node_map[item_name];
|
|
this->SetNodeStatus(energy_total_count_spec_item, status, status_ok);
|
|
}
|
|
item_name = QStringLiteral(u"三维符合能谱[%1ns]").arg(conform_time_win);
|
|
if (node_map.contains(item_name)) {
|
|
auto energy_total_count_spec_item = node_map[item_name];
|
|
this->SetNodeStatus(energy_total_count_spec_item, status, status_ok);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
pro_model->SaveProjectModel();
|
|
}
|
|
}
|
|
|
|
void MeasureAnalysisProjectModelList::onEnergyScaleAntiCoincidenceDataFinished(bool ok, const QString &project_name, const QVariant &data)
|
|
{
|
|
Q_UNUSED(data);
|
|
if ( !ok )
|
|
return;
|
|
if (this->_project_models.contains(project_name)) {
|
|
auto pro_model = this->_project_models[project_name];
|
|
auto& node_map = this->_project_node_items[project_name];
|
|
const auto& anti_conform_energy_data = pro_model->GetAntiConformEnergyData();
|
|
for (const auto& time_win : anti_conform_energy_data.keys()) {
|
|
bool status_ok = false;
|
|
QString status = QStringLiteral(u"无效");
|
|
const QString& data_filename = anti_conform_energy_data.value(time_win);
|
|
if ( (!data_filename.isEmpty()) && QFile::exists(data_filename) ) {
|
|
status_ok = true;
|
|
status = QStringLiteral(u"有效");
|
|
}
|
|
QString item_name = QStringLiteral(u"反符合能谱[%1ns]").arg(time_win);
|
|
if (node_map.contains(item_name)) {
|
|
auto anti_conform_erergy_spec_item = node_map[item_name];
|
|
this->SetNodeStatus(anti_conform_erergy_spec_item, status, status_ok);
|
|
}
|
|
}
|
|
pro_model->SaveProjectModel();
|
|
}
|
|
}
|
|
|
|
void MeasureAnalysisProjectModelList::intiProjectNodeStruce(MeasureAnalysisProjectModel* pro_model)
|
|
{
|
|
if (!pro_model) {
|
|
return;
|
|
}
|
|
|
|
QMap<QString, QStandardItem*> node_map;
|
|
QStandardItem* root_item = invisibleRootItem();
|
|
|
|
const QString& project_name = pro_model->GetProjectName();
|
|
QString status = pro_model->GetIsMeasureComplete() ? QStringLiteral(u"测量完成") : QStringLiteral(u"未测量");
|
|
QVariant analys_type = QVariant::fromValue(AnalysisType::Project);
|
|
QStandardItem* project_item = AddChildNode(root_item, project_name, status, analys_type, false, true);
|
|
project_item->setData(project_name, ProjectName);
|
|
node_map[project_name] = project_item;
|
|
|
|
// 测量控制
|
|
QString item_name = QStringLiteral(u"测量控制");
|
|
analys_type = QVariant::fromValue(AnalysisType::None);
|
|
QStandardItem* measure_ctrl_item = AddChildNode(project_item, item_name, QString(), analys_type, true, true);
|
|
measure_ctrl_item->setData(project_name, ProjectName);
|
|
node_map[item_name] = measure_ctrl_item;
|
|
|
|
const QString& measure_device_params_cfg_filename = pro_model->GetMeasureDeviceParamsCfgFilename();
|
|
bool status_ok = !measure_device_params_cfg_filename.isEmpty();
|
|
status = status_ok ? QStringLiteral(u"已配置") : QStringLiteral(u"未配置");
|
|
analys_type = QVariant::fromValue(AnalysisType::DeviceParamsCfg);
|
|
item_name = QStringLiteral(u"设备配置参数");
|
|
QStandardItem* node_item = AddChildNode(measure_ctrl_item, item_name, status, analys_type, true, status_ok);
|
|
node_item->setData(project_name, ProjectName);
|
|
node_map[item_name] = node_item;
|
|
|
|
status_ok = !pro_model->GetEnergyScaleFilename().isEmpty();
|
|
status = status_ok ? QStringLiteral(u"已配置") : QStringLiteral(u"未配置");
|
|
analys_type = QVariant::fromValue(AnalysisType::EnergyScale);
|
|
item_name = QStringLiteral(u"能量刻度");
|
|
node_item = AddChildNode(measure_ctrl_item, item_name, status, analys_type, true, status_ok);
|
|
node_item->setData(project_name, ProjectName);
|
|
node_map[item_name] = node_item;
|
|
|
|
status_ok = !pro_model->GetEfficiencyScaleFilename().isEmpty();
|
|
status = status_ok ? QStringLiteral(u"已配置") : QStringLiteral(u"未配置");
|
|
analys_type = QVariant::fromValue(AnalysisType::EfficiencyScale);
|
|
item_name = QStringLiteral(u"效率刻度");
|
|
node_item = AddChildNode(measure_ctrl_item, item_name, status, analys_type, true, status_ok);
|
|
node_item->setData(project_name, ProjectName);
|
|
node_map[item_name] = node_item;
|
|
|
|
// 分析数据
|
|
item_name = QStringLiteral(u"分析数据");
|
|
analys_type = QVariant::fromValue(AnalysisType::None);
|
|
QStandardItem* analysis_data_item = AddChildNode(project_item, item_name, QString(), analys_type, true, true);
|
|
analysis_data_item->setData(project_name, ProjectName);
|
|
node_map[item_name] = node_item;
|
|
|
|
status_ok = !pro_model->GetAllChannelParticleDataFilename().isEmpty();
|
|
status = status_ok ? QStringLiteral(u"有效") : QStringLiteral(u"无效");
|
|
analys_type = QVariant::fromValue(AnalysisType::ParticleData);
|
|
item_name = QStringLiteral(u"测量粒子数据");
|
|
node_item = AddChildNode(analysis_data_item, item_name, status, analys_type, true, status_ok);
|
|
node_item->setData(project_name, ProjectName);
|
|
node_map[item_name] = node_item;
|
|
|
|
const auto& ch_addr_count_data_filename_list = pro_model->GetChannelAddressCountDataFilenameList();
|
|
status_ok = !ch_addr_count_data_filename_list.isEmpty();
|
|
status = status_ok ? QStringLiteral(u"有效") : QStringLiteral(u"无效");
|
|
item_name = QStringLiteral(u"道址计数");
|
|
analys_type = QVariant::fromValue(AnalysisType::None);
|
|
node_item = AddChildNode(analysis_data_item, item_name, status, analys_type, true, status_ok);
|
|
node_item->setData(project_name, ProjectName);
|
|
node_map[item_name] = node_item;
|
|
QStandardItem* adrr_count_item = node_item;
|
|
for (auto it = ch_addr_count_data_filename_list.begin(); it != ch_addr_count_data_filename_list.end(); ++it) {
|
|
uint ch_num = it.key();
|
|
QString item_name = QStringLiteral(u"通道%1道址计数").arg(ch_num);
|
|
const QVariant& analys_type = QVariant::fromValue(AnalysisType::AddressCountData);
|
|
QStandardItem* node_item = AddChildNode(adrr_count_item, item_name, status, analys_type, true, status_ok);
|
|
node_item->setData(project_name, ProjectName);
|
|
node_item->setData(ch_num, ChannelNum);
|
|
node_map[item_name] = node_item;
|
|
}
|
|
|
|
status_ok = !pro_model->GetParticleEnergyDataFilename().isEmpty();
|
|
status = status_ok ? QStringLiteral(u"有效") : QStringLiteral(u"无效");
|
|
analys_type = QVariant::fromValue(AnalysisType::ParticleEnergyData);
|
|
item_name = QStringLiteral(u"粒子能量数据");
|
|
node_item = AddChildNode(analysis_data_item, item_name, status, analys_type, true, status_ok);
|
|
node_item->setData(project_name, ProjectName);
|
|
node_map[item_name] = node_item;
|
|
|
|
status_ok = !pro_model->GetAllChannelEnergyTotalCountDataFilename().isEmpty();
|
|
status = status_ok ? QStringLiteral(u"有效") : QStringLiteral(u"无效");
|
|
item_name = QStringLiteral(u"能量计数");
|
|
analys_type = QVariant::fromValue(AnalysisType::EnergyCountData);
|
|
node_item = AddChildNode(analysis_data_item, item_name, status, analys_type, true, status_ok);
|
|
node_item->setData(project_name, ProjectName);
|
|
node_map[item_name] = node_item;
|
|
QStandardItem* energy_count_item = node_item;
|
|
const auto& ch_energy_count_data_filename_list = pro_model->GetChannelEnergyCountDataFilenameList();
|
|
status_ok = !ch_energy_count_data_filename_list.isEmpty();
|
|
for (auto it = ch_energy_count_data_filename_list.begin(); it != ch_energy_count_data_filename_list.end(); ++it) {
|
|
uint ch_num = it.key();
|
|
QString item_name = QStringLiteral(u"通道%1能量计数").arg(ch_num);
|
|
const QVariant& analys_type = QVariant::fromValue(AnalysisType::ChannelEnergyCountData);
|
|
QStandardItem* node_item = AddChildNode(energy_count_item, item_name, status, analys_type, true, status_ok);
|
|
node_item->setData(project_name, ProjectName);
|
|
node_item->setData(ch_num, ChannelNum);
|
|
node_map[item_name] = node_item;
|
|
}
|
|
|
|
uint conform_time_win = pro_model->GetConformTimeWin();
|
|
status_ok = !pro_model->GetTimeWinConformEnergyDataFilenameList(conform_time_win).isEmpty();
|
|
status = status_ok ? QStringLiteral(u"有效") : QStringLiteral(u"无效");
|
|
item_name = QStringLiteral(u"符合粒子能量数据");
|
|
analys_type = QVariant::fromValue(AnalysisType::None);
|
|
QStandardItem* conform_energy_data_group_item = AddChildNode(analysis_data_item, item_name, status, analys_type, true, status_ok);
|
|
conform_energy_data_group_item->setData(project_name, ProjectName);
|
|
node_map[item_name] = conform_energy_data_group_item;
|
|
|
|
auto time_win_file_name_set = pro_model->GetConformParticleEnergyDataFilenameList();
|
|
for (int conform_time_win : time_win_file_name_set.keys()) {
|
|
const auto& conform_energy_data_filename_list = pro_model->GetTimeWinConformEnergyDataFilenameList(conform_time_win);
|
|
for (auto it = conform_energy_data_filename_list.constBegin(); it!=conform_energy_data_filename_list.constEnd(); ++it) {
|
|
int order = it.key();
|
|
status_ok = !it.value().isEmpty();
|
|
status = status_ok ? QStringLiteral(u"有效") : QStringLiteral(u"无效");
|
|
QString item_name = QStringLiteral(u"%1个粒子符合[%2ns]").arg(order).arg(conform_time_win);
|
|
const QVariant& analys_type = QVariant::fromValue(AnalysisType::CoincidenceParticleEnergyData);
|
|
QStandardItem* node_item = AddChildNode(conform_energy_data_group_item, item_name, status, analys_type, true, status_ok);
|
|
node_item->setData(project_name, ProjectName);
|
|
QVariantList conform_info { conform_time_win, order };
|
|
node_item->setData(conform_info, ConformInfo);
|
|
node_map[item_name] = node_item;
|
|
}
|
|
}
|
|
|
|
// 交互分析
|
|
item_name = QStringLiteral(u"交互分析");
|
|
QStandardItem* interactive_analysis_item = AddChildNode(project_item, item_name, QString(), QVariant(), true, true);
|
|
interactive_analysis_item->setData(project_name, ProjectName);
|
|
node_map[item_name] = interactive_analysis_item;
|
|
|
|
status_ok = !pro_model->GetChannelAddressCountDataFilenameList().isEmpty();
|
|
status = status_ok ? QStringLiteral(u"有效") : QStringLiteral(u"无效");
|
|
analys_type = QVariant::fromValue(AnalysisType::AddressCountSpectrumView);
|
|
item_name = QStringLiteral(u"道址计数谱");
|
|
node_item = AddChildNode(interactive_analysis_item, item_name, status, analys_type, true, status_ok);
|
|
node_item->setData(project_name, ProjectName);
|
|
node_map[item_name] = node_item;
|
|
|
|
status_ok = !pro_model->GetAllChannelEnergyTotalCountDataFilename().isEmpty();
|
|
status_ok &= !pro_model->GetChannelEnergyCountDataFilenameList().isEmpty();
|
|
status = status_ok ? QStringLiteral(u"有效") : QStringLiteral(u"无效");
|
|
analys_type = QVariant::fromValue(AnalysisType::EnergyCountSpectrumView);
|
|
item_name = QStringLiteral(u"能量计数谱");
|
|
node_item = AddChildNode(interactive_analysis_item, item_name, status, analys_type, true, status_ok);
|
|
node_item->setData(project_name, ProjectName);
|
|
node_map[item_name] = node_item;
|
|
|
|
status_ok = !pro_model->GetParticleEnergyDataFilename().isEmpty();
|
|
status = status_ok ? QStringLiteral(u"有效") : QStringLiteral(u"无效");
|
|
analys_type = QVariant::fromValue(AnalysisType::CountingRateView);
|
|
item_name = QStringLiteral(u"计数率分析");
|
|
node_item = AddChildNode(interactive_analysis_item, item_name, status, analys_type, true, status_ok);
|
|
node_item->setData(project_name, ProjectName);
|
|
node_map[item_name] = node_item;
|
|
|
|
status_ok = !pro_model->GetParticleEnergyDataFilename().isEmpty();
|
|
status = status_ok ? QStringLiteral(u"有效") : QStringLiteral(u"无效");
|
|
analys_type = QVariant::fromValue(AnalysisType::EnergyPeakFitView);
|
|
item_name = QStringLiteral(u"峰拟合分析");
|
|
node_item = AddChildNode(interactive_analysis_item, item_name, status, analys_type, true, status_ok);
|
|
node_item->setData(project_name, ProjectName);
|
|
node_map[item_name] = node_item;
|
|
|
|
status_ok = !pro_model->GetParticleEnergyDataFilename().isEmpty();
|
|
status = status_ok ? QStringLiteral(u"有效") : QStringLiteral(u"无效");
|
|
analys_type = QVariant::fromValue(AnalysisType::NuclideAnalysisView);
|
|
item_name = QStringLiteral(u"核素分析");
|
|
node_item = AddChildNode(interactive_analysis_item, item_name, status, analys_type, true, status_ok);
|
|
node_item->setData(project_name, ProjectName);
|
|
node_map[item_name] = node_item;
|
|
|
|
status_ok = !pro_model->GetParticleEnergyDataFilename().isEmpty();
|
|
status = status_ok ? QStringLiteral(u"有效") : QStringLiteral(u"无效");
|
|
analys_type = QVariant::fromValue(AnalysisType::ParticleInTimeView);
|
|
item_name = QStringLiteral(u"粒子入射时间分析");
|
|
node_item = AddChildNode(interactive_analysis_item, item_name, status, analys_type, true, status_ok);
|
|
node_item->setData(project_name, ProjectName);
|
|
node_map[item_name] = node_item;
|
|
|
|
status_ok = !pro_model->GetAllChannelParticleDataFilename().isEmpty();
|
|
status = status_ok ? QStringLiteral(u"有效") : QStringLiteral(u"无效");
|
|
analys_type = QVariant::fromValue(AnalysisType::ParticleTimeDiffView);
|
|
item_name = QStringLiteral(u"粒子时间差分析");
|
|
node_item = AddChildNode(interactive_analysis_item, item_name, status, analys_type, true, status_ok);
|
|
node_item->setData(project_name, ProjectName);
|
|
node_map[item_name] = node_item;
|
|
|
|
status_ok = !pro_model->GetTimeWinConformEnergyDataFilenameList(conform_time_win).isEmpty();
|
|
status = status_ok ? QStringLiteral(u"有效") : QStringLiteral(u"无效");
|
|
analys_type = QVariant::fromValue(AnalysisType::CoincidenceEventTimeView);
|
|
item_name = QStringLiteral(u"符合事件时间分析");
|
|
node_item = AddChildNode(interactive_analysis_item, item_name, status, analys_type, true, status_ok);
|
|
node_item->setData(project_name, ProjectName);
|
|
node_map[item_name] = node_item;
|
|
|
|
status_ok = !pro_model->GetTimeWinConformEnergyDataFilenameList(conform_time_win).isEmpty();
|
|
status = status_ok ? QStringLiteral(u"有效") : QStringLiteral(u"无效");
|
|
analys_type = QVariant::fromValue(AnalysisType::CoincidenceParticleEnergySpectrumView);
|
|
item_name = QStringLiteral(u"符合能谱[%1ns]").arg(conform_time_win);
|
|
node_item = AddChildNode(interactive_analysis_item, item_name, status, analys_type, true, status_ok);
|
|
node_item->setData(project_name, ProjectName);
|
|
node_map[item_name] = node_item;
|
|
|
|
analys_type = QVariant::fromValue(AnalysisType::AntiCoincidenceSpectrumView);
|
|
item_name = QStringLiteral(u"反符合能谱[%1ns]").arg(conform_time_win);
|
|
node_item = AddChildNode(interactive_analysis_item, item_name, status, analys_type, true, status_ok);
|
|
node_item->setData(project_name, ProjectName);
|
|
node_map[item_name] = node_item;
|
|
|
|
status_ok = !pro_model->GetTimeWinConformEnergyDataFilenameList(conform_time_win).isEmpty();
|
|
status = status_ok ? QStringLiteral(u"有效") : QStringLiteral(u"无效");
|
|
analys_type = QVariant::fromValue(AnalysisType::CoincidenceParticleEnergySpectrum2DView);
|
|
item_name = QStringLiteral(u"二维符合能谱[%1ns]").arg(conform_time_win);
|
|
node_item = AddChildNode(interactive_analysis_item, item_name, status, analys_type, true, status_ok);
|
|
node_item->setData(project_name, ProjectName);
|
|
node_map[item_name] = node_item;
|
|
|
|
status_ok = !pro_model->GetTimeWinConformEnergyDataFilenameList(conform_time_win).isEmpty();
|
|
status = status_ok ? QStringLiteral(u"有效") : QStringLiteral(u"无效");
|
|
analys_type = QVariant::fromValue(AnalysisType::CoincidenceParticleEnergySpectrum3DView);
|
|
item_name = QStringLiteral(u"三维符合能谱[%1ns]").arg(conform_time_win);
|
|
node_item = AddChildNode(interactive_analysis_item, item_name, status, analys_type, true, status_ok);
|
|
node_item->setData(project_name, ProjectName);
|
|
node_map[item_name] = node_item;
|
|
|
|
_project_node_items[project_name] = node_map;
|
|
|
|
LOG_INFO(QStringLiteral(u"测量分析项目\"%1\"创建成功.").arg(project_name));
|
|
if (!pro_model->GetIsMeasureComplete()) {
|
|
if (pro_model->GetMeasureDeviceParamsCfgFilename().isEmpty()) {
|
|
LOG_WARN(QStringLiteral(u"测量分析项目\"%1\"测量设备参数未配置!").arg(project_name));
|
|
}
|
|
}
|
|
if (pro_model->GetEnergyScaleFilename().isEmpty()) {
|
|
LOG_WARN(QStringLiteral(u"测量分析项目\"%1\"能量刻度未配置!").arg(project_name));
|
|
}
|
|
if (pro_model->GetEfficiencyScaleFilename().isEmpty()) {
|
|
LOG_WARN(QStringLiteral(u"测量分析项目\"%1\"效率刻度未配置!").arg(project_name));
|
|
}
|
|
}
|