applications/staticProps/NanoVolume.cpp

/* Copyright (c) 2006, 2009, 2010 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, 24107 (2008).          
 * [4]  Vardeman & Gezelter, in progress (2009).                        
 *
 *
 *  NanoVolume.cpp
 *
 *  Created by Charles F. Vardeman II on 14 Dec 2006.
 *  @author  Charles F. Vardeman II
 *  @version $Id: NanoVolume.cpp,v 1.10 2009-11-25 20:01:59 gezelter Exp $
 *
 */

#include "applications/staticProps/NanoVolume.hpp"
#include "math/ConvexHull.hpp"
#include "math/AlphaHull.hpp"
#include "utils/simError.h"
#include "io/DumpReader.hpp"
#include "primitives/Molecule.hpp"
#include "utils/NumericConstant.hpp"

using namespace OpenMD;

NanoVolume::NanoVolume(SimInfo* info,
                       const std::string& filename,
                       const std::string& sele)
  : StaticAnalyser(info, filename), selectionScript_(sele), evaluator_(info), seleMan_(info) {
  setOutputName(getPrefix(filename) + ".avol");
  
  evaluator_.loadScriptString(sele);
  if (!evaluator_.isDynamic()) {
    seleMan_.setSelectionSet(evaluator_.evaluate());
  }
  frameCounter_ = 0;
  totalVolume_ = 0.0;
}

