orthocellaccessor.cpp

Go to the documentation of this file.

#include "orthomesh.h"
#include "exception.h"
#include "numericmethods.h"

OrthoCellAccessor::OrthoCellAccessor(const OrthoMesh &mesh,unsigned index) 
   :_pMesh(&mesh)
{
  assert(index < _pMesh->numRawCells());
  _index = index;
  _pMesh->getCellPositionFromIndex(index,_i,_j,_k);
}

OrthoCellAccessor::OrthoCellAccessor(const OrthoMesh &mesh,unsigned i,unsigned j,unsigned k) 
:_pMesh(&mesh)
{
  _i=i;
  _j=j;
  _k=k;
  _index=_pMesh->getCellIndexFromPosition(_i,_j,_k);
}

OrthoCellAccessor::OrthoCellAccessor() 
{
  _pMesh=NULL;
  _i=_j=_k=_index=0;
}

unsigned OrthoCellAccessor::vertex_index(VertexDirection3D dir) const
{
  assert(this->isValid());
  assert(_index < _pMesh->numRawCells());
  return _pMesh->getVerticeIndexFromCell(dir,_i,_j,_k);
}

void OrthoCellAccessor::barycenter(Point3D &p) const
{
  assert(_index < _pMesh->numRawCells());
  _pMesh->getBarycenterFromCell(_i,_j,_k,p);
}


void OrthoCellAccessor::vertex(VertexDirection3D dir, Point3D &p) const
{
  assert(this->isValid());
  assert(_index < _pMesh->numRawCells());
  _pMesh->getVerticeFromCell(dir, _i,_j,_k,p);
}

Point3D OrthoCellAccessor::vertex(VertexDirection3D dir) const
{
  Point3D p;
  vertex(dir,p);
  return p;
}

void OrthoCellAccessor::operator++ (int) 
{
  assert(this->isValid());
  assert(_index < _pMesh->numRawCells());
  _index++;
  _i++;
  if (_i >= _pMesh->_nElemX)
  {
    _i=0;
    _j++;
    if (_j >= _pMesh->_nElemY)
    {
      _j=0;
      _k++;
    }
  }
}

unsigned OrthoCellAccessor::face_index(FaceDirection3D dir) const
{
  assert(this->isValid());
  return _pMesh->getFaceIndexFromCell(dir,_i,_j,_k);
}

OrthoMesh::Raw_Face_It OrthoCellAccessor::face(FaceDirection3D dir)
{
  assert(this->isValid());
  OrthoFaceAccessor face(*_pMesh,_pMesh->getFaceIndexFromCell(dir,_i,_j,_k));
  return OrthoMesh::Raw_Face_It(face);
}


bool OrthoCellAccessor::at_boundary() const
{
  assert(this->isValid());
  return _pMesh->isCellAtBoundary(_i,_j,_k);
}





Point3D OrthoCellAccessor::barycenter()  const
{
  assert(this->isValid());
  Point3D p;
  barycenter(p);
  return p;
}


unsigned OrthoCellAccessor::neighbor_index(unsigned int dir) const
{
  assert(dir <= 5);
  assert(this->isValid());

  switch(dir)
  {
  case LEFT_CELL:
    {
      if (_i == 0)
        return OrthoMesh::INVALID_INDEX;
      else
        return _index-1;
    }
  case RIGHT_CELL:
    {
      if (_i == _pMesh->_nElemX-1)
        return OrthoMesh::INVALID_INDEX;
      else
        return _index+1;
    }
  case FRONT_CELL:
    {
      if (_j == 0)
        return OrthoMesh::INVALID_INDEX;
      else
        return _index-_pMesh->_YStride;
    }
  case BACK_CELL:
    {
      if (_j == _pMesh->_nElemY-1)
        return OrthoMesh::INVALID_INDEX;
      else
        return _index+_pMesh->_YStride;
    }
  case BOTTOM_CELL:
    {
      if (_k == 0)
        return OrthoMesh::INVALID_INDEX;
      else
        return _index-_pMesh->_ZStride;
    }  
  case UP_CELL:
    {
      if (_k == _pMesh->_nElemZ-1)
        return OrthoMesh::INVALID_INDEX;
      else
        return _index+_pMesh->_ZStride;
    }
  default:
   throw new Exception("OrthoMesh::neighbor_index(): Invalid direction number");
  }
  
}


bool OrthoCellAccessor::isValid() const 
{

  return (_pMesh != NULL && _index < _pMesh->numRawCells());
}


OrthoMesh::Raw_Cell_It OrthoCellAccessor::neighbor(CellDirection3D dir) 
{
  unsigned index = this->neighbor_index(dir);
  if (index == _pMesh->invalidIndex())
    return _pMesh->end_raw_cell();
  
  OrthoCellAccessor result(*_pMesh,index);
  return OrthoMesh::Raw_Cell_It(result);
}

unsigned OrthoCellAccessor::advance(CellDirection3D dir,unsigned stps) 
{
  unsigned i;
  for (i=0;i<stps;i++)
  {
    if (!this->advance(dir))
    {
      return i;
    }
  }
  return i;
}





