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
#	Content
1	/*
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	selectionScript1_(sele1), seleMan1_(info), evaluator1_(info),
60	selectionScript2_(sele2), seleMan2_(info), evaluator2_(info) {
61
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
85	initializeHistogram();
86	}
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	Molecule* mol1;
103	Molecule* mol2;
104	RigidBody* rb1;
105	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	SimInfo::MoleculeIterator mi;
114	Molecule::RigidBodyIterator rbIter;
115	Vector3d dPos;
116	Vector3d aPos;
117	Vector3d hPos;
118	Vector3d DH;
119	Vector3d DA;
120	RealType DAdist, DHdist, theta, ctheta;
121	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	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	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	for (mol1 = seleMan1_.beginSelectedMolecule(ii);
151	mol1 != NULL; mol1 = seleMan1_.nextSelectedMolecule(ii)) {
152
153	// We're collecting statistics on the molecules in selection 1:
154	nHB = 0;
155	nA = 0;
156	nD = 0;
157
158	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
170	// 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
178	// 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	}
191	}
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
200	// 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
205	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	}
225	}
226	}
227	}
228	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	osq << "# molecules in selection1: " << nSelected_ << "\n";
253	osq << "# nHBonds\tnAcceptor\tnDonor\tp(nHBonds)\tp(nAcceptor)\tp(nDonor)\n";
254	// Normalize by number of frames and write it out:
255	for (int i = 0; i < nBins_; ++i) {
256	osq << i;
257	osq << "\t" << nHBonds_[i];
258	osq << "\t" << nAcceptor_[i];
259	osq << "\t" << nDonor_[i];
260	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