OpenMPCD
test_ParticleCollection.py
1 from MPCDAnalysis.ParticleCollection import ParticleCollection
2 
3 def test___init__():
4  ParticleCollection()
5 
6 
7 def test_setPositionsAndVelocities_getPositions_getVelocities():
8  from MPCDAnalysis.Vector3DReal import Vector3DReal
9 
10  import pytest
11 
12 
13  nullVector = Vector3DReal(0.0, 0.0, 0.0)
14 
15  pc = ParticleCollection()
16  pc.setPositionsAndVelocities([nullVector], [nullVector])
17 
18  with pytest.raises(TypeError):
19  pc = ParticleCollection()
20  pc.setPositionsAndVelocities((nullVector,), [nullVector])
21  with pytest.raises(TypeError):
22  pc = ParticleCollection()
23  pc.setPositionsAndVelocities([nullVector], (nullVector,))
24 
25  with pytest.raises(TypeError):
26  pc = ParticleCollection()
27  pc.setPositionsAndVelocities([[0.0, 0.0, 0.0]], [nullVector])
28  with pytest.raises(TypeError):
29  pc = ParticleCollection()
30  pc.setPositionsAndVelocities([nullVector], [[0.0, 0.0, 0.0]])
31 
32 
33  with pytest.raises(ValueError):
34  pc = ParticleCollection()
35  pc.setPositionsAndVelocities([nullVector, nullVector], [nullVector])
36  with pytest.raises(ValueError):
37  pc = ParticleCollection()
38  pc.setPositionsAndVelocities([nullVector], [nullVector, nullVector])
39 
40 
41  pc = ParticleCollection()
42  positions = []
43  velocities = []
44  for x in range(0, 5):
45  positions.append(Vector3DReal(0.5 * x, -0.5 + x, x * x / 2.0))
46  velocities.append(Vector3DReal(1.23 / (x + 1), x, -x))
47 
48  pc.setPositionsAndVelocities(positions, velocities)
49 
50  assert isinstance(pc.getPositions(), list)
51  assert isinstance(pc.getVelocities(), list)
52  for x in range(0, 5):
53  assert isinstance(pc.getPositions()[x], Vector3DReal)
54  assert isinstance(pc.getVelocities()[x], Vector3DReal)
55 
56  assert \
57  pc.getPositions()[x] == Vector3DReal(0.5 * x, -0.5 + x, x * x / 2.0)
58  assert \
59  pc.getVelocities()[x] == Vector3DReal(1.23 / (x + 1), x, -x)
60 
61 
62  positions[0].normalize()
63  velocities[1].normalize()
64  assert isinstance(pc.getPositions(), list)
65  assert isinstance(pc.getVelocities(), list)
66  for x in range(0, 5):
67  assert isinstance(pc.getPositions()[x], Vector3DReal)
68  assert isinstance(pc.getVelocities()[x], Vector3DReal)
69 
70  assert \
71  pc.getPositions()[x] == Vector3DReal(0.5 * x, -0.5 + x, x * x / 2.0)
72  assert \
73  pc.getVelocities()[x] == Vector3DReal(1.23 / (x + 1), x, -x)
74 
75 
76 def test_setUniformMass():
77  import pytest
78 
79  pc = ParticleCollection()
80  with pytest.raises(TypeError):
81  pc.setUniformMass([1.0])
82 
83  pc = ParticleCollection()
84  with pytest.raises(ValueError):
85  pc.setUniformMass(-0.5)
86 
87  pc = ParticleCollection()
88  pc.setUniformMass(0.0)
89  pc.setUniformMass(1.0)
90  pc.setUniformMass(1.5)
91  pc.setUniformMass(0)
92  pc.setUniformMass(1)
93 
94  from MPCDAnalysis.Vector3DReal import Vector3DReal
95  nullVector = Vector3DReal(0, 0, 0)
96 
97  pc.setPositionsAndVelocities([nullVector], [nullVector])
98  pc.setUniformMass(0.0)
99  pc.setUniformMass(1.0)
100  pc.setUniformMass(1.5)
101  pc.setUniformMass(0)
102  pc.setUniformMass(1)
103 
104 
105 def test_isEmpty():
106  pc = ParticleCollection()
107  assert pc.isEmpty()
108  assert pc.isEmpty()
109 
110  from MPCDAnalysis.Vector3DReal import Vector3DReal
111  nullVector = Vector3DReal(0, 0, 0)
112 
113  pc.setPositionsAndVelocities([nullVector], [nullVector])
114 
115  assert not pc.isEmpty()
116  assert not pc.isEmpty()
117 
118  twice = [nullVector, nullVector]
119  pc.setPositionsAndVelocities(twice, twice)
120 
121  assert not pc.isEmpty()
122  assert not pc.isEmpty()
123 
124 
125 def test_getParticleCount():
126  pc = ParticleCollection()
127  assert pc.getParticleCount() == 0
128  assert pc.getParticleCount() == 0
129  assert isinstance(pc.getParticleCount(), int)
130 
131  from MPCDAnalysis.Vector3DReal import Vector3DReal
132  nullVector = Vector3DReal(0, 0, 0)
133 
134  pc.setPositionsAndVelocities([nullVector], [nullVector])
135 
136  assert pc.getParticleCount() == 1
137  assert pc.getParticleCount() == 1
138  assert isinstance(pc.getParticleCount(), int)
139 
140  twice = [nullVector, nullVector]
141  pc.setPositionsAndVelocities(twice, twice)
142 
143  assert pc.getParticleCount() == 2
144  assert pc.getParticleCount() == 2
145  assert isinstance(pc.getParticleCount(), int)
146 
147 
148 def test_getPosition_getVelocity():
149  from MPCDAnalysis.Vector3DReal import Vector3DReal
150 
151  import pytest
152 
153 
154  pc = ParticleCollection()
155  with pytest.raises(IndexError):
156  pc.getPosition(0)
157  with pytest.raises(IndexError):
158  pc.getPosition(-1)
159  with pytest.raises(IndexError):
160  pc.getVelocity(0)
161  with pytest.raises(IndexError):
162  pc.getVelocity(-1)
163 
164 
165  pc = ParticleCollection()
166  positions = []
167  velocities = []
168  for x in range(0, 5):
169  positions.append(Vector3DReal(0.5 * x, -0.5 + x, x * x / 2.0))
170  velocities.append(Vector3DReal(1.23 / (x + 1), x, -x))
171 
172  pc.setPositionsAndVelocities(positions, velocities)
173 
174 
175  with pytest.raises(TypeError):
176  pc.getPosition(0.0)
177  with pytest.raises(TypeError):
178  pc.getVelocity(0.0)
179 
180  with pytest.raises(IndexError):
181  pc.getPosition(-1)
182  with pytest.raises(IndexError):
183  pc.getPosition(pc.getParticleCount())
184  with pytest.raises(IndexError):
185  pc.getPosition(pc.getParticleCount() + 1)
186 
187  with pytest.raises(IndexError):
188  pc.getVelocity(-1)
189  with pytest.raises(IndexError):
190  pc.getVelocity(pc.getParticleCount())
191  with pytest.raises(IndexError):
192  pc.getVelocity(pc.getParticleCount() + 1)
193 
194 
195  for x in range(0, 5):
196  assert isinstance(pc.getPosition(x), Vector3DReal)
197  assert isinstance(pc.getVelocity(x), Vector3DReal)
198 
199  assert \
200  pc.getPosition(x) == Vector3DReal(0.5 * x, -0.5 + x, x * x / 2.0)
201  assert \
202  pc.getVelocity(x) == Vector3DReal(1.23 / (x + 1), x, -x)
203 
204 
205  positions[0].normalize()
206  velocities[1].normalize()
207  for x in range(0, 5):
208  assert isinstance(pc.getPosition(x), Vector3DReal)
209  assert isinstance(pc.getVelocity(x), Vector3DReal)
210 
211  assert \
212  pc.getPosition(x) == Vector3DReal(0.5 * x, -0.5 + x, x * x / 2.0)
213  assert \
214  pc.getVelocity(x) == Vector3DReal(1.23 / (x + 1), x, -x)
215 
216 
217 def test_getMass():
218  from MPCDAnalysis.Vector3DReal import Vector3DReal
219 
220  import pytest
221 
222 
223  pc = ParticleCollection()
224  with pytest.raises(IndexError):
225  pc.getMass(0)
226  with pytest.raises(IndexError):
227  pc.getMass(-1)
228 
229 
230  pc = ParticleCollection()
231  positions = []
232  velocities = []
233  for x in range(0, 5):
234  positions.append(Vector3DReal(0.5 * x, -0.5 + x, x * x / 2.0))
235  velocities.append(Vector3DReal(1.23 / (x + 1), x, -x))
236 
237  pc.setPositionsAndVelocities(positions, velocities)
238 
239  with pytest.raises(RuntimeError):
240  pc.getMass(0)
241 
242 
243  with pytest.raises(TypeError):
244  pc.getMass(0.0)
245  with pytest.raises(TypeError):
246  pc.getMass(0.0)
247 
248  with pytest.raises(IndexError):
249  pc.getMass(-1)
250  with pytest.raises(IndexError):
251  pc.getMass(pc.getParticleCount())
252  with pytest.raises(IndexError):
253  pc.getMass(pc.getParticleCount() + 1)
254 
255 
256  pc.setUniformMass(1.23)
257 
258  for x in range(0, pc.getParticleCount()):
259  assert isinstance(pc.getMass(x), float)
260  assert pc.getMass(x) == 1.23
261 
262  pc.setPositionsAndVelocities(positions[:3], velocities[:3])
263  for x in range(0, pc.getParticleCount()):
264  assert isinstance(pc.getMass(x), float)
265  assert pc.getMass(x) == 1.23
266 
267  pc.setPositionsAndVelocities(positions + velocities, velocities + positions)
268  for x in range(0, pc.getParticleCount()):
269  assert isinstance(pc.getMass(x), float)
270  assert pc.getMass(x) == 1.23
271 
272  pc.setUniformMass(4)
273  for x in range(0, pc.getParticleCount()):
274  assert isinstance(pc.getMass(x), float)
275  assert pc.getMass(x) == 4
276 
277 
278 def test_getMomentum():
279  from MPCDAnalysis.Vector3DReal import Vector3DReal
280 
281  import pytest
282 
283 
284  pc = ParticleCollection()
285  with pytest.raises(IndexError):
286  pc.getMomentum(0)
287  with pytest.raises(IndexError):
288  pc.getMomentum(-1)
289 
290 
291  pc = ParticleCollection()
292  positions = []
293  velocities = []
294  for x in range(0, 5):
295  positions.append(Vector3DReal(0.5 * x, -0.5 + x, x * x / 2.0))
296  velocities.append(Vector3DReal(1.23 / (x + 1), x, -x))
297 
298  pc.setPositionsAndVelocities(positions, velocities)
299 
300  with pytest.raises(RuntimeError):
301  pc.getMomentum(0)
302 
303 
304  with pytest.raises(TypeError):
305  pc.getMomentum(0.0)
306  with pytest.raises(TypeError):
307  pc.getMomentum(0.0)
308 
309  with pytest.raises(IndexError):
310  pc.getMomentum(-1)
311  with pytest.raises(IndexError):
312  pc.getMomentum(pc.getParticleCount())
313  with pytest.raises(IndexError):
314  pc.getMomentum(pc.getParticleCount() + 1)
315 
316 
317  pc.setUniformMass(1.23)
318 
319  for x in range(0, pc.getParticleCount()):
320  assert isinstance(pc.getMomentum(x), Vector3DReal)
321  assert pc.getMomentum(x) == pc.getVelocity(x) * pc.getMass(x)
322  assert pc.getMomentum(x) == pc.getVelocity(x) * pc.getMass(x)
323 
324  pc.setPositionsAndVelocities(positions[:3], velocities[:3])
325  for x in range(0, pc.getParticleCount()):
326  assert isinstance(pc.getMomentum(x), Vector3DReal)
327  assert pc.getMomentum(x) == pc.getVelocity(x) * pc.getMass(x)
328  assert pc.getMomentum(x) == pc.getVelocity(x) * pc.getMass(x)
329 
330  pc.setPositionsAndVelocities(positions + velocities, velocities + positions)
331  for x in range(0, pc.getParticleCount()):
332  assert isinstance(pc.getMomentum(x), Vector3DReal)
333  assert pc.getMomentum(x) == pc.getVelocity(x) * pc.getMass(x)
334  assert pc.getMomentum(x) == pc.getVelocity(x) * pc.getMass(x)
335 
336  pc.setUniformMass(4.56)
337  for x in range(0, pc.getParticleCount()):
338  assert isinstance(pc.getMomentum(x), Vector3DReal)
339  assert pc.getMomentum(x) == pc.getVelocity(x) * pc.getMass(x)
340  assert pc.getMomentum(x) == pc.getVelocity(x) * pc.getMass(x)
341 
342 
343 def test_getCenterOfMass():
344  from MPCDAnalysis.Vector3DReal import Vector3DReal
345 
346  import pytest
347 
348 
349  pc = ParticleCollection()
350  with pytest.raises(RuntimeError):
351  pc.getCenterOfMass()
352 
353  positions = []
354  velocities = []
355  for x in range(0, 5):
356  positions.append(Vector3DReal(0.5 * x, -0.5 + x, x * x / 2.0))
357  velocities.append(Vector3DReal(1.23 / (x + 1), x, -x))
358 
359  pc.setPositionsAndVelocities(positions, velocities)
360 
361  with pytest.raises(RuntimeError):
362  pc.getCenterOfMass()
363 
364  mass = 1.23
365  pc.setUniformMass(mass)
366 
367  expected = Vector3DReal(0.0, 0.0, 0.0)
368  totalMass = 0.0
369  for position in positions:
370  expected += position * mass
371  totalMass += mass
372  expected /= totalMass
373 
374  assert isinstance(pc.getCenterOfMass(), Vector3DReal)
375  assert pc.getCenterOfMass() == expected
376  assert pc.getCenterOfMass() == expected
377 
378 
379 def test_getCenterOfPositions():
380  from MPCDAnalysis.Vector3DReal import Vector3DReal
381 
382  import pytest
383 
384 
385  pc = ParticleCollection()
386  with pytest.raises(RuntimeError):
387  pc.getCenterOfPositions()
388 
389  positions = []
390  velocities = []
391  for x in range(0, 5):
392  positions.append(Vector3DReal(0.5 * x, -0.5 + x, x * x / 2.0))
393  velocities.append(Vector3DReal(1.23 / (x + 1), x, -x))
394 
395  pc.setPositionsAndVelocities(positions, velocities)
396 
397  expected = Vector3DReal(0.0, 0.0, 0.0)
398  for position in positions:
399  expected += position
400  expected /= len(positions)
401 
402  assert isinstance(pc.getCenterOfPositions(), Vector3DReal)
403  assert pc.getCenterOfPositions() == expected
404  assert pc.getCenterOfPositions() == expected
405 
406 
407 def test_getCenterOfMassVelocity():
408  from MPCDAnalysis.Vector3DReal import Vector3DReal
409 
410  import pytest
411 
412 
413  pc = ParticleCollection()
414  with pytest.raises(RuntimeError):
415  pc.getCenterOfMassVelocity()
416 
417  positions = []
418  velocities = []
419  for x in range(0, 5):
420  positions.append(Vector3DReal(0.5 * x, -0.5 + x, x * x / 2.0))
421  velocities.append(Vector3DReal(1.23 / (x + 1), x, -x))
422 
423  pc.setPositionsAndVelocities(positions, velocities)
424 
425  with pytest.raises(RuntimeError):
426  pc.getCenterOfMassVelocity()
427 
428  mass = 1.23
429  pc.setUniformMass(mass)
430 
431  expected = Vector3DReal(0.0, 0.0, 0.0)
432  totalMass = 0.0
433  for velocity in velocities:
434  expected += velocity * mass
435  totalMass += mass
436  expected /= totalMass
437 
438  assert isinstance(pc.getCenterOfMassVelocity(), Vector3DReal)
439  assert pc.getCenterOfMassVelocity() == expected
440  assert pc.getCenterOfMassVelocity() == expected
441 
442 
443 def test_rotateAroundNormalizedAxis():
444  from MPCDAnalysis.Vector3DReal import Vector3DReal
445 
446  import pytest
447 
448  axis = Vector3DReal(1, 2, 3)
449  axis.normalize()
450  angle = -2.34
451 
452  pc = ParticleCollection()
453  pc.rotateAroundNormalizedAxis(axis, angle)
454 
455  with pytest.raises(TypeError):
456  pc.rotateAroundNormalizedAxis([1.0, 0.0, 0.0], angle)
457  with pytest.raises(TypeError):
458  pc.rotateAroundNormalizedAxis(axis, 1)
459  with pytest.raises(ValueError):
460  pc.rotateAroundNormalizedAxis(Vector3DReal(0, 0, 0), angle)
461 
462  positions = []
463  velocities = []
464  for x in range(0, 5):
465  positions.append(Vector3DReal(0.5 * x, -0.5 + x, x * x / 2.0))
466  velocities.append(Vector3DReal(1.23 / (x + 1), x, -x))
467 
468  pc.setPositionsAndVelocities(positions, velocities)
469 
470  pc.rotateAroundNormalizedAxis(axis, angle)
471 
472  for x in range(0, pc.getParticleCount()):
473  expectedPos = positions[x].getRotatedAroundNormalizedAxis(axis, angle)
474  expectedVel = velocities[x].getRotatedAroundNormalizedAxis(axis, angle)
475 
476  assert pc.getPosition(x) == expectedPos
477  assert pc.getPosition(x) == expectedPos
478 
479  assert pc.getVelocity(x) == expectedVel
480  assert pc.getVelocity(x) == expectedVel
481 
482 
483 def test_getGyrationTensor():
484  from MPCDAnalysis.Vector3DReal import Vector3DReal
485 
486  import numpy
487  import pytest
488 
489 
490  pc = ParticleCollection()
491  with pytest.raises(ValueError):
492  pc.getGyrationTensor()
493  with pytest.raises(ValueError):
494  pc.getGyrationTensor()
495 
496  particleCount = 5
497  positions = []
498  velocities = []
499  for x in range(0, particleCount):
500  positions.append(Vector3DReal(0.5 * x, -0.5 + x, x * x / 2.0))
501  velocities.append(Vector3DReal(1.23 / (x + 1), x, -x))
502 
503  pc.setPositionsAndVelocities(positions, velocities)
504 
505  expected = numpy.zeros((3, 3))
506  for m in range(0, 3):
507  for n in range(0, 3):
508  for i in range(0, len(positions)):
509  for j in range(0, len(positions)):
510  r1 = positions[i]
511  r2 = positions[j]
512  expected[m][n] += (r1[m] - r2[m]) * (r1[n] - r2[n])
513 
514  for i in range(0, 3):
515  for j in range(0, 3):
516  expected[i][j] /= (2 * particleCount * particleCount)
517 
518  S = pc.getGyrationTensor()
519  S2 = pc.getGyrationTensor()
520 
521  assert numpy.array_equal(S, S2)
522 
523  assert isinstance(S, numpy.ndarray)
524  assert S.shape == (3, 3)
525  for i in range(0, 3):
526  for j in range(0, 3):
527  assert S[i][j] == S[j][i]
528 
529  for i in range(0, 3):
530  for j in range(0, 3):
531  assert S[i][j] == pytest.approx(expected[i][j])
532 
533 
534 def test_getGyrationTensorPrincipalMoments():
535  from MPCDAnalysis.Vector3DReal import Vector3DReal
536 
537  import numpy
538  import pytest
539 
540 
541  pc = ParticleCollection()
542  with pytest.raises(ValueError):
543  pc.getGyrationTensor()
544  with pytest.raises(ValueError):
545  pc.getGyrationTensor()
546 
547  particleCount = 5
548  positions = []
549  velocities = []
550  for x in range(0, particleCount):
551  positions.append(Vector3DReal(0.5 * x, -0.5 + x, x * x / 2.0))
552  velocities.append(Vector3DReal(1.23 / (x + 1), x, -x))
553 
554  pc.setPositionsAndVelocities(positions, velocities)
555 
556  eigensystem = pc.getGyrationTensorEigensystem()
557 
558  eigenvalues1 = pc.getGyrationTensorPrincipalMoments()
559  eigenvalues2 = pc.getGyrationTensorPrincipalMoments()
560 
561  for eigenvalues in [eigenvalues1, eigenvalues2]:
562  assert isinstance(eigenvalues, list)
563  assert len(eigenvalues) == 3
564 
565  for i in range(0, 3):
566  assert isinstance(eigenvalues[i], numpy.float64)
567  assert numpy.isreal(eigenvalues[i])
568 
569  assert eigenvalues[i] == eigensystem[i][0]
570 
571 
572 def test_getGyrationTensorEigensystem():
573  from MPCDAnalysis.Vector3DReal import Vector3DReal
574 
575  import numpy
576  import pytest
577 
578 
579  pc = ParticleCollection()
580  with pytest.raises(ValueError):
581  pc.getGyrationTensor()
582  with pytest.raises(ValueError):
583  pc.getGyrationTensor()
584 
585  particleCount = 5
586  positions = []
587  velocities = []
588  for x in range(0, particleCount):
589  positions.append(Vector3DReal(0.5 * x, -0.5 + x, x * x / 2.0))
590  velocities.append(Vector3DReal(1.23 / (x + 1), x, -x))
591 
592  pc.setPositionsAndVelocities(positions, velocities)
593 
594  eigensystem1 = pc.getGyrationTensorEigensystem()
595  eigensystem2 = pc.getGyrationTensorEigensystem()
596 
597  gyrationTensor = pc.getGyrationTensor()
598 
599  for eigensystem in [eigensystem1, eigensystem2]:
600  assert isinstance(eigensystem, list)
601  assert len(eigensystem) == 3
602 
603  previous = None
604  for eigenpair in eigensystem:
605  assert isinstance(eigenpair, list)
606  assert len(eigenpair) == 2
607 
608  eigenvalue = eigenpair[0]
609  eigenvector = eigenpair[1]
610 
611  assert numpy.isreal(eigenvalue)
612  assert isinstance(eigenvalue, numpy.float64)
613 
614  if previous is None:
615  previous = eigenvalue
616  else:
617  assert previous < eigenvalue
618  previous = eigenvalue
619 
620  assert eigenvector.shape == (3,)
621  for i in range(0, 3):
622  assert isinstance(eigenvector[i], numpy.float64)
623 
624 
625  Sv = gyrationTensor.dot(eigenvector)
626  lambda_v = eigenvalue * eigenvector
627 
628  for i in range(0, 3):
629  assert Sv[i] == pytest.approx(lambda_v[i])
630 
631 
632 def test___eq__():
633  pc1 = ParticleCollection()
634  pc2 = ParticleCollection()
635 
636  assert pc1 == pc1
637  assert pc1 == pc2
638  assert pc2 == pc2
639  assert pc2 == pc1
640 
641 
642  pc1.setUniformMass(1.0)
643 
644  assert pc1 == pc1
645  assert not pc1 == pc2
646  assert not pc2 == pc1
647  assert pc2 == pc2
648 
649  pc2.setUniformMass(1.0)
650 
651  assert pc1 == pc1
652  assert pc1 == pc2
653  assert pc2 == pc2
654  assert pc2 == pc1
655 
656 
657  from MPCDAnalysis.Vector3DReal import Vector3DReal
658  v1 = Vector3DReal(0, 1, 2)
659  v2 = Vector3DReal(0.1, -1, 2.4)
660 
661  pc1.setPositionsAndVelocities([v1], [v2])
662  assert pc1 == pc1
663  assert not pc1 == pc2
664  assert not pc2 == pc1
665  assert pc2 == pc2
666 
667  pc2.setPositionsAndVelocities([v1], [v2])
668  assert pc1 == pc1
669  assert pc1 == pc2
670  assert pc2 == pc2
671  assert pc2 == pc1
672 
673 
674  pc1.setPositionsAndVelocities([v1, v2], [v1, v2])
675  assert pc1 == pc1
676  assert not pc1 == pc2
677  assert not pc2 == pc1
678  assert pc2 == pc2
679 
680  pc2.setPositionsAndVelocities([v1], [v1])
681  assert pc1 == pc1
682  assert not pc1 == pc2
683  assert not pc2 == pc1
684  assert pc2 == pc2
685 
686  pc2.setPositionsAndVelocities([v1, v2], [v1, v2])
687  assert pc1 == pc1
688  assert pc1 == pc2
689  assert pc2 == pc2
690  assert pc2 == pc1
691 
692 
693  pc2.setPositionsAndVelocities([v1, v2], [v1, v1])
694  assert pc1 == pc1
695  assert not pc1 == pc2
696  assert not pc2 == pc1
697  assert pc2 == pc2
698 
699 
700  pc2.setPositionsAndVelocities([v1, v1], [v1, v2])
701  assert pc1 == pc1
702  assert not pc1 == pc2
703  assert not pc2 == pc1
704  assert pc2 == pc2
705 
706 
707  pc1.setUniformMass(0.1)
708  assert pc1 == pc1
709  assert not pc1 == pc2
710  assert not pc2 == pc1
711  assert pc2 == pc2
712 
713 
714 def test___ne__():
715  pc1 = ParticleCollection()
716  pc2 = ParticleCollection()
717 
718  assert not pc1 != pc1
719  assert not pc1 != pc2
720  assert not pc2 != pc2
721  assert not pc2 != pc1
722 
723 
724  pc1.setUniformMass(1.0)
725 
726  assert not pc1 != pc1
727  assert pc1 != pc2
728  assert pc2 != pc1
729  assert not pc2 != pc2
730 
731  pc2.setUniformMass(1.0)
732 
733  assert not pc1 != pc1
734  assert not pc1 != pc2
735  assert not pc2 != pc2
736  assert not pc2 != pc1
737 
738 
739  from MPCDAnalysis.Vector3DReal import Vector3DReal
740  v1 = Vector3DReal(0, 1, 2)
741  v2 = Vector3DReal(0.1, -1, 2.4)
742 
743  pc1.setPositionsAndVelocities([v1], [v2])
744  assert not pc1 != pc1
745  assert pc1 != pc2
746  assert pc2 != pc1
747  assert not pc2 != pc2
748 
749  pc2.setPositionsAndVelocities([v1], [v2])
750  assert not pc1 != pc1
751  assert not pc1 != pc2
752  assert not pc2 != pc2
753  assert not pc2 != pc1
754 
755 
756  pc1.setPositionsAndVelocities([v1, v2], [v1, v2])
757  assert pc1 == pc1
758  assert not pc1 == pc2
759  assert not pc2 == pc1
760  assert pc2 == pc2
761 
762  pc2.setPositionsAndVelocities([v1], [v1])
763  assert pc1 == pc1
764  assert not pc1 == pc2
765  assert not pc2 == pc1
766  assert pc2 == pc2
767 
768  pc2.setPositionsAndVelocities([v1, v2], [v1, v2])
769  assert pc1 == pc1
770  assert pc1 == pc2
771  assert pc2 == pc2
772  assert pc2 == pc1
773 
774 
775  pc2.setPositionsAndVelocities([v1, v2], [v1, v1])
776  assert not pc1 != pc1
777  assert pc1 != pc2
778  assert pc2 != pc1
779  assert not pc2 != pc2
780 
781 
782  pc2.setPositionsAndVelocities([v1, v1], [v1, v2])
783  assert not pc1 != pc1
784  assert pc1 != pc2
785  assert pc2 != pc1
786  assert not pc2 != pc2
787 
788 
789  pc1.setUniformMass(0.1)
790  assert pc1 == pc1
791  assert not pc1 == pc2
792  assert not pc2 == pc1
793  assert pc2 == pc2
MPCDAnalysis.ParticleCollection
Definition: ParticleCollection.py:1
MPCDAnalysis.Vector3DReal
Definition: Vector3DReal.py:1
Generated by   doxygen 1.8.17