psi::extrema::deloc Class Reference

Derived class for delocalized internal coordinates. More...

#include <deloc.h>

Inheritance diagram for psi::extrema::deloc:

Public Member Functions
	deloc ()
	~deloc ()
	Frees memory.
void	optimize ()
	Delocalized internals optimization driver.

---

Detailed Description

Derived class for delocalized internal coordinates.

A top level class which allows delocalized internal coordinate manipulations by driving member functions of the abstract classes.

Definition at line 20 of file deloc.h.

---

Constructor & Destructor Documentation

deloc::deloc

(

)

Constructor for the top-level delocalized internals derived class. /*---------------------------------------------------------------------------

Definition at line 26 of file deloc.cc.

References psi::extrema::internals::B, chkpt_rd_felement(), chkpt_rd_rottype(), chkpt_rd_sym_label(), psi::extrema::internals::compute_G(), psi::extrema::coord_base::coords, psi::extrema::coord_base::do_deriv, psi::extrema::coord_base::do_opt, psi::extrema::coord_base::felement, ffile_noexit(), psi::extrema::internals::fnum_coords, free_matrix(), psi::extrema::internals::G, init_array(), init_int_array(), init_matrix(), ip_exist(), psi::extrema::coord_base::iteration, psi::extrema::coord_base_carts::masses, psi::extrema::internals::mem_alloc(), mmult(), NORMAL_PRINT, psi::extrema::coord_base_carts::num_atoms, psi::extrema::coord_base::num_coords, psi::extrema::coord_base_carts::num_entries, psi::extrema::internals::print_B(), psi::extrema::coord_base::print_lvl, print_mat(), RIDICULOUS_PRINT, sq_rsp(), and psi::extrema::internals::u.

               : internals() {

  int i,j,pos;

  deloc::parse_input();  

  felement = chkpt_rd_felement();
  point_group = chkpt_rd_sym_label();

  FILE *opt_ptr;
  ffile_noexit(&opt_ptr,"opt.dat",2);
  int form_deloc=0;
  if( opt_ptr == NULL ) {
      form_deloc=1;
      if( do_opt )
          do_deriv=0;
      iteration = 1;
  }
  
  else {
      ip_done();
      ip_set_uppercase(1);
      ip_initialize(opt_ptr,outfile);
      ip_cwk_add(":OPT_INFO");
      if(ip_exist("DO_DERIV",0)) {
          do_deriv=1;
          punt("Can't do derivatives yet");
      }
      else
          do_deriv=0;
      iteration = 2; /* proper number set in read_opt */
      read_bonds();
  }
  
  deloc::init_simples(); 
  if(print_lvl > NORMAL_PRINT)
      deloc::print_simples();

  /* form B matrix */
  deloc::compute_B_simple();

  if(print_lvl >= RIDICULOUS_PRINT) {
      fprintf(outfile,"\n  B matrix in simples representation:\n");
      fnum_coords = num_simples;
      print_B();
  }

  if(form_deloc) {

      fprintf(outfile,"\n\n  Forming delocalized internal coordinates\n"); 
   
      iteration = 1;
      
      /* form and diagonalize G */
      fnum_coords = num_simples; /* for now */
      G = init_matrix(num_simples,num_simples);
      internals::compute_G();
            
      double **temp_mat, *evals, **evects;
      evals = init_array(num_simples);
      evects = init_matrix(num_simples,num_simples);
      temp_mat = init_matrix(num_simples,num_simples);
      sq_rsp(num_simples,num_simples, G, evals, 1, evects, 1.0e-14);
      mmult(G,0,evects,0,temp_mat,0,num_simples,num_simples,num_simples,0);
      for (j=0;j<num_simples;++j) {
          error = 0;
          for (i=0;i<num_simples;++i) {
              if ( fabs(temp_mat[i][j] - evals[j]*evects[i][j]) > 1.0e-13)  
                  error=1;
              if (error == 1) { 
                  fprintf(outfile,
                          "\n  WARNING error detected in evect %d\n",j); 
                  error = 0;
              }
          }
      }      
      free_matrix(temp_mat,num_simples);
      
      if(print_lvl>NORMAL_PRINT) {
          pos=0;
          fprintf(outfile,"\n  Eigenvalues of G:\n");
          for(i=(num_simples-1);i>-1;--i) {
              if(pos==4) {
                  fprintf(outfile,"\n");
                  pos=0;
              }
              fprintf(outfile,"   % 15.10lf",evals[i]);
              ++pos;
          }
      }

      num_nonzero = 0;
      for (i=0;i<num_simples;++i)
          if( evals[i] > ev_tol ) ++num_nonzero;
      fprintf(outfile,
              "\n  %d nonzero eigenvalues of G (non-redundant coordinates)\n",
              num_nonzero);

      /* check for proper number of non-redundant coordinates */
      int rotor_type;
      rotor_type = chkpt_rd_rottype();
      switch (rotor_type) {
      case 3:
          if(num_atoms==2)
              degrees_of_freedom = 3*num_atoms -5;
          else punt("Use z-matrix for linear molecules");
          break;
      case 6:
          degrees_of_freedom = 0;
          break;
      default:
          degrees_of_freedom = 3 * num_atoms - 6;
          break;
      }
      
      if(num_nonzero == degrees_of_freedom) {
          fprintf(outfile,
                  "  Non-zero eigenvalues of G equal degrees of freedom");
          fprintf(outfile,"(%d)\n",num_nonzero);
      }
       else if(num_nonzero > degrees_of_freedom) {
          fprintf(outfile,"  Only %d degrees of freedom",degrees_of_freedom);
          fprintf(outfile,"\n  Symmetry projection and orthogonalization");
          fprintf(outfile," will be performed\n");
      }
      if (num_nonzero < degrees_of_freedom) {
          fprintf(outfile,"\n  Not enough non-redundant coordinates,");
          fprintf(outfile,
                  "\n  try reducing 'ev_tol' and check atom connectivity\n");
          punt("Not enough non-redundant coordinates");
      }
      
      /* define delocalized internal coordinates */
      deloc_define = init_matrix(num_nonzero, num_simples);
      pos=0;
      for(i=0;i<num_simples;++i)
          if(evals[i] > ev_tol) {
              for(j=0;j<num_simples;++j) 
                  deloc_define[pos][j] = evects[j][i];
              ++pos;
          }
      free_matrix(evects,num_simples);
      
      if(print_lvl>=RIDICULOUS_PRINT) {
      fprintf(outfile,"\n  Initial coordinates:\n");
      print_mat(deloc_define,num_nonzero,num_simples,outfile);
      }

      /* clean up coordinate symmetry */
      deloc::ir_project();

      if(num_coords!=degrees_of_freedom) 
          punt("number of coordinates != degrees of freedom");
  
      for(i=0;i<num_coords;++i)
          for(j=0;j<num_simples;++j)
              deloc_define[i][j] *= fabs(deloc_define[i][j]);

      if(!do_deriv) {
          
          /* coordinates look good, allocate memory */

          /* save old B_mat first */
          free_matrix(B,num_simples);

          fnum_coords = num_coords;

          free_matrix(u,3*num_entries);

          /* keep only symmetric coordinates for optimization */
          int *irrep_temp;
          irrep_temp = init_int_array(num_nonzero);
          for(i=0;i<num_coords;++i) {
              irrep_temp[i] = deloc_irrep[i];
          }           
          free(deloc_irrep);
          deloc_irrep = init_int_array(num_coords);

          double **define_temp;
          int temp_num_coords=0;
          define_temp = init_matrix(num_coords,num_simples);
          for(i=0;i<num_coords;++i)
              for(j=0;j<num_simples;++j)
                  define_temp[i][j] = deloc_define[i][j];
          free_matrix(deloc_define,num_coords);
          deloc_define = init_matrix(num_coords,num_simples);
          int p=0;
          for(i=0;i<num_coords;++i) 
              if(irrep_temp[i]==0) {
                  ++temp_num_coords;
                  for(j=0;j<num_simples;++j)
                      deloc_define[p][j] = define_temp[i][j];
                  deloc_irrep[p] = irrep_temp[i];
                  ++p;
              }

          num_coords = fnum_coords = temp_num_coords;
        
          internals::mem_alloc();
          
          p = -1;
          /* compute coordinate values */
          double sum;
          for(i=0;i<num_coords;++i) 
              if(deloc_irrep[i]==0) {
                  sum=0;
                  for(j=0;j<num_simples;++j)
                      sum += deloc_define[i][j] * simples[j].get_val();
                  coords[++p] = sum;
              }         


          
          fprintf(outfile,"\n  Delocalized internal coordinate values:\n");
          for(i=0;i<num_coords;++i) 
              fprintf(outfile,"  %d: %lf\n",i+1,coords[i]);
          
          fflush(outfile);
          
      }    
  }
  
  /* reform u */
  for(i=0;i<num_atoms;++i) {
      u[3*i][3*i] = 1/masses[i];
      u[3*i+1][3*i+1] = 1/masses[i];
      u[3*i+2][3*i+2] = 1/masses[i];
  }
  
  return;
}

---

The documentation for this class was generated from the following files:

• deloc.h
• deloc.cc
• deloc_symm.cc

---