Program Listing for File experiment_list.cxx

↰ Return to documentation for file (dx2/experiment_list.cxx)

#include <dx2/beam.hpp>
#include <dx2/beam_io.hpp>
#include <dx2/crystal.hpp>
#include <dx2/detector.hpp>
#include <dx2/experiment_list.hpp>
#include <dx2/goniometer.hpp>
#include <dx2/imagesequence.hpp>
#include <dx2/scan.hpp>
#include <dx2/utils.hpp>
#include <unordered_set>

ExperimentList::ExperimentList(const json &experiment_data) {

  // Phase 1: deserialize all models

  std::vector<std::shared_ptr<Beam>> beams;
  for (const auto &beam_json : experiment_data["beam"]) {
    beams.push_back(std::make_shared<Beam>(beam_io::from_json(beam_json)));
  }

  std::vector<std::shared_ptr<Detector>> detectors;
  for (const auto &detector_json : experiment_data["detector"]) {
    detectors.push_back(std::make_shared<Detector>(Detector(detector_json)));
  }

  std::vector<std::shared_ptr<Scan>> scans;
  for (const auto &scan_json : experiment_data["scan"]) {
    scans.push_back(std::make_shared<Scan>(Scan(scan_json)));
  }

  std::vector<std::shared_ptr<Goniometer>> goniometers;
  for (const auto &gonio_json : experiment_data["goniometer"]) {
    goniometers.push_back(std::make_shared<Goniometer>(Goniometer(gonio_json)));
  }

  std::vector<std::shared_ptr<ImageSequence>> imagesets;
  for (const auto &imageset_json : experiment_data["imageset"]) {
    imagesets.push_back(
        std::make_shared<ImageSequence>(ImageSequence(imageset_json)));
  }

  std::vector<std::shared_ptr<Crystal>> crystals;
  if (experiment_data.contains("crystal")) {
    for (const auto &crystal_json : experiment_data["crystal"]) {
      crystals.push_back(std::make_shared<Crystal>(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<const Beam *, std::size_t> beam_indices;
  std::unordered_map<const Detector *, std::size_t> detector_indices;
  std::unordered_map<const Scan *, std::size_t> scan_indices;
  std::unordered_map<const Goniometer *, std::size_t> goniometer_indices;
  std::unordered_map<const ImageSequence *, std::size_t> imageset_indices;
  std::unordered_map<const Crystal *, std::size_t> 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<std::string> &identifiers) const {

  // Implement a simple linear scan and lookup for now.
  std::unordered_set<std::string> 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<std::size_t> &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));
}