예제 #1
0
파일: eem.cpp 프로젝트: CooperLiu/openbabel
  bool EEMCharges::ComputeCharges(OBMol &mol)
  {
    mol.SetPartialChargesPerceived();

    if(_parameters.empty())
      _loadParameters();

    // Copied from spectrophore.cpp
    // CHI and ETA
    unsigned int _nAtoms = mol.NumAtoms();
    unsigned int dim(_nAtoms + 1);
    std::vector<double> CHI(dim);
    double** ETA = new double*[dim];
    for (unsigned int i = 0; i < dim; ++i)
      {
        ETA[i] = new double[dim];
      }
    double totalCharge(0.0);
    unsigned int i(0);
    double hardness;
    double electronegativity;
    for (OpenBabel::OBMolAtomIter atom(mol); atom; atom++, i++) {

      int n = atom->GetAtomicNum();
      int b = atom->HighestBondOrder();

      // Search for parameters for a particular atom type
      bool found = false;
      for(unsigned int j = 0; j < _parameters.size(); j++) {
        if((_parameters[j].Z == n && _parameters[j].bond_order == b) ||
            (_parameters[j].Z == n && _parameters[j].bond_order == - 1) ||
            (_parameters[j].Z == -1 && _parameters[j].bond_order == -1)) {

          electronegativity = _parameters[j].A;
          hardness = _parameters[j].B;
          found = true;
          break;
        }
      }

      if(!found) {
        std::stringstream ss;
        ss << "No parameters found for: " << etab.GetSymbol(n) << " " << b
           << ". EEM charges were not calculated for the molecule." << std::endl;
        obErrorLog.ThrowError(__FUNCTION__, ss.str(), obError);
        return false;
      }

      CHI[i] = -electronegativity;
      ETA[i][i] = hardness;

      // Adjust the total molecular charge
      totalCharge += atom->GetFormalCharge();
    }

    // Complete CHI
    CHI[_nAtoms] = totalCharge;

    // Complete ETA
    OBAtom *rAtom, *cAtom;
    for (unsigned int r = 0; r < _nAtoms; ++r)
      {
        rAtom = mol.GetAtom(r+1); // Atom index
        for (unsigned int c = r + 1; c < _nAtoms; ++c)
          {
            cAtom = mol.GetAtom(c+1); // Atom index
            ETA[r][c] = _kappa / cAtom->GetDistance(rAtom);
            ETA[c][r] = ETA[r][c];
          }
      }
    for (unsigned int i = 0; i < dim; ++i)
      {
        ETA[i][_nAtoms] = -1.0;
        ETA[_nAtoms][i] = +1.0;
      }
    ETA[_nAtoms][_nAtoms] = 0.0;

    // Solve the matrix equation
    _solveMatrix(ETA, &(CHI[0]), dim);    // CHI will contain the values

    OBAtom *atom;
    for (unsigned int i = 0; i < _nAtoms; ++i)
      {
        atom = mol.GetAtom(i+1); // atom index issue
        atom->SetPartialCharge(CHI[i]);
      }

    OBChargeModel::FillChargeVectors(mol);

    // Cleanup
    for(unsigned int i = 0; i < dim; i++)
      delete [] ETA[i];

    delete [] ETA;

    return true;
  }
예제 #2
0
CPS_START_NAMESPACE
/*! \file
  \brief  Routine used internally in the DiracOpWilson class.

  $Id: wilson_mdag.C,v 1.2 2011-02-26 00:19:27 chulwoo Exp $
*/
//--------------------------------------------------------------------
//  CVS keywords
//
//  $Author: chulwoo $
//  $Date: 2011-02-26 00:19:27 $
//  $Header: /home/chulwoo/CPS/repo/CVS/cps_only/cps_pp/src/util/dirac_op/d_op_wilson/sse/wilson_mdag.C,v 1.2 2011-02-26 00:19:27 chulwoo Exp $
//  $Id: wilson_mdag.C,v 1.2 2011-02-26 00:19:27 chulwoo Exp $
//  $Name: not supported by cvs2svn $
//  $Locker:  $
//  $Revision: 1.2 $
//  $Source: /home/chulwoo/CPS/repo/CVS/cps_only/cps_pp/src/util/dirac_op/d_op_wilson/sse/wilson_mdag.C,v $
//  $State: Exp $
//
//--------------------------------------------------------------------

