coast_polygon.cpp

Go to the documentation of this file.

 
/*===============================================================================================================================
 
This file is part of CoastalME, the Coastal Modelling Environment.
 
CoastalME is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.
 
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
===============================================================================================================================*/
#include <assert.h>
#include <iostream>
using std::cerr;
 
#include "cme.h"
#include "coast_polygon.h"

CGeomCoastPolygon::CGeomCoastPolygon(int const nGlobalID, int const nCoastID, int const nNode, int const nProfileUpCoast, int const nProfileDownCoast, vector<CGeom2DPoint> const* pVIn, int const nLastPointUpCoast, const int nLastPointDownCoast, CGeom2DIPoint const* PtiNode, CGeom2DIPoint const* PtiAntinode, bool const bStartCoast, bool const bEndCoast)
:
//    m_bIsPointedSeaward(true),
   m_bUnconsSedimentMovementDownCoastThisIter(false),
   m_bCoastEndPolygon(bEndCoast),
   m_bCoastStartPolygon(bStartCoast),
   m_nGlobalID(nGlobalID),
   m_nCoastID(nCoastID),
   m_nCoastNode(nNode),
   m_nProfileUpCoast(nProfileUpCoast),
   m_nProfileDownCoast(nProfileDownCoast),
   m_nProfileUpCoastNumPointsUsed(nLastPointUpCoast),
   m_nProfileDownCoastNumPointsUsed(nLastPointDownCoast),
   m_nNumCells(0),
   m_dAvgUnconsD50(0),   
   m_dSeawaterVolume(0),
   m_dPotentialBeachErosionAllUncons(0),
   m_dBeachErosionUnconsFine(0),
   m_dBeachErosionUnconsSand(0),
   m_dBeachErosionUnconsCoarse(0),
   m_dBeachDepositionUnconsSand(0),
   m_dBeachDepositionUnconsCoarse(0),
   m_dSuspensionUnconsFine(0),
   m_dToDoBeachDepositionUnconsSand(0),
   m_dToDoBeachDepositionUnconsCoarse(0),
   m_dBeachSandErodedDeanProfile(0),
   m_dBeachCoarseErodedDeanProfile(0),
   m_dCliffCollapseErosionFine(0),
   m_dCliffCollapseErosionSand(0),
   m_dCliffCollapseErosionCoarse(0),
   m_dCliffCollapseTalusFineToSuspension(0),
   m_dCliffCollapseTalusSand(0),
   m_dCliffCollapseTalusCoarse(0),
   m_dCliffCollapseSandErodedDeanProfile(0),
   m_dCliffCollapseCoarseErodedDeanProfile(0),
   m_dPlatformErosionToSuspensionFine(0),
   m_dPlatformErosionUnconsSand(0),
   m_dPlatformErosionUnconsCoarse(0),
   m_dPreExistingUnconsFine(0),
   m_dPreExistingUnconsSand(0),
   m_dPreExistingUnconsCoarse(0),
   m_dPreExistingConsFine(0),
   m_dPreExistingConsSand(0),
   m_dPreExistingConsCoarse(0),
   m_dSedimentInputFine(0),
   m_dSedimentInputSand(0),
   m_dSedimentInputCoarse(0),
   m_dLength(0),
   m_PtiNode(*PtiNode),
   m_PtiAntinode(*PtiAntinode)
{
   m_VPoints = *pVIn;
}

CGeomCoastPolygon::~CGeomCoastPolygon(void)
{
}
 
// void CGeomCoastPolygon::SetNotPointed(void)
// {
//    m_bIsPointedSeaward = false;
// }
//
// bool CGeomCoastPolygon::bIsPointed(void) const
// {
//    return m_bIsPointedSeaward;
// }

void CGeomCoastPolygon::SetDownCoastThisIter(bool const bFlag)
{
   m_bUnconsSedimentMovementDownCoastThisIter = bFlag;
}

bool CGeomCoastPolygon::bDownCoastThisIter(void) const
{
   return m_bUnconsSedimentMovementDownCoastThisIter;
}

void CGeomCoastPolygon::SetCoastEndPolygon(void)
{
   m_bCoastEndPolygon = true;
}

bool CGeomCoastPolygon::bIsCoastEndPolygon(void) const
{
   return m_bCoastEndPolygon;
}

void CGeomCoastPolygon::SetCoastStartPolygon(void)
{
   m_bCoastStartPolygon = true;
}

