dotcode_wavefunction.c

Go to the documentation of this file.

/**Provides basic routines for getting and using a dotcode wavefunction.
 

    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 <stdlib.h>
#include <libdotcode/dotcode_wavefunction.h>

/**
 *Gets the index into the storage member for a wavefunction, or for a density
 *\param x x index component
 *\param y y index component
 *\param z z index component
 *\param b band index component
 *\param im 1 if imaginary component is wanted; 0 else.
 *\param Nx Number of x sites
 *\param Ny Number of y sites
 *\param Nb Number of bands
 *\returns long unsigned int, which is the address in the storage
 *array.
 *\note there is no error checking, for speed purposes. E.g. if im is
 *3, it'll just be blindly used as a 3 and you'll be addressing the
 *imaginary component of the next index.
 *\note Nz is not needed.
 */
hotfunc ___const ___always_inline long unsigned int get_wavefunction_storage_index(unsigned int x, unsigned int y, unsigned int z, unsigned int im, unsigned int b, unsigned int Nx, unsigned int Ny, int Nb) {
  return im + 2*(b + Nb*(x + Nx*(y + Ny*(z))));
}
___const long unsigned int get_wavefunction_storage_index_(unsigned int x, unsigned y, unsigned z, unsigned im, unsigned b, unsigned Nx, unsigned Ny, unsigned Nb) {
  return get_wavefunction_storage_index(x, y, z, im, b, Nx, Ny, Nb);
}

hotfunc ___always_inline double* get_wavefunction_storage(unsigned int x, unsigned int y, unsigned int z, unsigned int im, unsigned int b, struct wavefunction* wf) {
  return &(wf->storage[get_wavefunction_storage_index(x, y, z, im, b, wf->N[0], wf->N[1], wf->bands)]);
}
double* get_wavefunction_storage_(unsigned int x, unsigned int y, unsigned int z, unsigned int im, unsigned int b, struct wavefunction* wf) {
  return get_wavefunction_storage(x, y, z, im, b, wf);
}

hotfunc ___always_inline const double* get_wavefunction_storage_c(unsigned int x, unsigned int y, unsigned int z, unsigned int im, unsigned int b, const struct wavefunction* wf) {
  return &(wf->storage[get_wavefunction_storage_index(x, y, z, im, b, wf->N[0], wf->N[1], wf->bands)]);
}
const double* get_wavefunction_storage_c_(unsigned int x, unsigned int y, unsigned int z, unsigned int im, unsigned int b, const struct wavefunction* wf) {
  return get_wavefunction_storage_c(x, y, z, im, b, wf);
}

struct density* dotcode_wavefunction_get_density_in_band(const struct wavefunction* wf, int band) { 
  if(band >= wf->bands) return NULL;
  unsigned x, y, z;
  double re, im;
  struct density* d = new_density(wf->N, wf->dx, 0.0);
  #ifdef OPENMP
  #pragma omp parallel for private(x, y, z, re, im)
  #endif
  for(z=0; z<wf->N[2]; ++z) {
    for(y=0; y<wf->N[1]; ++y) {
      for(x=0; x<wf->N[0]; ++x) {
  re = *get_wavefunction_storage_c(x, y, z, 0, band, wf);
  im = *get_wavefunction_storage_c(x, y, z, 1, band, wf);
  *get_density_storage_at_(x, y, z, d) = re*re + im*im;
      }
    }
  }
  return d;
}

void dotcode_wavefunction_free(struct wavefunction* wf) {
  dotcode_wavefunction_free_resources(wf);
  free(wf);
}

void dotcode_wavefunction_free_resources(struct wavefunction* wf) {
  g_object_unref(wf->file);
  free(wf->storage);
}