MedRegistry.h

Go to the documentation of this file.

 
#ifndef __MED_REGISTRY_H__
#define __MED_REGISTRY_H__
#include <vector>
#include <SerializableObject/SerializableObject/SerializableObject.h>
#include <InfraMed/InfraMed/MedPidRepository.h>
#include <MedProcessTools/MedProcessTools/MedSamples.h>
#include <MedProcessTools/MedProcessTools/MedModel.h>
#include <MedProcessTools/MedProcessTools/RepProcess.h>
#include "MedSamplingStrategy.h"
#include "MedLabels.h"
#include "MedEnums.h"
#include "MedRegistryRecord.h"
 
using namespace std;
 
class MedRegistry : public SerializableObject
{
public:
    vector<MedRegistryRecord> registry_records; 
    int time_unit; 
 
    void write_text_file(const string &file_path) const;
    void read_text_file(const string &file_path);
 
    void create_registry(MedPidRepository &dataManager, medial::repository::fix_method method = medial::repository::fix_method::none, vector<RepProcessor *> *rep_processors = NULL);
 
    void get_registry_creation_codes(vector<string> &signal_codes) const;
    void get_registry_use_codes(vector<string> &signal_codes) const;
 
 
    void get_pids(vector<int> &pids) const;
 
    void merge_records();
 
    void *new_polymorphic(string dname);
 
    static MedRegistry *make_registry(const string &registry_type, const string &init_str = "");
 
    static MedRegistry *make_registry(const string &registry_type, MedRepository &rep, const string &init_str = "");
 
    static MedRegistry *create_registry_full(const string &registry_type, const string &init_str,
        const string &repository_path, MedModel &model_with_rep_processor, medial::repository::fix_method method = medial::repository::fix_method::none);
 
    MedRegistry() {
        need_bdate = false;
        time_unit = global_default_time_unit;
    }
 
    virtual ~MedRegistry() {};
 
    virtual void clear_create_variables() {};
 
    virtual bool get_pid_records(PidRec &rec, int bDateCode, const vector<int> &used_sigs, vector<MedRegistryRecord> &results);
 
    void set_rep_for_init(MedRepository &rep) { rep_for_init = &rep; }
 
    ADD_CLASS_NAME(MedRegistry)
        ADD_SERIALIZATION_FUNCS(time_unit, registry_records)
protected:
    vector<string> signalCodes_names; 
    bool need_bdate; 
    medial::repository::fix_method resolve_conlicts = medial::repository::fix_method::none; 
    MedRepository *rep_for_init = NULL; 
private:
    virtual void get_registry_records(int pid, int bdate, vector<UniversalSigVec_mem> &usv, vector<MedRegistryRecord> &results) { throw logic_error("Not Implemented"); };
};
 
namespace medial {
    namespace contingency_tables {
        double calc_chi_square_dist(const map<float, vector<int>> &gender_sorted, int smooth_balls = 0,
            float allowed_error = 0, int minimal_balls = 0);
 
        double calc_mcnemar_square_dist(const map<float, vector<int>> &gender_sorted);
 
        double calc_cmh_square_dist(const map<float, vector<int>> *gender_sorted, const map<float, vector<int>> *gender_sorted2, bool &ok);
 
        void calc_chi_scores(const map<float, map<float, vector<int>>> &male_stats,
            const map<float, map<float, vector<int>>> &female_stats,
            vector<int> &all_signal_values, vector<int> &signal_indexes,
            vector<double> &valCnts, vector<double> &posCnts,
            vector<double> &lift, vector<double> &scores,
            vector<double> &p_values, vector<double> &pos_ratio, int smooth_balls = 0, float allowed_error = 0,
            int minimal_balls = 0);
 
        void calc_mcnemar_scores(const map<float, map<float, vector<int>>> &male_stats,
            const map<float, map<float, vector<int>>> &female_stats,
            vector<int> &all_signal_values, vector<int> &signal_indexes,
            vector<double> &valCnts, vector<double> &posCnts, vector<double> &lift
            , vector<double> &scores, vector<double> &p_values, vector<double> &pos_ratio);
 
        void calc_cmh_scores(const map<float, map<float, vector<int>>> &male_stats,
            const map<float, map<float, vector<int>>> &female_stats,
            vector<int> &all_signal_values, vector<int> &signal_indexes,
            vector<double> &valCnts, vector<double> &posCnts, vector<double> &lift
            , vector<double> &scores, vector<double> &p_values, vector<double> &pos_ratio);
 
