| 54 |
|
#include <utility> |
| 55 |
|
#include <vector> |
| 56 |
|
|
| 57 |
< |
#include "brains/Exclude.hpp" |
| 57 |
> |
#include "brains/PairList.hpp" |
| 58 |
|
#include "io/Globals.hpp" |
| 59 |
|
#include "math/Vector3.hpp" |
| 60 |
|
#include "math/SquareMatrix3.hpp" |
| 64 |
|
#include "utils/LocalIndexManager.hpp" |
| 65 |
|
|
| 66 |
|
//another nonsense macro declaration |
| 67 |
< |
#define __C |
| 67 |
> |
#define __OOPSE_C |
| 68 |
|
#include "brains/fSimulation.h" |
| 69 |
|
|
| 70 |
|
namespace oopse{ |
| 77 |
|
/** |
| 78 |
|
* @class SimInfo SimInfo.hpp "brains/SimInfo.hpp" |
| 79 |
|
* @brief One of the heavy weight classes of OOPSE, SimInfo maintains a list of molecules. |
| 80 |
< |
* The Molecule class maintains all of the concrete objects |
| 81 |
< |
* (atoms, bond, bend, torsions, rigid bodies, cutoff groups, constrains). |
| 82 |
< |
* In both the single and parallel versions, atoms and |
| 83 |
< |
* rigid bodies have both global and local indices. The local index is |
| 84 |
< |
* not relevant to molecules or cutoff groups. |
| 85 |
< |
*/ |
| 80 |
> |
* The Molecule class maintains all of the concrete objects |
| 81 |
> |
* (atoms, bond, bend, torsions, inversions, rigid bodies, cutoff groups, |
| 82 |
> |
* constraints). In both the single and parallel versions, atoms and |
| 83 |
> |
* rigid bodies have both global and local indices. The local index is |
| 84 |
> |
* not relevant to molecules or cutoff groups. |
| 85 |
> |
*/ |
| 86 |
|
class SimInfo { |
| 87 |
|
public: |
| 88 |
|
typedef std::map<int, Molecule*>::iterator MoleculeIterator; |
| 171 |
|
return nTorsions_; |
| 172 |
|
} |
| 173 |
|
|
| 174 |
+ |
/** Returns the number of local torsions */ |
| 175 |
+ |
unsigned int getNInversions() { |
| 176 |
+ |
return nInversions_; |
| 177 |
+ |
} |
| 178 |
|
/** Returns the number of local rigid bodies */ |
| 179 |
|
unsigned int getNRigidBodies() { |
| 180 |
|
return nRigidBodies_; |
| 314 |
|
return i != molecules_.end() ? i->second : NULL; |
| 315 |
|
} |
| 316 |
|
|
| 317 |
+ |
int getGlobalMolMembership(int id){ |
| 318 |
+ |
return globalMolMembership_[id]; |
| 319 |
+ |
} |
| 320 |
+ |
|
| 321 |
|
RealType getRcut() { |
| 322 |
|
return rcut_; |
| 323 |
|
} |
| 374 |
|
* @see #SimCreator::setGlobalIndex |
| 375 |
|
*/ |
| 376 |
|
void setGlobalGroupMembership(const std::vector<int>& globalGroupMembership) { |
| 377 |
< |
assert(globalGroupMembership.size() == nGlobalAtoms_); |
| 377 |
> |
assert(globalGroupMembership.size() == static_cast<size_t>(nGlobalAtoms_)); |
| 378 |
|
globalGroupMembership_ = globalGroupMembership; |
| 379 |
|
} |
| 380 |
|
|
| 383 |
|
* @see #SimCreator::setGlobalIndex |
| 384 |
|
*/ |
| 385 |
|
void setGlobalMolMembership(const std::vector<int>& globalMolMembership) { |
| 386 |
< |
assert(globalMolMembership.size() == nGlobalAtoms_); |
| 386 |
> |
assert(globalMolMembership.size() == static_cast<size_t>(nGlobalAtoms_)); |
| 387 |
|
globalMolMembership_ = globalMolMembership; |
| 388 |
|
} |
| 389 |
|
|
| 441 |
|
GenericData* getPropertyByName(const std::string& propName); |
| 442 |
|
|
| 443 |
|
/** |
| 444 |
< |
* add all exclude pairs of a molecule into exclude list. |
| 444 |
> |
* add all special interaction pairs (including excluded |
| 445 |
> |
* interactions) in a molecule into the appropriate lists. |
| 446 |
|
*/ |
| 447 |
< |
void addExcludePairs(Molecule* mol); |
| 447 |
> |
void addInteractionPairs(Molecule* mol); |
| 448 |
|
|
| 449 |
|
/** |
| 450 |
< |
* remove all exclude pairs which belong to a molecule from exclude list |
| 450 |
> |
* remove all special interaction pairs which belong to a molecule |
| 451 |
> |
* from the appropriate lists. |
| 452 |
|
*/ |
| 453 |
< |
|
| 444 |
< |
void removeExcludePairs(Molecule* mol); |
| 453 |
> |
void removeInteractionPairs(Molecule* mol); |
| 454 |
|
|
| 455 |
|
|
| 456 |
|
/** Returns the unique atom types of local processor in an array */ |
| 521 |
|
std::vector<int> globalGroupMembership_; |
| 522 |
|
|
| 523 |
|
/** |
| 524 |
< |
* the size of globalGroupMembership_ is nGlobalAtoms. Its index is global index of an atom, and the |
| 524 |
> |
* the size of globalMolMembership_ is nGlobalAtoms. Its index is global index of an atom, and the |
| 525 |
|
* corresponding content is the global index of molecule this atom belong to. |
| 526 |
|
* It is filled by SimCreator once and only once, since it is never changed during the simulation. |
| 527 |
|
*/ |
| 532 |
|
std::vector<MoleculeStamp*> moleculeStamps_; /**< molecule stamps array */ |
| 533 |
|
|
| 534 |
|
//number of local objects |
| 535 |
< |
int nAtoms_; /**< number of atoms in local processor */ |
| 536 |
< |
int nBonds_; /**< number of bonds in local processor */ |
| 537 |
< |
int nBends_; /**< number of bends in local processor */ |
| 538 |
< |
int nTorsions_; /**< number of torsions in local processor */ |
| 539 |
< |
int nRigidBodies_; /**< number of rigid bodies in local processor */ |
| 540 |
< |
int nIntegrableObjects_; /**< number of integrable objects in local processor */ |
| 541 |
< |
int nCutoffGroups_; /**< number of cutoff groups in local processor */ |
| 542 |
< |
int nConstraints_; /**< number of constraints in local processors */ |
| 535 |
> |
int nAtoms_; /**< number of atoms in local processor */ |
| 536 |
> |
int nBonds_; /**< number of bonds in local processor */ |
| 537 |
> |
int nBends_; /**< number of bends in local processor */ |
| 538 |
> |
int nTorsions_; /**< number of torsions in local processor */ |
| 539 |
> |
int nInversions_; /**< number of inversions in local processor */ |
| 540 |
> |
int nRigidBodies_; /**< number of rigid bodies in local processor */ |
| 541 |
> |
int nIntegrableObjects_; /**< number of integrable objects in local processor */ |
| 542 |
> |
int nCutoffGroups_; /**< number of cutoff groups in local processor */ |
| 543 |
> |
int nConstraints_; /**< number of constraints in local processors */ |
| 544 |
|
|
| 545 |
|
simtype fInfo_; /**< A dual struct shared by c++/fortran which indicates the atom types in simulation*/ |
| 546 |
< |
Exclude exclude_; |
| 546 |
> |
PairList excludedInteractions_; |
| 547 |
> |
PairList oneTwoInteractions_; |
| 548 |
> |
PairList oneThreeInteractions_; |
| 549 |
> |
PairList oneFourInteractions_; |
| 550 |
|
PropertyMap properties_; /**< Generic Property */ |
| 551 |
|
SnapshotManager* sman_; /**< SnapshotManager */ |
| 552 |
|
|
| 571 |
|
RealType rsw_; /**< radius of switching function*/ |
| 572 |
|
RealType rlist_; /**< neighbor list radius */ |
| 573 |
|
|
| 574 |
+ |
bool ljsp_; /**< use shifted potential for LJ*/ |
| 575 |
+ |
bool ljsf_; /**< use shifted force for LJ*/ |
| 576 |
+ |
|
| 577 |
|
bool fortranInitialized_; /**< flag indicate whether fortran side |
| 578 |
|
is initialized */ |
| 579 |
|
|
| 602 |
|
//private: |
| 603 |
|
//std::vector<StuntDouble*> sdByGlobalIndex_; |
| 604 |
|
|
| 589 |
– |
#ifdef IS_MPI |
| 605 |
|
//in Parallel version, we need MolToProc |
| 606 |
|
public: |
| 607 |
|
|
| 622 |
|
void setMolToProcMap(const std::vector<int>& molToProcMap) { |
| 623 |
|
molToProcMap_ = molToProcMap; |
| 624 |
|
} |
| 610 |
– |
|
| 611 |
– |
|
| 625 |
|
|
| 626 |
|
private: |
| 627 |
|
|
| 628 |
|
void setupFortranParallel(); |
| 629 |
|
|
| 630 |
|
/** |
| 631 |
< |
* The size of molToProcMap_ is equal to total number of molecules in the system. |
| 632 |
< |
* It maps a molecule to the processor on which it resides. it is filled by SimCreator once and only |
| 633 |
< |
* once. |
| 631 |
> |
* The size of molToProcMap_ is equal to total number of molecules |
| 632 |
> |
* in the system. It maps a molecule to the processor on which it |
| 633 |
> |
* resides. it is filled by SimCreator once and only once. |
| 634 |
|
*/ |
| 635 |
|
std::vector<int> molToProcMap_; |
| 636 |
|
|
| 624 |
– |
#endif |
| 637 |
|
|
| 638 |
|
}; |
| 639 |
|
|
