wavefunction_simple_operations.h

Go to the documentation of this file.

/**Performs very simple operations on dotcode wavefunctions.

    Copyright (C) 2011 Joseph Pingenot

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#include <libpostproc/lp_wavefunction.h>
#include <libdotcode/dotcode_wavefunction.h>

#ifndef ____LIBDOTCODE_WAVEFUNCTION_SIMPLE_OPERATIONS_H___
#define ____LIBDOTCODE_WAVEFUNCTION_SIMPLE_OPERATIONS_H___

/**Gets the percentage of the wavefunction that is in the band (range is [0, 1])
 *\param wf pointer to the wavefunction
 *\param band the band to examine
 *\return percentage of the wavefunction in the specified band (range is [0, 1])
 *   (NaN if there was an error)
 */
double dotcode_wavefunction_get_percentage_in_band(const struct wavefunction* wf, int band);

/**Calculates product of two real-valued wavefunctions and a complex-valued callback f, <b|f|a>, using a cheesy summation (not only is the summation itself cheesy, but this method of doing it is cheesy. But seems to work.)
 *\param b wavefunction b
 *\param f real-valued callback: accepts x, y, z, pointers to real and imaginary value of f at this point, and private data
 *\param a wavefunction a
 *\param value_re real value of the integral
 *\param value_im imaginary value of the integral
 *\param privdat private data to be passed to f when it's called
 */
void dotcode_wavefunction_integrate_sum(const struct wavefunction* b, void (*f)(double x, double y, double z, double* re, double* im, void* privdat), const struct wavefunction* a, double* value_re, double* value_im, void* privdat);
/**Calculates product of two real-valued wavefunctions and a complex-valued callback f, <b|f|a>, using a cheesy summation (not only is the summation itself cheesy, but this method of doing it is cheesy. But seems to work.)
 *\param b wavefunction b
 *\param f real-valued callback: accepts x, y, z, pointers to real and imaginary value of f at this point, and private data
 *\param a wavefunction a
 *\param value pointer to a two-element double array, value[0] is the real value of the integral and value[1] is the imaginary value
 *\param privdat private data to be passed to f when it's called
 */
void dotcode_wavefunction_integrate_sum_1(const struct wavefunction* b, void (*f)(double x, double y, double z, double* re, double* im, void* privdat), const struct wavefunction* a, double* value, void* privdat);
/**Parallelized: calculates product of two real-valued wavefunctions and a complex-valued callback f, <b|f|a>, using a cheesy summation (not only is the summation itself cheesy, but this method of doing it is cheesy. But seems to work.)
 *\param b wavefunction b
 *\param f real-valued callback: accepts x, y, z, pointers to real and imaginary value of f at this point, and private data
 *\param a wavefunction a
 *\param value_re real value of the integral
 *\param value_im imaginary value of the integral
 *\param privdat array private data to be passed to f when it's called (if NULL, NULL will be passed to f)
 */
void dotcode_wavefunction_integrate_sum_parallel(const struct wavefunction* b, void (*f)(double x, double y, double z, double* re, double* im, void* privdat), const struct wavefunction* a, double* value_re, double* value_im, void** privdat);
/**Parallelized: calculates product of two real-valued wavefunctions and a complex-valued callback f, <b|f|a>, using a cheesy summation (not only is the summation itself cheesy, but this method of doing it is cheesy. But seems to work.)
 *\param b wavefunction b
 *\param f real-valued callback: accepts x, y, z, pointers to real and imaginary value of f at this point, and private data
 *\param a wavefunction a
 *\param value pointer to a two-element double array, value[0] is the real value of the integral and value[1] is the imaginary value
 *\param privdat array private data to be passed to f when it's called (if NULL, NULL will be passed to f)
 */
void dotcode_wavefunction_integrate_sum_parallel_1(const struct wavefunction* b, void (*f)(double x, double y, double z, double* re, double* im, void* privdat), const struct wavefunction* a, double* value, void** privdat);


#endif