        void FilterRange(vector<int> &indexes, const vector<double> &vecCnts
            , double min_val, double max_val);
 
        void filterHirarchy(const map<int, vector<int>> &member2Sets, const map<int, vector<int>> &set2Members,
            vector<int> &indexes, const vector<int> &signal_values, const vector<double> &pVals,
            const vector<double> &valCnts, const vector<double> &lifts, const unordered_map<int, double> &code_unfiltered_cnts,
            float pValue_diff, float lift_th, float count_similarity, float child_fitlered_ratio, const map<int, vector<string>> *categoryId_to_name = NULL);
 
        double chisqr(int Dof, double Cv);
        void write_stats(const string &file_path,
            const map<float, map<float, vector<int>>> &males_stats, const map<float, map<float, vector<int>>> &females_stats);
        void read_stats(const string &file_path,
            map<float, map<float, vector<int>>> &males_stats, map<float, map<float, vector<int>>> &females_stats);
        void FilterFDR(vector<int> &indexes,
            const vector<double> &scores, const vector<double> &p_vals, const vector<double> &lift,
            double filter_pval);
    }
    namespace print {
        void print_reg_stats(const vector<MedRegistryRecord> &regRecords, const string &log_file = "");
    }
    namespace registry {
        void complete_active_period_as_controls(vector<MedRegistryRecord> &registry,
            const vector<MedRegistryRecord> &active_periods_registry, bool unite_full_controls = true);
    }
}
 
class RegistrySignal : public SerializableObject {
public:
    string signalName; 
    int duration_flag; 
    int buffer_duration; 
    bool take_only_first; 
    int channel; 
    float outcome_value; 
 
    RegistrySignal() {
        signalName = "";
        duration_flag = 0;
        buffer_duration = 0;
        take_only_first = false;
        channel = 0;
        outcome_value = 1;
    }
 
    virtual bool get_outcome(const UniversalSigVec &s, int current_i, float &result) = 0;
 
    static RegistrySignal *make_registry_signal(const string &type, MedRepository &rep, const string &path_to_cfg_file);
    static RegistrySignal *make_registry_signal(const string &type, MedRepository &rep, const string &init_string, const string &path_to_cfg_file);
 
    static void parse_registry_rules(const string &reg_cfg, MedRepository &rep,
        vector<RegistrySignal *> &result);
 
    int init(map<string, string>& mapper);
 
    virtual void _init(const map<string, string>& mapper) {};
 
    virtual ~RegistrySignal() {};
 
    ADD_CLASS_NAME(RegistrySignal)
        ADD_SERIALIZATION_FUNCS(signalName, duration_flag, buffer_duration, take_only_first, channel, outcome_value)
 
        void *new_polymorphic(string dname);
};
 
class RegistrySignalSet : public RegistrySignal {
public:
    vector<string> sets;
 
    RegistrySignalSet(const string &sigName, int durr_time, int buffer_time, bool take_first,
        MedRepository &rep, const vector<string> &sets, const string &path_to_cfg_file, float outcome_val = 1, int chan = 0);
    RegistrySignalSet(const string &init_string, MedRepository &rep, const vector<string> &sets, const string &path_to_cfg_file, float outcome_val = 1);
    bool get_outcome(const UniversalSigVec &s, int current_i, float &result);
 
    void _init(const map<string, string>& mapper);
 
    bool is_empty() { return Flags.empty(); }
private:
    vector<char> Flags;
    MedRepository *repo;
    string base_cfg_path;
};
 
class RegistrySignalRange : public RegistrySignal {
public:
    float min_value; 
    float max_value; 
 
    RegistrySignalRange(const string &sigName, int durr_time, int buffer_time, bool take_first,
        float min_range, float max_range, float outcome_val = 1, int chan = 0);
    bool get_outcome(const UniversalSigVec &s, int current_i, float &result);
 
    void _init(const map<string, string>& mapper);
private:
 
};
 
class RegistrySignalAny : public RegistrySignal {
 
    bool get_outcome(const UniversalSigVec &s, int current_i, float &result);
 
    ADD_CLASS_NAME(RegistrySignalAny)
        ADD_SERIALIZATION_FUNCS(signalName, duration_flag, buffer_duration, take_only_first, channel, outcome_value)
};
 
class RegistrySignalDrug : public RegistrySignal {
public:
    vector<string> sets;
    RegistrySignalDrug(MedRepository &rep, const string &path_to_cfg_file);
    void _init(const map<string, string>& mapper);
 