CPS_END_NAMESPACE
#include <util/data_types.h>
#include <util/wilson.h>
#include <util/dirac_op.h>
CPS_START_NAMESPACE


//! Access to the elements of the \e SU(3) matrix
/*!
  Gets the element of the \e SU(3) matrix \e u with row \e row,
  column \e col and complex component \e d
*/
#define U(r,row,col,d,n,cb) *(u+(r+2*(row+3*(col+3*(d+4*(n+vol[0]*(cb)))))))
//! Access to the elements of a spinor vector.
/*!
  Gets the element of the spinor \e psi with spin \e s,
  colour \e c and complex component \e r
*/
#define PSI(r,c,s,n)     *(psi+(r+2*(c+3*(s+4*(n)))))
//! As above, but the vector is called chi
#define CHI(r,c,s,n)     *(chi+(r+2*(c+3*(s+4*(n)))))
#define TMP1(r,c,s,n)     *(tmp1+(r+2*(c+3*(s+4*(n)))))



void wilson_mdag(IFloat *chi_f, 
		 IFloat *u_f, 
		 IFloat *psi_f, 
		 IFloat kappa_f,
		 Wilson *wilson_p)
{
  IFloat *tmp1_f;
  int vol;
  int r, c, s, n;

/*--------------------------------------------------------------------------*/
/* Initializations                                                          */
/*--------------------------------------------------------------------------*/
  vol =  wilson_p->vol[0];
  tmp1_f = wilson_p->af[0];

  Float *chi = (Float *) chi_f;
  Float *psi = (Float *) psi_f;
  Float kappa = Float(kappa_f);

/*--------------------------------------------------------------------------*/
/* DslashDag_E0                                                             */
/*--------------------------------------------------------------------------*/
  wilson_dslash(tmp1_f, u_f, psi_f, 1, 1, wilson_p);

/*--------------------------------------------------------------------------*/
/* DslashDag_0E                                                             */
/*--------------------------------------------------------------------------*/
  wilson_dslash(chi_f, u_f, tmp1_f, 0, 1, wilson_p);

/*--------------------------------------------------------------------------*/
/* [1_OO - kappa * DslashDag_0E * DslashDag_E0] ]                           */
/*--------------------------------------------------------------------------*/
  for(n=0;n<vol;n++){
    for(s=0;s<4;s++){
      for(c=0;c<3;c++){
	for(r=0;r<2;r++){
	  CHI(r,c,s,n) = ( PSI(r,c,s,n) - kappa*kappa * CHI(r,c,s,n));
	}
      }
    }
  }
  DiracOp::CGflops += vol*24*2;

}
예제 #3
0
void
OBSpectrophore::_calculateProperties(OpenBabel::OBMol* mol)
{
   //
   // PROPERTY 1: ATOMIC PARTIAL CHARGES [0]
   //

   // CHI and ETA
   unsigned int dim(_nAtoms + 1);
   std::vector<double> CHI(dim);
   double** ETA = new double*[dim];
   double** ETA2 = new double*[dim];      // A copy for the electrophilicity later on
   for (unsigned int i = 0; i < dim; ++i)
   {
      ETA[i] = new double[dim];
      ETA2[i] = new double[dim];
   }
   double totalCharge(0.0);
   unsigned int i(0);
   unsigned int n;
   double hardness;
   double electronegativity;
   for (OpenBabel::OBMolAtomIter atom(mol); atom; ++atom)
   {
      n = (unsigned int) atom->GetAtomicNum();
      switch (n)
      {
         case 1:  // H
            hardness = 0.65971;
            electronegativity = 0.20606;
            break;
         case 3:  // Li
            hardness = 0.32966;
            electronegativity = 0.36237;
            break;
         case 5:  // B
            hardness = 0.32966;
            electronegativity = 0.36237;
            break;
         case 6:  // C
            hardness = 0.32966;
            electronegativity = 0.36237;
            break;
         case 7:  // N
            hardness = 0.34519;
            electronegativity = 0.49279;
            break;
         case 8:  // O
            hardness = 0.54428;
            electronegativity = 0.73013;
            break;
         case 9:  // F
            hardness = 0.72664;
            electronegativity = 0.72052;
            break;
         case 11: // Na
            hardness = 0.32966;
            electronegativity = 0.36237;
            break;
         case 12: // Mg
            hardness = 0.32966;
            electronegativity = 0.36237;
            break;
         case 14: // Si
            hardness = 0.32966;
            electronegativity = 0.36237;
            break;
         case 15: // P
            hardness = 0.32966;
            electronegativity = 0.36237;
            break;
         case 16: // S
            hardness = 0.20640;
            electronegativity = 0.62020;
            break;
         case 17: // Cl
            hardness = 0.32966;
            electronegativity = 0.36237;
            break;
         case 19: // K
            hardness = 0.32966;
            electronegativity = 0.36237;
            break;
         case 20: // Ca
            hardness = 0.32966;
            electronegativity = 0.36237;
            break;
         case 26: // Fe
            hardness = 0.32966;
            electronegativity = 0.36237;
            break;
         case 29: // Cu
            hardness = 0.32966;
            electronegativity = 0.36237;
            break;
         case 30: // Zn
            hardness = 0.32966;
            electronegativity = 0.36237;
            break;
         case 35: // Br
            hardness = 0.54554;
            electronegativity = 0.70052;
            break;
         case 53: // I
            hardness = 0.30664;
            electronegativity = 0.68052;
            break;
         default:
            hardness = 0.65971;
            electronegativity = 0.20606;
            break;
      }

      CHI[i] = -electronegativity;
      ETA[i][i] = 2.0 * hardness;

      // Adjust the total molecular charge
      totalCharge += atom->GetFormalCharge();

      // Increment
      ++i;
   }

   // Complete CHI
   CHI[_nAtoms] = totalCharge;

   // Complete ETA
   double d;
   for (unsigned int r = 0; r < _nAtoms; ++r)
   {
      for (unsigned int c = r + 1; c < _nAtoms; ++c)
      {
         d =  (_oricoor[r][0] - _oricoor[c][0]) * (_oricoor[r][0] - _oricoor[c][0]);
         d += (_oricoor[r][1] - _oricoor[c][1]) * (_oricoor[r][1] - _oricoor[c][1]);
         d += (_oricoor[r][2] - _oricoor[c][2]) * (_oricoor[r][2] - _oricoor[c][2]);
         ETA[r][c] = 0.529176 / sqrt(d);     // 0.529176: Angstrom to au
         ETA[c][r] = ETA[r][c];
      }
   }
   for (unsigned int i = 0; i < dim; ++i)
   {
      ETA[i][_nAtoms] = -1.0;
      ETA[_nAtoms][i] = +1.0;
   }
   ETA[_nAtoms][_nAtoms] = 0.0;

   // Make ETA2 a copy of ETA
   for (unsigned int r(0); r < dim; ++r)
   {
      for (unsigned int c(0); c < dim; ++c)
      {
         ETA2[r][c] = ETA[r][c];
      }
   }

   // Solve the matrix equation
   _solveMatrix(ETA, &(CHI[0]), dim);    // CHI will contain the values

   // Add values to property matrix
   for (unsigned int i = 0; i < _nAtoms; ++i)
   {
      _property[i][0] = CHI[i];
   }
   double CHIeq2 = CHI[dim - 1] * CHI[dim - 1]; // For electrophilicity later on

   // Clean
   for (unsigned int i = 0; i < dim; ++i)
   {
      delete[] ETA[i];
      ETA[i] = NULL;
   }
   delete[] ETA;
   ETA = NULL;



   //
   // PROPERTY 2: ATOMIC LIPOPHILICITY VALUES [1]
   //
   unsigned int a(0);
   for (OpenBabel::OBMolAtomIter atom(mol); atom; ++atom)
   {
      n = (unsigned int) atom->GetAtomicNum();
      switch (n)
      {
         case 1:		// H
            if (atom->GetValence())
            {
               if (atom->IsNonPolarHydrogen())
               // Non-polar H
               {
                  _property[a][1] = -0.018;
               }
               else
               // Polar H
               {
                  _property[a][1] = -0.374;
               }
            }
            else
            {
               _property[a][1] = -0.175;
            }
            break;
        case 6:		// C
            _property[a][1] = 0.271;
            break;
        case 7:		// N
            _property[a][1] = -0.137;
            break;
        case 8:		// O
            _property[a][1] = -0.321;
            break;
        case 9:		// F
            _property[a][1] = 0.217;
            break;
        case 16:	// S
            _property[a][1] = 0.385;
            break;
        case 17:	// Cl
            _property[a][1] = 0.632;
            break;
        case 35:	// Br
            _property[a][1] = 0.815;
            break;
        case 53:	// I
            _property[a][1] = 0.198;
            break;
        default:	// The rest
            _property[a][1] = -0.175;
            break;
        }

        // Increment
        ++a;
    }



   //
   // PROPERTY 3: ATOMIC SHAPE DEVIATIONS [2]
   //
   for (unsigned int a(0); a < _nAtoms; ++a)
   {
      for (unsigned int c(0); c < 3; ++c)
      {
         _coor[a][c] = _oricoor[a][c];
      }
   }
   double COG[3]; // Center of geometry
   for (unsigned int c(0); c < 3; ++c)
   {
      COG[c] = _coor[0][c];
      for (unsigned int a(1); a < _nAtoms; ++a)
      {
         COG[c] += _coor[a][c];
      }
      COG[c] /= _nAtoms;
   }

   // Shift molecules to COG and calculate individual distances
   std::vector<double> distance(_nAtoms);
   double averageDistance(0.0);
   for (unsigned int a(0); a < _nAtoms; ++a)
   {
      distance[a] = 0.0;
      for (unsigned int c(0); c < 3; ++c)
      {
         _coor[a][c] -= COG[c];
         distance[a] += _coor[a][c] * _coor[a][c];
      }
      distance[a] = sqrt(distance[a]);
      averageDistance += distance[a];
   }
   averageDistance /= _nAtoms;

   // Set relative to average distance
   for (unsigned int a(0); a < _nAtoms; ++a)
   {
      distance[a] -= averageDistance;
      distance[a] *= averageDistance;
   }

   // Add property
   for (unsigned int a(0); a < _nAtoms; ++a)
   {
      _property[a][2] = distance[a];
   }



   //
   // PROPERTY 4: ATOMIC ELECTROPHILICITY [3]
   //
   // CHI and ETA2
   for (unsigned int i(0); i < dim; ++i)
   {
      CHI[i] = 1.0;
   }
   CHI[_nAtoms] = 0.0;

   // Complete ETA2
   for (unsigned int i = 0; i < dim; ++i)
   {
      ETA2[i][_nAtoms] = 0.0;
      ETA2[_nAtoms][i] = 1.0;
   }
   ETA2[_nAtoms][_nAtoms] = -1.0;

   // Solve the matrix equation
   _solveMatrix(ETA2, &(CHI[0]), dim);    // CHI will contain the values

   // Add values to property matrix
   for (unsigned int i = 0; i < _nAtoms; ++i)
   {
      _property[i][3] = CHI[i] * CHIeq2;
   }

   // Clean
   for (unsigned int i = 0; i < dim; ++i)
   {
      delete[] ETA2[i];
      ETA2[i] = NULL;
   }
   delete[] ETA2;
   ETA2 = NULL;

   //
   // Return
   //
   return;
}