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;
    Molecule::IntegrableObjectIterator ioi;
    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:	2071
Committed:	Sat Mar 7 21:41:51 2015 UTC (10 years, 1 month ago) by gezelter
File size:	9780 byte(s)
Log Message:	Reducing the number of warnings when using g++ to compile.
#	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	Molecule::IntegrableObjectIterator ioi;
116	Vector3d dPos;
117	Vector3d aPos;
118	Vector3d hPos;
119	Vector3d DH;
120	Vector3d DA;
121	RealType DAdist, DHdist, theta, ctheta;
122	int ii, jj;
123	int nHB, nA, nD;
124
125	DumpReader reader(info_, dumpFilename_);
126	int nFrames = reader.getNFrames();
127	frameCounter_ = 0;
128
129	for (int istep = 0; istep < nFrames; istep += step_) {
130	reader.readFrame(istep);
131	frameCounter_++;
132	currentSnapshot_ = info_->getSnapshotManager()->getCurrentSnapshot();
133
134	// update the positions of atoms which belong to the rigidbodies
135
136	for (mol1 = info_->beginMolecule(mi); mol1 != NULL;
137	mol1 = info_->nextMolecule(mi)) {
138	for (rb1 = mol1->beginRigidBody(rbIter); rb1 != NULL;
139	rb1 = mol1->nextRigidBody(rbIter)) {
140	rb1->updateAtoms();
141	}
142	}
143
144	if (evaluator1_.isDynamic()) {
145	seleMan1_.setSelectionSet(evaluator1_.evaluate());
146	}
147	if (evaluator2_.isDynamic()) {
148	seleMan2_.setSelectionSet(evaluator2_.evaluate());
149	}
150
151	for (mol1 = seleMan1_.beginSelectedMolecule(ii);
152	mol1 != NULL; mol1 = seleMan1_.nextSelectedMolecule(ii)) {
153
154	// We're collecting statistics on the molecules in selection 1:
155	nHB = 0;
156	nA = 0;
157	nD = 0;
158
159	for (mol2 = seleMan2_.beginSelectedMolecule(jj);
160	mol2 != NULL; mol2 = seleMan2_.nextSelectedMolecule(jj)) {
161
162	// loop over the possible donors in molecule 1:
163	for (hbd1 = mol1->beginHBondDonor(hbdi); hbd1 != NULL;
164	hbd1 = mol1->nextHBondDonor(hbdi)) {
165	dPos = hbd1->donorAtom->getPos();
166	hPos = hbd1->donatedHydrogen->getPos();
167	DH = hPos - dPos;
168	currentSnapshot_->wrapVector(DH);
169	DHdist = DH.length();
170
171	// loop over the possible acceptors in molecule 2:
172	for (hba2 = mol2->beginHBondAcceptor(hbaj); hba2 != NULL;
173	hba2 = mol2->nextHBondAcceptor(hbaj)) {
174	aPos = hba2->getPos();
175	DA = aPos - dPos;
176	currentSnapshot_->wrapVector(DA);
177	DAdist = DA.length();
178
179	// Distance criteria: are the donor and acceptor atoms
180	// close enough?
181	if (DAdist < rCut_) {
182
183	ctheta = dot(DH, DA) / (DHdist * DAdist);
184	theta = acos(ctheta) * 180.0 / M_PI;
185
186	// Angle criteria: are the D-H and D-A and vectors close?
187	if (theta < thetaCut_) {
188	// molecule 1 is a Hbond donor:
189	nHB++;
190	nD++;
191	}
192	}
193	}
194	}
195
196	// now loop over the possible acceptors in molecule 1:
197	for (hba1 = mol1->beginHBondAcceptor(hbai); hba1 != NULL;
198	hba1 = mol1->nextHBondAcceptor(hbai)) {
199	aPos = hba1->getPos();
200
201	// loop over the possible donors in molecule 2:
202	for (hbd2 = mol2->beginHBondDonor(hbdj); hbd2 != NULL;
203	hbd2 = mol2->nextHBondDonor(hbdj)) {
204	dPos = hbd2->donorAtom->getPos();
205
206	DA = aPos - dPos;
207	currentSnapshot_->wrapVector(DA);
208	DAdist = DA.length();
209
210	// Distance criteria: are the donor and acceptor atoms
211	// close enough?
212	if (DAdist < rCut_) {
213	hPos = hbd2->donatedHydrogen->getPos();
214	DH = hPos - dPos;
215	currentSnapshot_->wrapVector(DH);
216	DHdist = DH.length();
217	ctheta = dot(DH, DA) / (DHdist * DAdist);
218	theta = acos(ctheta) * 180.0 / M_PI;
219	// Angle criteria: are the D-H and D-A and vectors close?
220	if (theta < thetaCut_) {
221	// molecule 1 is a Hbond acceptor:
222	nHB++;
223	nA++;
224	}
225	}
226	}
227	}
228	}
229	collectHistogram(nHB, nA, nD);
230	}
231	}
232	writeHistogram();
233	}
234
235
236	void HBondGeometric::collectHistogram(int nHB, int nA, int nD) {
237	nHBonds_[nHB] += 1;
238	nAcceptor_[nA] += 1;
239	nDonor_[nD] += 1;
240	nSelected_++;
241	}
242
243
244	void HBondGeometric::writeHistogram() {
245
246	std::ofstream osq(getOutputFileName().c_str());
247
248	if (osq.is_open()) {
249
250	osq << "# HydrogenBonding Statistics\n";
251	osq << "# selection1: (" << selectionScript1_ << ")"
252	<< "\tselection2: (" << selectionScript2_ << ")\n";
253	osq << "# molecules in selection1: " << nSelected_ << "\n";
254	osq << "# nHBonds\tnAcceptor\tnDonor\tp(nHBonds)\tp(nAcceptor)\tp(nDonor)\n";
255	// Normalize by number of frames and write it out:
256	for (int i = 0; i < nBins_; ++i) {
257	osq << i;
258	osq << "\t" << nHBonds_[i];
259	osq << "\t" << nAcceptor_[i];
260	osq << "\t" << nDonor_[i];
261	osq << "\t" << (RealType) (nHBonds_[i]) / nSelected_;
262	osq << "\t" << (RealType) (nAcceptor_[i]) / nSelected_;
263	osq << "\t" << (RealType) (nDonor_[i]) / nSelected_;
264	osq << "\n";
265	}
266	osq.close();
267
268	} else {
269	sprintf(painCave.errMsg, "HBondGeometric: unable to open %s\n",
270	(getOutputFileName() + "q").c_str());
271	painCave.isFatal = 1;
272	simError();
273	}
274	}
275	}
276
277
278
279