src/brains/SimInfo.hpp

/*
 * Copyright (C) 2000-2004  Object Oriented Parallel Simulation Engine (OOPSE) project
 * 
 * Contact: oopse@oopse.org
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 2.1
 * of the License, or (at your option) any later version.
 * All we ask is that proper credit is given for our work, which includes
 * - but is not limited to - adding the above copyright notice to the beginning
 * of your source code files, and to any copyright notice that you may distribute
 * with programs based on this work.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 */

/**
 * @file SimInfo.hpp
 * @author    tlin
 * @date  11/02/2004
 * @version 1.0
 */ 

#ifndef BRAINS_SIMMODEL_HPP
#define BRAINS_SIMMODEL_HPP
#include <vector>
#include <iostream>

#include "brains/fSimulation.h"
#include "primitives/Molecule.hpp"
#include "utils/PropertyMap.hpp"

namespace oopse{

/**
 * @class SimInfo SimInfo.hpp "brains/SimInfo.hpp" 
 * @brief
 */
class SimInfo {
    public:
        SimInfo();
        virtual ~SimInfo();

        /**
         * Adds a molecule
         * @return return true if adding successfully, return false if the molecule is already in SimInfo
         * @param mol molecule to be added
         */
        bool addMolecule(Molecule* mol);

        /**
         * Removes a molecule from SimInfo
         * @return true if removing successfully, return false if molecule is not in this SimInfo
         */
        bool removeMolecule(Molecule* mol);

        /** 
         * Returns the number of molecules.
         * @return the number of molecules in this SimInfo
         */
        int getNMolecules() {
            return molecules_.size();
        }

        /** Returns the total number of atoms in this SimInfo */
        unsigned int getNAtoms() {
            return nAtoms_;
        }

        /** Returns the total number of bonds in this SimInfo */        
        unsigned int getNBonds(){
            return nBonds_;
        }

        /** Returns the total number of bends in this SimInfo */        
        unsigned int getNBends() {
            return nBends_;
        }

        /** Returns the total number of torsions in this SimInfo */        
        unsigned int getNTorsions() {
            return nTorsions_;
        }

        /** Returns the total number of rigid bodies in this SimInfo */        
        unsigned int getNRigidBodies() {
            return nRigidBodies_;
        }

        /** Returns the total number of integrable objects in this SimInfo */
        unsigned int getNIntegrableObjects() {
            return nIntegrableObjects_;
        }

        /** Returns the total number of cutoff groups in this SimInfo */
        unsigned int getNCutoffGroups() {
            return nCutoffGroups_;
        }

        /** Returns the total number of constraints in this SimInfo */
        unsigned int getNConstraints() {
            return nConstraints_;
        }
        
        /**
         * Returns the first molecule in this SimInfo and intialize the iterator.
         * @return the first molecule, return NULL if there is not molecule in this SimInfo
         * @param i the iterator of molecule array (user shouldn't change it)
         */
        Molecule* beginMolecule(std::vector<Molecule*>::iterator& i);

        /** 
          * Returns the next avaliable Molecule based on the iterator.
          * @return the next avaliable molecule, return NULL if reaching the end of the array 
          * @param i the iterator of molecule array
          */
        Molecule* nextMolecule(std::vector<Molecule*>::iterator& i);

        /** Returns the number of degrees of freedom */
        int getNDF() {
            return ndf_;
        }

        /** Returns the number of raw degrees of freedom */
        int getNDFRaw() {
            return ndfRaw_;
        }

        /** Returns the number of translational degrees of freedom */
        int getNDFTrans() {
            return ndfTrans_;
        }

        /** Returns the snapshot manager. */
        SnapshotManager* getSnapshotManager() {
            return sman_;
        }

        /** Sets the snapshot manager. */
        void setSnapshotManager(SnapshotManager* sman) {
            sman_ = sman;
        }
        
    private:

        void calcNDF();
        void calcNDFRaw();
        void calcNDFTrans();

        int ndf_;
        int ndfRaw_;
        int ndfTrans_;
        
        int nAtoms_;
        int nBonds_;
        int nBends_;
        int nTorsions_;
        int nRigidBodies_;
        int nIntegrableObjects_;
        int nCutoffGroups_;
        int nConstraints_;

