QMC/Sampling.cpp at master · jorgehog/QMC · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
/*
 * File:   Sampling.cpp
 * Author: jorgehog
 *
 * Created on 15. juni 2012, 18:44
 */

#include "QMCheaders.h"

using namespace std;

Sampling::Sampling(int n_p, int dim) {
    this->n_p = n_p;
    this->dim = dim;
}

void Sampling::set_trial_pos(Walker* walker, bool load_VMC_dist, std::ifstream* file) const {
    int i, j;

    if (load_VMC_dist) {

        double pos;
        for (i = 0; i < n_p; i++) {
            for (j = 0; j < dim; j++) {
                *file >> pos;
                walker->r(i, j) = pos;
            }
        }
    } else {
        for (i = 0; i < n_p; i++) {
            for (j = 0; j < dim; j++) {
                walker->r(i, j) = diffusion->Diffusion::get_new_pos(walker, i, j);
            }
        }
    }

    walker->make_rel_matrix();

    get_necessities(walker);

}

double Sampling::get_new_pos(const Walker* walker_pre, int particle, int j) const {
    return diffusion->get_new_pos(walker_pre, particle, j);
}

double Sampling::get_g_ratio(const Walker* walker_post, const Walker* walker_pre, int particle) const {
    return diffusion->get_g_ratio(walker_post, walker_pre, particle);
}

void Sampling::update_walker(Walker* walker_pre, const Walker* walker_post, int particle) const {
    for (int i = 0; i < dim; i++) {
        walker_pre->r(particle, i) = walker_post->r(particle, i);
    }

    for (int i = 0; i < n_p; i++) {
        walker_pre->r_rel(i, particle) = walker_pre->r_rel(particle, i) = walker_post->r_rel(i, particle);
    }
}

double Sampling::get_branching_Gfunc(Walker* walker_pre, Walker* walker_post, double E_T) const {
    return diffusion->get_GBfunc(walker_pre, walker_post, E_T);
}

Brute_Force::Brute_Force(int n_p, int dim, double timestep, long random_seed, double D) : Sampling(n_p, dim) {
    is_importance = false;
    diffusion = new Simple(n_p, dim, timestep, random_seed, D);
}

void Brute_Force::update_walker(Walker* walker_pre, const Walker* walker_post, int particle) const {
    this->Sampling::update_walker(walker_pre, walker_post, particle);
    walker_pre->value = walker_post->value;
}

void Brute_Force::get_necessities(Walker* walker) const {
    qmc->get_wf_value(walker);
}

void Brute_Force::update_necessities(const Walker* walker_pre, Walker* walker_post, int particle) const {
    qmc->get_wf_value(walker_post);
}

void Brute_Force::reset_walker(const Walker* walker_pre, Walker* walker_post, int particle) const {
    //Nothing to reset;
}

void Brute_Force::calculate_energy_necessities_CF(Walker* walker) const {
    qmc->get_system_ptr()->initialize(walker);
    qmc->get_gradients(walker);
}

double Brute_Force::get_spatial_ratio(const Walker* walker_post, const Walker* walker_pre, int particle) const {
    return walker_post->value / walker_pre->value;
}

void Brute_Force::copy_walker(const Walker* parent, Walker* child) const {
    child->value = parent->value;
}

Importance::Importance(int n_p, int dim, double timestep, long random_seed, double D) : Sampling(n_p, dim) {
    is_importance = true;
    diffusion = new Fokker_Planck(n_p, dim, timestep, random_seed, D);
}

void Importance::calculate_energy_necessities_CF(Walker* walker) const {
    //CF IS has no spesific necessities
}

void Importance::copy_walker(const Walker* parent, Walker* child) const {
    qmc->get_kinetics_ptr()->copy_walker_IS(parent, child);

    child->qforce = parent->qforce;
}

void Importance::update_necessities(const Walker* walker_pre, Walker* walker_post, int particle) const {
    qmc->get_kinetics_ptr()->update_necessities_IS(walker_pre, walker_post, particle);
    qmc->get_kinetics_ptr()->get_QF(walker_post);
}

void Importance::update_walker(Walker* walker_pre, const Walker* walker_post, int particle) const {
    this->Sampling::update_walker(walker_pre, walker_post, particle);
    qmc->get_kinetics_ptr()->update_walker_IS(walker_pre, walker_post, particle);

    for (int i = 0; i < n_p; i++) {
        for (int j = 0; j < dim; j++) {
            walker_pre->qforce(i, j) = walker_post->qforce(i, j);
        }
    }
}

void Importance::reset_walker(const Walker* walker_pre, Walker* walker_post, int particle) const {
    qmc->get_kinetics_ptr()->reset_walker_IS(walker_pre, walker_post, particle);
}

double Importance::get_spatial_ratio(const Walker* walker_post, const Walker* walker_pre, int particle) const {
    return qmc->get_kinetics_ptr()->get_spatial_ratio_IS(walker_post, walker_pre, particle);
}

void Importance::get_necessities(Walker* walker) const {
    qmc->get_kinetics_ptr()->get_necessities_IS(walker);
    qmc->get_kinetics_ptr()->get_QF(walker);

    if (walker->check_bad_qforce()) {
        Sampling::set_trial_pos(walker);
    }
}