applications/staticProps/HBondGeometric.cpp

/*
 * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
 *
 * The University of Notre Dame grants you ("Licensee") a
 * non-exclusive, royalty free, license to use, modify and
 * redistribute this software in source and binary code form, provided
 * that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the
 *    distribution.
 *
 * This software is provided "AS IS," without a warranty of any
 * kind. All express or implied conditions, representations and
 * warranties, including any implied warranty of merchantability,
 * fitness for a particular purpose or non-infringement, are hereby
 * excluded.  The University of Notre Dame and its licensors shall not
 * be liable for any damages suffered by licensee as a result of
 * using, modifying or distributing the software or its
 * derivatives. In no event will the University of Notre Dame or its
 * licensors be liable for any lost revenue, profit or data, or for
 * direct, indirect, special, consequential, incidental or punitive
 * damages, however caused and regardless of the theory of liability,
 * arising out of the use of or inability to use software, even if the
 * University of Notre Dame has been advised of the possibility of
 * such damages.
 *
 * SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
 * research, please cite the appropriate papers when you publish your
 * work.  Good starting points are:
 *                                                                      
 * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).             
 * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
 * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (2008).          
 * [4] Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
 * [4] , Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011). 
 */
 
#include "applications/staticProps/HBondGeometric.hpp"
#include "utils/simError.h"
#include "io/DumpReader.hpp"
#include "primitives/Molecule.hpp"
#include "utils/NumericConstant.hpp"

#include <vector>

namespace OpenMD {

  HBondGeometric::HBondGeometric(SimInfo* info, 
                                 const std::string& filename, 
                                 const std::string& sele1,
                                 const std::string& sele2,
                                 double rCut, double thetaCut, int nbins) :
    StaticAnalyser(info, filename),
    selectionScript1_(sele1), seleMan1_(info), evaluator1_(info),
    selectionScript2_(sele2), seleMan2_(info), evaluator2_(info) {
    
    setOutputName(getPrefix(filename) + ".hbg");

    ff_ = info_->getForceField();

    evaluator1_.loadScriptString(sele1);
    if (!evaluator1_.isDynamic()) {
      seleMan1_.setSelectionSet(evaluator1_.evaluate());
    }
    evaluator2_.loadScriptString(sele2);
    if (!evaluator2_.isDynamic()) {
      seleMan2_.setSelectionSet(evaluator2_.evaluate());
    }

    // Set up cutoff values:

    rCut_ = rCut;
    thetaCut_ = thetaCut;
    nBins_ = nbins;

    nHBonds_.resize(nBins_);
    nDonor_.resize(nBins_);
    nAcceptor_.resize(nBins_);

    initializeHistogram();
  }

  HBondGeometric::~HBondGeometric() {
    nHBonds_.clear();
    nDonor_.clear();
    nAcceptor_.clear(); 
  }
  
  void HBondGeometric::initializeHistogram() {
    std::fill(nHBonds_.begin(),   nHBonds_.end(),   0);
    std::fill(nDonor_.begin(),    nDonor_.end(),    0);
    std::fill(nAcceptor_.begin(), nAcceptor_.end(), 0);
    nSelected_ = 0;
  }
  
