ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-3.0/src/visitors/OtherVisitor.hpp
(Generate patch)

Comparing trunk/OOPSE-3.0/src/visitors/OtherVisitor.hpp (file contents):
Revision 1490 by gezelter, Fri Sep 24 04:16:43 2004 UTC vs.
Revision 2091 by gezelter, Tue Mar 8 21:07:49 2005 UTC

# Line 1 | Line 1
1 < #ifndef _OTHERVISITOR_H_
2 < #define _OTHERVISITOR_H_
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. Acknowledgement of the program authors must be made in any
10 > *    publication of scientific results based in part on use of the
11 > *    program.  An acceptable form of acknowledgement is citation of
12 > *    the article in which the program was described (Matthew
13 > *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14 > *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15 > *    Parallel Simulation Engine for Molecular Dynamics,"
16 > *    J. Comput. Chem. 26, pp. 252-271 (2005))
17 > *
18 > * 2. Redistributions of source code must retain the above copyright
19 > *    notice, this list of conditions and the following disclaimer.
20 > *
21 > * 3. Redistributions in binary form must reproduce the above copyright
22 > *    notice, this list of conditions and the following disclaimer in the
23 > *    documentation and/or other materials provided with the
24 > *    distribution.
25 > *
26 > * This software is provided "AS IS," without a warranty of any
27 > * kind. All express or implied conditions, representations and
28 > * warranties, including any implied warranty of merchantability,
29 > * fitness for a particular purpose or non-infringement, are hereby
30 > * excluded.  The University of Notre Dame and its licensors shall not
31 > * be liable for any damages suffered by licensee as a result of
32 > * using, modifying or distributing the software or its
33 > * derivatives. In no event will the University of Notre Dame or its
34 > * licensors be liable for any lost revenue, profit or data, or for
35 > * direct, indirect, special, consequential, incidental or punitive
36 > * damages, however caused and regardless of the theory of liability,
37 > * arising out of the use of or inability to use software, even if the
38 > * University of Notre Dame has been advised of the possibility of
39 > * such damages.
40 > */
41 >
42 > #ifndef VISITORS_OTHERVISITOR_HPP
43 > #define VISITORS_OTHERVISITOR_HPP
44   #include <set>
45   #include <string>
46   #include <vector>
47  
48 < #include "BaseVisitor.hpp"
49 < #include "StuntDouble.hpp"
50 < using namespace std;
48 > #include "visitors/BaseVisitor.hpp"
49 > #include "primitives/StuntDouble.hpp"
50 > #include "visitors/AtomData.hpp"
51  
52 +
53 + namespace oopse {
54 +
55 + class SimInfo;
56 +
57   //IgnoreVisitor will turn on the ignoring flag of the stuntdouble
58   class IgnoreVisitor : public BaseVisitor{
59    public:
60 <    IgnoreVisitor() : BaseVisitor() {visitorName = "IgnoreVisitor";}
60 >    IgnoreVisitor(SimInfo* info) : BaseVisitor() {this->info = info; visitorName = "IgnoreVisitor";}
61  
62      virtual void visit(Atom* atom);
63      virtual void visit(DirectionalAtom* datom);
64      virtual void visit(RigidBody* rb);
65      
66 <    virtual const string toString();
66 >    virtual const std::string toString();
67  
68 <    void addIgnoreType(const string& type) {itList.insert(type);}
68 >    void addIgnoreType(const std::string& type) {itList.insert(type);}
69      
70    protected:
71 <    bool isIgnoreType(const string& name);
71 >    bool isIgnoreType(const std::string& name);
72      void internalVisit(StuntDouble* sd);
73 <    set<string> itList; //ignore type list;
73 >    std::set<std::string> itList; //ignore type list;
74 >    SimInfo* info;
75   };
76  
77  
# Line 38 | Line 85 | class WrappingVisitor : public BaseVisitor{
85      virtual void visit(DirectionalAtom* datom);
86      virtual void visit(RigidBody* rb);
87  
88 <    virtual const string toString();
88 >    virtual const std::string toString();
89  
90    protected:
91      void internalVisit(StuntDouble* sd);
# Line 46 | Line 93 | class IntVec3 {
93   };
94  
95  
49 – class IntVec3 {
50 –  public:
51 –    IntVec3(){}
52 –    IntVec3(int i, int j, int k){
53 –      vec[0] = i;
54 –      vec[1] = j;
55 –      vec[2] = k;
56 –    }
57 –    
58 –    int vec[3];
59 –    int& operator[](int index) {return vec[index];}  
60 – };
61 –
96   class ReplicateVisitor : public BaseVisitor{
97    public:
98 <    ReplicateVisitor(SimInfo* info, IntVec3 opt);
98 >    ReplicateVisitor(SimInfo* info, Vector3i opt);
99      virtual void visit(Atom* atom);
100      virtual void visit(DirectionalAtom* datom);
101      virtual void visit(RigidBody* rb);
102  
103 <    virtual const string toString();
103 >    virtual const std::string toString();
104    protected:
105      void internalVisit(StuntDouble* sd);
106 <    void replicate(vector<AtomInfo*>& infoList,  AtomData* data, double boxM[3][3]);
106 >    void replicate(std::vector<AtomInfo*>& infoList,  AtomData* data, const Mat3x3d& box);
107      
108    private:
109 <    vector<IntVec3> dir;
109 >    std::vector<Vector3i> dir;
110      SimInfo* info;
111 <    IntVec3 replicateOpt;
111 >    Vector3i replicateOpt;
112   };
113  
114   class XYZVisitor : public BaseVisitor{
# Line 85 | Line 119 | class XYZVisitor : public BaseVisitor{
119      virtual void visit(DirectionalAtom* datom);
120      virtual void visit(RigidBody* rb);
121  
122 <    virtual const string toString();
122 >    virtual const std::string toString();
123      
124 <    void writeFrame(ostream& outStream);    
124 >    void writeFrame(std::ostream& outStream);    
125      void clear() {frame.clear();}
126      
127    protected:
128      void internalVisit(StuntDouble* sd);
129 <    bool isIgnore(StuntDouble* sd);
129 >    bool isSelected(StuntDouble* sd);
130  
131    private:  
132      SimInfo* info;
133 <    vector<string> frame;
133 >    std::vector<std::string> frame;
134      bool printDipole;
135   };
136  
# Line 109 | Line 143 | class PrepareVisitor : public BaseVisitor{
143      virtual void visit(DirectionalAtom* datom) {internalVisit((Atom*)datom);}
144      virtual void visit(RigidBody* rb) {internalVisit(rb);}
145  
146 <    virtual const string toString();
146 >    virtual const std::string toString();
147  
148    protected:
149      void internalVisit(Atom* atom);
150      void internalVisit(RigidBody* rb);
151   };
152  
153 < class WaterTypeVisitor : public BaseVisitor{
153 >  class WaterTypeVisitor : public BaseVisitor{
154    public:
155      WaterTypeVisitor() ;
156      virtual void visit(Atom* atom) {}
157      virtual void visit(DirectionalAtom* datom) {}
158      virtual void visit(RigidBody* rb);
125 –
126 –    virtual const string toString();
159      
160 +    virtual const std::string toString();
161 +    
162    private:
163 <    void replaceType(string& atomType);
164 <      
165 <    set<string> waterTypeList;
163 >    std::string trimmedName(const std::string& atomType);
164 >    
165 >    std::set<std::string> waterTypeList;
166   };
167 +
168 +
169 + }//namespace oopse
170   #endif //_OTHERVISITOR_H_

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines