defs.hpp

Go to the documentation of this file.

#include <map>
#include <optional>
#include <string>
#include <vector>
 
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
#define SQR(x) (x)*(x)
 
#pragma once
 
enum class DecoherenceType {
  NONE,    
  DECAY,   
  DEPHASE, 
  BOTH     
};
 
const std::map<std::string, DecoherenceType> DECOHERENCE_TYPE_MAP = {
    {"none", DecoherenceType::NONE},
    {"decay", DecoherenceType::DECAY},
    {"dephase", DecoherenceType::DEPHASE},
    {"both", DecoherenceType::BOTH}
};
 
enum class InitialConditionType {
  FROMFILE,      
  PRODUCT_STATE, 
  ENSEMBLE,      
  DIAGONAL,      
  BASIS,         
  THREESTATES,   
  NPLUSONE,      
  PERFORMANCE    
};
 
const std::map<std::string, InitialConditionType> INITCOND_TYPE_MAP = {
    {"file", InitialConditionType::FROMFILE},
    {"state", InitialConditionType::PRODUCT_STATE},
    {"ensemble", InitialConditionType::ENSEMBLE},
    {"diagonal", InitialConditionType::DIAGONAL},
    {"basis", InitialConditionType::BASIS},
    {"3states", InitialConditionType::THREESTATES},
    {"nplus1", InitialConditionType::NPLUSONE},
    {"performance", InitialConditionType::PERFORMANCE}
};
 
enum class TargetType {
  NONE,          
  GATE,          
  STATE,         
};
 
const std::map<std::string, TargetType> TARGET_TYPE_MAP = {
    {"none", TargetType::NONE},
    {"gate", TargetType::GATE},
    {"state", TargetType::STATE},
};
 
enum class ObjectiveType {
  JFROBENIUS, 
  JTRACE,     
  JMEASURE    
};
 
const std::map<std::string, ObjectiveType> OBJECTIVE_TYPE_MAP = {
    {"jfrobenius", ObjectiveType::JFROBENIUS},
    {"jtrace", ObjectiveType::JTRACE},
    {"jmeasure", ObjectiveType::JMEASURE}
};
 
enum class LinearSolverType{
  GMRES,   
  NEUMANN  
};
 
const std::map<std::string, LinearSolverType> LINEAR_SOLVER_TYPE_MAP = {
    {"gmres", LinearSolverType::GMRES},
    {"neumann", LinearSolverType::NEUMANN}
};
 
enum class RunType {
  SIMULATION,   
  GRADIENT,     
  OPTIMIZATION, 
  EVALCONTROLS, 
  NONE          
};
 
const std::map<std::string, RunType> RUN_TYPE_MAP = {
    {"simulation", RunType::SIMULATION},
    {"gradient", RunType::GRADIENT},
    {"optimization", RunType::OPTIMIZATION},
    {"evalcontrols", RunType::EVALCONTROLS},
    {"none", RunType::NONE}
};
 
enum class ControlType {
  NONE,       
  BSPLINE,    
  BSPLINEAMP, 
  BSPLINE0    
};
 
const std::map<std::string, ControlType> CONTROL_TYPE_MAP = {
    {"none", ControlType::NONE},
    {"spline", ControlType::BSPLINE},
    {"spline_amplitude", ControlType::BSPLINEAMP},
    {"spline0", ControlType::BSPLINE0}
};
 
enum class ControlInitializationType {
  CONSTANT, 
  RANDOM,   
  FILE,     
};
 
const std::map<std::string, ControlInitializationType> CONTROL_INITIALIZATION_TYPE_MAP = {
    {"constant", ControlInitializationType::CONSTANT},
    {"random", ControlInitializationType::RANDOM},
    {"file", ControlInitializationType::FILE},
};
 
enum class TimeStepperType {
  IMR,   
  IMR4,  
  IMR8,  
  EE,    
};
 
const std::map<std::string, TimeStepperType> TIME_STEPPER_TYPE_MAP = {
    {"imr", TimeStepperType::IMR},
    {"imr4", TimeStepperType::IMR4},
    {"imr8", TimeStepperType::IMR8},
    {"ee", TimeStepperType::EE}
};
 
enum class GateType {
  NONE,     
  XGATE,    
  YGATE,    
  ZGATE,    
  HADAMARD, 
  CNOT,     
  SWAP,     
  SWAP_0Q,  
  CQNOT,    
  QFT,      
  FILE,     
};
 
const std::map<std::string, GateType> GATE_TYPE_MAP = {
    {"none", GateType::NONE},
    {"xgate", GateType::XGATE},
    {"ygate", GateType::YGATE},
    {"zgate", GateType::ZGATE},
    {"hadamard", GateType::HADAMARD},
    {"cnot", GateType::CNOT},
    {"swap", GateType::SWAP},
    {"swap0q", GateType::SWAP_0Q},
    {"cqnot", GateType::CQNOT},
    {"qft", GateType::QFT},
    {"file", GateType::FILE}
};
 
enum class OutputType {
  EXPECTED_ENERGY,           
  EXPECTED_ENERGY_COMPOSITE, 
  POPULATION,                
  POPULATION_COMPOSITE,      
  FULLSTATE,                 
};
 
const std::map<std::string, OutputType> OUTPUT_TYPE_MAP = {
  {"expectedenergy", OutputType::EXPECTED_ENERGY},
  {"expectedenergycomposite", OutputType::EXPECTED_ENERGY_COMPOSITE},
  {"population", OutputType::POPULATION},
  {"populationcomposite", OutputType::POPULATION_COMPOSITE},
  {"fullstate", OutputType::FULLSTATE},
};