[d82961] | 1 | /*
|
---|
| 2 | * Project: MoleCuilder
|
---|
| 3 | * Description: creates and alters molecular systems
|
---|
| 4 | * Copyright (C) 2011 University of Bonn. All rights reserved.
|
---|
| 5 | * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
|
---|
| 6 | */
|
---|
| 7 |
|
---|
| 8 | /*
|
---|
| 9 | * LinkedCell_ModelUnitTest.cpp
|
---|
| 10 | *
|
---|
| 11 | * Created on: Nov 17, 2011
|
---|
| 12 | * Author: heber
|
---|
| 13 | */
|
---|
| 14 |
|
---|
| 15 | // include config.h
|
---|
| 16 | #ifdef HAVE_CONFIG_H
|
---|
| 17 | #include <config.h>
|
---|
| 18 | #endif
|
---|
| 19 |
|
---|
| 20 | using namespace std;
|
---|
| 21 |
|
---|
| 22 | #include <cppunit/CompilerOutputter.h>
|
---|
| 23 | #include <cppunit/extensions/TestFactoryRegistry.h>
|
---|
| 24 | #include <cppunit/ui/text/TestRunner.h>
|
---|
| 25 |
|
---|
| 26 | #include <list>
|
---|
| 27 |
|
---|
| 28 | #include "Box.hpp"
|
---|
| 29 | #include "CodePatterns/Assert.hpp"
|
---|
| 30 | #include "CodePatterns/Log.hpp"
|
---|
| 31 | #include "LinearAlgebra/RealSpaceMatrix.hpp"
|
---|
| 32 | #include "LinkedCell/LinkedCell.hpp"
|
---|
| 33 | #include "LinkedCell/LinkedCell_Model.hpp"
|
---|
[54f3d1] | 34 | #include "LinkedCell/LinkedCell_Model_changeModel.hpp"
|
---|
[8c31865] | 35 | #include "LinkedCell/LinkedCell_Model_LinkedCellArrayCache.hpp"
|
---|
[54f3d1] | 36 | #include "LinkedCell/LinkedCell_Model_Update.hpp"
|
---|
[d82961] | 37 | #include "LinkedCell/PointCloudAdaptor.hpp"
|
---|
[c379f9] | 38 | #include "LinkedCell/unittests/defs.hpp"
|
---|
[d82961] | 39 |
|
---|
| 40 | #include "LinkedCell_ModelUnitTest.hpp"
|
---|
| 41 |
|
---|
| 42 | #ifdef HAVE_TESTRUNNER
|
---|
| 43 | #include "UnitTestMain.hpp"
|
---|
| 44 | #endif /*HAVE_TESTRUNNER*/
|
---|
| 45 |
|
---|
| 46 | /********************************************** Test classes **************************************/
|
---|
| 47 |
|
---|
| 48 | // Registers the fixture into the 'registry'
|
---|
| 49 | CPPUNIT_TEST_SUITE_REGISTRATION( LinkedCell_ModelTest );
|
---|
| 50 |
|
---|
| 51 |
|
---|
| 52 | void LinkedCell_ModelTest::setUp()
|
---|
| 53 | {
|
---|
| 54 | // failing asserts should be thrown
|
---|
| 55 | ASSERT_DO(Assert::Throw);
|
---|
| 56 |
|
---|
| 57 | setVerbosity(3);
|
---|
| 58 |
|
---|
| 59 | // create diag(20.) matrix
|
---|
| 60 | RealSpaceMatrix BoxM;
|
---|
| 61 | BoxM.setIdentity();
|
---|
| 62 | BoxM *= DOMAINLENGTH;
|
---|
| 63 |
|
---|
| 64 | // create Box with this matrix
|
---|
| 65 | domain = new Box(BoxM);
|
---|
| 66 |
|
---|
| 67 | // create LinkedCell structure with this Box
|
---|
| 68 | LC = new LinkedCell::LinkedCell_Model(EDGELENGTH, *domain);
|
---|
| 69 |
|
---|
| 70 | // create a list of nodes and add to LCImpl
|
---|
| 71 | std::vector< Vector > VectorList;
|
---|
| 72 | for (size_t i=0;i<((size_t)floor(NUMBERCELLS));++i)
|
---|
| 73 | VectorList.push_back(Vector((double)i*EDGELENGTH,(double)i*EDGELENGTH,(double)i*EDGELENGTH));
|
---|
| 74 | for (size_t i=0;i<VectorList.size();++i) {
|
---|
| 75 | TesselPoint * Walker = new TesselPoint();
|
---|
| 76 | Walker->setName(std::string("Walker")+toString(i));
|
---|
| 77 | Walker->setPosition(VectorList[i]);
|
---|
| 78 | NodeList.insert(Walker);
|
---|
| 79 | }
|
---|
| 80 | }
|
---|
| 81 |
|
---|
| 82 |
|
---|
| 83 | void LinkedCell_ModelTest::tearDown()
|
---|
| 84 | {
|
---|
| 85 | delete LC;
|
---|
| 86 | delete domain;
|
---|
| 87 |
|
---|
| 88 | // remove all nodes again
|
---|
| 89 | for (PointSet::iterator iter = NodeList.begin();
|
---|
| 90 | !NodeList.empty();
|
---|
| 91 | iter = NodeList.begin()) {
|
---|
| 92 | delete *iter;
|
---|
| 93 | NodeList.erase(iter);
|
---|
| 94 | }
|
---|
| 95 | }
|
---|
| 96 |
|
---|
| 97 | /** UnitTest for correct construction
|
---|
| 98 | */
|
---|
| 99 | void LinkedCell_ModelTest::AllocationTest()
|
---|
| 100 | {
|
---|
| 101 | // check that first cell is allocated
|
---|
| 102 | LinkedCell::tripleIndex index;
|
---|
| 103 | index[0] = index[1] = index[2] = 0;
|
---|
[8c31865] | 104 | CPPUNIT_ASSERT(LC->N->getN()(index) != NULL);
|
---|
[d82961] | 105 |
|
---|
| 106 | // check that very last cell is allocated
|
---|
| 107 | index[0] = index[1] = index[2] = (size_t)floor(NUMBERCELLS)-1;
|
---|
[8c31865] | 108 | CPPUNIT_ASSERT(LC->N->getN()(index) != NULL);
|
---|
[d82961] | 109 |
|
---|
| 110 | }
|
---|
| 111 |
|
---|
| 112 | /** UnitTest for getSize()
|
---|
| 113 | */
|
---|
| 114 | void LinkedCell_ModelTest::getSizeTest()
|
---|
| 115 | {
|
---|
| 116 | // check getSize()
|
---|
| 117 | for(size_t i=0; i<NDIM; ++i)
|
---|
| 118 | CPPUNIT_ASSERT_EQUAL((LinkedCell::LinkedCellArray::index)floor(NUMBERCELLS), LC->getSize(i));
|
---|
| 119 | #ifndef NDEBUG
|
---|
| 120 | std::cout << "The following assertion is intended and is not a failure of the code." << std::endl;
|
---|
| 121 | CPPUNIT_ASSERT_THROW( LC->getSize(4), Assert::AssertionFailure);
|
---|
| 122 | #endif
|
---|
| 123 | }
|
---|
| 124 |
|
---|
| 125 | /** UnitTest for Reset()
|
---|
| 126 | */
|
---|
| 127 | void LinkedCell_ModelTest::ResetTest()
|
---|
| 128 | {
|
---|
| 129 | LC->Reset();
|
---|
| 130 |
|
---|
| 131 | for(size_t i=0; i<NDIM; ++i)
|
---|
| 132 | CPPUNIT_ASSERT_EQUAL((LinkedCell::LinkedCellArray::index)0, LC->getSize(i));
|
---|
| 133 | }
|
---|
| 134 |
|
---|
| 135 |
|
---|
| 136 | /** UnitTest for insertPointCloud()
|
---|
| 137 | */
|
---|
| 138 | void LinkedCell_ModelTest::insertPointCloudTest()
|
---|
| 139 | {
|
---|
| 140 |
|
---|
| 141 | // create the linked cell structure
|
---|
| 142 | PointCloudAdaptor< PointSet > cloud(&NodeList, std::string("NodeList"));
|
---|
| 143 | LC->insertPointCloud(cloud);
|
---|
| 144 |
|
---|
[54f3d1] | 145 | // assure that we are updated before accessing internals
|
---|
| 146 | CPPUNIT_ASSERT_EQUAL( true, *(LC->N->UpToDate) );
|
---|
[d82961] | 147 | // test structure
|
---|
| 148 | CPPUNIT_ASSERT_EQUAL(((size_t)floor(NUMBERCELLS)), LC->CellLookup.size());
|
---|
| 149 | LinkedCell::tripleIndex index;
|
---|
| 150 | for (size_t i=0;i<((size_t)floor(NUMBERCELLS));++i) {
|
---|
| 151 | index[0] = index[1] = index[2] = i;
|
---|
| 152 | // assert that in the destined cell we have one Walker
|
---|
[8c31865] | 153 | CPPUNIT_ASSERT_EQUAL((size_t)1, LC->N->getN()(index)->size());
|
---|
[d82961] | 154 | }
|
---|
| 155 | index[0] = 9;
|
---|
| 156 | index[1] = index[2] = 0;
|
---|
| 157 | // assert that in the destined cell we have one Walker
|
---|
[8c31865] | 158 | CPPUNIT_ASSERT_EQUAL((size_t)0, LC->N->getN()(index)->size());
|
---|
[d82961] | 159 |
|
---|
| 160 | }
|
---|
| 161 |
|
---|
[8c31865] | 162 | /** UnitTest for setPartition()
|
---|
[d82961] | 163 | */
|
---|
| 164 | void LinkedCell_ModelTest::setPartitionTest()
|
---|
| 165 | {
|
---|
| 166 | RealSpaceMatrix Pmatrix = LC->Partition;
|
---|
| 167 | RealSpaceMatrix Dmatrix = LC->Dimensions;
|
---|
| 168 |
|
---|
| 169 | LC->Reset();
|
---|
| 170 |
|
---|
| 171 | LC->setPartition(2.*EDGELENGTH);
|
---|
| 172 |
|
---|
| 173 | Pmatrix *= 0.5;
|
---|
| 174 | Dmatrix *= 0.5;
|
---|
| 175 |
|
---|
| 176 | CPPUNIT_ASSERT_EQUAL(Pmatrix, LC->Partition);
|
---|
| 177 | CPPUNIT_ASSERT_EQUAL(Dmatrix, LC->Dimensions);
|
---|
| 178 | }
|
---|
| 179 |
|
---|
[8c31865] | 180 | /** UnitTest for getStep()
|
---|
[d82961] | 181 | */
|
---|
| 182 | void LinkedCell_ModelTest::getStepTest()
|
---|
| 183 | {
|
---|
| 184 | // zero distance
|
---|
| 185 | LinkedCell::tripleIndex index = LC->getStep(0.);
|
---|
| 186 | for (size_t i = 0; i<NDIM; ++i)
|
---|
| 187 | CPPUNIT_ASSERT( (size_t)0 == index[i]);
|
---|
| 188 | // check all possible shells on boundary
|
---|
| 189 | for (double length = EDGELENGTH; length < DOMAINLENGTH; length+=EDGELENGTH) {
|
---|
| 190 | LinkedCell::tripleIndex index = LC->getStep(length);
|
---|
| 191 | for (size_t i = 0; i<NDIM; ++i) {
|
---|
| 192 | std::cout << (size_t)(length/EDGELENGTH) << " ==" << index[i] << std::endl;
|
---|
| 193 | CPPUNIT_ASSERT( (LinkedCell::LinkedCellArray::index)(length/EDGELENGTH) == index[i]);
|
---|
| 194 | }
|
---|
| 195 | }
|
---|
| 196 | // check all possible shells at half interval
|
---|
| 197 | for (double length = 0.5 * EDGELENGTH; length < DOMAINLENGTH; length+=EDGELENGTH) {
|
---|
| 198 | LinkedCell::tripleIndex index = LC->getStep(length);
|
---|
| 199 | for (size_t i = 0; i<NDIM; ++i)
|
---|
| 200 | CPPUNIT_ASSERT( (LinkedCell::LinkedCellArray::index)ceil(length/EDGELENGTH) == index[i]);
|
---|
| 201 | }
|
---|
| 202 | }
|
---|
| 203 |
|
---|
[8c31865] | 204 | /** UnitTest for getIndexToVector()
|
---|
[d82961] | 205 | */
|
---|
| 206 | void LinkedCell_ModelTest::getIndexToVectorTest()
|
---|
| 207 | {
|
---|
| 208 | {
|
---|
| 209 | const Vector test(0.,0.,0.);
|
---|
| 210 | const LinkedCell::tripleIndex index = LC->getIndexToVector(test);
|
---|
| 211 | for (size_t i = 0; i<NDIM; ++i)
|
---|
| 212 | CPPUNIT_ASSERT( (size_t)0 == index[i]);
|
---|
| 213 | }
|
---|
| 214 | {
|
---|
| 215 | const Vector test(DOMAINLENGTH/2.,DOMAINLENGTH/2.,DOMAINLENGTH/2.);
|
---|
| 216 | const LinkedCell::tripleIndex index = LC->getIndexToVector(test);
|
---|
| 217 | for (size_t i = 0; i<NDIM; ++i)
|
---|
| 218 | CPPUNIT_ASSERT( (size_t)floor(DOMAINLENGTH/EDGELENGTH/2.) == index[i]);
|
---|
| 219 | }
|
---|
| 220 | {
|
---|
| 221 | const Vector test(DOMAINLENGTH/2.,DOMAINLENGTH/3.,DOMAINLENGTH/4.);
|
---|
| 222 | const LinkedCell::tripleIndex index = LC->getIndexToVector(test);
|
---|
| 223 | for (size_t i = 0; i<NDIM; ++i)
|
---|
| 224 | CPPUNIT_ASSERT( (LinkedCell::LinkedCellArray::index)floor(DOMAINLENGTH/EDGELENGTH/(double)(i+2.)) == index[i]);
|
---|
| 225 | }
|
---|
| 226 | }
|
---|
| 227 |
|
---|
[8c31865] | 228 | /** UnitTest for updating nodes
|
---|
[d82961] | 229 | */
|
---|
| 230 | void LinkedCell_ModelTest::nodeTest()
|
---|
| 231 | {
|
---|
| 232 | // create point
|
---|
| 233 | TesselPoint * Walker = new TesselPoint();
|
---|
| 234 | Walker->setName(std::string("Walker9"));
|
---|
| 235 | Walker->setPosition(Vector(9.8,7.6,5.4));
|
---|
| 236 | PointCloudAdaptor< PointSet > cloud(&NodeList, std::string("NodeList"));
|
---|
| 237 | LC->insertPointCloud(cloud);
|
---|
| 238 |
|
---|
| 239 | // check addNode
|
---|
[cf6530] | 240 | {
|
---|
| 241 | LC->addNode(Walker);
|
---|
[54f3d1] | 242 | // assure that we are updated before accessing internals
|
---|
| 243 | CPPUNIT_ASSERT_EQUAL( true, *(LC->N->UpToDate) );
|
---|
[cf6530] | 244 | CPPUNIT_ASSERT_EQUAL( NodeList.size()+1, LC->CellLookup.size());
|
---|
| 245 | LinkedCell::tripleIndex index1 = LC->getIndexToVector(Walker->getPosition());
|
---|
| 246 | const LinkedCell::tripleIndex &index2 = LC->CellLookup[Walker]->getIndices();
|
---|
| 247 | CPPUNIT_ASSERT(index1 == index2);
|
---|
| 248 | }
|
---|
[d82961] | 249 |
|
---|
| 250 | // check moveNode
|
---|
[cf6530] | 251 | {
|
---|
| 252 | LinkedCell::tripleIndex index1 = LC->getIndexToVector(Walker->getPosition());
|
---|
| 253 | const LinkedCell::tripleIndex &index2 = LC->CellLookup[Walker]->getIndices();
|
---|
| 254 | Walker->setPosition(Vector(0.,0.,0.));
|
---|
| 255 | LinkedCell::tripleIndex newindex1 = LC->getIndexToVector(Walker->getPosition());
|
---|
| 256 | CPPUNIT_ASSERT( index1 != newindex1);
|
---|
| 257 | // we have to call moveNode ourselves, as we have just added TesselPoints, not via World
|
---|
| 258 | LC->moveNode(Walker);
|
---|
[54f3d1] | 259 | // assure that we are updated before accessing internals
|
---|
| 260 | CPPUNIT_ASSERT_EQUAL( true, *(LC->N->UpToDate) );
|
---|
[cf6530] | 261 | const LinkedCell::tripleIndex &newindex2 = LC->CellLookup[Walker]->getIndices();
|
---|
| 262 | CPPUNIT_ASSERT( index2 != newindex2);
|
---|
| 263 | }
|
---|
[d82961] | 264 |
|
---|
| 265 | // check deleteNode
|
---|
[cf6530] | 266 | {
|
---|
| 267 | LC->deleteNode(Walker);
|
---|
[54f3d1] | 268 | // assure that we are updated before accessing internals
|
---|
| 269 | CPPUNIT_ASSERT_EQUAL( true, *(LC->N->UpToDate) );
|
---|
[cf6530] | 270 | CPPUNIT_ASSERT_EQUAL( NodeList.size(), LC->CellLookup.size());
|
---|
| 271 | }
|
---|
[d82961] | 272 |
|
---|
| 273 | delete Walker;
|
---|
| 274 | }
|
---|
[54f3d1] | 275 |
|
---|
| 276 | /** UnitTest whether lazy updates are working.
|
---|
| 277 | */
|
---|
| 278 | void LinkedCell_ModelTest::lazyUpdatesTest()
|
---|
| 279 | {
|
---|
| 280 | // create point
|
---|
| 281 | TesselPoint * Walker = new TesselPoint();
|
---|
| 282 | Walker->setName(std::string("Walker9"));
|
---|
| 283 | Walker->setPosition(Vector(9.8,7.6,5.4));
|
---|
| 284 | TesselPoint * Walker2 = new TesselPoint();
|
---|
| 285 | Walker2->setName(std::string("Walker10"));
|
---|
| 286 | Walker2->setPosition(Vector(9.8,7.6,5.4));
|
---|
| 287 | PointCloudAdaptor< PointSet > cloud(&NodeList, std::string("NodeList"));
|
---|
| 288 | LC->insertPointCloud(cloud);
|
---|
| 289 |
|
---|
| 290 | // initial read operation
|
---|
| 291 | {
|
---|
| 292 | CPPUNIT_ASSERT( !NodeList.empty() );
|
---|
| 293 | LinkedCell::tripleIndex index = LC->getIndexToVector((*NodeList.begin())->getPosition());
|
---|
| 294 | const size_t size = LC->N->getN()(index)->size(); // this will cause the update
|
---|
| 295 | CPPUNIT_ASSERT( size >= (size_t)1 );
|
---|
| 296 | }
|
---|
| 297 |
|
---|
| 298 | // do some write ops
|
---|
| 299 | LC->addNode(Walker);
|
---|
| 300 | LC->addNode(Walker2);
|
---|
| 301 | CPPUNIT_ASSERT( LC->Changes->queue.find(Walker) != LC->Changes->queue.end() );
|
---|
| 302 | LinkedCell::LinkedCell_Model::Update *update = LC->Changes->queue[Walker];
|
---|
| 303 | Walker->setPosition(Vector(0.,0.,0.));
|
---|
| 304 | LC->moveNode(Walker);
|
---|
| 305 |
|
---|
| 306 | // check that they all reside in cache and nothing is changed so far
|
---|
| 307 | CPPUNIT_ASSERT( LC->Changes->queue.size() > (size_t)0 );
|
---|
| 308 |
|
---|
| 309 | // check that add priority is prefered over move
|
---|
| 310 | CPPUNIT_ASSERT( LC->Changes->queue[Walker] == update );
|
---|
| 311 |
|
---|
| 312 | // perform read op
|
---|
| 313 | {
|
---|
| 314 | LinkedCell::tripleIndex index = LC->getIndexToVector(Walker->getPosition());
|
---|
| 315 | CPPUNIT_ASSERT( LC->N->getN()(index)->size() >= (size_t)1 );
|
---|
| 316 | }
|
---|
| 317 |
|
---|
| 318 | // check that cache is emptied
|
---|
| 319 | CPPUNIT_ASSERT( LC->Changes->queue.size() == (size_t)0 );
|
---|
| 320 |
|
---|
| 321 | delete Walker;
|
---|
| 322 | delete Walker2;
|
---|
| 323 | }
|
---|