bool CGeomCoastPolygon::bIsCoastStartPolygon(void) const
{
   return m_bCoastStartPolygon;
}

int CGeomCoastPolygon::nGetGlobalID(void) const
{
   return m_nGlobalID;
}

int CGeomCoastPolygon::nGetCoastID(void) const
{
   return m_nCoastID;
}
 
// void CGeomCoastPolygon::SetCoastNode(int const nNode)
// {
//    m_nCoastNode = nNode;
// }

int CGeomCoastPolygon::nGetNodeCoastPoint(void) const
{
   return m_nCoastNode;
}

CGeom2DIPoint* CGeomCoastPolygon::pPtiGetNode(void)
{
   return &m_PtiNode;
 
}

CGeom2DIPoint* CGeomCoastPolygon::pPtiGetAntiNode(void)
{
   return &m_PtiAntinode;
}

void CGeomCoastPolygon::SetLength(double const dLength)
{
   m_dLength = dLength;
}

double CGeomCoastPolygon::dGetLength(void) const
{
   return m_dLength;
}

void CGeomCoastPolygon::SetNumCellsInPolygon(int const nCells)
{
   m_nNumCells = nCells;
}
 
// //! Get the number of cells in the polygon
// int CGeomCoastPolygon::nGetNumCellsinPolygon(void) const
// {
//    return m_nNumCells;
// }

int CGeomCoastPolygon::nGetUpCoastProfile(void) const
{
   return m_nProfileUpCoast;
}

int CGeomCoastPolygon::nGetDownCoastProfile(void) const
{
   return m_nProfileDownCoast;
}
 
// void CGeomCoastPolygon::SetBoundary(vector<CGeom2DPoint> const* pVIn)
// {
//    m_VPoints = *pVIn;
// }
 
// vector<CGeom2DPoint>* CGeomCoastPolygon::pPtVGetBoundary(void)
// {
//    return &m_VPoints;
// }

CGeom2DPoint* CGeomCoastPolygon::pPtGetBoundaryPoint(int const nPoint)
{
   // TODO 055 No check to see if nPoint < m_VPoints.size()
   return &m_VPoints[nPoint];
}

int CGeomCoastPolygon::nGetBoundarySize(void) const
{
   return static_cast<int>(m_VPoints.size());
}

int CGeomCoastPolygon::nGetNumPointsUsedUpCoastProfile(void) const
{
   return m_nProfileUpCoastNumPointsUsed;
}

int CGeomCoastPolygon::nGetNumPointsUsedDownCoastProfile(void) const
{
   return m_nProfileDownCoastNumPointsUsed;
}

void CGeomCoastPolygon::SetSeawaterVolume(const double dDepth)
{
   m_dSeawaterVolume = dDepth;
}

double CGeomCoastPolygon::dGetSeawaterVolume(void) const
{
   return m_dSeawaterVolume;
}

void CGeomCoastPolygon::AddPotentialErosion(double const dDepth)
{
   m_dPotentialBeachErosionAllUncons += dDepth;
}

double CGeomCoastPolygon::dGetPotentialErosion(void) const
{
   return m_dPotentialBeachErosionAllUncons;
}

void CGeomCoastPolygon::SetBeachErosionUnconsFine(double const dDepth)
{
   m_dBeachErosionUnconsFine = dDepth;
}

double CGeomCoastPolygon::dGetBeachErosionUnconsFine(void) const
{
   return m_dBeachErosionUnconsFine;
}

void CGeomCoastPolygon::SetBeachErosionUnconsSand(double const dDepth)
{
   m_dBeachErosionUnconsSand = dDepth;
}

double CGeomCoastPolygon::dGetBeachErosionUnconsSand(void) const
{
   return m_dBeachErosionUnconsSand;
}

void CGeomCoastPolygon::SetBeachErosionUnconsCoarse(double const dDepth)
{
   m_dBeachErosionUnconsCoarse = dDepth;
}

double CGeomCoastPolygon::dGetBeachErosionUnconsCoarse(void) const
{
   return m_dBeachErosionUnconsCoarse;
}

double CGeomCoastPolygon::dGeBeachErosionAllUncons(void) const
{
   return m_dBeachErosionUnconsFine + m_dBeachErosionUnconsSand + m_dBeachErosionUnconsCoarse;
}

void CGeomCoastPolygon::AddToSuspensionUnconsFine(double const dDepth)
{
   m_dSuspensionUnconsFine += dDepth;
}
 
