---

Orbital.h

Go to the documentation of this file.

/***************************************************************************
 *cr                                                                       
 *cr            (C) Copyright 1995-2011 The Board of Trustees of the           
 *cr                        University of Illinois                       
 *cr                         All Rights Reserved                        
 *cr                                                                   
 ***************************************************************************/

/***************************************************************************
 * RCS INFORMATION:
 *
 *      $RCSfile: Orbital.h,v $
 *      $Author: johns $        $Locker:  $             $State: Exp $
 *      $Revision: 1.36 $       $Date: 2010/12/16 04:08:28 $
 *
 ***************************************************************************
 * DESCRIPTION:
 *
 * The Orbital class, which stores orbitals, for a
 * single timestep.
 *
 ***************************************************************************/
#ifndef ORBITAL_H
#define ORBITAL_H

#include<string.h>
#include "QMData.h"
#include "Molecule.h"

class Orbital {
private:
  int atomid;
  int shellid;

  int numatoms;         
  const float *atompos; 


  int num_wave_f; 


  float *wave_f;            

  int num_basis_funcs;      

  const float *basis_array; 






  int numtypes;
  const basis_atom_t *basis_set;  

  const int *atom_types;          
  const int *atom_sort;           

  const int *atom_basis;          

  const float **norm_factors;     


  const int *num_shells_per_atom; 
  const int *num_prim_per_shell;  
  const int *shell_types;         


  // grid related data
  int numvoxels[3];  
  float voxelsize;   
  float origin[3];   
  float gridsize[3]; 

  float *grid_data;  



public:
  Orbital(const float *atompos,
          const float *wave_function,
          const float *basis,
          const basis_atom_t *bset,
          const int *types,
          const int *atom_sort,
          const int *atom_basis,
          const float **norm_factors,
          const int *num_shells_per_atom,
          const int *num_prim_per_shell,
          const int *orbital_symmetry,
          int numatoms, int numtypes, int num_wave_f,
          int num_basis_funcs, 
          int orbid); 

  ~Orbital(void);               


  // Return array sizes need for GPU-acclerated versions
  int total_shells() {
    int shellcnt=0;
    for (int at=0; at<numatoms; at++) {
      for (int shell=0; shell < num_shells_per_atom[at]; shell++) { 
        shellcnt++;
      }
    }

    return shellcnt;
  }

  // Return the max number of primitives that occur in a basis function
  int max_primitives(void);

  // Return maximum shell type contained in the orbital
  int max_shell_type(void);

  // Count the max number of wave_f accesses for the shell types
  // contained in this orbital 
  int max_wave_f_count(void);

  // Get the grid origin
  const float* get_origin() { return origin; }

  // Get the side lengths of the grid in Angstrom
  const float* get_gridsize() { return gridsize; }

  // Get the number of voxels in each dimension
  const int* get_numvoxels() { return numvoxels; }

  // Get the axes of the volumetric grid as defined in 
  // volumetric_t.
  void get_grid_axes(float xaxis[3], float yaxis[3], float zaxis[3]) {
    xaxis[0] = gridsize[0];
    yaxis[1] = gridsize[1];
    zaxis[2] = gridsize[2];
    xaxis[1] = xaxis[2] = yaxis[0] = yaxis[2] = zaxis[0] = zaxis[1] = 0.0;
  }

  // Get the grid resolution, i.e. the side length of a voxel
  float get_resolution() { return voxelsize; }

  // Set the grid size and resolution
  // The given grid dimensions will be rounded to a multiple
  // of the voxel size.
  void set_grid(float newori[3], float newdim[3], float voxelsize);

  // Change the resolution of the grid
  void set_resolution(float voxelsize);

  // Get a pointer to the raw volumetric data
  float* get_grid_data() { return grid_data; }

  // Sets the grid dimensions to the bounding box of the given
  // set of atoms *pos including a padding in all dimensions.
  // The resulting grid dimensions will be rounded to a multiple
  // of the voxel size.
  int set_grid_to_bbox(const float *pos, float padding,
                       float resolution);

  // Optimize position and dimension of current grid so that
  // all orbital values higher than threshold are contained
  // in the grid.
  void find_optimal_grid(float threshold,
                         int minstepsize, int maxstepsize);

  // Check if all values in the boundary plane given by dir 
  // are below threshold.
  // If not, jump back, decrease the stepsize and test again.
  // Helper function for find_optimal_grid().
  int check_plane(int w, float threshold, int minstepsize, int &stepsize);

  // Multiply wavefunction coefficients with the
  // basis set normalization factors.
  void normalize_wavefunction(const float *wfn);

  // Compute the volumetric data for the orbital
  int calculate_mo(DrawMolecule *mol, int density);

  // Compute the volumetric data for given point in space
  float evaluate_grid_point(float grid_x, float grid_y, float grid_z);

  // Compute total FLOPS executed for a single gridpoint
  double flops_per_gridpoint();

  void print_wavefunction();
};


// Compute the volumetric data for the whole grid
int evaluate_grid(int numatoms, 
                  const float *wave_f, 
                  const float *basis_array,
                  const float *atompos,
                  const int *atom_basis,
                  const int *num_shells_per_atom,
                  const int *num_prim_per_shell,
                  const int *shell_types,
                  const int *numvoxels,
                  float voxelsize,
                  const float *origin,
                  int density,
                  float * orbitalgrid); 

// Multiprocessor implementation
int evaluate_grid_fast(int numatoms, 
                       const float *wave_f,
                       const float *basis_array,
                       const float *atompos,
                       const int *atom_basis,
                       const int *num_shells_per_atom,
                       const int *num_prim_per_shell,
                       const int *shell_types,
                       const int *numvoxels,
                       float voxelsize,
                       const float *origin,
                       int density,
                       float * orbitalgrid); 

#endif

---