Stability_certificate.h

Go to the documentation of this file.

#ifndef STABILITY_CERTIFICATE_H
#define STABILITY_CERTIFICATE_H
 
#include "../../Constants.h"
#include "../Helper_Functions/Visualization.h"
#include "Certificate_spec.h"
#include "Geometric_certificates.h"
 
#include <complex>
#include <string>
#include <vector>
 
class Element;
class StabilityEstimate;
 
struct CertificateSweep {
    std::vector<double> freq_Hz;
    std::vector<double> passivity_index;    
    std::vector<double> shifted_passivity;  
    std::vector<double> max_phase_deg;      
    std::vector<double> nr_phase_deg;       
    std::vector<double> nr_zero_margin;     
    std::vector<double> small_gain;         
    std::vector<double> shortage_passivity; 
    std::vector<double> min_real_eig;       
    std::vector<double> dw_margin;          
    bool pass_passivity = false;
    bool pass_phase = false;
    bool pass_shifted = false;
    bool pass_nr_phase = false;
    bool pass_nr_zero = false;
    bool pass_small_gain = false;
    bool pass_dw = false;
    bool pass_sector = false;
    double worst_passivity = 0.0;
    double worst_shifted = 0.0;
    double worst_phase_deg = 0.0;
    double worst_nr_phase_deg = 0.0;
    double worst_nr_zero_margin = 0.0;
    double worst_small_gain = 0.0;
    double worst_shortage = 0.0;
    double worst_dw = 0.0;
    double phase_limit_deg = 90.0;
    double shift_delta = 0.0;
    double gain_limit = 1.0;
};
 
struct OperatingRegionSample {
    double P = 0.0;
    double Q = 0.0;
    bool certified = false;
    double margin = 0.0;
    double phase_deg = 0.0;
    std::string note;
};
 
double passivityIndex(const Eigen::MatrixXcd& Y);
 
double shiftedPassivityIndex(const Eigen::MatrixXcd& Y, double delta);
 
double dwHermitianMargin(const Eigen::MatrixXcd& Y);
 
double maxEigenPhaseDeg(const Eigen::MatrixXcd& Y);
 
bool sweepPassesSpec(const CertificateSweep& sweep, const CertificateSpec& spec);
 
Eigen::MatrixXcd extractAcDqBlock(const Eigen::MatrixXcd& Y);
 
Eigen::MatrixXcd elementAdmittance(
    Element& elem,
    double freq_Hz,
    bool ac_dq_block = true);
 
CertificateSweep sweepDeviceCertificate(
    Element& elem,
    const CertificateSpec& spec);
 
CertificateSweep sweepDeviceCertificate(
    Element& elem,
    double f_min,
    double f_max,
    int n_points,
    bool ac_block = true,
    double phase_limit_deg = 90.0);
 
CertificateSweep sweepReturnRatioCertificate(
    StabilityEstimate& stability,
    const std::string& converter_name,
    const std::string& location,
    const CertificateSpec& spec);
 
CertificateSweep sweepReturnRatioCertificate(
    StabilityEstimate& stability,
    const std::string& converter_name,
    const std::string& location,
    double f_min,
    double f_max,
    int n_points);
 
void finalizeCertificateSweep(CertificateSweep& sweep, const CertificateSpec& spec);
 
void writeCertificateSweepCsv(const CertificateSweep& sweep, const std::string& path);
void writeOperatingRegionCsv(
    const std::vector<OperatingRegionSample>& samples,
    const std::string& path);
 
// ----- Paper-style ImPlot figures -----
 
void plot_certificate_passivity(
    const CertificateSweep& sweep,
    const std::string& title = "Passivity index");
 
void plot_certificate_phase(
    const CertificateSweep& sweep,
    const std::string& title = "Device phase certificate");
 
void plot_certificate_gate(
    const CertificateSweep& sweep,
    const std::string& title = "Device gate certificate");
 
void plot_certificate_operating_region(
    const std::vector<OperatingRegionSample>& samples,
    const std::string& title = "Certified operating region (P,Q)");
 
void plot_certificate_local_vs_system(
    const CertificateSweep& local,
    const CertificateSweep& system_H,
    const std::string& title = "Local vs system certificate");
 
void plot_certificate_tuning_compare(
    const CertificateSweep& before,
    const CertificateSweep& after,
    const std::string& title = "Control tuning: passivity");
 
void plot_certificate_dw_slice(
    const Eigen::MatrixXcd& Y,
    double freq_Hz,
    const std::string& title = "DW-style Hermitian slice");
 
void plot_certificate_numerical_range(
    const Eigen::MatrixXcd& Y,
    double freq_Hz,
    double phase_limit_deg = 90.0,
    const std::string& title = "Numerical range W(Y)");
 
void plot_certificate_dw_shell(
    const Eigen::MatrixXcd& Y,
    double freq_Hz,
    const CertificateSpec& spec = {},
    const std::string& title = "DW shell (xz projection)");
 
void plot_certificate_geometric_sweep(
    const CertificateSweep& sweep,
    const std::string& title = "Geometric certificates");
 
#endif // STABILITY_CERTIFICATE_H