  void HBondGeometric::process() {
    Molecule* mol1;
    Molecule* mol2;
    RigidBody* rb1;
    Molecule::HBondDonor* hbd1;
    Molecule::HBondDonor* hbd2;
    std::vector<Molecule::HBondDonor*>::iterator hbdi;
    std::vector<Molecule::HBondDonor*>::iterator hbdj;
    std::vector<Atom*>::iterator hbai;
    std::vector<Atom*>::iterator hbaj;
    Atom* hba1;
    Atom* hba2;
    SimInfo::MoleculeIterator mi;
    Molecule::RigidBodyIterator rbIter;
    Vector3d dPos;
    Vector3d aPos;
    Vector3d hPos;
    Vector3d DH;
    Vector3d DA;
    RealType DAdist, DHdist, theta, ctheta;
    int ii, jj;
    int nHB, nA, nD;

    DumpReader reader(info_, dumpFilename_);    
    int nFrames = reader.getNFrames();
    frameCounter_ = 0;

    for (int istep = 0; istep < nFrames; istep += step_) {
      reader.readFrame(istep);
      frameCounter_++;
      currentSnapshot_ = info_->getSnapshotManager()->getCurrentSnapshot();
     
      // update the positions of atoms which belong to the rigidbodies
      
      for (mol1 = info_->beginMolecule(mi); mol1 != NULL; 
           mol1 = info_->nextMolecule(mi)) {
        for (rb1 = mol1->beginRigidBody(rbIter); rb1 != NULL; 
             rb1 = mol1->nextRigidBody(rbIter)) {
          rb1->updateAtoms();
        }        
      }           
      
      if  (evaluator1_.isDynamic()) {
        seleMan1_.setSelectionSet(evaluator1_.evaluate());
      }
      if  (evaluator2_.isDynamic()) {
        seleMan2_.setSelectionSet(evaluator2_.evaluate());
      }
      
      for (mol1 = seleMan1_.beginSelectedMolecule(ii);
           mol1 != NULL; mol1 = seleMan1_.nextSelectedMolecule(ii)) {

        // We're collecting statistics on the molecules in selection 1:
        nHB = 0;
        nA = 0;
        nD = 0;
        
        for (mol2 = seleMan2_.beginSelectedMolecule(jj);
             mol2 != NULL; mol2 = seleMan2_.nextSelectedMolecule(jj)) {
          
          // loop over the possible donors in molecule 1:
          for (hbd1 = mol1->beginHBondDonor(hbdi); hbd1 != NULL;
               hbd1 = mol1->nextHBondDonor(hbdi)) {
            dPos = hbd1->donorAtom->getPos();
            hPos = hbd1->donatedHydrogen->getPos();
            DH = hPos - dPos; 
            currentSnapshot_->wrapVector(DH);
            DHdist = DH.length();

            // loop over the possible acceptors in molecule 2:
            for (hba2 = mol2->beginHBondAcceptor(hbaj); hba2 != NULL;
                 hba2 = mol2->nextHBondAcceptor(hbaj)) {
              aPos = hba2->getPos();
              DA = aPos - dPos;              
              currentSnapshot_->wrapVector(DA);
              DAdist = DA.length();

              // Distance criteria: are the donor and acceptor atoms
              // close enough?
              if (DAdist < rCut_) {

                ctheta = dot(DH, DA) / (DHdist * DAdist);
                theta = acos(ctheta) * 180.0 / M_PI;

                // Angle criteria: are the D-H and D-A and vectors close?
                if (theta < thetaCut_) {
                  // molecule 1 is a Hbond donor:
                  nHB++;
                  nD++;
                }
              }            
            }            
          }

          // now loop over the possible acceptors in molecule 1:
          for (hba1 = mol1->beginHBondAcceptor(hbai); hba1 != NULL;
               hba1 = mol1->nextHBondAcceptor(hbai)) {
            aPos = hba1->getPos();
            
            // loop over the possible donors in molecule 2:
            for (hbd2 = mol2->beginHBondDonor(hbdj); hbd2 != NULL;
               hbd2 = mol2->nextHBondDonor(hbdj)) {
              dPos = hbd2->donorAtom->getPos();

              DA = aPos - dPos;
              currentSnapshot_->wrapVector(DA);
              DAdist = DA.length();
              
              // Distance criteria: are the donor and acceptor atoms
              // close enough?
              if (DAdist < rCut_) {
                hPos = hbd2->donatedHydrogen->getPos();
                DH = hPos - dPos; 
                currentSnapshot_->wrapVector(DH);
                DHdist = DH.length();
                ctheta = dot(DH, DA) / (DHdist * DAdist);
                theta = acos(ctheta) * 180.0 / M_PI;
                // Angle criteria: are the D-H and D-A and vectors close?
                if (theta < thetaCut_) {
                  // molecule 1 is a Hbond acceptor:
                  nHB++;
                  nA++;
                }                
              }
            }
          }
        }                 
        collectHistogram(nHB, nA, nD);
      }
    }
    writeHistogram();
  }
 
        
  void HBondGeometric::collectHistogram(int nHB, int nA, int nD) {
    nHBonds_[nHB] += 1;
    nAcceptor_[nA] += 1;
    nDonor_[nD] += 1;
    nSelected_++;
  }