// //! Re-initializes this timestep's to-suspension movement of unconsolidated fine sediment on this polygon
// void CGeomCoastPolygon::SetZeroSuspensionUnconsFine(void)
// {
//    m_dSuspensionUnconsFine = 0;
// }

double CGeomCoastPolygon::dGetSuspensionUnconsFine(void) const
{
   return m_dSuspensionUnconsFine;
}

void CGeomCoastPolygon::SetBeachDepositionUnconsSand(double const dDepth)
{
   m_dBeachDepositionUnconsSand = dDepth;
}

double CGeomCoastPolygon::dGetBeachDepositionUnconsSand(void) const
{
   return m_dBeachDepositionUnconsSand;
}

void CGeomCoastPolygon::SetBeachDepositionUnconsCoarse(double const dDepth)
{
   m_dBeachDepositionUnconsCoarse = dDepth;
}

double CGeomCoastPolygon::dGetBeachDepositionUnconsCoarse(void) const
{
   return m_dBeachDepositionUnconsCoarse;
}

void CGeomCoastPolygon::SetZeroToDoDepositionUnconsSand(void)
{
   m_dToDoBeachDepositionUnconsSand = 0;
}

void CGeomCoastPolygon::AddToDoBeachDepositionUnconsSand(double const dDepth)
{
   m_dToDoBeachDepositionUnconsSand += dDepth;
}

double CGeomCoastPolygon::dGetToDoBeachDepositionUnconsSand(void) const
{
   return m_dToDoBeachDepositionUnconsSand;
}

void CGeomCoastPolygon::SetZeroToDoDepositionUnconsCoarse(void)
{
   m_dToDoBeachDepositionUnconsCoarse = 0;
}

void CGeomCoastPolygon::AddToDoBeachDepositionUnconsCoarse(double const dDepth)
{
   m_dToDoBeachDepositionUnconsCoarse += dDepth;
}

double CGeomCoastPolygon::dGetToDoBeachDepositionUnconsCoarse(void) const
{
   return m_dToDoBeachDepositionUnconsCoarse;
}

void CGeomCoastPolygon::AddBeachSandErodedDeanProfile(double const dDepth)
{
   m_dBeachSandErodedDeanProfile += dDepth;
}

double CGeomCoastPolygon::dGetBeachSandErodedDeanProfile(void) const
{
   return m_dBeachSandErodedDeanProfile;
}

void CGeomCoastPolygon::AddBeachCoarseErodedDeanProfile(double const dDepth)
{
   m_dBeachCoarseErodedDeanProfile += dDepth;
}

double CGeomCoastPolygon::dGetBeachCoarseErodedDeanProfile(void) const
{
   return m_dBeachCoarseErodedDeanProfile;
}

double CGeomCoastPolygon::dGetBeachDepositionAndSuspensionAllUncons(void) const
{
   return m_dSuspensionUnconsFine + m_dToDoBeachDepositionUnconsSand + m_dToDoBeachDepositionUnconsCoarse;
}

void CGeomCoastPolygon::SetUpCoastAdjacentPolygons(vector<int> const* pnVPolygons)
{
   m_VnUpCoastAdjacentPolygon = *pnVPolygons;
}

int CGeomCoastPolygon::nGetUpCoastAdjacentPolygon(int const nIndex) const
{
//    assert(nIndex < m_VnUpCoastAdjacentPolygon.size());
   return m_VnUpCoastAdjacentPolygon[nIndex];
}

int CGeomCoastPolygon::nGetNumUpCoastAdjacentPolygons(void) const
{
   return static_cast<int>(m_VnUpCoastAdjacentPolygon.size());
}

void CGeomCoastPolygon::SetDownCoastAdjacentPolygons(vector<int> const* pnVPolygons)
{
   m_VnDownCoastAdjacentPolygon = *pnVPolygons;
}

int CGeomCoastPolygon::nGetDownCoastAdjacentPolygon(int const nIndex) const
{
//    assert(nIndex < m_VnDownCoastAdjacentPolygon.size());
   return m_VnDownCoastAdjacentPolygon[nIndex];
}

int CGeomCoastPolygon::nGetNumDownCoastAdjacentPolygons(void) const
{
   return static_cast<int>(m_VnDownCoastAdjacentPolygon.size());
}

void CGeomCoastPolygon::SetUpCoastAdjacentPolygonBoundaryShares(vector<double> const* pdVShares)
{
   m_VdUpCoastAdjacentPolygonBoundaryShare = *pdVShares;
}