bool OrthoCellAccessor::advance(CellDirection3D dir) 
{
  assert(dir <= 5);
  assert(this->isValid());

  switch(dir)
  {
  case LEFT_CELL:
    {
      return advanceLeft();
    }
  case RIGHT_CELL:
    {
      return advanceRight();
    }
  case FRONT_CELL:
    {
      return advanceFront();
    }
  case BACK_CELL:
    {
      return advanceBack();
    }
  case BOTTOM_CELL:
    {
      return advanceDown();
    }  
  case UP_CELL:
    {
      return advanceUp();
    }
  default:
   throw new Exception("OrthoMesh::neighbor_index(): Invalid direction number");
  }
  return true;
}

bool OrthoCellAccessor::advanceRight() 
{
      if (_i == _pMesh->_LastI)
        return false;
      else
      {
        _i++;
        _index++;
        return true;
      }

}

bool OrthoCellAccessor::advanceLeft() 
{
  if (_i == 0)
    return false;
  else
  {
    _i--;
    _index--;
    return true;
  }
}

bool OrthoCellAccessor::advanceUp() 
{
      if (_k == _pMesh->_LastK)
        return false;
      else
      {
         _index+=_pMesh->_ZStride;
         _k++;
        return true;
      }
}

bool OrthoCellAccessor::advanceDown() 
{
      if (_k == 0)
        return false;
      else
      {
        _index-=_pMesh->_ZStride;
        _k--;
        return true;
      }
}

bool OrthoCellAccessor::advanceBack() 
{
      if (_j == _pMesh->_LastJ)
        return false;
      else
      {
        _index+=_pMesh->_YStride;
        _j++;
        return true;
      }
}

bool OrthoCellAccessor::advanceFront() 
{
      if (_j == 0)
        return false;
      else
      {
        _index-=_pMesh->_YStride;
        _j--;
        return true;
      }
}




unsigned OrthoCellAccessor::face_index_up() const
{
    return _i + _j*_pMesh->_fzYStride + (_k +1)*_pMesh->_fzZStride + _pMesh->_fzOff;
}

unsigned OrthoCellAccessor::face_index_bottom() const
{
    return  _i + _j*_pMesh->_fzYStride + _k*_pMesh->_fzZStride + _pMesh->_fzOff;
}

unsigned OrthoCellAccessor::face_index_left() const
{
  return _i  + _j*_pMesh->_fxYStride + _k*_pMesh->_fxZStride;
  
}

unsigned OrthoCellAccessor::face_index_right() const
{
    return _i + 1  + _j*_pMesh->_fxYStride + _k*_pMesh->_fxZStride;
}

unsigned OrthoCellAccessor::face_index_front() const
{
    return _i + _j*_pMesh->_fyYStride + _k*_pMesh->_fyZStride + _pMesh->_fyOff;

}

unsigned OrthoCellAccessor::face_index_back() const
{
  return  _i + (_j+1)*_pMesh->_fyYStride + _k*_pMesh->_fyZStride + _pMesh->_fyOff;
}










bool OrthoCellAccessor::operator!= (OrthoCellAccessor &cell) const 
{
  assert(_index <= _pMesh->numRawCells());
  assert(cell._index <= _pMesh->numRawCells());
  return _index != cell._index;
}




unsigned OrthoCellAccessor::index_up() const
{
  assert(this->isValid());

  if (_k == _pMesh->_LastK)
    return OrthoMesh::INVALID_INDEX;
  else
    return _index+_pMesh->_ZStride;

}

unsigned OrthoCellAccessor::index_bottom() const
{
  assert(this->isValid());
  if (_k == 0)
    return OrthoMesh::INVALID_INDEX;
  else
    return _index-_pMesh->_ZStride;

}

unsigned OrthoCellAccessor::index_left() const
{
  assert(this->isValid());
  if (_i == 0)
    return OrthoMesh::INVALID_INDEX;
  else
    return _index-1;
}

unsigned OrthoCellAccessor::index_right() const
{
  assert(this->isValid());
  if (_i == _pMesh->_LastI)
    return OrthoMesh::INVALID_INDEX;
  else
    return _index+1;

}



unsigned OrthoCellAccessor::index_front() const
{
  assert(this->isValid());
  if (_j == 0)
    return OrthoMesh::INVALID_INDEX;
  else
    return _index-_pMesh->_YStride;
}




unsigned OrthoCellAccessor::index_back() const
{
  assert(this->isValid());
  if (_j == _pMesh->_LastJ)
    return OrthoMesh::INVALID_INDEX;
  else
    return _index+_pMesh->_YStride;

}


bool OrthoCellAccessor::containPoint(Point3D &p) const 
{
  Point3D v1 = vertex(VERTEX_000);
  Point3D v2 = vertex(VERTEX_111);
  return NumericMethods::isInCube(p,v1,v2);

}

//Advance the cell to next cell that is not ar boundary
void OrthoCellAccessor::advance_inner() 
{
  assert(!this->at_boundary());
  assert(this->isValid());
  _index++;
  _i++;
  if (_i >= _pMesh->_LastI)
  {
    _i=1;
    _j++;
    if (_j >= _pMesh->_LastJ)
    {
      _j=1;
      _k++;
    }
  }
}
  

---