        simtype fInfo;
        Exclude excludeList;
        
        
        std::vector<Molecule*> molecules_; /**< Molecule array */
        PropertyMap properties_;                  /** Generic Property */
        SnapshotManager* sman_;               /** SnapshotManager */

};

} //namespace oopse
#endif //BRAINS_SIMMODEL_HPP
Revision:	1710
Committed:	Thu Nov 4 19:48:22 2004 UTC (19 years, 7 months ago) by tim
File size:	5525 byte(s)
Log Message:	adding Stats class
#	User	Rev	Content
1	tim	1710	/*
2			* Copyright (C) 2000-2004 Object Oriented Parallel Simulation Engine (OOPSE) project
3			*
4			* Contact: oopse@oopse.org
5			*
6			* This program is free software; you can redistribute it and/or
7			* modify it under the terms of the GNU Lesser General Public License
8			* as published by the Free Software Foundation; either version 2.1
9			* of the License, or (at your option) any later version.
10			* All we ask is that proper credit is given for our work, which includes
11			* - but is not limited to - adding the above copyright notice to the beginning
12			* of your source code files, and to any copyright notice that you may distribute
13			* with programs based on this work.
14			*
15			* This program is distributed in the hope that it will be useful,
16			* but WITHOUT ANY WARRANTY; without even the implied warranty of
17			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18			* GNU Lesser General Public License for more details.
19			*
20			* You should have received a copy of the GNU Lesser General Public License
21			* along with this program; if not, write to the Free Software
22			* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23			*
24			*/
25	gezelter	1490
26	tim	1710	/**
27			* @file SimInfo.hpp
28			* @author tlin
29			* @date 11/02/2004
30			* @version 1.0
31			*/
32
33			#ifndef BRAINS_SIMMODEL_HPP
34			#define BRAINS_SIMMODEL_HPP
35	gezelter	1490	#include <vector>
36	tim	1710	#include <iostream>
37	gezelter	1490
38	tim	1710	#include "brains/fSimulation.h"
39	tim	1492	#include "primitives/Molecule.hpp"
40	tim	1710	#include "utils/PropertyMap.hpp"
41	gezelter	1490
42	tim	1710	namespace oopse{
43	gezelter	1490
44	tim	1710	/**
45			* @class SimInfo SimInfo.hpp "brains/SimInfo.hpp"
46			* @brief
47			*/
48			class SimInfo {
49			public:
50			SimInfo();
51			virtual ~SimInfo();
52	gezelter	1490
53	tim	1710	/**
54			* Adds a molecule
55			* @return return true if adding successfully, return false if the molecule is already in SimInfo
56			* @param mol molecule to be added
57			*/
58			bool addMolecule(Molecule* mol);
59	gezelter	1490
60	tim	1710	/**
61			* Removes a molecule from SimInfo
62			* @return true if removing successfully, return false if molecule is not in this SimInfo
63			*/
64			bool removeMolecule(Molecule* mol);
65	gezelter	1490
66	tim	1710	/**
67			* Returns the number of molecules.
68			* @return the number of molecules in this SimInfo
69			*/
70			int getNMolecules() {
71			return molecules_.size();
72			}
73	gezelter	1490
74	tim	1710	/** Returns the total number of atoms in this SimInfo */
75			unsigned int getNAtoms() {
76			return nAtoms_;
77			}
78	gezelter	1490
79	tim	1710	/** Returns the total number of bonds in this SimInfo */
80			unsigned int getNBonds(){
81			return nBonds_;
82			}
83	gezelter	1490
84	tim	1710	/** Returns the total number of bends in this SimInfo */
85			unsigned int getNBends() {
86			return nBends_;
87			}
88	gezelter	1490
89	tim	1710	/** Returns the total number of torsions in this SimInfo */
90			unsigned int getNTorsions() {
91			return nTorsions_;
92			}
93	gezelter	1490
94	tim	1710	/** Returns the total number of rigid bodies in this SimInfo */
95			unsigned int getNRigidBodies() {
96			return nRigidBodies_;
97			}
98	gezelter	1490
99	tim	1710	/** Returns the total number of integrable objects in this SimInfo */
100			unsigned int getNIntegrableObjects() {
101			return nIntegrableObjects_;
102			}
103	gezelter	1490
104	tim	1710	/** Returns the total number of cutoff groups in this SimInfo */
105			unsigned int getNCutoffGroups() {
106			return nCutoffGroups_;
107			}
108	gezelter	1490
109	tim	1710	/** Returns the total number of constraints in this SimInfo */
110			unsigned int getNConstraints() {
111			return nConstraints_;
112			}
113
114			/**
115			* Returns the first molecule in this SimInfo and intialize the iterator.
116			* @return the first molecule, return NULL if there is not molecule in this SimInfo
117			* @param i the iterator of molecule array (user shouldn't change it)
118			*/
119			Molecule* beginMolecule(std::vector<Molecule*>::iterator& i);
120	gezelter	1490
121	tim	1710	/**
122			* Returns the next avaliable Molecule based on the iterator.
123			* @return the next avaliable molecule, return NULL if reaching the end of the array
124			* @param i the iterator of molecule array
125			*/
126			Molecule* nextMolecule(std::vector<Molecule*>::iterator& i);
127	gezelter	1490
128	tim	1710	/** Returns the number of degrees of freedom */
129			int getNDF() {
130			return ndf_;
131			}
132	gezelter	1490
133	tim	1710	/** Returns the number of raw degrees of freedom */
134			int getNDFRaw() {
135			return ndfRaw_;
136			}
137	gezelter	1490
138	tim	1710	/** Returns the number of translational degrees of freedom */
139			int getNDFTrans() {
140			return ndfTrans_;
141			}
142	gezelter	1490
143	tim	1710	/** Returns the snapshot manager. */
144			SnapshotManager* getSnapshotManager() {
145			return sman_;
146			}
147	gezelter	1490
148	tim	1710	/** Sets the snapshot manager. */
149			void setSnapshotManager(SnapshotManager* sman) {
150			sman_ = sman;
151			}
152
153			private:
154	gezelter	1490
155	tim	1710	void calcNDF();
156			void calcNDFRaw();
157			void calcNDFTrans();
158	gezelter	1490
159	tim	1710	int ndf_;
160			int ndfRaw_;
161			int ndfTrans_;
162
163			int nAtoms_;
164			int nBonds_;
165			int nBends_;
166			int nTorsions_;
167			int nRigidBodies_;
168			int nIntegrableObjects_;
169			int nCutoffGroups_;
170			int nConstraints_;
171	gezelter	1490
172	tim	1710	simtype fInfo;
173			Exclude excludeList;
174
175
176			std::vector<Molecule> molecules_; /< Molecule array /
177			PropertyMap properties_; /** Generic Property */
178			SnapshotManager* sman_; /** SnapshotManager */
179	gezelter	1490
180			};
181
182	tim	1710	} //namespace oopse
183			#endif //BRAINS_SIMMODEL_HPP