  void HBondGeometric::writeHistogram() {
        
    std::ofstream osq(getOutputFileName().c_str());

    if (osq.is_open()) {
      
      osq << "# HydrogenBonding Statistics\n";
      osq << "# selection1: (" << selectionScript1_ << ")"
          << "\tselection2: (" << selectionScript2_ <<  ")\n";
      osq << "# molecules in selection1: " << nSelected_ << "\n";
      osq << "# nHBonds\tnAcceptor\tnDonor\tp(nHBonds)\tp(nAcceptor)\tp(nDonor)\n";
      // Normalize by number of frames and write it out:
      for (int i = 0; i < nBins_; ++i) {
        osq << i;
        osq << "\t" << nHBonds_[i];
        osq << "\t" << nAcceptor_[i];
        osq << "\t" << nDonor_[i];
        osq << "\t" << (RealType) (nHBonds_[i]) / nSelected_;
        osq << "\t" << (RealType) (nAcceptor_[i]) / nSelected_;
        osq << "\t" << (RealType) (nDonor_[i]) / nSelected_;
        osq << "\n";
      }
      osq.close();
      
    } else {
      sprintf(painCave.errMsg, "HBondGeometric: unable to open %s\n", 
              (getOutputFileName() + "q").c_str());
      painCave.isFatal = 1;
      simError();  
    }
  }
}

      
Revision:	2076
Committed:	Mon Mar 9 01:19:31 2015 UTC (10 years, 1 month ago) by gezelter
File size:	9736 byte(s)
Log Message:	Removed an unused variable caught by PGI
#	User	Rev	Content
1	gezelter	2049	/*
2			* Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3			*
4			* The University of Notre Dame grants you ("Licensee") a
5			* non-exclusive, royalty free, license to use, modify and
6			* redistribute this software in source and binary code form, provided
7			* that the following conditions are met:
8			*
9			* 1. Redistributions of source code must retain the above copyright
10			* notice, this list of conditions and the following disclaimer.
11			*
12			* 2. Redistributions in binary form must reproduce the above copyright
13			* notice, this list of conditions and the following disclaimer in the
14			* documentation and/or other materials provided with the
15			* distribution.
16			*
17			* This software is provided "AS IS," without a warranty of any
18			* kind. All express or implied conditions, representations and
19			* warranties, including any implied warranty of merchantability,
20			* fitness for a particular purpose or non-infringement, are hereby
21			* excluded. The University of Notre Dame and its licensors shall not
22			* be liable for any damages suffered by licensee as a result of
23			* using, modifying or distributing the software or its
24			* derivatives. In no event will the University of Notre Dame or its
25			* licensors be liable for any lost revenue, profit or data, or for
26			* direct, indirect, special, consequential, incidental or punitive
27			* damages, however caused and regardless of the theory of liability,
28			* arising out of the use of or inability to use software, even if the
29			* University of Notre Dame has been advised of the possibility of
30			* such damages.
31			*
32			* SUPPORT OPEN SCIENCE! If you use OpenMD or its source code in your
33			* research, please cite the appropriate papers when you publish your
34			* work. Good starting points are:
35			*
36			* [1] Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).
37			* [2] Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).
38			* [3] Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (2008).
39			* [4] Kuang & Gezelter, J. Chem. Phys. 133, 164101 (2010).
40			* [4] , Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41			*/
42
43			#include "applications/staticProps/HBondGeometric.hpp"
44			#include "utils/simError.h"
45			#include "io/DumpReader.hpp"
46			#include "primitives/Molecule.hpp"
47			#include "utils/NumericConstant.hpp"
48
49			#include <vector>
50
51			namespace OpenMD {
52
53			HBondGeometric::HBondGeometric(SimInfo* info,
54			const std::string& filename,
55			const std::string& sele1,
56			const std::string& sele2,
57			double rCut, double thetaCut, int nbins) :
58			StaticAnalyser(info, filename),
59	gezelter	2071	selectionScript1_(sele1), seleMan1_(info), evaluator1_(info),
60			selectionScript2_(sele2), seleMan2_(info), evaluator2_(info) {
61	gezelter	2049
62			setOutputName(getPrefix(filename) + ".hbg");
63
64			ff_ = info_->getForceField();
65
66			evaluator1_.loadScriptString(sele1);
67			if (!evaluator1_.isDynamic()) {
68			seleMan1_.setSelectionSet(evaluator1_.evaluate());
69			}
70			evaluator2_.loadScriptString(sele2);
71			if (!evaluator2_.isDynamic()) {
72			seleMan2_.setSelectionSet(evaluator2_.evaluate());
73			}
74
75			// Set up cutoff values:
76
77			rCut_ = rCut;
78			thetaCut_ = thetaCut;
79			nBins_ = nbins;
80
81			nHBonds_.resize(nBins_);
82			nDonor_.resize(nBins_);
83			nAcceptor_.resize(nBins_);
84	gezelter	2050
85			initializeHistogram();
86	gezelter	2049	}
87
88			HBondGeometric::~HBondGeometric() {
89			nHBonds_.clear();
90			nDonor_.clear();
91			nAcceptor_.clear();
92			}
93
94			void HBondGeometric::initializeHistogram() {
95			std::fill(nHBonds_.begin(), nHBonds_.end(), 0);
96			std::fill(nDonor_.begin(), nDonor_.end(), 0);
97			std::fill(nAcceptor_.begin(), nAcceptor_.end(), 0);
98			nSelected_ = 0;
99			}
100
101			void HBondGeometric::process() {
102	gezelter	2052	Molecule* mol1;
103			Molecule* mol2;
104	gezelter	2049	RigidBody* rb1;
105	gezelter	2052	Molecule::HBondDonor* hbd1;
106			Molecule::HBondDonor* hbd2;
107			std::vector<Molecule::HBondDonor*>::iterator hbdi;
108			std::vector<Molecule::HBondDonor*>::iterator hbdj;
109			std::vector<Atom*>::iterator hbai;
110			std::vector<Atom*>::iterator hbaj;
111			Atom* hba1;
112			Atom* hba2;
113	gezelter	2049	SimInfo::MoleculeIterator mi;
114			Molecule::RigidBodyIterator rbIter;
115	gezelter	2052	Vector3d dPos;
116			Vector3d aPos;
117			Vector3d hPos;
118			Vector3d DH;
119			Vector3d DA;
120			RealType DAdist, DHdist, theta, ctheta;
121	gezelter	2049	int ii, jj;
122			int nHB, nA, nD;
123
124			DumpReader reader(info_, dumpFilename_);
125			int nFrames = reader.getNFrames();
126			frameCounter_ = 0;
127
128			for (int istep = 0; istep < nFrames; istep += step_) {
129			reader.readFrame(istep);
130			frameCounter_++;
131			currentSnapshot_ = info_->getSnapshotManager()->getCurrentSnapshot();
132
133			// update the positions of atoms which belong to the rigidbodies
134
135	gezelter	2052	for (mol1 = info_->beginMolecule(mi); mol1 != NULL;
136			mol1 = info_->nextMolecule(mi)) {
137			for (rb1 = mol1->beginRigidBody(rbIter); rb1 != NULL;
138			rb1 = mol1->nextRigidBody(rbIter)) {
139	gezelter	2049	rb1->updateAtoms();
140			}
141			}
142
143			if (evaluator1_.isDynamic()) {
144			seleMan1_.setSelectionSet(evaluator1_.evaluate());
145			}
146			if (evaluator2_.isDynamic()) {
147			seleMan2_.setSelectionSet(evaluator2_.evaluate());
148			}
149
150	gezelter	2052	for (mol1 = seleMan1_.beginSelectedMolecule(ii);
151			mol1 != NULL; mol1 = seleMan1_.nextSelectedMolecule(ii)) {
152	gezelter	2049
153	gezelter	2052	// We're collecting statistics on the molecules in selection 1:
154	gezelter	2049	nHB = 0;
155			nA = 0;
156			nD = 0;
157
158	gezelter	2052	for (mol2 = seleMan2_.beginSelectedMolecule(jj);
159			mol2 != NULL; mol2 = seleMan2_.nextSelectedMolecule(jj)) {
160
161			// loop over the possible donors in molecule 1:
162			for (hbd1 = mol1->beginHBondDonor(hbdi); hbd1 != NULL;
163			hbd1 = mol1->nextHBondDonor(hbdi)) {
164			dPos = hbd1->donorAtom->getPos();
165			hPos = hbd1->donatedHydrogen->getPos();
166			DH = hPos - dPos;
167			currentSnapshot_->wrapVector(DH);
168			DHdist = DH.length();
169	gezelter	2049
170	gezelter	2052	// loop over the possible acceptors in molecule 2:
171			for (hba2 = mol2->beginHBondAcceptor(hbaj); hba2 != NULL;
172			hba2 = mol2->nextHBondAcceptor(hbaj)) {
173			aPos = hba2->getPos();
174			DA = aPos - dPos;
175			currentSnapshot_->wrapVector(DA);
176			DAdist = DA.length();
177	gezelter	2049
178	gezelter	2052	// Distance criteria: are the donor and acceptor atoms
179			// close enough?
180			if (DAdist < rCut_) {
181
182			ctheta = dot(DH, DA) / (DHdist * DAdist);
183			theta = acos(ctheta) * 180.0 / M_PI;
184
185			// Angle criteria: are the D-H and D-A and vectors close?
186			if (theta < thetaCut_) {
187			// molecule 1 is a Hbond donor:
188			nHB++;
189			nD++;
190	gezelter	2049	}
191	gezelter	2052	}
192			}
193			}
194
195			// now loop over the possible acceptors in molecule 1:
196			for (hba1 = mol1->beginHBondAcceptor(hbai); hba1 != NULL;
197			hba1 = mol1->nextHBondAcceptor(hbai)) {
198			aPos = hba1->getPos();
199	gezelter	2049
200	gezelter	2052	// loop over the possible donors in molecule 2:
201			for (hbd2 = mol2->beginHBondDonor(hbdj); hbd2 != NULL;
202			hbd2 = mol2->nextHBondDonor(hbdj)) {
203			dPos = hbd2->donorAtom->getPos();
204	gezelter	2049
205	gezelter	2052	DA = aPos - dPos;
206			currentSnapshot_->wrapVector(DA);
207			DAdist = DA.length();
208
209			// Distance criteria: are the donor and acceptor atoms
210			// close enough?
211			if (DAdist < rCut_) {
212			hPos = hbd2->donatedHydrogen->getPos();
213			DH = hPos - dPos;
214			currentSnapshot_->wrapVector(DH);
215			DHdist = DH.length();
216			ctheta = dot(DH, DA) / (DHdist * DAdist);
217			theta = acos(ctheta) * 180.0 / M_PI;
218			// Angle criteria: are the D-H and D-A and vectors close?
219			if (theta < thetaCut_) {
220			// molecule 1 is a Hbond acceptor:
221			nHB++;
222			nA++;
223			}
224	gezelter	2049	}
225	gezelter	2052	}
226	gezelter	2049	}
227	gezelter	2052	}
228	gezelter	2049	collectHistogram(nHB, nA, nD);
229			}
230			}
231			writeHistogram();
232			}
233
234
235			void HBondGeometric::collectHistogram(int nHB, int nA, int nD) {
236			nHBonds_[nHB] += 1;
237			nAcceptor_[nA] += 1;
238			nDonor_[nD] += 1;
239			nSelected_++;
240			}
241
242
243			void HBondGeometric::writeHistogram() {
244
245			std::ofstream osq(getOutputFileName().c_str());
246
247			if (osq.is_open()) {
248
249			osq << "# HydrogenBonding Statistics\n";
250			osq << "# selection1: (" << selectionScript1_ << ")"
251			<< "\tselection2: (" << selectionScript2_ << ")\n";
252	gezelter	2052	osq << "# molecules in selection1: " << nSelected_ << "\n";
253			osq << "# nHBonds\tnAcceptor\tnDonor\tp(nHBonds)\tp(nAcceptor)\tp(nDonor)\n";
254	gezelter	2049	// Normalize by number of frames and write it out:
255			for (int i = 0; i < nBins_; ++i) {
256			osq << i;
257	gezelter	2052	osq << "\t" << nHBonds_[i];
258			osq << "\t" << nAcceptor_[i];
259			osq << "\t" << nDonor_[i];
260	gezelter	2049	osq << "\t" << (RealType) (nHBonds_[i]) / nSelected_;
261			osq << "\t" << (RealType) (nAcceptor_[i]) / nSelected_;
262			osq << "\t" << (RealType) (nDonor_[i]) / nSelected_;
263			osq << "\n";
264			}
265			osq.close();
266
267			} else {
268			sprintf(painCave.errMsg, "HBondGeometric: unable to open %s\n",
269			(getOutputFileName() + "q").c_str());
270			painCave.isFatal = 1;
271			simError();
272			}
273			}
274			}
275
276
277
278