src/types/AtomType.hpp

#ifndef TYPES_ATOMTYPE_HPP

#define TYPES_ATOMTYPE_HPP

#include <string>

#include "utils/PropertyMap.hpp"

#define __C
#include "types/AtomTypeProperties.h"
#include "UseTheForce/DarkSide/atype_interface.h"

using name_space std;

name_space oopse {
    /**
     * @class AtomType
     * AtomType is what OOPSE looks to for unchanging data about an atom.
     * Things that belong to AtomType are universal properties (i.e. does
     * this atom have a Charge?  What is it's mass_?)  Dynamic properties of
     * an atom are not intended to be properties of an atom type
     */
    class AtomType {
        public:

            AtomType();

            virtual ~AtomType() { } ;
            /**
             * Finishes off the AtomType by communicating the logical portions of the
             * structure to the Fortran atype module
             */
            void complete();

            void setMass(double m) {
                mass_ = m;
            }

            double getMass(void) {
                return mass_;
            }

            void setIdent(int id) {
                atp_.ident = id;
            }

            int getIdent() {
                return atp_.ident;
            }

            void setName(const std::string&name) {
                name_ = name;
            }

            std::string getName() {
                return name_;
            }

            void setLennardJones() {
                atp_.is_LennardJones = 1;
            }

            bool isLennardJones() {
                return atp_.is_LennardJones;
            }

            void setElectrostatic() {
                atp_.is_Electrostatic = 1;
            }

            bool isElectrostatic() {
                return atp_.is_Electrostatic;
            }

            void setEAM() {
                atp_.is_EAM = 1;
            }

            bool isEAM() {
                return atp_.is_EAM;
            }

            void setCharge() {
                atp_.is_Charge = 1;
                atp_.is_Electrostatic = 1;
            }

            bool isCharge() {
                return atp_.is_Charge;
            }

            bool isDirectional() {
                return atp_.is_Directional;
            }

            bool isDipole() {
                return atp_.is_Dipole;
            }

            bool isGayBerne() {
                return atp_.is_GayBerne;
            }

            bool isSticky() {
                return atp_.is_Sticky;
            }

            bool isShape() {
                return atp_.is_Shape;
            }

            //below functions are just forward functions
            /**
             * Adds property into property map
             * @param genData GenericData to be added into PropertyMap
             */
            void addProperty(GenericData* genData);

            /**
             * Removes property from PropertyMap by name
             * @param propName the name of property to be removed
             */
            void removeProperty(const std::string& propName);

            /**
             * clear all of the properties
             */
            void clearProperties();

            /**
             * Returns all names of properties
             * @return all names of properties
             */
            std::vector<std::string> getPropertyNames();

            /**
             * Returns all of the properties in PropertyMap
             * @return all of the properties in PropertyMap
             */      
            std::vector<GenericData*> getProperties();

            /**
             * Returns property 
             * @param propName name of property
             * @return a pointer point to property with propName. If no property named propName
             * exists, return NULL
             */      
        GenericData* getPropertyByName(const std::string& propName);

        protected:

            AtomTypeProperties atp_;
            double mass_;
            std::string name_;

        private:
            //prevent copy construction and copy assignment, since property map contains
            //pointers which can not be copied and managered safely, except make the generic data
            //at PropertyMap as copy on write shared pointer
            AtomType(const AtomType&);
            AtomType& operator=(const AtomType& atomType);

            
            PropertyMap properties_;
             
    };

}

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