diff --git a/dx2/CMakeLists.txt b/dx2/CMakeLists.txt index e780486..1c5e3c0 100644 --- a/dx2/CMakeLists.txt +++ b/dx2/CMakeLists.txt @@ -12,6 +12,7 @@ add_library( detector_attenuations.cxx imagesequence.cxx experiment.cxx + experiment_list.cxx beam_ops.cxx beam_io.cxx ) diff --git a/dx2/beam.cxx b/dx2/beam.cxx index c56ebbc..f94a58b 100644 --- a/dx2/beam.cxx +++ b/dx2/beam.cxx @@ -138,6 +138,14 @@ json MonochromaticBeam::to_json() const { return to_json("x-ray"); } +void MonochromaticBeam::update(const MonochromaticBeam &beam) { + Vector3d s0 = beam.get_s0(); + polarization_normal_ = beam.get_polarization_normal(); + polarization_fraction_ = beam.get_polarization_fraction(); + wavelength_ = beam.get_wavelength(); + sample_to_source_direction_ = -1.0 * s0 * wavelength_; +} + double MonochromaticBeam::get_wavelength() const { return wavelength_; } void MonochromaticBeam::set_wavelength(double wavelength) { @@ -221,6 +229,13 @@ void PolychromaticBeam::set_wavelength_range( wavelength_range_ = wavelength_range; } +void PolychromaticBeam::update(const PolychromaticBeam &beam) { + wavelength_range_ = beam.get_wavelength_range(); + polarization_normal_ = beam.get_polarization_normal(); + polarization_fraction_ = beam.get_polarization_fraction(); + // sample_to_source_direction_ = FIXME is this modifiable in Poly? +} + // MonoXrayBeam definitions json MonoXrayBeam::to_json() const { diff --git a/dx2/experiment.cxx b/dx2/experiment.cxx index 959c386..7b05295 100644 --- a/dx2/experiment.cxx +++ b/dx2/experiment.cxx @@ -1,100 +1,32 @@ #include #include -Experiment::Experiment(const json &experiment_data) { - std::string identifier = experiment_data["experiment"][0]["identifier"]; - json beam_data = experiment_data["beam"][0]; - Beam beam = beam_io::from_json(beam_data); - json scan_data = experiment_data["scan"][0]; - Scan scan(scan_data); - json gonio_data = experiment_data["goniometer"][0]; - Goniometer gonio(gonio_data); - json detector_data = experiment_data["detector"][0]; - Detector detector(detector_data); - this->_identifier = identifier; - this->_beam = std::move(beam); - this->_scan = std::move(scan); - this->_goniometer = std::move(gonio); - this->_detector = std::move(detector); - // Save the imageset json to propagate when saving to file. - json imagesequence_data = experiment_data["imageset"][0]; - ImageSequence imagesequence(imagesequence_data); - this->_imagesequence = imagesequence; - if (experiment_data.contains("crystal") && - experiment_data["crystal"].is_array() && - !experiment_data["crystal"].empty()) { - const json &crystal_data = experiment_data["crystal"][0]; - Crystal crystal(crystal_data); - this->_crystal = crystal; +Experiment::Experiment(Models models, std::string identifier) + : _models(std::move(models)), _identifier(std::move(identifier)) { + if (_identifier.empty()) { + generate_identifier(); } } -json Experiment::to_json() const { - // save this experiment as an example experiment list - json elist_out; // a list of potentially multiple experiments - elist_out["__id__"] = "ExperimentList"; - json expt_out; // our single experiment - expt_out["__id__"] = "Experiment"; - expt_out["identifier"] = _identifier; - expt_out["beam"] = - 0; // the indices of the models that will correspond to our experiment - expt_out["detector"] = 0; - expt_out["goniometer"] = 0; - expt_out["scan"] = 0; - expt_out["imageset"] = 0; - - // add the the actual models - elist_out["scan"] = std::array{_scan.to_json()}; - elist_out["goniometer"] = std::array{_goniometer.to_json()}; - elist_out["beam"] = std::array{beam_io::to_json(_beam)}; - elist_out["detector"] = std::array{_detector.to_json()}; - elist_out["imageset"] = std::array{_imagesequence.to_json()}; - - if (_crystal.get_U_matrix().determinant()) { - expt_out["crystal"] = 0; - elist_out["crystal"] = std::array{_crystal.to_json()}; - } else { - elist_out["crystal"] = std::array{}; +Crystal &Experiment::crystal() { + if (!_models.crystal) { + throw std::runtime_error("Experiment has no crystal"); } - - elist_out["experiment"] = std::array{expt_out}; - return elist_out; + return *_models.crystal; } - -Scan &Experiment::scan() { return _scan; } - -const Goniometer &Experiment::goniometer() const { return _goniometer; } - -Detector &Experiment::detector() { return _detector; } - -Crystal &Experiment::crystal() { return _crystal; } - -ImageSequence &Experiment::imagesequence() { return _imagesequence; } - -void Experiment::set_crystal(Crystal crystal) { _crystal = crystal; } - -void Experiment::set_beam(Beam beam) { _beam = std::move(beam); } - -Beam &Experiment::beam() { return _beam; } - -const Beam &Experiment::beam() const { return _beam; } - -void Experiment::set_scan(Scan scan) { _scan = scan; } - -void Experiment::set_detector(Detector detector) { _detector = detector; } - -void Experiment::set_goniometer(Goniometer goniometer) { - _goniometer = goniometer; +const Crystal &Experiment::crystal() const { + if (!_models.crystal) { + throw std::runtime_error("Experiment has no crystal"); + } + return *_models.crystal; } -void Experiment::set_imagesequence(ImageSequence imagesequence) { - _imagesequence = imagesequence; +void Experiment::set_crystal(Crystal crystal) { + _models.crystal = std::make_shared(std::move(crystal)); } -const std::string &Experiment::identifier() const { return _identifier; } - -void Experiment::set_identifier(std::string identifier) { - _identifier = identifier; +void Experiment::set_crystal(std::shared_ptr crystal) { + _models.crystal = std::move(crystal); } void Experiment::generate_identifier() { _identifier = ersatz_uuid4(); } diff --git a/dx2/experiment_list.cxx b/dx2/experiment_list.cxx new file mode 100644 index 0000000..aa9d286 --- /dev/null +++ b/dx2/experiment_list.cxx @@ -0,0 +1,218 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +ExperimentList::ExperimentList(const json &experiment_data) { + + // Phase 1: deserialize all models + + std::vector> beams; + for (const auto &beam_json : experiment_data["beam"]) { + beams.push_back(std::make_shared(beam_io::from_json(beam_json))); + } + + std::vector> detectors; + for (const auto &detector_json : experiment_data["detector"]) { + detectors.push_back(std::make_shared(Detector(detector_json))); + } + + std::vector> scans; + for (const auto &scan_json : experiment_data["scan"]) { + scans.push_back(std::make_shared(Scan(scan_json))); + } + + std::vector> goniometers; + for (const auto &gonio_json : experiment_data["goniometer"]) { + goniometers.push_back(std::make_shared(Goniometer(gonio_json))); + } + + std::vector> imagesets; + for (const auto &imageset_json : experiment_data["imageset"]) { + imagesets.push_back( + std::make_shared(ImageSequence(imageset_json))); + } + + std::vector> crystals; + if (experiment_data.contains("crystal")) { + for (const auto &crystal_json : experiment_data["crystal"]) { + crystals.push_back(std::make_shared(Crystal(crystal_json))); + } + } + + // Phase 2: construct experiments + + for (const auto &expt_json : experiment_data["experiment"]) { + + Experiment::Models models{ + beams.at(expt_json["beam"]), detectors.at(expt_json["detector"]), + scans.at(expt_json["scan"]), goniometers.at(expt_json["goniometer"]), + imagesets.at(expt_json["imageset"])}; + + if (expt_json.contains("crystal")) { + models.crystal = crystals.at(expt_json["crystal"]); + } + + _experiments.emplace_back(std::move(models), expt_json["identifier"]); + } +} + +json ExperimentList::to_json() const { + + json result; + result["__id__"] = "ExperimentList"; + + result["experiment"] = json::array(); + result["beam"] = json::array(); + result["detector"] = json::array(); + result["scan"] = json::array(); + result["goniometer"] = json::array(); + result["imageset"] = json::array(); + result["crystal"] = json::array(); + + std::unordered_map beam_indices; + std::unordered_map detector_indices; + std::unordered_map scan_indices; + std::unordered_map goniometer_indices; + std::unordered_map imageset_indices; + std::unordered_map crystal_indices; + + for (const auto &expt : _experiments) { + + json expt_json; + expt_json["__id__"] = "Experiment"; + expt_json["identifier"] = expt.identifier(); + + // + // Beam + // + const Beam *beam_ptr = expt._models.beam.get(); + auto [beam_it, beam_inserted] = + beam_indices.emplace(beam_ptr, beam_indices.size()); + + if (beam_inserted) { + result["beam"].push_back(beam_io::to_json(*expt._models.beam)); + } + + expt_json["beam"] = beam_it->second; + + // + // Detector + // + const Detector *detector_ptr = expt._models.detector.get(); + auto [detector_it, detector_inserted] = + detector_indices.emplace(detector_ptr, detector_indices.size()); + + if (detector_inserted) { + result["detector"].push_back(expt._models.detector->to_json()); + } + + expt_json["detector"] = detector_it->second; + + // + // Scan + // + const Scan *scan_ptr = expt._models.scan.get(); + auto [scan_it, scan_inserted] = + scan_indices.emplace(scan_ptr, scan_indices.size()); + + if (scan_inserted) { + result["scan"].push_back(expt._models.scan->to_json()); + } + + expt_json["scan"] = scan_it->second; + + // + // Goniometer + // + const Goniometer *gonio_ptr = expt._models.goniometer.get(); + + auto [gonio_it, gonio_inserted] = + goniometer_indices.emplace(gonio_ptr, goniometer_indices.size()); + + if (gonio_inserted) { + result["goniometer"].push_back(expt._models.goniometer->to_json()); + } + + expt_json["goniometer"] = gonio_it->second; + + // + // Imageset + // + const ImageSequence *imageset_ptr = expt._models.imagesequence.get(); + + auto [imageset_it, imageset_inserted] = + imageset_indices.emplace(imageset_ptr, imageset_indices.size()); + + if (imageset_inserted) { + result["imageset"].push_back(expt._models.imagesequence->to_json()); + } + + expt_json["imageset"] = imageset_it->second; + + // + // Optional crystal + // + if (expt.has_crystal()) { + + const Crystal *crystal_ptr = expt._models.crystal.get(); + + auto [crystal_it, crystal_inserted] = + crystal_indices.emplace(crystal_ptr, crystal_indices.size()); + + if (crystal_inserted) { + result["crystal"].push_back(expt._models.crystal->to_json()); + } + + expt_json["crystal"] = crystal_it->second; + } + + result["experiment"].push_back(std::move(expt_json)); + } + + return result; +} + +ExperimentList +ExperimentList::select(const std::vector &identifiers) const { + + // Implement a simple linear scan and lookup for now. + std::unordered_set wanted(identifiers.begin(), + identifiers.end()); + + ExperimentList result; + + for (const auto &expt : _experiments) { + if (wanted.contains(expt.identifier())) { + result.append(expt); + } + } + + return result; +} + +ExperimentList +ExperimentList::select(const std::vector &indices) const { + + ExperimentList result; + + for (std::size_t i : indices) { + if (i >= _experiments.size()) { + throw std::out_of_range("Experiment index out of range"); + } + + result.append(_experiments[i]); + } + + return result; +} + +void ExperimentList::append(Experiment experiment) { + _experiments.push_back(std::move(experiment)); +} diff --git a/include/dx2/beam.hpp b/include/dx2/beam.hpp index ff7b921..4446e0b 100644 --- a/include/dx2/beam.hpp +++ b/include/dx2/beam.hpp @@ -62,6 +62,7 @@ class MonochromaticBeam : public BeamBase { void set_wavelength(double wavelength); Vector3d get_s0() const; void set_s0(Vector3d const s0); + void update(const MonochromaticBeam &beam); protected: double wavelength_{0.0}; @@ -101,6 +102,7 @@ class PolychromaticBeam : public BeamBase { json to_json() const; // overload for default std::array get_wavelength_range() const; void set_wavelength_range(std::array wavelength_range); + void update(const PolychromaticBeam &beam); protected: std::array wavelength_range_{{0.0, 0.0}}; diff --git a/include/dx2/experiment.hpp b/include/dx2/experiment.hpp index 5f454ae..da6bd81 100644 --- a/include/dx2/experiment.hpp +++ b/include/dx2/experiment.hpp @@ -12,36 +12,64 @@ using Eigen::Vector3d; using json = nlohmann::json; +class ExperimentList; // forward declaration + class Experiment { + friend class ExperimentList; + public: - Experiment() = default; - Experiment(const json &experiment_data); - json to_json() const; + struct Models { + Models(std::shared_ptr beam, std::shared_ptr detector, + std::shared_ptr scan, std::shared_ptr goniometer, + std::shared_ptr imagesequence, + std::shared_ptr crystal = nullptr) // Optional argument + : beam(std::move(beam)), detector(std::move(detector)), + scan(std::move(scan)), goniometer(std::move(goniometer)), + imagesequence(std::move(imagesequence)), crystal(std::move(crystal)) { + } + + std::shared_ptr beam; + std::shared_ptr detector; + std::shared_ptr scan; + std::shared_ptr goniometer; + std::shared_ptr imagesequence; + std::shared_ptr crystal; + }; + + explicit Experiment(Models models, std::string identifier = {}); + + // These models should always exist as they are defined by the experiment + // metadata + + Beam &beam() { return *_models.beam; } + const Beam &beam() const { return *_models.beam; } - Beam &beam(); - const Beam &beam() const; + Detector &detector() { return *_models.detector; } + const Detector &detector() const { return *_models.detector; } - const std::string &identifier() const; - const Goniometer &goniometer() const; - Scan &scan(); - Detector &detector(); + Scan &scan() { return *_models.scan; } + const Scan &scan() const { return *_models.scan; } + + Goniometer &goniometer() { return *_models.goniometer; } + const Goniometer &goniometer() const { return *_models.goniometer; } + + ImageSequence &imagesequence() { return *_models.imagesequence; } + const ImageSequence &imagesequence() const { return *_models.imagesequence; } + + // These models are discovered during processing and so are optional Crystal &crystal(); - ImageSequence &imagesequence(); + const Crystal &crystal() const; + bool has_crystal() const { return static_cast(_models.crystal); } + void set_crystal(Crystal crystal); - void set_beam(Beam beam); - void set_scan(Scan scan); - void set_detector(Detector detector); - void set_goniometer(Goniometer goniometer); - void set_imagesequence(ImageSequence imagesequence); - void set_identifier(std::string identifier); + void set_crystal(std::shared_ptr crystal); + + const std::string &identifier() const { return _identifier; } + void set_identifier(std::string identifier) { _identifier = identifier; } + void generate_identifier(); -protected: - Beam _beam{}; - Scan _scan{}; - Goniometer _goniometer{}; - Detector _detector{}; - Crystal _crystal{}; - ImageSequence _imagesequence{}; +private: + Models _models; std::string _identifier{}; }; diff --git a/include/dx2/experiment_list.hpp b/include/dx2/experiment_list.hpp new file mode 100644 index 0000000..f24cac5 --- /dev/null +++ b/include/dx2/experiment_list.hpp @@ -0,0 +1,35 @@ +#pragma once +#include +#include + +using json = nlohmann::json; + +class ExperimentList { +public: + ExperimentList() = default; + ExperimentList(const json &experiment_data); + json to_json() const; + + std::size_t size() const { return _experiments.size(); } + + Experiment &operator[](std::size_t i) { return _experiments[i]; } + + const Experiment &operator[](std::size_t i) const { return _experiments[i]; } + + auto begin() { return _experiments.begin(); } + auto end() { return _experiments.end(); } + + auto begin() const { return _experiments.begin(); } + auto end() const { return _experiments.end(); } + + ExperimentList select(const std::vector &identifiers) + const; // Select on identifiers + + ExperimentList + select(const std::vector &indices) const; // Select on indices + + void append(Experiment experiment); + +private: + std::vector _experiments; +}; diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index fd33832..985a2ab 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -34,6 +34,9 @@ target_link_libraries(test_read_h5_array GTest::gtest_main dx2 hdf5::hdf5) add_executable(test_reflection_table test_reflection_table.cxx) target_link_libraries(test_reflection_table GTest::gtest_main dx2) +add_executable(test_experiment test_experiment.cxx) +target_link_libraries(test_experiment GTest::gtest_main dx2) + set(DX2_TESTS test_crystal test_beam @@ -45,6 +48,7 @@ set(DX2_TESTS test_write_h5_array test_read_h5_array test_reflection_table + test_experiment ) # Tests that open the same HDF5 files on disk. HDF5 locks a file opened for diff --git a/tests/test_experiment.cxx b/tests/test_experiment.cxx new file mode 100644 index 0000000..07869b8 --- /dev/null +++ b/tests/test_experiment.cxx @@ -0,0 +1,54 @@ +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +TEST(ModelTests, ExperimentTest) { + + Experiment::Models models( + std::make_shared(), std::make_shared(), + std::make_shared(), std::make_shared(), + std::make_shared()); + + Experiment expt(models); + + // Required models exist + (void)expt.beam(); + (void)expt.detector(); + (void)expt.scan(); + (void)expt.goniometer(); + (void)expt.imagesequence(); + + // Crystal initially absent + assert(!expt.has_crystal()); + + bool threw = false; + try { + (void)expt.crystal(); + } catch (const std::runtime_error &) { + threw = true; + } + assert(threw); + + // Attach crystal + auto crystal = std::make_shared(); + expt.set_crystal(crystal); + + assert(expt.has_crystal()); + + // Shared crystal + Experiment expt2(models); + expt2.set_crystal(crystal); + + assert(&expt.crystal() == &expt2.crystal()); + + // Identifier generated automatically + assert(!expt.identifier().empty()); +} \ No newline at end of file