oscillator.hpp

Go to the documentation of this file.

#include <stdio.h>
#include "defs.hpp"
#include "controlbasis.hpp"
#include <fstream>
#include <iostream> 
#include <iomanip>
#include <petscmat.h>
#include <vector>
#include <assert.h>
#include "util.hpp"
#include "config.hpp"
#include <stdlib.h> 
#include<random>
 
#pragma once
 
class Oscillator {
  protected:
    int myid; 
    size_t nlevels; 
    double ground_freq; 
    double selfkerr; 
 
    double detuning_freq; 
    DecoherenceType decoherence_type; 
    double decay_time; 
    double dephase_time; 
 
    std::vector<double> params; 
    double Tfinal; 
    std::vector<ControlBasis *> basisfunctions; 
    std::vector<double> carrier_freq; 
 
    int mpirank_world; 
    int mpirank_petsc; 
    int mpisize_petsc; 
    PetscInt localsize_u; 
    PetscInt ilow; 
    PetscInt iupp; 
 
    bool control_zero_boundary_condition; 
 
  public:
    PetscInt dim_preOsc; 
    PetscInt dim_postOsc; 
 
    Oscillator();
 
    Oscillator(const Config& config, size_t id, std::mt19937 rand_engine, int param_offset, bool quietmode);
 
    virtual ~Oscillator();
 
    size_t getNParams() { return params.size(); };
 
    size_t getNLevels() { return nlevels; };
 
    double getSelfkerr() { return selfkerr; }; 
 
    double getDetuning() { return detuning_freq; }; 
 
    double getDecayTime() {return decay_time; };
 
    double getDephaseTime() {return dephase_time; };
 
    size_t getNParameterizations() {return basisfunctions.size(); };
 
    size_t getNCarrierfrequencies() {return carrier_freq.size(); };
 
    ControlType getControlType() {return basisfunctions[0]->getType(); };
 
    int getNSplines() {return basisfunctions[0]->getNSplines();};
 
    double getRotFreq() {return (ground_freq - detuning_freq) / (2.0*M_PI); };
 
    int getNSegParams(int parameterizationID);
 
    void setParams(const double* x);
 
    void getParams(double* x);
 
    void clearParams() { params.clear(); };
 
    int evalControl(const double t, double* Re_ptr, double* Im_ptr);
 
    int evalControl_diff(const double t, double* grad_for_this_oscillator, const double pbar, const double qbar);
 
    int evalControl_Labframe(const double t, double* f_ptr);
 
    double expectedEnergy(const Vec x);
 
    void expectedEnergy_diff(const Vec x, Vec x_bar, const double obj_bar);
 
    void population(const Vec x, std::vector<double> &pop);
 
    double evalControlVariation();
 
    void evalControlVariationDiff(Vec G, double var_reg_bar, int skip_to_oscillator);
};