ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/brains/SimInfo.hpp
(Generate patch)

Comparing branches/development/src/brains/SimInfo.hpp (file contents):
Revision 1544 by gezelter, Fri Mar 18 19:31:52 2011 UTC vs.
Revision 1577 by gezelter, Wed Jun 8 20:26:56 2011 UTC

# Line 64 | Line 64
64   #include "utils/LocalIndexManager.hpp"
65   #include "nonbonded/SwitchingFunction.hpp"
66  
67 – //another nonsense macro declaration
68 – #define __OPENMD_C
69 – #include "brains/fSimulation.h"
70 –
67   using namespace std;
68   namespace OpenMD{
69 <  //forward decalration
69 >  //forward declaration
70    class SnapshotManager;
71    class Molecule;
72    class SelectionManager;
# Line 170 | Line 166 | namespace OpenMD{
166        return nAtoms_;
167      }
168  
169 +    /** Returns the number of effective cutoff groups on local processor */
170 +    unsigned int getNLocalCutoffGroups();
171 +
172      /** Returns the number of local bonds */        
173      unsigned int getNBonds(){
174        return nBonds_;
# Line 302 | Line 301 | namespace OpenMD{
301  
302      void update();
303      /**
304 <     * Setup Fortran Simulation
304 >     * Do final bookkeeping before Force managers need their data.
305       */
306 <    void setupFortran();
306 >    void prepareTopology();
307  
308  
309      /** Returns the local index manager */
# Line 341 | Line 340 | namespace OpenMD{
340      int getGlobalMolMembership(int id){
341        return globalMolMembership_[id];
342      }
343 +
344 +    /**
345 +     * returns a vector which maps the local atom index on this
346 +     * processor to the global atom index.  With only one processor,
347 +     * these should be identical.
348 +     */
349 +    vector<int> getGlobalAtomIndices();
350 +
351 +    /**
352 +     * returns a vector which maps the local cutoff group index on
353 +     * this processor to the global cutoff group index.  With only one
354 +     * processor, these should be identical.
355 +     */
356 +    vector<int> getGlobalGroupIndices();
357 +
358          
359      string getFinalConfigFileName() {
360        return finalConfigFileName_;
# Line 400 | Line 414 | namespace OpenMD{
414      }
415  
416  
417 <    bool isFortranInitialized() {
418 <      return fortranInitialized_;
417 >    bool isTopologyDone() {
418 >      return topologyDone_;
419      }
420          
421      bool getCalcBoxDipole() {
# Line 532 | Line 546 | namespace OpenMD{
546      bool usesElectrostaticAtoms() { return usesElectrostaticAtoms_; }
547      bool usesDirectionalAtoms() { return usesDirectionalAtoms_; }
548      bool usesMetallicAtoms() { return usesMetallicAtoms_; }
549 +    bool usesAtomicVirial() { return usesAtomicVirial_; }
550 +    bool requiresPrepair() { return requiresPrepair_; }
551 +    bool requiresSkipCorrection() { return requiresSkipCorrection_;}
552 +    bool requiresSelfCorrection() { return requiresSelfCorrection_;}
553  
554    private:
555      /// Data structures holding primary simulation objects
556      map<int, Molecule*>  molecules_;  /**< map holding pointers to LOCAL molecules */
539 –    simtype fInfo_;                   /**< A dual struct shared by C++
540 –                                         and Fortran to pass
541 –                                         information about what types
542 –                                         of calculation are
543 –                                         required */
557  
558      /// Stamps are templates for objects that are then used to create
559      /// groups of objects.  For example, a molecule stamp contains
# Line 557 | Line 570 | namespace OpenMD{
570       * the simulation.  It should be nGlobalAtoms_ in size.
571       */
572      vector<int> globalGroupMembership_;
573 +  public:
574 +    vector<int> getGlobalGroupMembership() { return globalGroupMembership_; }
575 +  private:
576  
577      /**
578       * A vector that maps between the global index of an atom and the
# Line 571 | Line 587 | namespace OpenMD{
587       * index of the AtomType.
588       */
589      vector<int> identArray_;
590 +  public:
591      vector<int> getIdentArray() { return identArray_; }
592 +  private:
593      
594 +    /**
595 +     * A vector which contains the fractional contribution of an
596 +     * atom's mass to the total mass of the cutoffGroup that atom
597 +     * belongs to.  In the case of single atom cutoff groups, the mass
598 +     * factor for that atom is 1.  For massless atoms, the factor is
599 +     * also 1.
600 +     */
601 +    vector<RealType> massFactors_;
602 +  public:
603 +    vector<RealType> getMassFactors() { return massFactors_; }
604 +
605 +    PairList getExcludedInteractions() { return excludedInteractions_; }
606 +    PairList getOneTwoInteractions() { return oneTwoInteractions_; }
607 +    PairList getOneThreeInteractions() { return oneThreeInteractions_; }
608 +    PairList getOneFourInteractions() { return oneFourInteractions_; }
609 +
610 +  private:
611 +
612                
613      /// lists to handle atoms needing special treatment in the non-bonded interactions
614      PairList excludedInteractions_;  /**< atoms excluded from interacting with each other */
# Line 603 | Line 639 | namespace OpenMD{
639      string restFileName_;
640          
641  
642 <    bool fortranInitialized_; /** flag to indicate whether the fortran side is initialized */
642 >    bool topologyDone_;  /** flag to indicate whether the topology has
643 >                             been scanned and all the relevant
644 >                             bookkeeping has been done*/
645      
646      bool calcBoxDipole_; /**< flag to indicate whether or not we calculate
647                              the simulation box dipole moment */

Diff Legend

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