timefreq.h

Go to the documentation of this file.

 
#ifndef TIMEFREQ_H
#define TIMEFREQ_H
 
#include <vector>
#include <string>
 
#include "complexmatrix.h"
#include "matrix.h"
 
 
class TFGrids
{
    public:
        enum GRID_TYPES { GaussLegendre,
                          GaussChebyshevI,
                          GaussChebyshevII,
                          Minimax,
                          EvenSpaced, EvenSpaced_TF,
                          COUNT, // NOTE: always the last
        };
        static const string GRID_TYPES_NOTES[GRID_TYPES::COUNT];
        static const bool SUPPORT_TIME_GRIDS[GRID_TYPES::COUNT];
        static GRID_TYPES get_grid_type(const string& grid_str);
    private:
        GRID_TYPES grid_type;
        bool _has_time_grids;
        unsigned n_grids;
        vector<double> freq_nodes;
        vector<double> freq_weights;
        vector<double> time_nodes;
        vector<double> time_weights;
        matrix costrans_t2f;
        matrix costrans_f2t;
        matrix sintrans_t2f;
        matrix sintrans_f2t;
        // ComplexMatrix fourier_t2f;
        // ComplexMatrix fourier_f2t;
        void set_freq();
        void set_time();
        void unset();
    public:
        TFGrids::GRID_TYPES get_grid_type() const { return grid_type; }
        TFGrids(): n_grids(0) {};
        TFGrids(unsigned N);
        // disable copy at present
        TFGrids(const TFGrids &tfg) {};
        void reset(unsigned N);
        void show();
        size_t get_n_grids() const { return n_grids; }
        size_t size() const { return n_grids; }
        const vector<double> get_freq_nodes() const { return freq_nodes; }
        const vector<double> get_freq_weights() const { return freq_weights; }
        const vector<double> get_time_nodes() const { return time_nodes; }
        const vector<double> get_time_weights() const { return time_weights; }
        // NOTE: use reference for return matrix?
        const matrix &get_costrans_t2f() const { return costrans_t2f; }
        const matrix &get_sintrans_t2f() const { return sintrans_t2f; }
        const matrix &get_costrans_f2t() const { return costrans_f2t; }
        const matrix &get_sintrans_f2t() const { return sintrans_f2t; }
        int get_time_index(const double &time) const;
        int get_freq_index(const double &freq) const;
        const pair<int, int> get_tf_index(const pair<double, double> &tf) const;
        // NOTE:(ZMY) attempt to use a map<double, double> to store,
        //      but will lead to a segfault in chi0tauR calculation, not knowing why
        double find_freq_weight(const double &freq) const;
        void generate_evenspaced(double emin, double interval);
        void generate_evenspaced_tf(double emin, double eintv, double tmin, double tintv);
        void generate_minimax(double emin, double emax);
        void generate_GaussChebyshevI();
        void generate_GaussChebyshevII();
        void generate_GaussLegendre();
        bool has_time_grids() const { return time_nodes.size() > 0; }
        ~TFGrids();
};
 
#endif