ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libmdtools/mpiSimulation.cpp
(Generate patch)

Comparing trunk/OOPSE/libmdtools/mpiSimulation.cpp (file contents):
Revision 418 by mmeineke, Thu Mar 27 14:30:24 2003 UTC vs.
Revision 434 by chuckv, Fri Mar 28 19:30:59 2003 UTC

# Line 1 | Line 1
1   #ifdef IS_MPI
2 <
2 > #include <iostream>
3   #include <cstdlib>
4   #include <cstring>
5   #include <cmath>
# Line 25 | Line 25 | mpiSimulation::mpiSimulation(SimInfo* the_entryPlug)
25  
26    MolToProcMap = new int[entryPlug->n_mol];
27    MolComponentType = new int[entryPlug->n_mol];
28 –
28    AtomToProcMap = new int[entryPlug->n_atoms];
29  
30    mpiSim = this;
# Line 86 | Line 85 | int* mpiSimulation::divideLabor( void ){
85  
86    myRandom = new randomSPRNG( baseSeed );
87  
88 <  a = (double)mpiPlug->nMolGlobal / (double)mpiPlug->nAtomsGlobal;
88 >  a = 3.0 * (double)mpiPlug->nMolGlobal / (double)mpiPlug->nAtomsGlobal;
89  
90    // Initialize things that we'll send out later:
91    for (i = 0; i < mpiPlug->numberProcessors; i++ ) {
# Line 134 | Line 133 | int* mpiSimulation::divideLabor( void ){
133          // How many atoms does this processor have?
134          
135          old_atoms = AtomsPerProc[which_proc];
137 –
138 –        // If the processor already had too many atoms, just skip this
139 –        // processor and try again.
140 –
141 –        if (old_atoms >= nTarget) continue;
142 –
136          add_atoms = compStamps[MolComponentType[i]]->getNAtoms();
137          new_atoms = old_atoms + add_atoms;
145 –    
146 –        // If we can add this molecule to this processor without sending
147 –        // it above nTarget, then go ahead and do it:
148 –    
149 –        if (new_atoms <= nTarget) {
150 –          MolToProcMap[i] = which_proc;
151 –          AtomsPerProc[which_proc] += add_atoms;
152 –          for (j = 0 ; j < add_atoms; j++ ) {
153 –            atomIndex++;
154 –            AtomToProcMap[atomIndex] = which_proc;
155 –          }
156 –          done = 1;
157 –          continue;
158 –        }
138  
139          // If we've been through this loop too many times, we need
140          // to just give up and assign the molecule to this processor
# Line 173 | Line 152 | int* mpiSimulation::divideLabor( void ){
152            MolToProcMap[i] = which_proc;
153            AtomsPerProc[which_proc] += add_atoms;
154            for (j = 0 ; j < add_atoms; j++ ) {
155 <            atomIndex++;
156 <            AtomToProcMap[atomIndex] = which_proc;
155 >            AtomToProcMap[atomIndex] = which_proc;
156 >            atomIndex++;
157 >          }
158 >          done = 1;
159 >          continue;
160 >        }
161 >    
162 >        // If we can add this molecule to this processor without sending
163 >        // it above nTarget, then go ahead and do it:
164 >    
165 >        if (new_atoms <= nTarget) {
166 >          MolToProcMap[i] = which_proc;
167 >          AtomsPerProc[which_proc] += add_atoms;
168 >          for (j = 0 ; j < add_atoms; j++ ) {
169 >            AtomToProcMap[atomIndex] = which_proc;
170 >            atomIndex++;
171            }
172            done = 1;
173            continue;
174          }
175  
183 –        // The only situation left is where old_atoms < nTarget, but
184 –        // new_atoms > nTarget.   We want to accept this with some
185 –        // probability that dies off the farther we are from nTarget
176  
177 +        // The only situation left is when new_atoms > nTarget.  We
178 +        // want to accept this with some probability that dies off the
179 +        // farther we are from nTarget
180 +
181          // roughly:  x = new_atoms - nTarget
182          //           Pacc(x) = exp(- a * x)
183 <        // where a = 1 / (average atoms per molecule)
183 >        // where a = penalty / (average atoms per molecule)
184  
185          x = (double) (new_atoms - nTarget);
186          y = myRandom->getRandom();
187 <        
188 <        if (exp(- a * x) > y) {
187 >      
188 >        if (y < exp(- a * x)) {
189            MolToProcMap[i] = which_proc;
190            AtomsPerProc[which_proc] += add_atoms;
191            for (j = 0 ; j < add_atoms; j++ ) {
192 <            atomIndex++;
193 <            AtomToProcMap[atomIndex] = which_proc;
194 <          }
192 >            AtomToProcMap[atomIndex] = which_proc;
193 >            atomIndex++;
194 >           }
195            done = 1;
196            continue;
197          } else {
# Line 235 | Line 229 | int* mpiSimulation::divideLabor( void ){
229      
230      MPI::COMM_WORLD.Bcast(AtomsPerProc, mpiPlug->numberProcessors,
231                            MPI_INT, 0);
232 +
233 +
234    }
235  
236  
# Line 286 | Line 282 | int* mpiSimulation::divideLabor( void ){
282    local_index = 0;
283    for (i = 0; i < mpiPlug->nAtomsGlobal; i++) {
284      if (AtomToProcMap[i] == mpiPlug->myNode) {
289 –      local_index++;
285        globalIndex[local_index] = i;
286 +      local_index++;
287      }
288    }
289 <
289 >  
290    return globalIndex;
291   }
292  

Diff Legend

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