ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/branches/new_design/OOPSE-3.0/src/types/AtomType.hpp
(Generate patch)

Comparing:
trunk/OOPSE-3.0/src/types/AtomType.hpp (file contents), Revision 1634 by gezelter, Fri Oct 22 21:21:02 2004 UTC vs.
branches/new_design/OOPSE-3.0/src/types/AtomType.hpp (file contents), Revision 1816 by tim, Wed Dec 1 19:10:51 2004 UTC

# Line 1 | Line 1
1   #ifndef TYPES_ATOMTYPE_HPP
2 +
3   #define TYPES_ATOMTYPE_HPP
4  
5 + #include <string>
6 +
7   #include "utils/PropertyMap.hpp"
8 +
9   #define __C
10   #include "types/AtomTypeProperties.h"
11   #include "UseTheForce/DarkSide/atype_interface.h"
12  
13   namespace oopse {
10 –  /**
11 –   * @class AtomType
12 –   * AtomType is what OOPSE looks to for unchanging data about an atom.
13 –   * Things that belong to AtomType are universal properties (i.e. does
14 –   * this atom have a Charge?  What is it's mass?)  Dynamic properties of
15 –   * an atom are not intended to be properties of an atom type
16 –   */
17 –  class AtomType{
18 –    
19 –  public:
20 –    
21 –    AtomType();
22 –    ~AtomType();
14      /**
15 <     * Finishes off the AtomType by communicating the logical portions of the
16 <     * structure to the Fortran atype module
15 >     * @class AtomType
16 >     * AtomType is what OOPSE looks to for unchanging data about an atom.
17 >     * Things that belong to AtomType are universal properties (i.e. does
18 >     * this atom have a Charge?  What is it's mass_?)  Dynamic properties of
19 >     * an atom are not intended to be properties of an atom type
20       */
21 <    void    complete();
22 <    
29 <    void    setMass(double m) { mass = m; }
30 <    double  getMass(void) { return mass; }
21 >    class AtomType {
22 >        public:
23  
24 <    void    setIdent(int id) {atp.ident = id;}
33 <    int     getIdent() {return atp.ident;}
24 >            AtomType();
25  
26 <    void    setName(char* n) {strcpy(name, n);}
27 <    char*   getName() {return name;}
28 <    
29 <    void    setLennardJones() { atp.is_LennardJones = 1; }
30 <    bool    isLennardJones()  { return atp.is_LennardJones; }
31 <    
32 <    void    setElectrostatic() { atp.is_Electrostatic = 1; }
33 <    bool    isElectrostatic()  { return atp.is_Electrostatic; }
26 >            virtual ~AtomType() { } ;
27 >
28 >            virtual void complete();
29 >
30 >            /**
31 >             * Finishes off the AtomType by communicating the logical portions of the
32 >             * structure to the Fortran atype module
33 >             */
34 >            void makeFortranAtomType();
35 >            
36 >            void setMass(double m) {
37 >                mass_ = m;
38 >            }
39 >
40 >            double getMass(void) {
41 >                return mass_;
42 >            }
43 >
44 >            void setIdent(int id) {
45 >                atp.ident = id;
46 >            }
47 >
48 >            int getIdent() {
49 >                return atp.ident;
50 >            }
51 >
52 >            void setName(const std::string&name) {
53 >                name_ = name;
54 >            }
55 >
56 >            std::string getName() {
57 >                return name_;
58 >            }
59 >
60 >            void setLennardJones() {
61 >                atp.is_LennardJones = 1;
62 >            }
63 >
64 >            bool isLennardJones() {
65 >                return atp.is_LennardJones;
66 >            }
67 >
68 >
69 >            bool isElectrostatic() {
70 >                return isCharge() || isMultipole();
71 >            }
72 >
73 >            void setEAM() {
74 >                atp.is_EAM = 1;
75 >            }
76 >
77 >            bool isEAM() {
78 >                return atp.is_EAM;
79 >            }
80 >
81 >            void setCharge() {
82 >                atp.is_Charge = 1;
83 >            }
84 >
85 >            bool isCharge() {
86 >                return atp.is_Charge;
87 >            }
88 >
89 >            bool isDirectional() {
90 >                return atp.is_Directional;
91 >            }
92 >
93 >            bool isDipole() {
94 >                return atp.is_Dipole;
95 >            }
96 >
97 >            bool isQuadrupole() {
98 >                return atp.is_Quadrupole;
99 >            }
100 >            
101 >            bool isMultipole() {
102 >                return isDipole() || isQuadrupole();
103 >            }
104 >
105 >            bool isGayBerne() {
106 >                return atp.is_GayBerne;
107 >            }
108 >
109 >            bool isSticky() {
110 >                return atp.is_Sticky;
111 >            }
112 >
113 >            bool isShape() {
114 >                return atp.is_Shape;
115 >            }
116 >
117 >            //below functions are just forward functions
118 >            /**
119 >             * Adds property into property map
120 >             * @param genData GenericData to be added into PropertyMap
121 >             */
122 >            void addProperty(GenericData* genData);
123 >
124 >            /**
125 >             * Removes property from PropertyMap by name
126 >             * @param propName the name of property to be removed
127 >             */
128 >            void removeProperty(const std::string& propName);
129 >
130 >            /**
131 >             * clear all of the properties
132 >             */
133 >            void clearProperties();
134 >
135 >            /**
136 >             * Returns all names of properties
137 >             * @return all names of properties
138 >             */
139 >            std::vector<std::string> getPropertyNames();
140 >
141 >            /**
142 >             * Returns all of the properties in PropertyMap
143 >             * @return all of the properties in PropertyMap
144 >             */      
145 >            std::vector<GenericData*> getProperties();
146 >
147 >            /**
148 >             * Returns property
149 >             * @param propName name of property
150 >             * @return a pointer point to property with propName. If no property named propName
151 >             * exists, return NULL
152 >             */      
153 >        GenericData* getPropertyByName(const std::string& propName);
154 >
155 >        protected:
156 >
157 >            AtomTypeProperties atp;
158 >            double mass_;
159 >            std::string name_;
160 >
161 >        private:
162 >            //prevent copy construction and copy assignment, since property map contains
163 >            //pointers which can not be copied and managered safely, except make the generic data
164 >            //at PropertyMap as copy on write shared pointer
165 >            AtomType(const AtomType&);
166 >            AtomType& operator=(const AtomType& atomType);
167 >
168 >            
169 >            PropertyMap properties_;
170              
171 <    void    setEAM() { atp.is_EAM = 1; }
45 <    bool    isEAM()  { return atp.is_EAM; }
46 <        
47 <    void    setCharge() { atp.is_Charge = 1; atp.is_Electrostatic = 1;}
48 <    bool    isCharge()  { return atp.is_Charge; }
171 >    };
172  
173 <    PropertyMap properties;
174 <                
175 <  protected:
176 <    
177 <    AtomTypeProperties atp;
178 <    double mass;
179 <    char* name;
180 <    
181 <  };
173 >    struct LJParam {
174 >        double epsilon;
175 >        double sigma;
176 >    };
177 >    typedef SimpleTypeData<LJParam> LJParamGenericData;
178 >
179 >    struct EAMParam {
180 >        double latticeConstant;        
181 >        int nrho;
182 >        double drho;
183 >        int nr;
184 >        double dr;
185 >        double rcut;
186 >        std::vector<double> rvals;
187 >        std::vector<double> rhovals;
188 >        std::vector<double> Frhovals;    
189 >    };
190 >
191 >    typedef SimpleTypeData<EAMParam> EAMParamGenericData;
192   }
193 +
194   #endif

Diff Legend

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