Merge branch 'master' of github.com:aglowacki/XRF-Maps

Arthur Glowacki · Arthur Glowacki · commit 3c8aacaf10f6 · 2026-03-09T09:20:47.000-05:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -385,10 +385,14 @@ IF (BUILD_WITH_PYBIND11)
       IF (WIN32)
           target_link_libraries(pyxrfmaps PRIVATE libxrf_fit libxrf_io netCDF::netcdf hdf5::hdf5-shared libzmq-static ws2_32.lib rpcrt4.lib iphlpapi.lib)
       ELSEIF (UNIX)
-          target_link_libraries(pyxrfmaps PRIVATE libxrf_fit libxrf_io netCDF::netcdf hdf5::hdf5-shared libzmq-static)
+          target_link_libraries(pyxrfmaps PRIVATE libxrf_fit libxrf_io netCDF::netcdf libzmq-static)
       ENDIF()
     ELSE()
-        target_link_libraries(pyxrfmaps PRIVATE libxrf_fit libxrf_io netCDF::netcdf hdf5::hdf5-shared)
+        IF (WIN32)
+          target_link_libraries(pyxrfmaps PRIVATE libxrf_fit libxrf_io netCDF::netcdf hdf5::hdf5-shared)
+      ELSEIF (UNIX)
+          target_link_libraries(pyxrfmaps PRIVATE libxrf_fit libxrf_io netCDF::netcdf libzmq-static)
+      ENDIF()
     ENDIF()
 ENDIF()
 
@@ -514,8 +518,13 @@ ELSEIF (UNIX)
 ENDIF()
 
 target_link_libraries(libxrf_fit PRIVATE NLopt::nlopt ${CMAKE_THREAD_LIBS_INIT} )
-target_link_libraries(libxrf_io PRIVATE libxrf_fit netCDF::netcdf hdf5::hdf5-shared yaml-cpp::yaml-cpp JsonCpp::JsonCpp NLopt::nlopt ${CMAKE_THREAD_LIBS_INIT} )
-target_link_libraries (xrf_maps PRIVATE libxrf_io libxrf_fit netCDF::netcdf hdf5::hdf5-shared yaml-cpp::yaml-cpp JsonCpp::JsonCpp NLopt::nlopt ${CMAKE_THREAD_LIBS_INIT} )
+IF (WIN32)
+  target_link_libraries(libxrf_io PRIVATE libxrf_fit netCDF::netcdf hdf5::hdf5-shared yaml-cpp::yaml-cpp JsonCpp::JsonCpp NLopt::nlopt ${CMAKE_THREAD_LIBS_INIT} )
+  target_link_libraries (xrf_maps PRIVATE libxrf_io libxrf_fit netCDF::netcdf hdf5::hdf5-shared yaml-cpp::yaml-cpp JsonCpp::JsonCpp NLopt::nlopt ${CMAKE_THREAD_LIBS_INIT} )
+ELSEIF (UNIX)
+  target_link_libraries(libxrf_io PRIVATE libxrf_fit netCDF::netcdf yaml-cpp::yaml-cpp JsonCpp::JsonCpp NLopt::nlopt ${CMAKE_THREAD_LIBS_INIT} )
+  target_link_libraries (xrf_maps PRIVATE libxrf_io libxrf_fit netCDF::netcdf yaml-cpp::yaml-cpp JsonCpp::JsonCpp NLopt::nlopt ${CMAKE_THREAD_LIBS_INIT} )
+ENDIF()
 
 IF (BUILD_WITH_QT)
   target_link_libraries (libxrf_io LINK_PUBLIC ${Qt6Charts_LIBRARIES} )
diff --git a/reference/Scaler_to_PV_map.yaml b/reference/Scaler_to_PV_map.yaml
@@ -14,8 +14,6 @@ BeamLines:
       US_IC: 2idd:scaler1_cts1.C
       DS_IC: 
         - 2idd:scaler1_cts1.B
-        - 2iddtmm1:Current4:MeanValue_RBV
-        - 2iddtmm1:Current4
       DS_IC_SCALE_FACTOR: 2iddtmm1:CurrentScale4
       ELT1: 2iddXMAP:mca1.ELTM
       ELT2: 2iddXMAP:mca2.ELTM
