anonymous_namespace{adhesion.cpp} Namespace Reference

Functions
void	gen_init_expot (const Mesh &potential, Mesh &expotential, double nu)
double	get_summation (const std::vector< double > &exp_aux)
void	convolution_y1 (Mesh &potential, const std::vector< double > &gaussian, const Mesh &expotential_0)
void	convolution_y2 (Mesh &potential, const std::vector< double > &gaussian)
void	convolution_y3 (Mesh &potential, const std::vector< double > &gaussian)
void	gen_expot (Mesh &potential, const Mesh &expotential_0, double nu, double b)

Variables
const double	ACC = 1e-10
const double	log_acc = log(ACC)

Function Documentation

void anonymous_namespace{adhesion.cpp}::convolution_y1	(	Mesh &	potential,
		const std::vector< double > &	gaussian,
		const Mesh &	expotential_0
	)

Definition at line 40 of file adhesion.cpp.

References get_summation(), and Mesh::N.

Referenced by gen_expot().

                                                                                                   {
    // multi-thread index is y3
    // compute f1 (x1, y2, y3)

    const unsigned int N = potential.N;
    std::vector<FTYPE_t> exp_aux;
    
    #pragma omp parallel for private(exp_aux)
    for (int x1 = 0; x1 < N; x1++){
        for (int y2 = 0; y2 < N; y2++){
            for (int y3 = 0; y3 < N; y3++){
                exp_aux.reserve(N);
                // fill in exponents
                for (int y1 = 0; y1 < N; y1++){
                    exp_aux.push_back(expotential_0(y1, y2, y3)+gaussian[std::abs(x1-y1)]);
                }
                potential(x1, y2, y3) = get_summation(exp_aux); // potential is now f1
                exp_aux.clear();
            }
        }
    }
}

void anonymous_namespace{adhesion.cpp}::convolution_y2	(	Mesh &	potential,
		const std::vector< double > &	gaussian
	)

Definition at line 63 of file adhesion.cpp.

References get_summation(), and Mesh::N.

Referenced by gen_expot().

                                                                        {
    // compute f2 (x1, x2, y3)

    const unsigned int N = potential.N;
    std::vector<FTYPE_t> sum_aux;
    std::vector<FTYPE_t> exp_aux;

    #pragma omp parallel for private(sum_aux, exp_aux)
    for (int x1 = 0; x1 < N; x1++){
        for (int y3 = 0; y3 < N; y3++){
            sum_aux.reserve(N);
            for (int x2 = 0; x2 < N; x2++){
                exp_aux.reserve(N);
                // fill in exponents
                for (int y2 = 0; y2 < N; y2++){
                    exp_aux.push_back(potential(x1, y2, y3) + gaussian[abs(x2-y2)]);
                }
                sum_aux.push_back(get_summation(exp_aux));
                exp_aux.clear();
            }

            for (int x2 = 0; x2 < N; x2++){
                potential(x1, x2, y3) = sum_aux[x2]; // potential is now f2
            }
            sum_aux.clear();
        }
    }
}

void anonymous_namespace{adhesion.cpp}::convolution_y3	(	Mesh &	potential,
		const std::vector< double > &	gaussian
	)

Definition at line 92 of file adhesion.cpp.

References get_summation(), and Mesh::N.

Referenced by gen_expot().

                                                                        {
    // compute f3 (x1, x2, x3) == expotential(x, b)

    const unsigned int N = potential.N;
    std::vector<FTYPE_t> sum_aux;
    std::vector<FTYPE_t> exp_aux;

    #pragma omp parallel for private(sum_aux, exp_aux)
    for (int x1 = 0; x1 < N; x1++){
        for (int x2 = 0; x2 < N; x2++){
            sum_aux.reserve(N);
            for (int x3 = 0; x3 < N; x3++){
                exp_aux.reserve(N);
                // fill in exponents
                for (int y3 = 0; y3 < N; y3++){
                    exp_aux.push_back(potential(x1, x2, y3) + gaussian[abs(x3-y3)]);
                }
                sum_aux.push_back(get_summation(exp_aux));
                exp_aux.clear();
            }
            for (int x3 = 0; x3 < N; x3++){
                potential(x1, x2, x3) = sum_aux[x3]; // potential is now f3
            }
            sum_aux.clear();
        }
    }
}

void anonymous_namespace{adhesion.cpp}::gen_expot	(	Mesh &	potential,
		const Mesh &	expotential_0,
		double	nu,
		double	b
	)

Definition at line 120 of file adhesion.cpp.

References convolution_y1(), convolution_y2(), convolution_y3(), and Mesh::N.

Referenced by App_Var_AA::AAImpl::aa_convolution().

{
    /* Computing convolution using direct sum */
    BOOST_LOG_TRIVIAL(debug) << "Computing expotential in q-space...";
    /*
    f(x1, x2, x3) = \int dy^3 { g(y1, y2, y3) * h(x1 - y1) * h(x2 - y2) * h(x3 - y3)}
    ..
    f1 (x1, y2, y3) = \int dy1 { g  (y1, y2, y3) * h(x1 - y1)}  :: N^3 sums of length N
    f2 (x1, x2, y3) = \int dy2 { f1 (x1, y2, y3) * h(x2 - y2)}  :: N^3 sums of length N
    f3 (x1, x2, x3) = \int dy3 { f2 (x1, x2, y3) * h(x3 - y3)}  :: N^3 sums of length N
    */

    // store values of exponential - every convolution uses the same exp(-r^2/4bv)
    std::vector<FTYPE_t> gaussian(expotential_0.N);

    #pragma omp parallel for
    for (size_t i = 0; i < expotential_0.N; i++){
        gaussian[i]=-i*i/(4*b*nu);
    }

    convolution_y1(potential, gaussian, expotential_0);
    convolution_y2(potential, gaussian);
    convolution_y3(potential, gaussian);
}

void anonymous_namespace{adhesion.cpp}::gen_init_expot	(	const Mesh &	potential,
		Mesh &	expotential,
		double	nu
	)

Definition at line 21 of file adhesion.cpp.

References Mesh_base< T >::length.

Referenced by App_Var_AA::pot_corr().

{
    BOOST_LOG_TRIVIAL(debug) << "Storing initial expotenital in q-space...";
    // store exponent only
    // *expotential = potential; !!! <- do not use this in case potential and expotential are meshes of different size
    #pragma omp parallel for
    for (size_t i = 0; i < expotential.length; i++) expotential[i] = -potential[i] / (2*nu);
}

double anonymous_namespace{adhesion.cpp}::get_summation

(

const std::vector< double > &

exp_aux

)

Definition at line 30 of file adhesion.cpp.

References log_acc.

Referenced by convolution_y1(), convolution_y2(), and convolution_y3().

{
    FTYPE_t max_exp = *max_element(exp_aux.begin(), exp_aux.end());
    FTYPE_t sum = 0;
    for(auto const& a_exp: exp_aux) {
        if ((a_exp - max_exp) > log_acc) sum+= exp(a_exp - max_exp);
    }
    return max_exp + log(sum);
}

Variable Documentation

const double anonymous_namespace{adhesion.cpp}::ACC = 1e-10

Definition at line 18 of file adhesion.cpp.

const double anonymous_namespace{adhesion.cpp}::log_acc = log(ACC)

Definition at line 19 of file adhesion.cpp.

Referenced by get_summation().