src/lagrangian/molecularDynamics/molecule/interactionLists/referredCell/referredCell.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2008-2009 OpenCFD Ltd.
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software; you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM; if not, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 \*----------------------------------------------------------------------------*/
  26
  27 #include "referredCell.H"
  28 #include "interactionLists.H"
  29
  30 namespace Foam
  31 {
  32
  33 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  34
  35 void referredCell::setConstructionData
  36 (
  37     const polyMesh& mesh,
  38     const label sourceCell
  39 )
  40 {
  41     // Points
  42
  43     const labelList& points = mesh.cellPoints()[sourceCell];
  44
  45     vectorList sourceCellVertices(points.size());
  46
  47     forAll(sourceCellVertices, sCV)
  48     {
  49         sourceCellVertices[sCV] = mesh.points()[points[sCV]];
  50     }
  51
  52     vertexPositions_ = referPositions(sourceCellVertices);
  53
  54
  55     // Edges
  56
  57     const labelList& edges = mesh.cellEdges()[sourceCell];
  58
  59     edgeList sourceCellEdges(edges.size());
  60
  61     forAll(sourceCellEdges, sCE)
  62     {
  63         sourceCellEdges[sCE] = mesh.edges()[edges[sCE]];
  64     }
  65
  66     locallyMapEdgeList(points, sourceCellEdges);
  67
  68
  69     // Faces
  70
  71     labelList faces(mesh.cells()[sourceCell]);
  72
  73     vectorList sourceCellFaceCentres(faces.size());
  74
  75     vectorList sourceCellFaceAreas(faces.size());
  76
  77     labelListList sourceCellFaces(faces.size());
  78
  79     forAll(faces, f)
  80     {
  81         sourceCellFaces[f] = mesh.faces()[faces[f]];
  82
  83         sourceCellFaceCentres[f] = mesh.faceCentres()[faces[f]];
  84
  85         sourceCellFaceAreas[f] = mesh.faceAreas()[faces[f]];
  86     }
  87
  88     locallyMapFaceList(points, sourceCellFaces);
  89
  90     faceCentres_ = referPositions(sourceCellFaceCentres);
  91
  92     faceAreas_ = rotateVectors(sourceCellFaceAreas);
  93 }
  94
  95
  96 void referredCell::locallyMapEdgeList
  97 (
  98     const labelList& points,
  99     const edgeList& sourceCellEdges
 100 )
 101 {
 102     edges_.setSize(sourceCellEdges.size());
 103
 104     forAll(sourceCellEdges, sCE)
 105     {
 106         const edge& e(sourceCellEdges[sCE]);
 107
 108         edges_[sCE].start() = findIndex(points, e.start());
 109
 110         edges_[sCE].end() = findIndex(points, e.end());
 111
 112         if
 113         (
 114             edges_[sCE].start() == -1
 115          || edges_[sCE].end() == -1
 116         )
 117         {
 118             FatalErrorIn("Foam::referredCell::locallyMapEdgeList")
 119                 << "edgeList and points labelList for "
 120                 << "referred cell do not match: "
 121                 << nl << "points: " << points
 122                 << nl << "egdes: " << sourceCellEdges
 123                 << abort(FatalError);
 124         }
 125     }
 126 }
 127
 128
 129 void referredCell::locallyMapFaceList
 130 (
 131     const labelList& points,
 132     const labelListList& sourceCellFaces
 133 )
 134 {
 135     faces_.setSize(sourceCellFaces.size());
 136
 137     forAll(sourceCellFaces, sCF)
 138     {
 139         const labelList& sourceCellFace(sourceCellFaces[sCF]);
 140
 141         labelList& localFace(faces_[sCF]);
 142
 143         localFace.setSize(sourceCellFace.size());
 144
 145         forAll(sourceCellFace, p)
 146         {
 147             localFace[p] = findIndex(points, sourceCellFace[p]);
 148
 149             if (localFace[p] == -1)
 150             {
 151                 FatalErrorIn("Foam::referredCell::locallyMapEdgeList")
 152                     << "edgeList and points labelList for "
 153                     << "referred cell do not match: "
 154                     << nl << "points: " << points
 155                     << nl << "faces: " << sourceCellFaces
 156                     << abort(FatalError);
 157             }
 158         }
 159     }
 160 }
 161
 162
 163 vector referredCell::referPosition(const vector& positionToRefer)
 164 {
 165     return offset_ + (rotation_ & positionToRefer);
 166 }
 167
 168
 169 vectorList referredCell::referPositions(const vectorList& positionsToRefer)
 170 {
 171     return offset_ + (rotation_ & positionsToRefer);
 172 }
 173
 174
 175 vector referredCell::rotateVector(const vector& vectorToRotate)
 176 {
 177     return rotation_ & vectorToRotate;
 178 }
 179
 180
 181 vectorList referredCell::rotateVectors(const vectorList& vectorsToRotate)
 182 {
 183     return rotation_ & vectorsToRotate;
 184 }
 185
 186
 187 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 188
 189 referredCell::referredCell()
 190 :
 191     DynamicList<referredMolecule>(),
 192     sourceProc_(-1),
 193     sourceCell_(-1),
 194     vertexPositions_(),
 195     offset_(vector::zero),
 196     rotation_(I)
 197 {}
 198
 199
 200 referredCell::referredCell
 201 (
 202     const polyMesh& mesh,
 203     const label sourceProc,
 204     const label sourceCell,
 205     const vector& offset,
 206     const tensor& rotation
 207 )
 208 :
 209     DynamicList<referredMolecule>(),
 210     sourceProc_(sourceProc),
 211     sourceCell_(sourceCell),
 212     offset_(offset),
 213     rotation_(rotation)
 214 {
 215     setConstructionData(mesh, sourceCell);
 216 }
 217
 218
 219 referredCell::referredCell
 220 (
 221     const label sourceProc,
 222     const label sourceCell,
 223     const vectorList& vertexPositions,
 224     const edgeList& localEdges,
 225     const labelListList& localFaces,
 226     const vectorList& faceCentres,
 227     const vectorList& faceAreas,
 228     const vector& offset,
 229     const tensor& rotation
 230 )
 231 :
 232     DynamicList<referredMolecule>(),
 233     sourceProc_(sourceProc),
 234     sourceCell_(sourceCell),
 235     edges_(localEdges),
 236     faces_(localFaces),
 237     offset_(offset),
 238     rotation_(rotation)
 239 {
 240     // Supplied vertexPositions, faceCentres and faceAreas are of the
 241     // "original" cell, and need to be transformed to the referred
 242     // locations on construction
 243
 244     vertexPositions_ = referPositions(vertexPositions);
 245
 246     faceCentres_ = referPositions(faceCentres);
 247
 248     faceAreas_ = rotateVectors(faceAreas);
 249 }
 250
 251
 252 referredCell::referredCell
 253 (
 254     const polyMesh& mesh,
 255     const label sourceProc,
 256     const label sourceCell,
 257     const vector& cS,
 258     const vector& cD,
 259     const vector& nS,
 260     const vector& nD
 261 )
 262 :
 263     DynamicList<referredMolecule>(),
 264     sourceProc_(sourceProc),
 265     sourceCell_(sourceCell)
 266 {
 267     // It is assumed that the vectors originating from the faces being referred
 268     // here are correct periodic faces - i.e. they have the same area etc.
 269
 270     vector nA = -nS/mag(nS);
 271     vector nB = nD/mag(nD);
 272
 273     rotation_ = rotationTensor(nA, nB);
 274
 275     offset_ = cD - (rotation_ & cS);
 276
 277     // Allow sourceCell = -1 to create a dummy referredCell
 278     // to obtain the transformation
 279
 280     if(sourceCell >= 0)
 281     {
 282         setConstructionData(mesh, sourceCell);
 283     }
 284 }
 285
 286
 287 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 288
 289 referredCell::~referredCell()
 290 {}
 291
 292
 293 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 294
 295 referredCell referredCell::reRefer
 296 (
 297     const vector& cS,
 298     const vector& cD,
 299     const vector& nS,
 300     const vector& nD
 301 )
 302 {
 303     vector nA = -nS/mag(nS);
 304     vector nB = nD/mag(nD);
 305
 306     tensor newRotation = rotationTensor(nA, nB);
 307
 308     vector newOffset = cD - (newRotation & cS);
 309
 310     tensor reReferredRotation = newRotation & rotation_;
 311
 312     vector reReferredOffset = newOffset + (newRotation & offset_);
 313
 314     return referredCell
 315     (
 316         sourceProc_,
 317         sourceCell_,
 318         rotation_.T() & (vertexPositions_ - offset_),
 319         edges_,
 320         faces_,
 321         rotation_.T() & (faceCentres_ - offset_),
 322         rotation_.T() & (faceAreas_),
 323         reReferredOffset,
 324         reReferredRotation
 325     );
 326 }
 327
 328
 329 vector referredCell::referPosition(const vector& positionToRefer) const
 330 {
 331     return offset_ + (rotation_ & positionToRefer);
 332 }
 333
 334
 335 vectorList referredCell::referPosition
 336 (
 337     const vectorList& positionsToRefer
 338 ) const
 339 {
 340     return offset_ + (rotation_ & positionsToRefer);
 341 }
 342
 343
 344 vector referredCell::rotateVector(const vector& vectorToRotate) const
 345 {
 346     return rotation_ & vectorToRotate;
 347 }
 348
 349
 350 vectorList referredCell::rotateVectors(const vectorList& vectorsToRotate) const
 351 {
 352     return rotation_ & vectorsToRotate;
 353 }
 354
 355
 356 void referredCell::referInMols(const List<referredMolecule>& incomingMols)
 357 {
 358     clear();
 359
 360     forAll(incomingMols, iM)
 361     {
 362         append
 363         (
 364             referredMolecule
 365             (
 366                 incomingMols[iM].id(),
 367                 referPosition
 368                 (
 369                     incomingMols[iM].position()
 370                 ),
 371                 referPosition
 372                 (
 373                     incomingMols[iM].sitePositions()
 374                 )
 375             )
 376         );
 377     }
 378
 379     shrink();
 380 }
 381
 382
 383 bool referredCell::duplicate(const referredCell& refCellDupl) const
 384 {
 385     return
 386     (
 387         sourceProc_ == refCellDupl.sourceProc()
 388      && sourceCell_ == refCellDupl.sourceCell()
 389      && mag(offset_ - refCellDupl.offset()) < interactionLists::transTol
 390     );
 391 }
 392
 393
 394 bool referredCell::duplicate(const label procNo,const label nCells) const
 395 {
 396     return
 397     (
 398         sourceProc_ == procNo
 399      && sourceCell_ < nCells
 400      && mag(offset_) < interactionLists::transTol
 401     );
 402 }
 403
 404
 405 // * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
 406
 407 Istream& operator>>(Istream& is, referredCell& rC)
 408 {
 409
 410     is  >> rC.sourceProc_
 411         >> rC.sourceCell_
 412         >> rC.vertexPositions_
 413         >> rC.edges_
 414         >> rC.faces_
 415         >> rC.faceCentres_
 416         >> rC.faceAreas_
 417         >> rC.offset_
 418         >> rC.rotation_;
 419
 420     is.check("Istream& operator<<(Istream& f, const referredCell& rC");
 421
 422     return is;
 423 }
 424
 425
 426 Ostream& operator<<(Ostream& os, const referredCell& rC)
 427 {
 428
 429     os  << rC.sourceProc()
 430         << token::SPACE << rC.sourceCell()
 431         << token::SPACE << rC.vertexPositions()
 432         << token::SPACE << rC.edges()
 433         << token::SPACE << rC.faces()
 434         << token::SPACE << rC.faceCentres()
 435         << token::SPACE << rC.faceAreas()
 436         << token::SPACE << rC.offset()
 437         << token::SPACE << rC.rotation();
 438
 439     os.check("Ostream& operator<<(Ostream& f, const referredCell& rC");
 440
 441     return os;
 442 }
 443
 444
 445 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 446
 447 }  // End namespace Foam
 448
 449 // ************************************************************************* //