diff --git a/src/core/process_whole.cpp b/src/core/process_whole.cpp
diff --git a/src/data_struct/detector.cpp b/src/data_struct/detector.cpp
@@ -186,6 +186,7 @@ void Detector<T_real>::update_element_quants(Fitting_Routines routine,
                                 // e_cal_ratio defined as 0 , add this value. If we have multiple standards
                                 // then we will normalize this later .
                                 eq_itr.e_cal_ratio += (T_real)1.0 / e_cal;
+                                logI<<"Ecal : "<<eq_itr.e_cal_ratio<<"\n";
 
                             }
                             else
@@ -248,15 +249,15 @@ void Detector<T_real>::avg_element_quants(Fitting_Routines routine,
 template<typename T_real>
 void Detector<T_real>::generage_avg_quantification_scalers()
 {
-    T_real avg_sr_current = 0.0;
-    T_real avg_US_IC = 0.0;
-    T_real avg_US_FM = 0.0;
-    T_real avg_DS_IC = 0.0;
-
-    T_real crnt_cnt = 0.0;
-    T_real us_cnt = 0.0;
-    T_real us_fm_cnt = 0.0;
-    T_real ds_cnt = 0.0;
+    T_real avg_sr_current = (T_real)0.0;
+    T_real avg_US_IC = (T_real)0.0;
+    T_real avg_US_FM = (T_real)0.0;
+    T_real avg_DS_IC = (T_real)0.0;
+
+    T_real crnt_cnt = (T_real)0.0;
+    T_real us_cnt = (T_real)0.0;
+    T_real us_fm_cnt = (T_real)0.0;
+    T_real ds_cnt = (T_real)0.0;
 
     //average quantification scalers
     for (const auto& itr : quantification_standards)
diff --git a/src/data_struct/fit_element_map.cpp b/src/data_struct/fit_element_map.cpp
@@ -81,9 +81,9 @@ Fit_Element_Map<T_real>::Fit_Element_Map(std::string name, Element_Info<T_real>*
     else
     {
         std::string str_shell = _full_name.substr(idx);
-        if (str_shell == "L")
+        if (str_shell == "M")
         {
-            _shell_type = Electron_Shell::L_SHELL;
+            _shell_type = Electron_Shell::M_SHELL;
         }
         else if (str_shell == "L")
         {
diff --git a/src/data_struct/fit_parameters.cpp b/src/data_struct/fit_parameters.cpp
@@ -210,7 +210,7 @@ void Fit_Parameters<T_real>::from_array_d(const std::vector<double> &arr)
     {
         if (itr.second.opt_array_index != -1 && itr.second.opt_array_index < arr.size())
         {
-            itr.second.value = arr[itr.second.opt_array_index];
+            itr.second.value = static_cast<T_real>(arr[itr.second.opt_array_index]);
         }
     }
 }
diff --git a/src/io/file/aps/aps_roi.h b/src/io/file/aps/aps_roi.h
@@ -129,7 +129,7 @@ DLL_EXPORT bool load_v10_rois(std::string path, std::map<std::string, std::vecto
                         && json_spectra.isMember(STR_ICR.c_str())
                         && json_spectra.isMember(STR_OCR.c_str()))
                     {
-                        std::string filename = json_spectra[STR_MAP_ROI_INT_SPEC_FILENAME.c_str()].asString();
+                        std::string filename = json_spectra[STR_MAP_ROI_INT_SPEC_FILENAME.c_str()].asString() + roi_name;
                         const Json::Value json_spectra_values = json_spectra[STR_SPECTRA.c_str()];
                         int_specs[filename].resize(json_spectra_values.size());
                         int_specs[filename].elapsed_livetime(json_spectra[STR_ELT.c_str()].asDouble());
diff --git a/src/io/file/hdf5_io.h b/src/io/file/hdf5_io.h
@@ -1658,6 +1658,13 @@ class DLL_EXPORT HDF5_IO
                     ocr_array.setOnes();
                 }
             }
+            else
+            {
+                elt_array.setOnes();
+                ert_array.setOnes();
+                icr_array.setOnes();
+                ocr_array.setOnes();
+            }
             err = _read_h5d<T_real2>(energy_dset_id, H5S_ALL, energy_space_id, H5P_DEFAULT, energy_array.data());
             if(err < 0)
             {
@@ -1694,6 +1701,9 @@ class DLL_EXPORT HDF5_IO
             int left_pol_idx = 0;
             int right_pol_idx = 0;
 
+            int scaler_idx = 0;
+            int scaler_cntr = 0;
+            int scaler_inc = params_override->polarity_pattern.size();
             for(size_t i = 0; i < dims3[0]; i++)
             {
                 offset3[0] = i;
@@ -1774,11 +1784,21 @@ class DLL_EXPORT HDF5_IO
                 (*spec_vol)[polarity][idx].input_counts(icr_array[i]);
                 (*spec_vol)[polarity][idx].output_counts(ocr_array[i]);
 
-                energy_map.values(polarity, idx) = energy_array[i];
-                i0_map.values(polarity, idx) = i0_array[i];
+                
+                energy_map.values(0, idx) = energy_array[scaler_idx];
+                energy_map.values(1, idx) = energy_array[scaler_idx];
+                i0_map.values(0, idx) = i0_array[scaler_idx];
+                i0_map.values(1, idx) = i0_array[scaler_idx];
 
-                dtf_map.values(polarity, idx) = dtf_array[i];
-                dtp_map.values(polarity, idx) = dtp_array[i];
+                scaler_cntr ++;
+                if(scaler_cntr > scaler_inc)
+                {
+                    scaler_cntr = 0;
+                    scaler_idx ++;
+                }   
+                
+                dtf_map.values(0, idx) = dtf_array[i];
+                dtp_map.values(0, idx) = dtp_array[i];
             }
 
             scan_info.scaler_maps.push_back(dtf_map);
diff --git a/src/io/file/hl_file_io.h b/src/io/file/hl_file_io.h
@@ -688,22 +688,24 @@ DLL_EXPORT bool load_and_integrate_spectra_volume(std::string dataset_directory,
                         size_t spec_size = io::file::NetCDF_IO<T_real>::inst()->load_scalers_line(full_filename, "tetra2_", i, mda_io.get_scan_info(), params_override);
                     }
                 }
-                T_real val = mda_io.get_scan_info()->scaler_avg_value(STR_US_IC);
-                if(val > (T_real)0.0)
+                if(params_override != nullptr)
                 {
-                    params_override->US_IC = val;
-                }
-                val = mda_io.get_scan_info()->scaler_avg_value(STR_DS_IC);
-                if(val > (T_real)0.0)
-                {
-                    params_override->DS_IC = val;
-                }
-                val = mda_io.get_scan_info()->scaler_avg_value(STR_US_FM);
-                if(val > (T_real)0.0)
-                {
-                    params_override->US_FM = val;
+                    T_real val = mda_io.get_scan_info()->scaler_avg_value(STR_US_IC);
+                    if(val > (T_real)0.0)
+                    {
+                        params_override->US_IC = val;
+                    }
+                    val = mda_io.get_scan_info()->scaler_avg_value(STR_DS_IC);
+                    if(val > (T_real)0.0)
+                    {
+                        params_override->DS_IC = val;
+                    }
+                    val = mda_io.get_scan_info()->scaler_avg_value(STR_US_FM);
+                    if(val > (T_real)0.0)
+                    {
+                        params_override->US_FM = val;
+                    }
                 }
-                
             }
             if (hasNetcdf)
             {
@@ -1232,13 +1234,14 @@ DLL_EXPORT bool load_spectra_volume(std::string dataset_directory,
     }
 
     // try to load spectra from mda file
-    if (false == mda_io.load_spectra_volume(dataset_directory + "mda" + DIR_END_CHAR + dataset_file, detector_num, spectra_volume, (hasNetcdf || hasBnpNetcdf || hasHdf || hasXspress), hasNetcdf))
+    auto mda_ret_val = mda_io.load_spectra_volume(dataset_directory + "mda" + DIR_END_CHAR + dataset_file, detector_num, spectra_volume, (hasNetcdf || hasBnpNetcdf || hasHdf || hasXspress), hasNetcdf);
+    if (Load_Status::Failed == mda_ret_val)
     {
         scan_type = STR_SCAN_TYPE_2D_MAP;
         logE << "Load spectra " << dataset_directory + "mda" + DIR_END_CHAR + dataset_file << "\n";
         return false;
     }
-    else
+    else if (Load_Status::Half_need_spectra == mda_ret_val)
     {
         // tetramm is scalers only
         if(hasTetraMM)
diff --git a/src/io/file/mda_io.cpp b/src/io/file/mda_io.cpp
@@ -233,7 +233,7 @@ bool MDA_IO<T_real>::load_quantification_scalers(std::string path, data_struct::
 //-----------------------------------------------------------------------------
 
 template<typename T_real>
-bool MDA_IO<T_real>::load_spectra_volume(std::string path,
+Load_Status MDA_IO<T_real>::load_spectra_volume(std::string path,
                                  size_t detector_num,
                                  data_struct::Spectra_Volume<T_real>* vol,
                                  bool hasNetCDF,
@@ -252,22 +252,22 @@ bool MDA_IO<T_real>::load_spectra_volume(std::string path,
 
     if (fptr == nullptr)
     {
-        return false;
+        return Load_Status::Failed;
     }
 
 
     _mda_file = mda_load(fptr);
     std::fclose(fptr);
     if (_mda_file == nullptr || vol == nullptr)
     {
-        return false;
+        return Load_Status::Failed;
     }
     logI<<"mda info ver:"<<_mda_file->header->version<<" data rank:"<<_mda_file->header->data_rank<<"\n";
 
     if (_mda_file->header->data_rank == 1)
     {
         logE << "Cannot load mda file data rank == 1" << "\n";
-        return false;
+        return Load_Status::Failed;
     }
 
     _load_scalers(false,hasNetCDF, subtract_two_cols);
@@ -311,7 +311,7 @@ bool MDA_IO<T_real>::load_spectra_volume(std::string path,
             }
 
             vol->resize_and_zero(rows, cols, 2048);
-            return true;
+            return Load_Status::Half_need_spectra;
         }
         else
         {
@@ -322,7 +322,7 @@ bool MDA_IO<T_real>::load_spectra_volume(std::string path,
                 {
                     logE<<"Max detectors saved = "<<_mda_file->scan->sub_scans[0]->number_detectors<< "\n";
                     unload();
-                    return false;
+                    return Load_Status::Failed;
                 }
 
                 rows = 1;
@@ -347,7 +347,7 @@ bool MDA_IO<T_real>::load_spectra_volume(std::string path,
                 //if not then we don't know what is dataset is.
                 logE << "Don't understand this dataset layout. Can not load it.\n";
                 unload();
-                return false;
+                return Load_Status::Failed;
             }
         }
     }
@@ -392,15 +392,15 @@ bool MDA_IO<T_real>::load_spectra_volume(std::string path,
                     cols = 1;
                 }
                 vol->resize_and_zero(rows, cols, 2048);
-                return true;
+                return Load_Status::Half_need_spectra;
             }
             // TODO: might need to check if is XANES like above 
         }
         if(_mda_file->scan->sub_scans[0]->sub_scans[0]->number_detectors-1 < (int)detector_num)
         {
             logE<<"Max detectors saved = "<<_mda_file->scan->sub_scans[0]->sub_scans[0]->number_detectors<< "\n";
             unload();
-            return false;
+            return Load_Status::Failed;
         }
 
         if(_mda_file->scan->requested_points == 0 || _mda_file->scan->last_point == 0)
@@ -442,7 +442,7 @@ bool MDA_IO<T_real>::load_spectra_volume(std::string path,
     {
         logE<<" No support for data rank "<< _mda_file->header->data_rank <<"\n";
         unload();
-        return false;
+        return Load_Status::Failed;
     }
 
     elt_arr = _scan_info.scaler_values(STR_ELT + std::to_string(detector_num + 1));
@@ -524,10 +524,10 @@ bool MDA_IO<T_real>::load_spectra_volume(std::string path,
     {
         logE<<"Caught exception loading mda file."<<"\n";
         std::cerr << "Exception catched : " << e.what() << "\n";
-        return false;
+        return Load_Status::Failed;
     }
 
-    return true;
+    return Load_Status::Loaded;
 }
 
 
diff --git a/src/io/file/mda_io.h b/src/io/file/mda_io.h
@@ -81,6 +81,8 @@ namespace io
 namespace file
 {
 
+enum class Load_Status{ Failed, Half_need_spectra, Loaded };
+
 template<typename T_real>
 class DLL_EXPORT MDA_IO
 {
@@ -101,7 +103,7 @@ class DLL_EXPORT MDA_IO
 
     bool load_scalers(std::string path);
 
-    bool load_spectra_volume(std::string path,
+    Load_Status load_spectra_volume(std::string path,
                             size_t detector_num,
                             data_struct::Spectra_Volume<T_real>* vol,
                             bool hasNetCDF,
diff --git a/src/io/file/netcdf_io.cpp b/src/io/file/netcdf_io.cpp
diff --git a/src/quantification/models/quantification_model.cpp b/src/quantification/models/quantification_model.cpp

Original file line number	Diff line number	Diff line change
`@@ -81,9 +81,9 @@ Fit_Element_Map<T_real>::Fit_Element_Map(std::string name, Element_Info<T_real>*`
`81`	`81`	`else`
`82`	`82`	`{`
`83`	`83`	`std::string str_shell = _full_name.substr(idx);`
`84`		`- if (str_shell == "L")`
	`84`	`+ if (str_shell == "M")`
`85`	`85`	`{`
`86`		`- _shell_type = Electron_Shell::L_SHELL;`
	`86`	`+ _shell_type = Electron_Shell::M_SHELL;`
`87`	`87`	`}`
`88`	`88`	`else if (str_shell == "L")`
`89`	`89`	`{`
Original file line number	Diff line number	Diff line change
`@@ -210,7 +210,7 @@ void Fit_Parameters<T_real>::from_array_d(const std::vector<double> &arr)`
`210`	`210`	`{`
`211`	`211`	`if (itr.second.opt_array_index != -1 && itr.second.opt_array_index < arr.size())`
`212`	`212`	`{`
`213`		`- itr.second.value = arr[itr.second.opt_array_index];`
	`213`	`+ itr.second.value = static_cast<T_real>(arr[itr.second.opt_array_index]);`
`214`	`214`	`}`
`215`	`215`	`}`
`216`	`216`	`}`
Original file line number	Diff line number	Diff line change
`@@ -129,7 +129,7 @@ DLL_EXPORT bool load_v10_rois(std::string path, std::map<std::string, std::vecto`
`129`	`129`	`&& json_spectra.isMember(STR_ICR.c_str())`
`130`	`130`	`&& json_spectra.isMember(STR_OCR.c_str()))`
`131`	`131`	`{`
`132`		`- std::string filename = json_spectra[STR_MAP_ROI_INT_SPEC_FILENAME.c_str()].asString();`
	`132`	`+ std::string filename = json_spectra[STR_MAP_ROI_INT_SPEC_FILENAME.c_str()].asString() + roi_name;`
`133`	`133`	`const Json::Value json_spectra_values = json_spectra[STR_SPECTRA.c_str()];`
`134`	`134`	`int_specs[filename].resize(json_spectra_values.size());`
`135`	`135`	`int_specs[filename].elapsed_livetime(json_spectra[STR_ELT.c_str()].asDouble());`
Original file line number	Diff line number	Diff line change
`@@ -688,22 +688,24 @@ DLL_EXPORT bool load_and_integrate_spectra_volume(std::string dataset_directory,`
`688`	`688`	`size_t spec_size = io::file::NetCDF_IO<T_real>::inst()->load_scalers_line(full_filename, "tetra2_", i, mda_io.get_scan_info(), params_override);`
`689`	`689`	`}`
`690`	`690`	`}`
`691`		`- T_real val = mda_io.get_scan_info()->scaler_avg_value(STR_US_IC);`
`692`		`- if(val > (T_real)0.0)`
	`691`	`+ if(params_override != nullptr)`
`693`	`692`	`{`
`694`		`- params_override->US_IC = val;`
`695`		`- }`
`696`		`- val = mda_io.get_scan_info()->scaler_avg_value(STR_DS_IC);`
`697`		`- if(val > (T_real)0.0)`
`698`		`- {`
`699`		`- params_override->DS_IC = val;`
`700`		`- }`
`701`		`- val = mda_io.get_scan_info()->scaler_avg_value(STR_US_FM);`
`702`		`- if(val > (T_real)0.0)`
`703`		`- {`
`704`		`- params_override->US_FM = val;`
	`693`	`+ T_real val = mda_io.get_scan_info()->scaler_avg_value(STR_US_IC);`
	`694`	`+ if(val > (T_real)0.0)`
	`695`	`+ {`
	`696`	`+ params_override->US_IC = val;`
	`697`	`+ }`
	`698`	`+ val = mda_io.get_scan_info()->scaler_avg_value(STR_DS_IC);`
	`699`	`+ if(val > (T_real)0.0)`
	`700`	`+ {`
	`701`	`+ params_override->DS_IC = val;`
	`702`	`+ }`
	`703`	`+ val = mda_io.get_scan_info()->scaler_avg_value(STR_US_FM);`
	`704`	`+ if(val > (T_real)0.0)`
	`705`	`+ {`
	`706`	`+ params_override->US_FM = val;`
	`707`	`+ }`
`705`	`708`	`}`
`706`		`-`
`707`	`709`	`}`
`708`	`710`	`if (hasNetcdf)`
`709`	`711`	`{`
`@@ -1232,13 +1234,14 @@ DLL_EXPORT bool load_spectra_volume(std::string dataset_directory,`
`1232`	`1234`	`}`
`1233`	`1235`
`1234`	`1236`	`// try to load spectra from mda file`
`1235`		`- if (false == mda_io.load_spectra_volume(dataset_directory + "mda" + DIR_END_CHAR + dataset_file, detector_num, spectra_volume, (hasNetcdf \|\| hasBnpNetcdf \|\| hasHdf \|\| hasXspress), hasNetcdf))`
	`1237`	`+ auto mda_ret_val = mda_io.load_spectra_volume(dataset_directory + "mda" + DIR_END_CHAR + dataset_file, detector_num, spectra_volume, (hasNetcdf \|\| hasBnpNetcdf \|\| hasHdf \|\| hasXspress), hasNetcdf);`
	`1238`	`+ if (Load_Status::Failed == mda_ret_val)`
`1236`	`1239`	`{`
`1237`	`1240`	`scan_type = STR_SCAN_TYPE_2D_MAP;`
`1238`	`1241`	`logE << "Load spectra " << dataset_directory + "mda" + DIR_END_CHAR + dataset_file << "\n";`
`1239`	`1242`	`return false;`
`1240`	`1243`	`}`
`1241`		`- else`
	`1244`	`+ else if (Load_Status::Half_need_spectra == mda_ret_val)`
`1242`	`1245`	`{`
`1243`	`1246`	`// tetramm is scalers only`
`1244`	`1247`	`if(hasTetraMM)`
Original file line number	Diff line number	Diff line change
`@@ -233,7 +233,7 @@ bool MDA_IO<T_real>::load_quantification_scalers(std::string path, data_struct::`
`233`	`233`	`//-----------------------------------------------------------------------------`
`234`	`234`
`235`	`235`	`template<typename T_real>`
`236`		`-bool MDA_IO<T_real>::load_spectra_volume(std::string path,`
	`236`	`+Load_Status MDA_IO<T_real>::load_spectra_volume(std::string path,`
`237`	`237`	`size_t detector_num,`
`238`	`238`	`data_struct::Spectra_Volume<T_real>* vol,`
`239`	`239`	`bool hasNetCDF,`
`@@ -252,22 +252,22 @@ bool MDA_IO<T_real>::load_spectra_volume(std::string path,`
`252`	`252`
`253`	`253`	`if (fptr == nullptr)`
`254`	`254`	`{`
`255`		`- return false;`
	`255`	`+ return Load_Status::Failed;`
`256`	`256`	`}`
`257`	`257`
`258`	`258`
`259`	`259`	`_mda_file = mda_load(fptr);`
`260`	`260`	`std::fclose(fptr);`
`261`	`261`	`if (_mda_file == nullptr \|\| vol == nullptr)`
`262`	`262`	`{`
`263`		`- return false;`
	`263`	`+ return Load_Status::Failed;`
`264`	`264`	`}`
`265`	`265`	`logI<<"mda info ver:"<<_mda_file->header->version<<" data rank:"<<_mda_file->header->data_rank<<"\n";`
`266`	`266`
`267`	`267`	`if (_mda_file->header->data_rank == 1)`
`268`	`268`	`{`
`269`	`269`	`logE << "Cannot load mda file data rank == 1" << "\n";`
`270`		`- return false;`
	`270`	`+ return Load_Status::Failed;`
`271`	`271`	`}`
`272`	`272`
`273`	`273`	`_load_scalers(false,hasNetCDF, subtract_two_cols);`
`@@ -311,7 +311,7 @@ bool MDA_IO<T_real>::load_spectra_volume(std::string path,`
`311`	`311`	`}`
`312`	`312`
`313`	`313`	`vol->resize_and_zero(rows, cols, 2048);`
`314`		`- return true;`
	`314`	`+ return Load_Status::Half_need_spectra;`
`315`	`315`	`}`
`316`	`316`	`else`
`317`	`317`	`{`
`@@ -322,7 +322,7 @@ bool MDA_IO<T_real>::load_spectra_volume(std::string path,`
`322`	`322`	`{`
`323`	`323`	`logE<<"Max detectors saved = "<<_mda_file->scan->sub_scans[0]->number_detectors<< "\n";`
`324`	`324`	`unload();`
`325`		`- return false;`
	`325`	`+ return Load_Status::Failed;`
`326`	`326`	`}`
`327`	`327`
`328`	`328`	`rows = 1;`
`@@ -347,7 +347,7 @@ bool MDA_IO<T_real>::load_spectra_volume(std::string path,`
`347`	`347`	`//if not then we don't know what is dataset is.`
`348`	`348`	`logE << "Don't understand this dataset layout. Can not load it.\n";`
`349`	`349`	`unload();`
`350`		`- return false;`
	`350`	`+ return Load_Status::Failed;`
`351`	`351`	`}`
`352`	`352`	`}`
`353`	`353`	`}`
`@@ -392,15 +392,15 @@ bool MDA_IO<T_real>::load_spectra_volume(std::string path,`
`392`	`392`	`cols = 1;`
`393`	`393`	`}`
`394`	`394`	`vol->resize_and_zero(rows, cols, 2048);`
`395`		`- return true;`
	`395`	`+ return Load_Status::Half_need_spectra;`
`396`	`396`	`}`
`397`	`397`	`// TODO: might need to check if is XANES like above`
`398`	`398`	`}`
`399`	`399`	`if(_mda_file->scan->sub_scans[0]->sub_scans[0]->number_detectors-1 < (int)detector_num)`
`400`	`400`	`{`
`401`	`401`	`logE<<"Max detectors saved = "<<_mda_file->scan->sub_scans[0]->sub_scans[0]->number_detectors<< "\n";`
`402`	`402`	`unload();`
`403`		`- return false;`
	`403`	`+ return Load_Status::Failed;`
`404`	`404`	`}`
`405`	`405`
`406`	`406`	`if(_mda_file->scan->requested_points == 0 \|\| _mda_file->scan->last_point == 0)`
`@@ -442,7 +442,7 @@ bool MDA_IO<T_real>::load_spectra_volume(std::string path,`
`442`	`442`	`{`
`443`	`443`	`logE<<" No support for data rank "<< _mda_file->header->data_rank <<"\n";`
`444`	`444`	`unload();`
`445`		`- return false;`
	`445`	`+ return Load_Status::Failed;`
`446`	`446`	`}`
`447`	`447`
`448`	`448`	`elt_arr = _scan_info.scaler_values(STR_ELT + std::to_string(detector_num + 1));`
`@@ -524,10 +524,10 @@ bool MDA_IO<T_real>::load_spectra_volume(std::string path,`
`524`	`524`	`{`
`525`	`525`	`logE<<"Caught exception loading mda file."<<"\n";`
`526`	`526`	`std::cerr << "Exception catched : " << e.what() << "\n";`
`527`		`- return false;`
	`527`	`+ return Load_Status::Failed;`
`528`	`528`	`}`
`529`	`529`
`530`		`- return true;`
	`530`	`+ return Load_Status::Loaded;`
`531`	`531`	`}`
`532`	`532`
`533`	`533`