config.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <petsc.h>
#include <cstddef>
#include <optional>
#include <set>
#include <sstream>
#include <string>
#include <toml++/toml.hpp>
#include <vector>
#include <cassert>
#include <iostream>
#include <iomanip>
#include <limits>
#include <random>
#include <type_traits>
#include "defs.hpp"
#include "mpi_logger.hpp"
#include "config_defaults.hpp"
#include "config_validators.hpp"
 
 
class Config {
 private:
  // Logging
  MPILogger logger; 
 
  // General options
  std::vector<size_t> nlevels; 
  std::vector<size_t> nessential; 
  size_t ntime; 
  double dt; 
  double total_time; 
  std::vector<double> transition_frequency; 
  std::vector<double> selfkerr; 
  std::vector<double> crosskerr_coupling; 
  std::vector<double> dipole_coupling; 
  std::vector<double> rotation_frequency; 
  DecoherenceType decoherence_type; 
  std::vector<double> decay_time; 
  std::vector<double> dephase_time; 
  size_t n_initial_conditions; 
  InitialConditionSettings initial_condition; 
  std::optional<std::string> hamiltonian_file_Hsys; 
  std::optional<std::string> hamiltonian_file_Hc; 
 
  // Optimization options
  bool control_zero_boundary_condition; 
  std::vector<ControlParameterizationSettings> control_parameterizations; 
  std::vector<ControlInitializationSettings> control_initializations; 
  std::vector<double> control_amplitude_bounds; 
  std::vector<std::vector<double>> carrier_frequencies; 
  OptimTargetSettings optim_target; 
  ObjectiveType optim_objective; 
  std::vector<double> optim_weights; 
  double optim_tol_grad_abs; 
  double optim_tol_grad_rel; 
  double optim_tol_final_cost; 
  double optim_tol_infidelity; 
  size_t optim_maxiter; 
  double optim_tikhonov_coeff; 
  bool optim_tikhonov_use_x0; 
  double optim_penalty_leakage; 
  double optim_penalty_weightedcost; 
  double optim_penalty_weightedcost_width; 
  double optim_penalty_dpdm; 
  double optim_penalty_energy; 
  double optim_penalty_variation; 
 
  // Output and runtypes
  std::string output_directory; 
  std::vector<OutputType> output_observables; 
  size_t output_timestep_stride; 
  size_t output_optimization_stride; 
  RunType runtype; 
  bool usematfree; 
  LinearSolverType linearsolver_type; 
  size_t linearsolver_maxiter; 
  TimeStepperType timestepper_type; 
  int rand_seed; 
 
 public:
  Config(const MPILogger& logger, const toml::table& table);
 
  ~Config() = default;
 
  static Config fromFile(const std::string& filename, const MPILogger& logger);
  static Config fromString(const std::string& toml_content, const MPILogger& logger);
 
  void printConfig(std::stringstream& log) const;
 
  // getters
  const std::vector<size_t>& getNLevels() const { return nlevels; }
  size_t getNLevels(size_t i_osc) const { return nlevels[i_osc]; }
  size_t getNumOsc() const { return nlevels.size(); }
  const std::vector<size_t>& getNEssential() const { return nessential; }
  size_t getNEssential(size_t i_osc) const { return nessential[i_osc]; }
  size_t getNTime() const { return ntime; }
  double getDt() const { return dt; }
  double getTotalTime() const { return total_time; }
 
  const std::vector<double>& getTransitionFrequency() const { return transition_frequency; }
  const std::vector<double>& getSelfKerr() const { return selfkerr; }
  const std::vector<double>& getCrossKerrCoupling() const { return crosskerr_coupling; }
  const std::vector<double>& getDipoleCoupling() const { return dipole_coupling; }
  const std::vector<double>& getRotationFrequency() const { return rotation_frequency; }
  DecoherenceType getDecoherenceType() const { return decoherence_type; }
  const std::vector<double>& getDecayTime() const { return decay_time; }
  const std::vector<double>& getDephaseTime() const { return dephase_time; }
  size_t getNInitialConditions() const { return n_initial_conditions; }
  const InitialConditionSettings& getInitialCondition() const { return initial_condition; }
  const std::optional<std::string>& getHamiltonianFileHsys() const { return hamiltonian_file_Hsys; }
  const std::optional<std::string>& getHamiltonianFileHc() const { return hamiltonian_file_Hc; }
 
  const ControlParameterizationSettings& getControlParameterizations(size_t i_osc) const { return control_parameterizations[i_osc]; }
  bool getControlZeroBoundaryCondition() const { return control_zero_boundary_condition; }
  const ControlInitializationSettings& getControlInitializations(size_t i_osc) const {
    return control_initializations[i_osc];
  }
  double getControlAmplitudeBound(size_t i_osc) const { return control_amplitude_bounds[i_osc]; }
  const std::vector<double>& getCarrierFrequencies(size_t i_osc) const { return carrier_frequencies[i_osc]; }
  const OptimTargetSettings& getOptimTarget() const { return optim_target; }
  ObjectiveType getOptimObjective() const { return optim_objective; }
  const std::vector<double>& getOptimWeights() const { return optim_weights; }
  double getOptimTolGradAbs() const { return optim_tol_grad_abs; }
  double getOptimTolGradRel() const { return optim_tol_grad_rel; }
  double getOptimTolFinalCost() const { return optim_tol_final_cost; }
  double getOptimTolInfidelity() const { return optim_tol_infidelity; }
  size_t getOptimMaxiter() const { return optim_maxiter; }
  double getOptimTikhonovCoeff() const { return optim_tikhonov_coeff; }
  bool getOptimTikhonovUseX0() const { return optim_tikhonov_use_x0; }
  double getOptimPenaltyLeakage() const { return optim_penalty_leakage; }
  double getOptimPenaltyWeightedCost() const { return optim_penalty_weightedcost; }
  double getOptimPenaltyWeightedCostWidth() const { return optim_penalty_weightedcost_width; }
  double getOptimPenaltyDpdm() const { return optim_penalty_dpdm; }
  double getOptimPenaltyEnergy() const { return optim_penalty_energy; }
  double getOptimPenaltyVariation() const { return optim_penalty_variation; }
 
  const std::string& getOutputDirectory() const { return output_directory; }
  const std::vector<OutputType>& getOutputObservables() const { return output_observables; }
  size_t getOutputTimestepStride() const { return output_timestep_stride; }
  size_t getOutputOptimizationStride() const { return output_optimization_stride; }
  RunType getRuntype() const { return runtype; }
  bool getUseMatFree() const { return usematfree; }
  LinearSolverType getLinearSolverType() const { return linearsolver_type; }
  size_t getLinearSolverMaxiter() const { return linearsolver_maxiter; }
  TimeStepperType getTimestepperType() const { return timestepper_type; }
  int getRandSeed() const { return rand_seed; }
 
 private:
  void finalize();
  void validate() const;
 
  size_t computeNumInitialConditions(InitialConditionSettings init_cond_settings, std::vector<size_t> nlevels, std::vector<size_t> nessential, DecoherenceType decoherence_type) const;
 
  void setRandSeed(int rand_seed_);
 
  // Helper function to parse a single control parameterization table
  ControlParameterizationSettings parseControlParameterizationSpecs(const toml::table& param_table) const;
 
  // Helper function to parse a single control initialization table
  ControlInitializationSettings parseControlInitializationSpecs(const toml::table& table) const;
 
  OptimTargetSettings parseOptimTarget(const toml::table& table, size_t num_osc) const;
};