/* * Initialize all Angle objects for Molecules of one Species. * * This functions assigns pointers to Atoms and angle types ids within a * contiguous block of Angle objects, and sets a pointer in each Molecule * to the first Angle in the associated block. */ void Simulation::initializeSpeciesAngles(int iSpecies) { if (nAngleType_ <= 0) { UTIL_THROW("nAngleType must be positive"); } Species* speciesPtr = 0; Molecule *moleculePtr = 0; Angle *anglePtr = 0; Atom *firstAtomPtr, *atom0Ptr, *atom1Ptr, *atom2Ptr; int iMol, iAngle, atom0Id, atom1Id, atom2Id, type; int capacity, nAngle; speciesPtr = &species(iSpecies); capacity = speciesPtr->capacity(); nAngle = speciesPtr->nAngle(); // Initialize pointers before loop moleculePtr = &molecules_[firstMoleculeIds_[iSpecies]]; anglePtr = &angles_[firstAngleIds_[iSpecies]]; // Loop over molecules in Species for (iMol = 0; iMol < capacity; ++iMol) { firstAtomPtr = &(moleculePtr->atom(0)); moleculePtr->setFirstAngle(*anglePtr); moleculePtr->setNAngle(nAngle); if (nAngle > 0) { // Create angles for a molecule for (iAngle = 0; iAngle < nAngle; ++iAngle) { // Get pointers to atoms spanning the angle and angle type atom0Id = speciesPtr->speciesAngle(iAngle).atomId(0); atom1Id = speciesPtr->speciesAngle(iAngle).atomId(1); atom2Id = speciesPtr->speciesAngle(iAngle).atomId(2); type = speciesPtr->speciesAngle(iAngle).typeId(); atom0Ptr = firstAtomPtr + atom0Id; atom1Ptr = firstAtomPtr + atom1Id; atom2Ptr = firstAtomPtr + atom2Id; // Set fields of the Angle object anglePtr->setAtom(0, *atom0Ptr); anglePtr->setAtom(1, *atom1Ptr); anglePtr->setAtom(2, *atom2Ptr); anglePtr->setTypeId(type); ++anglePtr; } } ++moleculePtr; } }
/* * Allocate and initialize all private data (private method). * * Allocates global arrays (molecules_, atoms_, bonds_, angles_) and the * arrays first<class>Ids_ of integers to species blocks. Initializes: * * - Capacity values and first<class>Ptr_ addresses. * - Integer ids for Species and Molecule objects. * - Pointers between Species, Molecule, and Atom objects * - Atom typeIds and all Bond and Angle objects. */ void Simulation::initialize() { //Preconditions assert(nSpecies() > 0); if (nSpecies() <= 0) { UTIL_THROW("Error: nSpecies() <= 0 in Simulation::initialize()"); } if (nBondType_ < 0) { UTIL_THROW("Error: nBondType < 0 in Simulation::initialize()"); } #ifdef INTER_ANGLE if (nAngleType_ < 0) { UTIL_THROW("Error: nAngleType < 0 in Simulation::initialize()"); } #endif #ifdef INTER_DIHEDRAL if (nDihedralType_ < 0) { UTIL_THROW("Error: nDihedralType < 0 in Simulation::initialize()"); } #endif #ifdef MCMD_LINK if (nLinkType_ < 0) { UTIL_THROW("Error: nLinkType_ < 0 in Simulation::initialize()"); } #endif Species *speciesPtr; int nAtom, nBond, iSpecies; int capacity; #ifdef INTER_ANGLE int nAngle; #endif #ifdef INTER_DIHEDRAL int nDihedral; #endif // Allocate arrays of pointers to first object in a species block. firstMoleculeIds_.allocate(nSpecies()); firstAtomIds_.allocate(nSpecies()); if (nBondType_ > 0) { firstBondIds_.allocate(nSpecies()); } #ifdef INTER_ANGLE if (nAngleType_ > 0) { firstAngleIds_.allocate(nSpecies()); } #endif #ifdef INTER_DIHEDRAL if (nDihedralType_ > 0) { firstDihedralIds_.allocate(nSpecies()); } #endif // Count Molecules, Atoms and Groups. moleculeCapacity_ = 0; atomCapacity_ = 0; bondCapacity_ = 0; #ifdef INTER_ANGLE angleCapacity_ = 0; #endif #ifdef INTER_DIHEDRAL dihedralCapacity_ = 0; #endif for (iSpecies = 0; iSpecies < nSpecies(); ++iSpecies) { speciesPtr = &species(iSpecies); // Check species id if (speciesPtr->id() != iSpecies) { UTIL_THROW("Inconsistent species ids"); } //speciesPtr->setId(iSpecies); // Set indexes of first objects of the blocks for this species firstMoleculeIds_[iSpecies] = moleculeCapacity_; firstAtomIds_[iSpecies] = atomCapacity_; if (nBondType_ > 0) { firstBondIds_[iSpecies] = bondCapacity_; } #ifdef INTER_ANGLE if (nAngleType_ > 0) { firstAngleIds_[iSpecies] = angleCapacity_; } #endif #ifdef INTER_DIHEDRAL if (nDihedralType_ > 0) { firstDihedralIds_[iSpecies] = dihedralCapacity_; } #endif // Increment total capacity values capacity = speciesPtr->capacity(); nAtom = speciesPtr->nAtom(); moleculeCapacity_ += capacity; atomCapacity_ += capacity*nAtom; if (nBondType_ > 0) { nBond = speciesPtr->nBond(); bondCapacity_ += capacity*nBond; } #ifdef INTER_ANGLE if (nAngleType_ > 0) { nAngle = speciesPtr->nAngle(); angleCapacity_ += capacity*nAngle; } #endif #ifdef INTER_DIHEDRAL if (nDihedralType_ > 0) { nDihedral = speciesPtr->nDihedral(); dihedralCapacity_ += capacity*nDihedral; } #endif } // Allocate global array of atoms (static member of Atom class). Atom::allocate(atomCapacity_, atoms_); // Allocate other global arrays (members of Simulation). molecules_.allocate(moleculeCapacity_); // Initialize all Atoms and Molecule objects. for (iSpecies = 0; iSpecies < nSpecies(); ++iSpecies) { speciesPtr = &species(iSpecies); initializeSpecies(iSpecies); } // Initialize bonds. if (nBondType_ > 0) { if (bondCapacity_ > 0) { bonds_.allocate(bondCapacity_); } else { bonds_.allocate(1); } for (iSpecies = 0; iSpecies < nSpecies(); ++iSpecies) { initializeSpeciesBonds(iSpecies); } } #ifdef INTER_ANGLE // Initialize angles. if (nAngleType_ > 0) { if (angleCapacity_ > 0) { angles_.allocate(angleCapacity_); } else { angles_.allocate(1); } for (iSpecies = 0; iSpecies < nSpecies(); ++iSpecies) { initializeSpeciesAngles(iSpecies); } } #endif #ifdef INTER_DIHEDRAL // Initialize dihedrals. if (nDihedralType_ > 0) { if (dihedralCapacity_ > 0) { dihedrals_.allocate(dihedralCapacity_); } else { dihedrals_.allocate(1); } for (iSpecies = 0; iSpecies < nSpecies(); ++iSpecies) { initializeSpeciesDihedrals(iSpecies); } } #endif }