    bool is_empty() { return Flags.empty(); }
 
    bool get_outcome(const UniversalSigVec &s, int current_i, float &result);
private:
    vector<char> Flags; 
    vector<pair<float, float>> Flags_range; 
    MedRepository *repo;
    string base_path;
};
 
class RegistrySignalAnd : public RegistrySignal {
public:
    vector<RegistrySignal *> conditions; 
 
    RegistrySignalAnd(MedRepository &rep);
    void _init(const map<string, string>& mapper);
 
    bool get_outcome(const UniversalSigVec &s, int current_i, float &result);
 
    ~RegistrySignalAnd();
private:
    MedRepository * repo;
};
 
class MedRegistryCodesList : public MedRegistry {
public:
    int start_buffer_duration; 
    int end_buffer_duration; 
    int max_repo_date; 
    bool allow_prediciton_in_case; 
    bool seperate_cases; 
 
    vector<RegistrySignal *> signal_filters; 
 
    MedRegistryCodesList() {
        init_called = false;
        start_buffer_duration = 0;
        end_buffer_duration = 0;
        max_repo_date = 0;
        need_bdate = false;
        allow_prediciton_in_case = false;
        seperate_cases = false;
    }
 
    ~MedRegistryCodesList() {
        clear_create_variables();
    }
 
    void init(MedRepository &rep, int start_dur, int end_durr, int max_repo,
        const vector<RegistrySignal *> signal_conditions, const string &skip_pid_file = "",
        const unordered_map<int, int> *pid_to_censor_dates = NULL);
 
    int init(map<string, string>& map);
 
    void clear_create_variables();
 
    ADD_CLASS_NAME(MedRegistryCodesList)
        ADD_SERIALIZATION_FUNCS(time_unit, registry_records,
            start_buffer_duration, end_buffer_duration, max_repo_date, allow_prediciton_in_case,
            seperate_cases)
private:
    vector<bool> SkipPids; 
    unordered_map<int, int> pid_to_max_allowed; 
 
    void get_registry_records(int pid, int bdate, vector<UniversalSigVec_mem> &usv, vector<MedRegistryRecord> &results);
    bool init_called; 
};
 
class MedRegistryCategories : public MedRegistry {
public:
    int start_buffer_duration; 
    int end_buffer_duration; 
    int max_repo_date; 
 
    vector<vector<RegistrySignal *>> signals_rules; 
 
    int init(map<string, string>& map);
 
    MedRegistryCategories() {
        start_buffer_duration = 0;
        end_buffer_duration = 0;
        max_repo_date = 0;
        need_bdate = false;
    }
 
    void clear_create_variables();
 
    ~MedRegistryCategories() {
        clear_create_variables();
    }
 
    ADD_CLASS_NAME(MedRegistryCategories)
        ADD_SERIALIZATION_FUNCS(time_unit, registry_records, start_buffer_duration, end_buffer_duration,
            max_repo_date)
private:
    unordered_map<int, int> pid_to_max_allowed; 
 
    void get_registry_records(int pid, int bdate, vector<UniversalSigVec_mem> &usv, vector<MedRegistryRecord> &results);
};
 
class MedRegistryKeepAlive : public MedRegistry {
public:
    int duration; 
    int max_repo_date; 
    int start_buffer_duration; 
    int secondry_start_buffer_duration; 
    int end_buffer_duration; 
    vector<string> signal_list; 
 
    MedRegistryKeepAlive() {
        duration = 0;
        max_repo_date = 0;
        need_bdate = false;
        start_buffer_duration = 0;
        end_buffer_duration = 0;
        secondry_start_buffer_duration = 0;
    }
 
    int init(map<string, string>& map);
 
    ADD_CLASS_NAME(MedRegistryKeepAlive)
        ADD_SERIALIZATION_FUNCS(time_unit, registry_records, duration, max_repo_date, start_buffer_duration,
            secondry_start_buffer_duration, end_buffer_duration, signal_list)
private:
    unordered_map<int, int> pid_to_max_allowed; 
 
    void get_registry_records(int pid, int bdate, vector<UniversalSigVec_mem> &usv, vector<MedRegistryRecord> &results);
};
 
MEDSERIALIZE_SUPPORT(MedRegistry)
MEDSERIALIZE_SUPPORT(MedRegistryCodesList)
MEDSERIALIZE_SUPPORT(MedRegistryCategories)
MEDSERIALIZE_SUPPORT(MedRegistryKeepAlive)
 
#endif