double CGeomCoastPolygon::dGetUpCoastAdjacentPolygonBoundaryShare(int const nIndex) const
{
   // TODO 055 No check to see if nIndex < m_VdUpCoastAdjacentPolygonBoundaryShare.size()
   return m_VdUpCoastAdjacentPolygonBoundaryShare[nIndex];
}

void CGeomCoastPolygon::SetDownCoastAdjacentPolygonBoundaryShares(vector<double> const* pdVShares)
{
   m_VdDownCoastAdjacentPolygonBoundaryShare = *pdVShares;
}

double CGeomCoastPolygon::dGetDownCoastAdjacentPolygonBoundaryShare(int const nIndex) const
{
   // TODO 055 No check to see if nIndex < m_VdDownCoastAdjacentPolygonBoundaryShare.size()
   return m_VdDownCoastAdjacentPolygonBoundaryShare[nIndex];
}

void CGeomCoastPolygon::SetAvgUnconsD50(double const dD50)
{
   m_dAvgUnconsD50 = dD50;
}

double CGeomCoastPolygon::dGetAvgUnconsD50(void) const
{
   return m_dAvgUnconsD50;
}

void CGeomCoastPolygon::Display(void)
{
}

void CGeomCoastPolygon::AddCircularity(int const nPoly)
{
   m_VnCircularityWith.push_back(nPoly);
}

vector<int> CGeomCoastPolygon::VnGetCircularities(void) const
{
   return m_VnCircularityWith;
}

void CGeomCoastPolygon::AddCliffCollapseToSuspensionFine(double const dDepth)
{
   m_dCliffCollapseTalusFineToSuspension += dDepth;
}

double CGeomCoastPolygon::dGetCliffCollapseToSuspensionFine(void) const
{
  return m_dCliffCollapseTalusFineToSuspension;
}

void CGeomCoastPolygon::AddCliffCollapseErosionFine(double const dDepth)
{
   m_dCliffCollapseErosionFine += dDepth;
}

double CGeomCoastPolygon::dGetCliffCollapseErosionFine(void) const
{
   return m_dCliffCollapseErosionFine;
}

void CGeomCoastPolygon::AddCliffCollapseErosionSand(double const dDepth)
{
   m_dCliffCollapseErosionSand += dDepth;
}

double CGeomCoastPolygon::dGetCliffCollapseErosionSand(void) const
{
   return m_dCliffCollapseErosionSand;
}

void CGeomCoastPolygon::AddCliffCollapseErosionCoarse(double const dDepth)
{
   m_dCliffCollapseErosionCoarse += dDepth;
}

double CGeomCoastPolygon::dGetCliffCollapseErosionCoarse(void) const
{
   return m_dCliffCollapseErosionCoarse;
}

void CGeomCoastPolygon::AddCliffCollapseUnconsSandDeposition(double const dDepth)
{
   m_dCliffCollapseTalusSand += dDepth;
}

double CGeomCoastPolygon::dGetCliffCollapseUnconsSandDeposition(void) const
{
   return m_dCliffCollapseTalusSand;
}

void CGeomCoastPolygon::AddCliffCollapseUnconsCoarseDeposition(double const dDepth)
{  
   m_dCliffCollapseTalusCoarse += dDepth;
}

double CGeomCoastPolygon::dGetCliffCollapseUnconsCoarseDeposition(void) const
{
   return m_dCliffCollapseTalusCoarse;
}

void CGeomCoastPolygon::AddCliffCollapseSandErodedDeanProfile(double const dDepth)
{
   m_dCliffCollapseSandErodedDeanProfile += dDepth;
}

double CGeomCoastPolygon::dGetCliffCollapseSandErodedDeanProfile(void) const
{
   return m_dCliffCollapseSandErodedDeanProfile;
}

void CGeomCoastPolygon::AddCliffCollapseCoarseErodedDeanProfile(double const dDepth)
{
   m_dCliffCollapseCoarseErodedDeanProfile += dDepth;
}

double CGeomCoastPolygon::dGetCliffCollapseCoarseErodedDeanProfile(void) const
{
   return m_dCliffCollapseCoarseErodedDeanProfile;
}

void CGeomCoastPolygon::AddPlatformErosionToSuspensionUnconsFine(double const dDepth)
{
   m_dPlatformErosionToSuspensionFine += dDepth;
}

