Correlator.h

Go to the documentation of this file.

#ifndef TTTRLIB_CORRELATOR_H
#define TTTRLIB_CORRELATOR_H
 
#include <iostream>
#include <cstdio>
#include <vector>
#include <list>
#include <iterator>
#include <functional>
#include <utility> /* std::pair */
#include <algorithm>
#include <climits>
#include <map>
 
#include "TTTR.h"
#include "CorrelatorPhotonStream.h"
#include "CorrelatorCurve.h"
#include "CLSMImage.h"
 
 
class Correlator {
 
    friend class CorrelatorCurve;
    friend class CLSMImage;
 
private:
 
    std::string correlation_method = "wahl";
 
    bool is_valid = false;
 
protected:
 
    static void ccf_felekyan(
            const unsigned long long *t1,
            const unsigned long long *t2,
            const double *weights1,
            const double *weights2,
            unsigned int nc,
            unsigned int nb,
            unsigned int np1,
            unsigned int np2,
            const unsigned long long *xdat, double *corrl
    );
 
    static void normalize_ccf_felekyan(
            std::vector<unsigned long long> &x_axis,
            std::vector<double> &corr,
            std::vector<unsigned long long> &x_axis_normalized,
            std::vector<double> &corr_normalized,
            double cr1, double cr2,
            unsigned int n_bins,
            unsigned int n_casc,
            unsigned long long maximum_macro_time
    );
 
    static void ccf_wahl(
            size_t n_casc, size_t n_bins,
            std::vector<unsigned long long> &taus, 
            std::vector<double> &corr,
            CorrelatorPhotonStream &p1,
            CorrelatorPhotonStream &p2
    );
 
    static void normalize_ccf_wahl(
            double np1, uint64_t dt1,
            double np2, uint64_t dt2,
            std::vector<unsigned long long> &x_axis, 
            std::vector<double> &corr,
            size_t n_bins
    );
    
    static void ccf_laurence(
            std::vector<unsigned long long> &taus, 
            std::vector<double> &corr,
            CorrelatorPhotonStream &p1,
            CorrelatorPhotonStream &p2
    );
    
    static void normalize_ccf_laurence(
            CorrelatorPhotonStream &p1,
            CorrelatorPhotonStream &p2,
            std::vector<unsigned long long> &x_axis, 
            std::vector<double> &corr,
            std::vector<double> &corr_normalized
    );
 
   static void normalize(Correlator* correlator, CorrelatorCurve &curve);
 
public:
 
    CorrelatorPhotonStream p1;
    CorrelatorPhotonStream p2;
    CorrelatorCurve curve;
 
    uint64_t dt();
 
    Correlator(
        std::shared_ptr<TTTR> tttr = nullptr,
        std::string method = "wahl",
        int n_bins = 17,
        int n_casc = 25,
        bool make_fine = false
    );
 
 
    ~Correlator() = default;
 
    void set_n_casc(int n_casc) {
     curve.set_n_casc(n_casc);
     is_valid = false;
    }
 
 
    CorrelatorCurve *get_curve() {
        if (!is_valid) run();
        return &curve;
       }
 
 
    unsigned int get_n_casc() {
        return curve.get_n_casc();
       }
 
    void set_n_bins(int v) {
        curve.set_n_bins(v);
        is_valid = false;
       }
 
    unsigned int get_n_bins() const {
        return curve.settings.n_bins;
    }
 
 
    void set_correlation_method(std::string cm) {
        is_valid = false;
        correlation_method = cm;
       }
 
 
    std::string get_correlation_method() {
        return correlation_method;
       }
 
    void set_microtimes(
        unsigned short *tac_1, int n_tac_1,
        unsigned short *tac_2, int n_tac_2,
        unsigned int number_of_microtime_channels
    );
 
    void set_macrotimes(
        unsigned long long *t1, int n_t1,
        unsigned long long *t2, int n_t2
    );
 
     std::pair<std::vector<unsigned long long>, std::vector<unsigned long long>> get_macrotimes() {
      return {this->p1.times, this->p2.times};
     }
 
 
    void set_events(
            unsigned long long *t1, int n_t1,
            double *weight_ch1, int n_weights_ch1,
            unsigned long long *t2, int n_t2,
            double *weight_ch2, int n_weights_ch2
    );
 
 
    void set_weights(
            double *weight_ch1, int n_weights_ch1,
            double *weight_ch2, int n_weights_ch2
    );
 
    std::pair<std::vector<double>, std::vector<double>> get_weights(){
        return {this->p1.weights, this->p2.weights};
    }
 
    void get_x_axis(double **output, int *n_output);
 
    void get_corr_normalized(double **output, int *n_output);
 
    void get_corr(double** output, int* n_output);
 
    void run();
 
    void set_tttr(
            std::shared_ptr<TTTR> tttr_1,
            std::shared_ptr<TTTR> tttr_2 = nullptr ,
            bool make_fine = false
    );
 
    std::pair<std::shared_ptr<TTTR>, std::shared_ptr<TTTR>> get_tttr();
 
    void set_filter(
            const std::map<short, std::vector<double>> &filter,
            const std::vector<unsigned int> &micro_times_1,
            const std::vector<signed char> &routing_channels_1,
            const std::vector<unsigned int> &micro_times_2,
            const std::vector<signed char> &routing_channels_2
    );
 
};
 
#endif //TTTRLIB_CORRELATOR_H