void NanoVolume::process() {
#if defined(HAVE_QHULL)
  Molecule* mol;
  Atom* atom;
  RigidBody* rb;
  int myIndex;
  SimInfo::MoleculeIterator mi;
  Molecule::RigidBodyIterator rbIter;
  Molecule::AtomIterator ai;
  StuntDouble* sd;
  Vector3d vec;
  int i,j;

#ifdef HAVE_QHULL
   //ConvexHull* thishull = new ConvexHull();
   AlphaHull* thishull = new AlphaHull(2.0);
#endif

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

  theAtoms_.reserve(info_->getNGlobalAtoms());

  for (int istep = 0; istep < nFrames; istep += step_) {
    reader.readFrame(istep);
    frameCounter_++;
    currentSnapshot_ = info_->getSnapshotManager()->getCurrentSnapshot();
    
    // Clear pos vector between each frame.
    theAtoms_.clear();
    
    if (evaluator_.isDynamic()) {
      seleMan_.setSelectionSet(evaluator_.evaluate());
    }
    
    // update the positions of atoms which belong to the rigidbodies
    
    for (mol = info_->beginMolecule(mi); mol != NULL;
         mol = info_->nextMolecule(mi)) {
      for (rb = mol->beginRigidBody(rbIter); rb != NULL;
           rb = mol->nextRigidBody(rbIter)) {   
        rb->updateAtoms();
      }
    }
    
    // outer loop is over the selected StuntDoubles:
    
    for (sd = seleMan_.beginSelected(i); sd != NULL;
            sd = seleMan_.nextSelected(i)) {
      
     theAtoms_.push_back(sd);
      myIndex = sd->getGlobalIndex();
      
    }
    
    /*
    for (mol = info_->beginMolecule(mi); mol != NULL; 
                 mol = info_->nextMolecule(mi)) {
              for (atom = mol->beginAtom(ai); atom != NULL; 
                   atom = mol->nextAtom(ai)) {
                     theAtoms_.push_back(atom);
              }
            }
    */
    // Generate convex hull for this frame.
    thishull->computeHull(theAtoms_);
  //  totalVolume_ += hull->getVolume();                
  }
  //RealType avgVolume = totalVolume_/(RealType) frameCounter_;
  //std::cout.precision(7);
  //std::cout  << avgVolume << std::endl;
/*
  std::ofstream osq(getOutputFileName().c_str());
  osq.precision(7);
  if (osq.is_open()){
      osq << avgVolume << std::endl;

  }
  osq.close();
*/
#else
  sprintf(painCave.errMsg, "NanoVolume: qhull support was not compiled in!\n");
  painCave.isFatal = 1;
  simError();  

#endif

}
Revision:	1404
Committed:	Fri Jan 15 20:46:49 2010 UTC (15 years, 3 months ago) by chuckv
File size:	5333 byte(s)
Log Message:	Cleanup of unit normal code in Triangle.cpp SMIPD now call getUnitNormal instead of getNormal.
#	Content
1	/* Copyright (c) 2006, 2009, 2010 The University of Notre Dame. All Rights Reserved.
2	*
3	* The University of Notre Dame grants you ("Licensee") a
4	* non-exclusive, royalty free, license to use, modify and
5	* redistribute this software in source and binary code form, provided
6	* that the following conditions are met:
7	*
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	*
11	* 2. Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the
14	* distribution.
15	*
16	* This software is provided "AS IS," without a warranty of any
17	* kind. All express or implied conditions, representations and
18	* warranties, including any implied warranty of merchantability,
19	* fitness for a particular purpose or non-infringement, are hereby
20	* excluded. The University of Notre Dame and its licensors shall not
21	* be liable for any damages suffered by licensee as a result of
22	* using, modifying or distributing the software or its
23	* derivatives. In no event will the University of Notre Dame or its
24	* licensors be liable for any lost revenue, profit or data, or for
25	* direct, indirect, special, consequential, incidental or punitive
26	* damages, however caused and regardless of the theory of liability,
27	* arising out of the use of or inability to use software, even if the
28	* University of Notre Dame has been advised of the possibility of
29	* such damages.
30	*
31	* SUPPORT OPEN SCIENCE! If you use OpenMD or its source code in your
32	* research, please cite the appropriate papers when you publish your
33	* work. Good starting points are:
34	*
35	* [1] Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).
36	* [2] Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).
37	* [3] Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).
38	* [4] Vardeman & Gezelter, in progress (2009).
39	*
40	*
41	* NanoVolume.cpp
42	*
43	* Created by Charles F. Vardeman II on 14 Dec 2006.
44	* @author Charles F. Vardeman II
45	* @version $Id: NanoVolume.cpp,v 1.10 2009-11-25 20:01:59 gezelter Exp $
46	*
47	*/
48
49	#include "applications/staticProps/NanoVolume.hpp"
50	#include "math/ConvexHull.hpp"
51	#include "math/AlphaHull.hpp"
52	#include "utils/simError.h"
53	#include "io/DumpReader.hpp"
54	#include "primitives/Molecule.hpp"
55	#include "utils/NumericConstant.hpp"
56
57	using namespace OpenMD;
58
59	NanoVolume::NanoVolume(SimInfo* info,
60	const std::string& filename,
61	const std::string& sele)
62	: StaticAnalyser(info, filename), selectionScript_(sele), evaluator_(info), seleMan_(info) {
63	setOutputName(getPrefix(filename) + ".avol");
64
65	evaluator_.loadScriptString(sele);
66	if (!evaluator_.isDynamic()) {
67	seleMan_.setSelectionSet(evaluator_.evaluate());
68	}
69	frameCounter_ = 0;
70	totalVolume_ = 0.0;
71	}
72
73	void NanoVolume::process() {
74	#if defined(HAVE_QHULL)
75	Molecule* mol;
76	Atom* atom;
77	RigidBody* rb;
78	int myIndex;
79	SimInfo::MoleculeIterator mi;
80	Molecule::RigidBodyIterator rbIter;
81	Molecule::AtomIterator ai;
82	StuntDouble* sd;
83	Vector3d vec;
84	int i,j;
85
86	#ifdef HAVE_QHULL
87	//ConvexHull* thishull = new ConvexHull();
88	AlphaHull* thishull = new AlphaHull(2.0);
89	#endif
90
91	DumpReader reader(info_, dumpFilename_);
92	int nFrames = reader.getNFrames();
93	frameCounter_ = 0;
94
95	theAtoms_.reserve(info_->getNGlobalAtoms());
96
97	for (int istep = 0; istep < nFrames; istep += step_) {
98	reader.readFrame(istep);
99	frameCounter_++;
100	currentSnapshot_ = info_->getSnapshotManager()->getCurrentSnapshot();
101
102	// Clear pos vector between each frame.
103	theAtoms_.clear();
104
105	if (evaluator_.isDynamic()) {
106	seleMan_.setSelectionSet(evaluator_.evaluate());
107	}
108
109	// update the positions of atoms which belong to the rigidbodies
110
111	for (mol = info_->beginMolecule(mi); mol != NULL;
112	mol = info_->nextMolecule(mi)) {
113	for (rb = mol->beginRigidBody(rbIter); rb != NULL;
114	rb = mol->nextRigidBody(rbIter)) {
115	rb->updateAtoms();
116	}
117	}
118
119	// outer loop is over the selected StuntDoubles:
120
121	for (sd = seleMan_.beginSelected(i); sd != NULL;
122	sd = seleMan_.nextSelected(i)) {
123
124	theAtoms_.push_back(sd);
125	myIndex = sd->getGlobalIndex();
126
127	}
128
129	/*
130	for (mol = info_->beginMolecule(mi); mol != NULL;
131	mol = info_->nextMolecule(mi)) {
132	for (atom = mol->beginAtom(ai); atom != NULL;
133	atom = mol->nextAtom(ai)) {
134	theAtoms_.push_back(atom);
135	}
136	}
137	*/
138	// Generate convex hull for this frame.
139	thishull->computeHull(theAtoms_);
140	// totalVolume_ += hull->getVolume();
141	}
142	//RealType avgVolume = totalVolume_/(RealType) frameCounter_;
143	//std::cout.precision(7);
144	//std::cout << avgVolume << std::endl;
145	/*
146	std::ofstream osq(getOutputFileName().c_str());
147	osq.precision(7);
148	if (osq.is_open()){
149	osq << avgVolume << std::endl;
150
151	}
152	osq.close();
153	*/
154	#else
155	sprintf(painCave.errMsg, "NanoVolume: qhull support was not compiled in!\n");
156	painCave.isFatal = 1;
157	simError();
158
159	#endif
160
161	}