double CGeomCoastPolygon::dGetPlatformErosionToSuspensionUnconsFine(void) const
{
   return m_dPlatformErosionToSuspensionFine;
}

void CGeomCoastPolygon::AddPlatformErosionUnconsSand(double const dDepth)
{
   m_dPlatformErosionUnconsSand += dDepth;
}

double CGeomCoastPolygon::dGetPlatformErosionUnconsSand(void) const
{
   return m_dPlatformErosionUnconsSand;
}

void CGeomCoastPolygon::AddPlatformErosionUnconsCoarse(double const dDepth)
{
   m_dPlatformErosionUnconsCoarse += dDepth;
}

double CGeomCoastPolygon::dGetPlatformErosionUnconsCoarse(void) const
{
   return m_dPlatformErosionUnconsCoarse;
}

void CGeomCoastPolygon::SetPreExistingUnconsFine(double const dDepth)
{
   m_dPreExistingUnconsFine = dDepth;
}

double CGeomCoastPolygon::dGetPreExistingUnconsFine(void) const
{
   return m_dPreExistingUnconsFine;
}

void CGeomCoastPolygon::SetPreExistingUnconsSand(double const dDepth)
{
   m_dPreExistingUnconsSand = dDepth;
}

double CGeomCoastPolygon::dGetPreExistingUnconsSand(void) const
{
   return m_dPreExistingUnconsSand;
}

void CGeomCoastPolygon::SetPreExistingUnconsCoarse(double const dDepth)
{
   m_dPreExistingUnconsCoarse = dDepth;
}

double CGeomCoastPolygon::dGetPreExistingUnconsCoarse(void) const
{
   return m_dPreExistingUnconsCoarse;
}

void CGeomCoastPolygon::SetPreExistingConsFine(double const dDepth)
{
   m_dPreExistingConsFine = dDepth;
}

double CGeomCoastPolygon::dGetPreExistingConsFine(void) const
{
   return m_dPreExistingConsFine;
}

void CGeomCoastPolygon::SetPreExistingConsSand(double const dDepth)
{
   m_dPreExistingConsSand = dDepth;
}

double CGeomCoastPolygon::dGetPreExistingConsSand(void) const
{
   return m_dPreExistingConsSand;
}

void CGeomCoastPolygon::SetPreExistingConsCoarse(double const dDepth)
{
   m_dPreExistingConsCoarse = dDepth;
}

double CGeomCoastPolygon::dGetPreExistingConsCoarse(void) const
{
   return m_dPreExistingConsCoarse;
}

void CGeomCoastPolygon::SetSedimentInputUnconsFine(double const dDepth)
{
   m_dSedimentInputFine = dDepth;
}

double CGeomCoastPolygon::dGetSedimentInputUnconsFine(void) const
{
   return m_dSedimentInputFine;
}

void CGeomCoastPolygon::SetSedimentInputUnconsSand(double const dDepth)
{
   m_dSedimentInputSand = dDepth;
}

double CGeomCoastPolygon::dGetSedimentInputUnconsSand(void) const
{
   return m_dSedimentInputSand;
}

void CGeomCoastPolygon::SetSedimentInputUnconsCoarse(double const dDepth)
{
   m_dSedimentInputCoarse = dDepth;
}

double CGeomCoastPolygon::dGetSedimentInputUnconsCoarse(void) const
{
   return m_dSedimentInputCoarse;
}

void CGeomCoastPolygon::AppendVertex(CGeom2DIPoint const* pPti)
{
   m_VPtiVertices.push_back(*pPti);
}

int CGeomCoastPolygon::nGetNumVertices(void) const
{
   return static_cast<int>(m_VPtiVertices.size());
}

CGeom2DIPoint CGeomCoastPolygon::PtiGetVertex(int const nIndex) const
{
   // Note no check to see if nUndex < m_VPtiVertices.size()
   return m_VPtiVertices[nIndex];
}
 
CGeom2DIPoint CGeomCoastPolygon::PtiGetFillStartPoint(void)
{
   int nVertices = static_cast<int>(m_VPtiVertices.size());
   double dXTot = 0;
   double dYTot = 0;
 
   for (int n = 0; n < nVertices; n++)
   {
      dXTot += m_VPtiVertices[n].nGetX();
      dYTot += m_VPtiVertices[n].nGetY();
   }
   return CGeom2DIPoint(nRound(dXTot / nVertices), nRound(dYTot / nVertices));
}