test/unit/test_particle_group.cc

   1 /*
   2 Highly Optimized Object-oriented Many-particle Dynamics -- Blue Edition
   3 (HOOMD-blue) Open Source Software License Copyright 2009-2014 The Regents of
   4 the University of Michigan All rights reserved.
   5
   6 HOOMD-blue may contain modifications ("Contributions") provided, and to which
   7 copyright is held, by various Contributors who have granted The Regents of the
   8 University of Michigan the right to modify and/or distribute such Contributions.
   9
  10 You may redistribute, use, and create derivate works of HOOMD-blue, in source
  11 and binary forms, provided you abide by the following conditions:
  12
  13 * Redistributions of source code must retain the above copyright notice, this
  14 list of conditions, and the following disclaimer both in the code and
  15 prominently in any materials provided with the distribution.
  16
  17 * Redistributions in binary form must reproduce the above copyright notice, this
  18 list of conditions, and the following disclaimer in the documentation and/or
  19 other materials provided with the distribution.
  20
  21 * All publications and presentations based on HOOMD-blue, including any reports
  22 or published results obtained, in whole or in part, with HOOMD-blue, will
  23 acknowledge its use according to the terms posted at the time of submission on:
  24 http://codeblue.umich.edu/hoomd-blue/citations.html
  25
  26 * Any electronic documents citing HOOMD-Blue will link to the HOOMD-Blue website:
  27 http://codeblue.umich.edu/hoomd-blue/
  28
  29 * Apart from the above required attributions, neither the name of the copyright
  30 holder nor the names of HOOMD-blue's contributors may be used to endorse or
  31 promote products derived from this software without specific prior written
  32 permission.
  33
  34 Disclaimer
  35
  36 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS'' AND
  37 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  38 WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND/OR ANY
  39 WARRANTIES THAT THIS SOFTWARE IS FREE OF INFRINGEMENT ARE DISCLAIMED.
  40
  41 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  42 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  43 BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  44 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  45 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  46 OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  47 ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  48 */
  49
  50
  51 /*! \file particle_group_test.cc
  52     \brief Unit tests for ParticleGroup
  53     \ingroup unit_tests
  54 */
  55
  56 #ifdef WIN32
  57 #pragma warning( push )
  58 #pragma warning( disable : 4103 4244 )
  59 #endif
  60
  61 #include <iostream>
  62
  63 #include "ParticleData.h"
  64 #include "Initializers.h"
  65 #include "ParticleGroup.h"
  66 #include "RigidBodyGroup.h"
  67
  68 using namespace std;
  69 using namespace boost;
  70
  71 //! Name the boost unit test module
  72 #define BOOST_TEST_MODULE ParticleGroupTests
  73 #include "boost_utf_configure.h"
  74
  75 //! initializes the particle data used by the tests
  76 boost::shared_ptr<SystemDefinition> create_sysdef()
  77     {
  78     // initialize a box with 10 particles of 4 groups
  79     BoxDim box(10.0);
  80     boost::shared_ptr<SystemDefinition> sysdef(new SystemDefinition(10, box, 4));
  81     boost::shared_ptr<ParticleData> pdata = sysdef->getParticleData();
  82
  83     // set the types
  84     // currently, the position is only set on the first 3 particles, intended for use in the total and center of mass
  85     // tests. Later, other particles will be added to test the new particle data selectors
  86     {
  87     ArrayHandle<Scalar4> h_pos(pdata->getPositions(), access_location::host, access_mode::readwrite);
  88     ArrayHandle<Scalar4> h_vel(pdata->getVelocities(), access_location::host, access_mode::readwrite);
  89     ArrayHandle<int3> h_image(pdata->getImages(), access_location::host, access_mode::readwrite);
  90     ArrayHandle<unsigned int> h_body(pdata->getBodies(), access_location::host, access_mode::readwrite);
  91
  92     h_pos.data[0].w = __int_as_scalar(0);
  93     h_pos.data[0].x = Scalar(0.0); h_pos.data[0].y = Scalar(0.0); h_pos.data[0].z = Scalar(0.0);
  94     h_image.data[0].x = 0; h_image.data[0].y = 0; h_image.data[0].z = 0;
  95     h_vel.data[0].w = Scalar(1.0); //mass
  96     h_body.data[0] = 0;
  97
  98     h_pos.data[1].w = __int_as_scalar(2);
  99     h_pos.data[1].x = Scalar(1.0); h_pos.data[1].y = Scalar(2.0); h_pos.data[1].z = Scalar(3.0);
 100     h_image.data[1].x = 1; h_image.data[1].y = -1; h_image.data[1].z = 2;
 101     h_vel.data[1].w = Scalar(2.0);
 102     h_body.data[1] = 0;
 103
 104     h_pos.data[2].w = __int_as_scalar(0);
 105     h_pos.data[2].x = Scalar(-1.0); h_pos.data[2].y = Scalar(-2.0); h_pos.data[2].z = Scalar(-3.0);
 106     h_image.data[2].x = 0; h_image.data[2].y = 0; h_image.data[2].z = 0;
 107     h_vel.data[2].w = Scalar(5.0);
 108     h_body.data[2] = 1;
 109
 110     h_pos.data[3].w = __int_as_scalar(1);
 111     h_pos.data[3].x = Scalar(-4.0); h_pos.data[3].y = Scalar(-4.0); h_pos.data[3].z = Scalar(-4.0);
 112     h_body.data[3] = 1;
 113
 114     h_pos.data[4].w = __int_as_scalar(3);
 115     h_pos.data[4].x = Scalar(-3.5); h_pos.data[4].y = Scalar(-4.5); h_pos.data[4].z = Scalar(-5.0);
 116
 117     h_pos.data[5].w = __int_as_scalar(0);
 118     h_pos.data[5].x = Scalar(-5.0); h_pos.data[5].y = Scalar(-4.5); h_pos.data[5].z = Scalar(-3.5);
 119
 120     h_pos.data[6].w = __int_as_scalar(1);
 121     h_pos.data[6].x = Scalar(4.0); h_pos.data[6].y = Scalar(4.0); h_pos.data[6].z = Scalar(4.0);
 122
 123     h_pos.data[7].w = __int_as_scalar(2);
 124     h_pos.data[7].x = Scalar(3.5); h_pos.data[7].y = Scalar(4.5); h_pos.data[7].z = Scalar(-5.0);
 125
 126     h_pos.data[8].w = __int_as_scalar(0);
 127     h_pos.data[8].x = Scalar(5.0); h_pos.data[8].y = Scalar(4.5); h_pos.data[8].z = Scalar(3.5);
 128
 129     h_pos.data[9].w = __int_as_scalar(3);
 130     h_pos.data[9].x = Scalar(5.0); h_pos.data[9].y = Scalar(5.0); h_pos.data[9].z = Scalar(5.0);
 131     }
 132
 133     sysdef->getRigidData()->initializeData();
 134     return sysdef;
 135     }
 136
 137 //! Checks that ParticleGroup can sucessfully initialize
 138 BOOST_AUTO_TEST_CASE( ParticleGroup_basic_test )
 139     {
 140     boost::shared_ptr<SystemDefinition> sysdef = create_sysdef();
 141     boost::shared_ptr<ParticleData> pdata = sysdef->getParticleData();
 142
 143     // create an empty group
 144     ParticleGroup a;
 145     // copy construct it
 146     ParticleGroup b(a);
 147     // copy it
 148     ParticleGroup c;
 149     c = a;
 150     }
 151
 152 //! Test copy and equals operators
 153 BOOST_AUTO_TEST_CASE( ParticleGroup_copy_test )
 154     {
 155     boost::shared_ptr<SystemDefinition> sysdef = create_sysdef();
 156     boost::shared_ptr<ParticleData> pdata = sysdef->getParticleData();
 157
 158     // create another particle group of all particles
 159     boost::shared_ptr<ParticleSelector> selector_all(new ParticleSelectorTag(sysdef, 0, pdata->getN()-1));
 160     ParticleGroup tags_all(sysdef, selector_all);
 161     // verify it
 162     BOOST_CHECK_EQUAL_UINT(tags_all.getNumMembers(), pdata->getN());
 163     BOOST_CHECK_EQUAL_UINT(tags_all.getIndexArray().getNumElements(), pdata->getN());
 164     for (unsigned int i = 0; i < pdata->getN(); i++)
 165         {
 166         BOOST_CHECK_EQUAL_UINT(tags_all.getMemberTag(i), i);
 167         BOOST_CHECK_EQUAL_UINT(tags_all.getMemberIndex(i), i);
 168         BOOST_CHECK(tags_all.isMember(i));
 169         }
 170
 171     // copy construct it
 172     ParticleGroup copy1(tags_all);
 173     // verify it
 174     BOOST_CHECK_EQUAL_UINT(copy1.getNumMembers(), pdata->getN());
 175     BOOST_CHECK_EQUAL_UINT(copy1.getIndexArray().getNumElements(), pdata->getN());
 176     for (unsigned int i = 0; i < pdata->getN(); i++)
 177         {
 178         BOOST_CHECK_EQUAL_UINT(copy1.getMemberTag(i), i);
 179         BOOST_CHECK_EQUAL_UINT(copy1.getMemberIndex(i), i);
 180         BOOST_CHECK(copy1.isMember(i));
 181         }
 182
 183     // copy it
 184     ParticleGroup copy2;
 185     copy2 = copy1;
 186     // verify it
 187     BOOST_CHECK_EQUAL_UINT(copy2.getNumMembers(), pdata->getN());
 188     BOOST_CHECK_EQUAL_UINT(copy2.getIndexArray().getNumElements(), pdata->getN());
 189     for (unsigned int i = 0; i < pdata->getN(); i++)
 190         {
 191         BOOST_CHECK_EQUAL_UINT(copy2.getMemberTag(i), i);
 192         BOOST_CHECK_EQUAL_UINT(copy2.getMemberIndex(i), i);
 193         BOOST_CHECK(copy2.isMember(i));
 194         }
 195     }
 196
 197 //! Checks that ParticleGroup can sucessfully handle particle resorts
 198 BOOST_AUTO_TEST_CASE( ParticleGroup_sort_test )
 199     {
 200     boost::shared_ptr<SystemDefinition> sysdef = create_sysdef();
 201     boost::shared_ptr<ParticleData> pdata = sysdef->getParticleData();
 202
 203     boost::shared_ptr<ParticleSelector> selector04(new ParticleSelectorTag(sysdef, 0, 4));
 204     ParticleGroup tags04(sysdef, selector04);
 205     // verify the initial set
 206     BOOST_CHECK_EQUAL_UINT(tags04.getNumMembers(), 5);
 207     BOOST_CHECK_EQUAL_UINT(tags04.getIndexArray().getNumElements(), 5);
 208     for (unsigned int i = 0; i < 5; i++)
 209         {
 210         BOOST_CHECK_EQUAL_UINT(tags04.getMemberTag(i), i);
 211         BOOST_CHECK_EQUAL_UINT(tags04.getMemberIndex(i), i);
 212         }
 213
 214     for (unsigned int i = 0; i < pdata->getN(); i++)
 215         {
 216         if (i <= 4)
 217             BOOST_CHECK(tags04.isMember(i));
 218         else
 219             BOOST_CHECK(!tags04.isMember(i));
 220         }
 221
 222     // resort the particles
 223     {
 224     ArrayHandle<unsigned int> h_tag(pdata->getTags(), access_location::host, access_mode::readwrite);
 225     ArrayHandle<unsigned int> h_rtag(pdata->getRTags(), access_location::host, access_mode::readwrite);
 226
 227     // set the types
 228     h_tag.data[0] = 9;
 229     h_tag.data[1] = 8;
 230     h_tag.data[2] = 7;
 231     h_tag.data[3] = 6;
 232     h_tag.data[4] = 5;
 233     h_tag.data[5] = 4;
 234     h_tag.data[6] = 3;
 235     h_tag.data[7] = 2;
 236     h_tag.data[8] = 1;
 237     h_tag.data[9] = 0;
 238
 239     h_rtag.data[0] = 9;
 240     h_rtag.data[1] = 8;
 241     h_rtag.data[2] = 7;
 242     h_rtag.data[3] = 6;
 243     h_rtag.data[4] = 5;
 244     h_rtag.data[5] = 4;
 245     h_rtag.data[6] = 3;
 246     h_rtag.data[7] = 2;
 247     h_rtag.data[8] = 1;
 248     h_rtag.data[9] = 0;
 249     }
 250
 251     pdata->notifyParticleSort();
 252
 253     // verify that the group has updated
 254     BOOST_CHECK_EQUAL_UINT(tags04.getNumMembers(), 5);
 255     BOOST_CHECK_EQUAL_UINT(tags04.getIndexArray().getNumElements(), 5);
 256     for (unsigned int i = 0; i < 5; i++)
 257         {
 258         BOOST_CHECK_EQUAL_UINT(tags04.getMemberTag(i), i);
 259         // indices are in sorted order (tags 0-4 are particles 9-5)
 260         BOOST_CHECK_EQUAL_UINT(tags04.getMemberIndex(i), i + 5);
 261         }
 262     {
 263     ArrayHandle<unsigned int> h_tag(pdata->getTags(), access_location::host, access_mode::readwrite);
 264     for (unsigned int i = 0; i < pdata->getN(); i++)
 265         {
 266         if (h_tag.data[i] <= 4)
 267             BOOST_CHECK(tags04.isMember(i));
 268         else
 269             BOOST_CHECK(!tags04.isMember(i));
 270         }
 271     }
 272     }
 273
 274 //! Checks that ParticleGroup can initialize by particle type
 275 BOOST_AUTO_TEST_CASE( ParticleGroup_type_test )
 276     {
 277     boost::shared_ptr<SystemDefinition> sysdef = create_sysdef();
 278     boost::shared_ptr<ParticleData> pdata = sysdef->getParticleData();
 279
 280     // create a group of type 0 and check it
 281     boost::shared_ptr<ParticleSelector> selector0(new ParticleSelectorType(sysdef, 0, 0));
 282     ParticleGroup type0(sysdef, selector0);
 283     BOOST_REQUIRE_EQUAL_UINT(type0.getNumMembers(), 4);
 284     BOOST_CHECK_EQUAL_UINT(type0.getIndexArray().getNumElements(), 4);
 285
 286     BOOST_CHECK_EQUAL_UINT(type0.getMemberTag(0), 0);
 287     BOOST_CHECK_EQUAL_UINT(type0.getMemberTag(1), 2);
 288     BOOST_CHECK_EQUAL_UINT(type0.getMemberTag(2), 5);
 289     BOOST_CHECK_EQUAL_UINT(type0.getMemberTag(3), 8);
 290
 291     // create a group of type 1 and check it
 292     boost::shared_ptr<ParticleSelector> selector1(new ParticleSelectorType(sysdef, 1, 1));
 293     ParticleGroup type1(sysdef, selector1);
 294     BOOST_REQUIRE_EQUAL_UINT(type1.getNumMembers(), 2);
 295     BOOST_CHECK_EQUAL_UINT(type1.getIndexArray().getNumElements(), 2);
 296     BOOST_CHECK_EQUAL_UINT(type1.getMemberTag(0), 3);
 297     BOOST_CHECK_EQUAL_UINT(type1.getMemberTag(1), 6);
 298
 299     // create a group of type 2 and check it
 300     boost::shared_ptr<ParticleSelector> selector2(new ParticleSelectorType(sysdef, 2, 2));
 301     ParticleGroup type2(sysdef, selector2);
 302     BOOST_REQUIRE_EQUAL_UINT(type2.getNumMembers(), 2);
 303     BOOST_CHECK_EQUAL_UINT(type2.getIndexArray().getNumElements(), 2);
 304     BOOST_CHECK_EQUAL_UINT(type2.getMemberTag(0), 1);
 305     BOOST_CHECK_EQUAL_UINT(type2.getMemberTag(1), 7);
 306
 307     // create a group of type 3 and check it
 308     boost::shared_ptr<ParticleSelector> selector3(new ParticleSelectorType(sysdef, 3, 3));
 309     ParticleGroup type3(sysdef, selector3);
 310     BOOST_REQUIRE_EQUAL_UINT(type3.getNumMembers(), 2);
 311     BOOST_CHECK_EQUAL_UINT(type3.getIndexArray().getNumElements(), 2);
 312     BOOST_CHECK_EQUAL_UINT(type3.getMemberTag(0), 4);
 313     BOOST_CHECK_EQUAL_UINT(type3.getMemberTag(1), 9);
 314
 315     // create a group of all types and check it
 316     boost::shared_ptr<ParticleSelector> selector_all(new ParticleSelectorType(sysdef, 0, 3));
 317     ParticleGroup alltypes(sysdef, selector_all);
 318     BOOST_REQUIRE_EQUAL_UINT(alltypes.getNumMembers(), 10);
 319     BOOST_CHECK_EQUAL_UINT(alltypes.getIndexArray().getNumElements(), 10);
 320     for (unsigned int i = 0; i < 10; i++)
 321         BOOST_CHECK_EQUAL_UINT(alltypes.getMemberTag(i), i);
 322     }
 323
 324 //! Checks that ParticleGroup can initialize to the empty set
 325 BOOST_AUTO_TEST_CASE( ParticleGroup_empty_test )
 326     {
 327     boost::shared_ptr<SystemDefinition> sysdef = create_sysdef();
 328     boost::shared_ptr<ParticleData> pdata = sysdef->getParticleData();
 329
 330     // create a group of type 100 and check it
 331     boost::shared_ptr<ParticleSelector> selector100(new ParticleSelectorType(sysdef, 100, 100));
 332     ParticleGroup empty(sysdef, selector100);
 333     BOOST_REQUIRE_EQUAL_UINT(empty.getNumMembers(), 0);
 334     BOOST_CHECK_EQUAL_UINT(empty.getIndexArray().getNumElements(), 0);
 335     }
 336
 337 //! Checks that ParticleGroup can initialize by particle body
 338 BOOST_AUTO_TEST_CASE( ParticleGroup_body_test )
 339     {
 340     boost::shared_ptr<SystemDefinition> sysdef = create_sysdef();
 341     boost::shared_ptr<ParticleData> pdata = sysdef->getParticleData();
 342
 343     // create a group of rigid bodies and check it
 344     boost::shared_ptr<ParticleSelector> selector_body_true(new ParticleSelectorRigid(sysdef, true));
 345     ParticleGroup type_true(sysdef, selector_body_true);
 346     BOOST_REQUIRE_EQUAL_UINT(type_true.getNumMembers(), 4);
 347     BOOST_CHECK_EQUAL_UINT(type_true.getMemberTag(0), 0);
 348     BOOST_CHECK_EQUAL_UINT(type_true.getMemberTag(1), 1);
 349     BOOST_CHECK_EQUAL_UINT(type_true.getMemberTag(2), 2);
 350     BOOST_CHECK_EQUAL_UINT(type_true.getMemberTag(3), 3);
 351
 352     // create a group of non rigid particles and check it
 353     boost::shared_ptr<ParticleSelector> selector_body_false(new ParticleSelectorRigid(sysdef, false));
 354     ParticleGroup type_false(sysdef, selector_body_false);
 355     BOOST_REQUIRE_EQUAL_UINT(type_false.getNumMembers(), 6);
 356     BOOST_CHECK_EQUAL_UINT(type_false.getMemberTag(0), 4);
 357     BOOST_CHECK_EQUAL_UINT(type_false.getMemberTag(1), 5);
 358     BOOST_CHECK_EQUAL_UINT(type_false.getMemberTag(2), 6);
 359     BOOST_CHECK_EQUAL_UINT(type_false.getMemberTag(3), 7);
 360     BOOST_CHECK_EQUAL_UINT(type_false.getMemberTag(4), 8);
 361     BOOST_CHECK_EQUAL_UINT(type_false.getMemberTag(5), 9);
 362     }
 363
 364 //! Checks that RigidBodyGroup can successfully initialize when given all bodies
 365 BOOST_AUTO_TEST_CASE( RigidBodyGroup_all_test )
 366     {
 367     boost::shared_ptr<SystemDefinition> sysdef = create_sysdef();
 368     boost::shared_ptr<ParticleData> pdata = sysdef->getParticleData();
 369
 370     // create a group of rigid bodies and check it
 371     boost::shared_ptr<ParticleSelector> selector_body_true(new ParticleSelectorRigid(sysdef, true));
 372     boost::shared_ptr<ParticleGroup> body_true(new ParticleGroup(sysdef, selector_body_true));
 373
 374     // create a rigid body group
 375     RigidBodyGroup body_group(sysdef, body_true);
 376     BOOST_CHECK_EQUAL_UINT(body_group.getNumMembers(), 2);
 377     BOOST_CHECK(body_group.isMember(0));
 378     BOOST_CHECK(body_group.isMember(1));
 379
 380     ArrayHandle<unsigned int> h_member_idx(body_group.getIndexArray(), access_location::host, access_mode::read);
 381     BOOST_CHECK_EQUAL_UINT(body_group.getIndexArray().getNumElements(), 2);
 382     BOOST_CHECK_EQUAL_UINT(h_member_idx.data[0], 0);
 383     BOOST_CHECK_EQUAL_UINT(h_member_idx.data[1], 1);
 384     }
 385
 386 //! Checks that RigidBodyGroup can successfully initialize when given all bodies
 387 BOOST_AUTO_TEST_CASE( RigidBodyGroup_one_test )
 388     {
 389     boost::shared_ptr<SystemDefinition> sysdef = create_sysdef();
 390     boost::shared_ptr<ParticleData> pdata = sysdef->getParticleData();
 391
 392     // create a group of rigid bodies and check it
 393     boost::shared_ptr<ParticleSelector> selector_body(new ParticleSelectorTag(sysdef, 2, 3));
 394     boost::shared_ptr<ParticleGroup> body_particles(new ParticleGroup(sysdef, selector_body));
 395
 396     // create a rigid body group
 397     RigidBodyGroup body_group(sysdef, body_particles);
 398     BOOST_CHECK_EQUAL_UINT(body_group.getNumMembers(), 1);
 399     BOOST_CHECK(!body_group.isMember(0));
 400     BOOST_CHECK(body_group.isMember(1));
 401
 402     ArrayHandle<unsigned int> h_member_idx(body_group.getIndexArray(), access_location::host, access_mode::read);
 403     BOOST_CHECK_EQUAL_UINT(body_group.getIndexArray().getNumElements(), 1);
 404     BOOST_CHECK_EQUAL_UINT(h_member_idx.data[0], 1);
 405     }
 406
 407
 408 //! Checks that ParticleGroup can initialize by particle tag
 409 BOOST_AUTO_TEST_CASE( ParticleGroup_tag_test )
 410     {
 411     boost::shared_ptr<SystemDefinition> sysdef = create_sysdef();
 412     boost::shared_ptr<ParticleData> pdata = sysdef->getParticleData();
 413
 414     // create a group of tags 0-4 and check it
 415     boost::shared_ptr<ParticleSelector> selector04(new ParticleSelectorTag(sysdef, 0, 4));
 416     ParticleGroup tags05(sysdef, selector04);
 417     BOOST_REQUIRE_EQUAL_UINT(tags05.getNumMembers(), 5);
 418     BOOST_CHECK_EQUAL_UINT(tags05.getIndexArray().getNumElements(), 5);
 419     BOOST_CHECK_EQUAL_UINT(tags05.getMemberTag(0), 0);
 420     BOOST_CHECK_EQUAL_UINT(tags05.getMemberTag(1), 1);
 421     BOOST_CHECK_EQUAL_UINT(tags05.getMemberTag(2), 2);
 422     BOOST_CHECK_EQUAL_UINT(tags05.getMemberTag(3), 3);
 423     BOOST_CHECK_EQUAL_UINT(tags05.getMemberTag(4), 4);
 424
 425     // create a group of tags 5-9 and check it
 426     boost::shared_ptr<ParticleSelector> selector59(new ParticleSelectorTag(sysdef, 5, 9));
 427     ParticleGroup tags59(sysdef, selector59);
 428     BOOST_REQUIRE_EQUAL_UINT(tags59.getNumMembers(), 5);
 429     BOOST_CHECK_EQUAL_UINT(tags59.getIndexArray().getNumElements(), 5);
 430     BOOST_CHECK_EQUAL_UINT(tags59.getMemberTag(0), 5);
 431     BOOST_CHECK_EQUAL_UINT(tags59.getMemberTag(1), 6);
 432     BOOST_CHECK_EQUAL_UINT(tags59.getMemberTag(2), 7);
 433     BOOST_CHECK_EQUAL_UINT(tags59.getMemberTag(3), 8);
 434     BOOST_CHECK_EQUAL_UINT(tags59.getMemberTag(4), 9);
 435     }
 436
 437 //! Checks that ParticleGroup can initialize by cuboid
 438 BOOST_AUTO_TEST_CASE( ParticleGroup_cuboid_test )
 439     {
 440     boost::shared_ptr<SystemDefinition> sysdef = create_sysdef();
 441     boost::shared_ptr<ParticleData> pdata = sysdef->getParticleData();
 442
 443     // create a group containing only particle 0
 444     boost::shared_ptr<ParticleSelector> selector0(new ParticleSelectorCuboid(sysdef,
 445                                                                       make_scalar3(-0.5, -0.5, -0.5),
 446                                                                       make_scalar3( 0.5,  0.5,  0.5)));
 447     ParticleGroup tags0(sysdef, selector0);
 448     BOOST_REQUIRE_EQUAL_UINT(tags0.getNumMembers(), 1);
 449     BOOST_CHECK_EQUAL_UINT(tags0.getIndexArray().getNumElements(), 1);
 450     BOOST_CHECK_EQUAL_UINT(tags0.getMemberTag(0), 0);
 451
 452     // create a group containing particles 0 and 1
 453     boost::shared_ptr<ParticleSelector> selector1(new ParticleSelectorCuboid(sysdef,
 454                                                                       make_scalar3(-0.5, -0.5, -0.5),
 455                                                                       make_scalar3( 1.5,  2.5,  3.5)));
 456     ParticleGroup tags1(sysdef, selector1);
 457     BOOST_REQUIRE_EQUAL_UINT(tags1.getNumMembers(), 2);
 458     BOOST_CHECK_EQUAL_UINT(tags1.getIndexArray().getNumElements(), 2);
 459     BOOST_CHECK_EQUAL_UINT(tags1.getMemberTag(0), 0);
 460     BOOST_CHECK_EQUAL_UINT(tags1.getMemberTag(1), 1);
 461
 462     // create a group containing particles 0, 1 and 2
 463     boost::shared_ptr<ParticleSelector> selector2(new ParticleSelectorCuboid(sysdef,
 464                                                                       make_scalar3(-1.5, -2.5, -3.5),
 465                                                                       make_scalar3( 1.5,  2.5,  3.5)));
 466     ParticleGroup tags2(sysdef, selector2);
 467     BOOST_REQUIRE_EQUAL_UINT(tags2.getNumMembers(), 3);
 468     BOOST_CHECK_EQUAL_UINT(tags2.getIndexArray().getNumElements(), 3);
 469     BOOST_CHECK_EQUAL_UINT(tags2.getMemberTag(0), 0);
 470     BOOST_CHECK_EQUAL_UINT(tags2.getMemberTag(1), 1);
 471     BOOST_CHECK_EQUAL_UINT(tags2.getMemberTag(2), 2);
 472     }
 473
 474 //! Checks that the ParticleGroup boolean operation work correctly
 475 BOOST_AUTO_TEST_CASE( ParticleGroup_boolean_tests)
 476     {
 477     boost::shared_ptr<SystemDefinition> sysdef = create_sysdef();
 478     boost::shared_ptr<ParticleData> pdata = sysdef->getParticleData();
 479
 480     // create a group of tags 0-4
 481     boost::shared_ptr<ParticleSelector> selector04(new ParticleSelectorTag(sysdef, 0, 4));
 482     boost::shared_ptr<ParticleGroup> tags04(new ParticleGroup(sysdef, selector04));
 483
 484     // create a group of type 0
 485     boost::shared_ptr<ParticleSelector> selector0(new ParticleSelectorType(sysdef, 0, 0));
 486     boost::shared_ptr<ParticleGroup> type0(new ParticleGroup(sysdef, selector0));
 487
 488     // make a union of the two groups and check it
 489     boost::shared_ptr<ParticleGroup> union_group = ParticleGroup::groupUnion(type0, tags04);
 490     BOOST_REQUIRE_EQUAL_UINT(union_group->getNumMembers(), 7);
 491     BOOST_CHECK_EQUAL_UINT(union_group->getIndexArray().getNumElements(), 7);
 492     BOOST_CHECK_EQUAL_UINT(union_group->getMemberTag(0), 0);
 493     BOOST_CHECK_EQUAL_UINT(union_group->getMemberTag(1), 1);
 494     BOOST_CHECK_EQUAL_UINT(union_group->getMemberTag(2), 2);
 495     BOOST_CHECK_EQUAL_UINT(union_group->getMemberTag(3), 3);
 496     BOOST_CHECK_EQUAL_UINT(union_group->getMemberTag(4), 4);
 497     BOOST_CHECK_EQUAL_UINT(union_group->getMemberTag(5), 5);
 498     BOOST_CHECK_EQUAL_UINT(union_group->getMemberTag(6), 8);
 499
 500     // make a intersection group and test it
 501     boost::shared_ptr<ParticleGroup> intersection_group = ParticleGroup::groupIntersection(type0, tags04);
 502     BOOST_REQUIRE_EQUAL_UINT(intersection_group->getNumMembers(), 2);
 503     BOOST_CHECK_EQUAL_UINT(intersection_group->getIndexArray().getNumElements(), 2);
 504     BOOST_CHECK_EQUAL_UINT(intersection_group->getMemberTag(0), 0);
 505     BOOST_CHECK_EQUAL_UINT(intersection_group->getMemberTag(1), 2);
 506     }
 507
 508 //! Checks that the ParticleGroup::getTotalMass works correctly
 509 BOOST_AUTO_TEST_CASE( ParticleGroup_total_mass_tests)
 510     {
 511     boost::shared_ptr<SystemDefinition> sysdef = create_sysdef();
 512     boost::shared_ptr<ParticleData> pdata = sysdef->getParticleData();
 513
 514     ParticleGroup group1(sysdef, boost::shared_ptr<ParticleSelector>(new ParticleSelectorTag(sysdef, 0, 0)));
 515     MY_BOOST_CHECK_CLOSE(group1.getTotalMass(), 1.0, tol);
 516
 517     ParticleGroup group2(sysdef, boost::shared_ptr<ParticleSelector>(new ParticleSelectorTag(sysdef, 0, 1)));
 518     MY_BOOST_CHECK_CLOSE(group2.getTotalMass(), 3.0, tol);
 519
 520     ParticleGroup group3(sysdef, boost::shared_ptr<ParticleSelector>(new ParticleSelectorTag(sysdef, 0, 2)));
 521     MY_BOOST_CHECK_CLOSE(group3.getTotalMass(), 8.0, tol);
 522     }
 523
 524 //! Checks that the ParticleGroup::getCenterOfMass works correctly
 525 BOOST_AUTO_TEST_CASE( ParticleGroup_center_of_mass_tests)
 526     {
 527     boost::shared_ptr<SystemDefinition> sysdef = create_sysdef();
 528     boost::shared_ptr<ParticleData> pdata = sysdef->getParticleData();
 529
 530     Scalar3 com;
 531     ParticleGroup group1(sysdef, boost::shared_ptr<ParticleSelector>(new ParticleSelectorTag(sysdef, 0, 0)));
 532     com = group1.getCenterOfMass();
 533     MY_BOOST_CHECK_SMALL(com.x, tol_small);
 534     MY_BOOST_CHECK_SMALL(com.y, tol_small);
 535     MY_BOOST_CHECK_SMALL(com.z, tol_small);
 536
 537     ParticleGroup group2(sysdef, boost::shared_ptr<ParticleSelector>(new ParticleSelectorTag(sysdef, 0, 1)));
 538     com = group2.getCenterOfMass();
 539     MY_BOOST_CHECK_CLOSE(com.x, 7.3333333333, tol);
 540     MY_BOOST_CHECK_CLOSE(com.y, -5.3333333333, tol);
 541     MY_BOOST_CHECK_CLOSE(com.z, 15.333333333, tol);
 542
 543     ParticleGroup group3(sysdef, boost::shared_ptr<ParticleSelector>(new ParticleSelectorTag(sysdef, 0, 2)));
 544     com = group3.getCenterOfMass();
 545     MY_BOOST_CHECK_CLOSE(com.x, 2.125, tol);
 546     MY_BOOST_CHECK_CLOSE(com.y, -3.25, tol);
 547     MY_BOOST_CHECK_CLOSE(com.z, 3.875, tol);
 548     }