coast.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 <vector>
#include <algorithm>
using std::sort;
 
#include "cme.h"
#include "coast.h"
#include "line.h"
#include "i_line.h"

CRWCoast::CRWCoast(CSimulation* pSimIn)
    : m_nSeaHandedness(NULL_HANDED),
      m_nStartEdge(INT_NODATA),
      m_nEndEdge(INT_NODATA),
      m_dCurvatureDetailedMean(0),
      m_dCurvatureDetailedSTD(0),
      m_dCurvatureSmoothMean(0),
      m_dCurvatureSmoothSTD(0),
      m_pSim(pSimIn)
{
}

CRWCoast::~CRWCoast(void)
{
   for (unsigned int i = 0; i < m_pVProfile.size(); i++)
      delete m_pVProfile[i];
 
   for (unsigned int i = 0; i < m_pVLandform.size(); i++)
      delete m_pVLandform[i];
}

CSimulation* CRWCoast::pGetSim(void) const
{
   return m_pSim;
}

void CRWCoast::SetSeaHandedness(int const nNewHandedness)
{
   m_nSeaHandedness = nNewHandedness;
}

int CRWCoast::nGetSeaHandedness(void) const
{
   return m_nSeaHandedness;
}

void CRWCoast::SetStartEdge(int const nEdge)
{
   m_nStartEdge = nEdge;
}

int CRWCoast::nGetStartEdge(void) const
{
   return m_nStartEdge;
}

void CRWCoast::SetEndEdge(int const nEdge)
{
   m_nEndEdge = nEdge;
}

int CRWCoast::nGetEndEdge(void) const
{
   return m_nEndEdge;
}

void CRWCoast::SetCoastlineExtCRS(CGeomLine const* pLCoast)
{
   m_LCoastlineExtCRS = *pLCoast;
 
   int nLen = m_LCoastlineExtCRS.nGetSize();
 
   m_VnPolygonNode = vector<int>(nLen, INT_NODATA);
   m_VnBreakingDistance = vector<int>(nLen, INT_NODATA);
 
   m_VdCurvatureDetailed = vector<double>(nLen, DBL_NODATA);
   m_VdCurvatureSmooth = vector<double>(nLen, DBL_NODATA);
   m_VdDeepWaterWaveHeight = vector<double>(nLen, DBL_NODATA);
   m_VdDeepWaterWaveAngle = vector<double>(nLen, DBL_NODATA);
   m_VdDeepWaterWavePeriod = vector<double>(nLen, DBL_NODATA);
   m_VdBreakingWaveHeight = vector<double>(nLen, DBL_NODATA);
   m_VdWaveSetupSurge = vector<double>(nLen, 0); // it is better to initiate with DBL_NODATA but some values are outside of range in the interpolation
   // m_VdStormSurge = vector<double>(nLen, DBL_NODATA);
   m_VdRunUp = vector<double>(nLen, 0);
   m_VdCoastWaveHeight = vector<double>(nLen, DBL_NODATA);
   m_VdBreakingWaveAngle = vector<double>(nLen, DBL_NODATA);
   m_VdDepthOfBreaking = vector<double>(nLen, DBL_NODATA);
   m_VdFluxOrientation = vector<double>(nLen, DBL_NODATA);
   m_VdWaveEnergyAtBreaking = vector<double>(nLen, 0);
}
 
// void CRWCoast::SetFloodWaveSetupPointExtCRS(CGeomLine const* pLCoast)
// {
//    m_LFloodWaveSetupExtCRS = *pLCoast;
 
//    // int nLen = m_LFloodWaveSetupLineExtCRS.nGetSize();
// }
 
// void CRWCoast::SetFloodWaveSetupSurgePointExtCRS(CGeomLine const* pLCoast)
// {
//    m_LFloodWaveSetupSurgeExtCRS = *pLCoast;
 
//    // int nLen = m_LFloodWaveSetupSurgeLineExtCRS.nGetSize();
// }
 
// void CRWCoast::SetFloodWaveSetupSurgeRunupPointExtCRS(CGeomLine const* pLCoast)
// {
//    m_LFloodWaveSetupSurgeRunupExtCRS = *pLCoast;
 
//    // int nLen = m_LFloodWaveSetupSurgeRunupLineExtCRS.nGetSize();
// }

CGeomLine *CRWCoast::pLGetCoastlineExtCRS(void)
{
   return &m_LCoastlineExtCRS;
}

CGeom2DPoint *CRWCoast::pPtGetCoastlinePointExtCRS(int const n)
{
   // Point is in external CRS TODO 055 No check to see that n is < m_LCoastlineExtCRS.Size()
   return &m_LCoastlineExtCRS[n];
}
 
// CGeomLine *CRWCoast::pLGetFloodWaveSetupExtCRS(void)
// {
//    return &m_LFloodWaveSetupExtCRS;
// }
 
// CGeom2DPoint *CRWCoast::pPtGetFloodWaveSetupPointExtCRS(int const n)
// {
//    // Point is in external CRS TODO 055 No check to see that n is < m_LCoastlineExtCRS.Size()
//    return &m_LFloodWaveSetupExtCRS[n];
// }
 
// CGeom2DPoint *CRWCoast::pPtGetFloodWaveSetupSurgePointExtCRS(int const n)
// {
//    // Point is in external CRS TODO 055 No check to see that n is < m_LCoastlineExtCRS.Size()
//    return &m_LFloodWaveSetupSurgeExtCRS[n];
// }
 
// CGeom2DPoint *CRWCoast::pPtGetFloodWaveSetupSurgeRunupPointExtCRS(int const n)
// {
//    // Point is in external CRS TODO 055 No check to see that n is < m_LCoastlineExtCRS.Size()
//    return &m_LFloodWaveSetupSurgeRunupExtCRS[n];
// }

int CRWCoast::nGetCoastlineSize(void) const
{
   return m_LCoastlineExtCRS.nGetSize();
}
 
// void CRWCoast::DisplayCoastline(void)
// {
//    m_LCoastlineExtCRS.Display();
// }

void CRWCoast::SetCoastlineGridCRS(CGeomILine const* pILCoastCells)
{
   m_ILCellsMarkedAsCoastline = *pILCoastCells;
}
 
// void CRWCoast::AppendCellMarkedAsCoastline(CGeom2DIPoint const* pPti)
// {
//    m_ILCellsMarkedAsCoastline.Append(*pPti);
// }
//
// void CRWCoast::AppendCellMarkedAsCoastline(int const nX, int const nY)
// {
//    m_ILCellsMarkedAsCoastline.Append(CGeom2DIPoint(nX, nY));
// }

CGeom2DIPoint* CRWCoast::pPtiGetCellMarkedAsCoastline(int const n)
{
   // TODO 055 No check to see if n < size()
   return &m_ILCellsMarkedAsCoastline[n];
}
 
// int CRWCoast::nGetNCellsMarkedAsCoastline(void) const
// {
//    return m_ILCellsMarkedAsCoastline.size();
// }
 
// double CRWCoast::dGetCoastlineSegmentLength(int const m, int const n)
// {
//    // TODO 055 No check to see that m is < m_LCoastlineExtCRS.Size(), same for n
//    if (m == n)
//       return 0;
//
//    return hypot(m_LCoastlineExtCRS[n].dGetX() - m_LCoastlineExtCRS[m].dGetX(), m_LCoastlineExtCRS[n].dGetY() - m_LCoastlineExtCRS[m].dGetY());
// }
 
// double CRWCoast::dGetCoastlineLengthSoFar(int const n)
// {
//    // TODO 055 No check to see that n is < m_LCoastlineExtCRS.Size()
//    double dLen = 0;
//    for (int m = 0; m < n; m++)
//       dLen += dGetCoastlineSegmentLength(m, m+1);
//    return dLen;
// }

int CRWCoast::nGetCoastPointGivenCell(CGeom2DIPoint* pPtiCell)
{
   for (int nCoastPoint = 0; nCoastPoint < m_ILCellsMarkedAsCoastline.nGetSize(); nCoastPoint++)
   {
      if (m_ILCellsMarkedAsCoastline[nCoastPoint] == pPtiCell)
      {
         return nCoastPoint;
      }
   }
 
   // This cell is not under a coastline, so try the adjacent cells
   int n = -1;
   int nX = pPtiCell->nGetX();
   int nY = pPtiCell->nGetY();
   int nXAdj = 0;
   int nYAdj = 0;
 
   while (n <= 7)
   {
      switch (++n)
      {
         case 0:
            nXAdj = nX;
            nYAdj = nY - 1;
            break;
         case 1:
            nXAdj = nX + 1;
            nYAdj = nY - 1;
            break;
         case 2:
            nXAdj = nX + 1;
            nYAdj = nY;
            break;
         case 3:
            nXAdj = nX + 1;
            nYAdj = nY + 1;
            break;
         case 4:
            nXAdj = nX;
            nYAdj = nY + 1;
            break;
         case 5:
            nXAdj = nX - 1;
            nYAdj = nY + 1;
            break;
         case 6:
            nXAdj = nX - 1;
            nYAdj = nY;
            break;
         case 7:
            nXAdj = nX - 1;
            nYAdj = nY - 1;
            break;
      }
 
      CGeom2DIPoint PtiTmp(nXAdj, nYAdj);
      for (int nCoastPoint = 0; nCoastPoint < m_ILCellsMarkedAsCoastline.nGetSize(); nCoastPoint++)
      {
         if (m_ILCellsMarkedAsCoastline[nCoastPoint] == &PtiTmp)
         {
            *pPtiCell = PtiTmp;
            return nCoastPoint;
         }
      }
   }
 
   return INT_NODATA;
}

double CRWCoast::dGetDetailedCurvature(int const nCoastPoint) const
{
   // TODO 055 No sanity check for nCoastPoint < m_VdCurvatureDetailed.Size()
   return m_VdCurvatureDetailed[nCoastPoint];
}

void CRWCoast::SetDetailedCurvature(int const nCoastPoint, double const dCurvature)
{
   // TODO 055 No check to see if nCoastPoint < m_VdCurvatureDetailed.size()
   m_VdCurvatureDetailed[nCoastPoint] = dCurvature;
}

vector<double>* CRWCoast::pVGetDetailedCurvature(void)
{
   return &m_VdCurvatureDetailed;
}

double CRWCoast::dGetSmoothCurvature(int const nCoastPoint) const
{
   // TODO 055 No sanity check for nCoastPoint < m_VdCurvatureSmooth.Size()
   return m_VdCurvatureSmooth[nCoastPoint];
}

void CRWCoast::SetSmoothCurvature(int const nCoastPoint, double const dCurvature)
{
   // TODO 055 No check to see if nCoastPoint < m_VdCurvatureSmooth.size()
   m_VdCurvatureSmooth[nCoastPoint] = dCurvature;
}

vector<double>* CRWCoast::pVGetSmoothCurvature(void)
{
   return &m_VdCurvatureSmooth;
}

void CRWCoast::SetDetailedCurvatureMean(double const dMean)
{
   m_dCurvatureDetailedMean = dMean;
}
 
// //! Gets the mean of the coast's detailed curvature
// double CRWCoast::dGetDetailedCurvatureMean(void) const
// {
//    return m_dCurvatureDetailedMean;
// }

void CRWCoast::SetDetailedCurvatureSTD(double const dSTD)
{
   m_dCurvatureDetailedSTD = dSTD;
}
 
// //! Gets the standard deviation of the coast's detailed curvature
// double CRWCoast::dGetDetailedCurvatureSTD(void) const
// {
//    return m_dCurvatureDetailedSTD;
// }

void CRWCoast::SetSmoothCurvatureMean(double const dMean)
{
   m_dCurvatureSmoothMean = dMean;
}

double CRWCoast::dGetSmoothCurvatureMean(void) const
{
   return m_dCurvatureSmoothMean;
}

void CRWCoast::SetSmoothCurvatureSTD(double const dSTD)
{
   m_dCurvatureSmoothSTD = dSTD;
}

double CRWCoast::dGetSmoothCurvatureSTD(void) const
{
   return m_dCurvatureSmoothSTD;
}

CGeomProfile* CRWCoast::pGetProfile(int const nProfile)
{
   // TODO 055 Maybe add a safety check? that nProfile < m_pVProfile.size()
   return m_pVProfile[nProfile];
}

CGeomProfile* CRWCoast::pGetLastProfile(void)
{
   // TODO 055 Maybe add a safety check? that nProfile < m_pVProfile.size()
   return m_pVProfile.back();
}

void CRWCoast::AppendProfile(CGeomProfile* pProfile)
{
   m_pVProfile.push_back(pProfile);
}
 
// void CRWCoast::ReplaceProfile(int const nProfile, vector<CGeom2DPoint> const* pPtVProfileNew)
// {
//    // TODO 055 Maybe add a safety check? that nProfile < m_pVProfile.size()
//    m_pVProfile[nProfile].SetPointsInProfile(pPtVProfileNew);
// }

int CRWCoast::nGetNumProfiles(void) const
{
   return static_cast<int>(m_pVProfile.size());
}

void CRWCoast::CreateProfileDownCoastIndex(void)
{
   for (int n = 0; n < static_cast<int>(m_pVNormalProfileDownAllCoastpointSeq.size()); n++)
   {
      if (m_pVNormalProfileDownAllCoastpointSeq[n] != NULL)
         m_pVProfileDownCoastSeq.push_back(m_pVNormalProfileDownAllCoastpointSeq[n]);
   }
}

CGeomProfile* CRWCoast::pGetProfileWithDownCoastSeq(int const nProf) const
{
   // Note no check whether n < size()
   return m_pVProfileDownCoastSeq[nProf];
}

CGeomProfile* CRWCoast::pGetProfileWithUpCoastSeq(int const nProf) const
{
   // Note no check whether n < size()
   int nSize = static_cast<int>(m_pVProfileDownCoastSeq.size());
   return m_pVProfileDownCoastSeq[nSize - (nProf + 1)];
}

CGeomProfile* CRWCoast::pGetDownCoastProfile(CGeomProfile const* pProfile)
{
   return pProfile->pGetDownCoastAdjacentProfile();
}

CGeomProfile* CRWCoast::pGetDownCoastProfileNotIncLastProfile(CGeomProfile const* pProfile)
{
   CGeomProfile* pDownCoastProfile = pProfile->pGetDownCoastAdjacentProfile();
 
   if ((pDownCoastProfile != NULL) && (pDownCoastProfile->bEndOfCoast()))
      return NULL;
 
   return pDownCoastProfile;
}

CGeomProfile* CRWCoast::pGetUpCoastProfile(CGeomProfile const* pProfile)
{
   return pProfile->pGetUpCoastAdjacentProfile();
}

void CRWCoast::SetCoastDeepWaterWaveHeight(int const nCoastPoint, double const dHeight)
{
   // TODO 055 No check to see if nCoastPoint < m_VdDeepWaterWaveHeight.size()
   m_VdDeepWaterWaveHeight[nCoastPoint] = dHeight;
}
 
// //! Gets the deep water wave height for this coast point
// double CRWCoast::dGetCoastDeepWaterWaveHeight(int const nCoastPoint) const
// {
//    // TODO 055 No check to see if nCoastPoint < m_VdDeepWaterWaveHeight.size()
//    return m_VdDeepWaterWaveHeight[nCoastPoint];
// }

void CRWCoast::SetCoastDeepWaterWaveAngle(int const nCoastPoint, double const dOrientation)
{
   // TODO 055 No check to see if nCoastPoint < m_VdDeepWaterWaveAngle.size()
   m_VdDeepWaterWaveAngle[nCoastPoint] = dOrientation;
}

double CRWCoast::dGetCoastDeepWaterWaveAngle(int const nCoastPoint) const
{
   // TODO 055 No check to see if nCoastPoint < m_VdDeepWaterWaveAngle.size()
   return m_VdDeepWaterWaveAngle[nCoastPoint];
}

void CRWCoast::SetCoastDeepWaterWavePeriod(int const nCoastPoint, double const dPeriod)
{
   m_VdDeepWaterWavePeriod[nCoastPoint] = dPeriod;
}

double CRWCoast::dGetCoastDeepWaterWavePeriod(int const nCoastPoint) const
{
   return m_VdDeepWaterWavePeriod[nCoastPoint];
}

void CRWCoast::SetBreakingWaveHeight(int const nCoastPoint, double const dHeight)
{
   // TODO 055 No check to see if nCoastPoint < m_VdBreakingWaveHeight.size()
   m_VdBreakingWaveHeight[nCoastPoint] = dHeight;
}

double CRWCoast::dGetBreakingWaveHeight(int const nCoastPoint) const
{
   // TODO 055 No check to see if nCoastPoint < m_VdBreakingWaveHeight.size()
   return m_VdBreakingWaveHeight[nCoastPoint];
}

void CRWCoast::SetWaveSetupSurge(int const nCoastPoint, double const dWaveSetup)
{
   m_VdWaveSetupSurge[nCoastPoint] = dWaveSetup;
}

double CRWCoast::dGetWaveSetupSurge(int const nCoastPoint) const
{
   return m_VdWaveSetupSurge[nCoastPoint];
}
 
// void CRWCoast::SetStormSurge(int const nCoastPoint, double const dStormSurge)
// {
//    m_VdStormSurge[nCoastPoint] = dStormSurge;
// }
 
// double CRWCoast::dGetStormSurge(int const nCoastPoint) const
// {
//    return m_VdStormSurge[nCoastPoint];
// }

void CRWCoast::SetRunUp(int const nCoastPoint, double const dRunUp)
{
   m_VdRunUp[nCoastPoint] = dRunUp;
}

double CRWCoast::dGetRunUp(int const nCoastPoint) const
{
   return m_VdRunUp[nCoastPoint];
}

double CRWCoast::dGetLevel(int const nCoastPoint, int const level) const
{
   switch (level)
   {
      case 0: // WAVESETUPSURGE:
         return m_VdWaveSetupSurge[nCoastPoint];
         break;
      case 1: // WAVESETUPSURGE + RUNUP:
         return m_VdWaveSetupSurge[nCoastPoint] + m_VdRunUp[nCoastPoint];
         break;
      default:
         return 0;
   }
}

void CRWCoast::SetCoastWaveHeight(int const nCoastPoint, double const dHeight)
{
   // TODO 055 No check to see if nCoastPoint < m_VdBreakingWaveHeight.size()
   m_VdCoastWaveHeight[nCoastPoint] = dHeight;
}

double CRWCoast::dGetCoastWaveHeight(int const nCoastPoint) const
{
   // TODO 055 No check to see if nCoastPoint < m_VdBreakingWaveHeight.size()
   return m_VdCoastWaveHeight[nCoastPoint];
}

void CRWCoast::SetBreakingWaveAngle(int const nCoastPoint, double const dOrientation)
{
   // TODO 055 No check to see if nCoastPoint < m_VdBreakingWaveAngle.size()
   m_VdBreakingWaveAngle[nCoastPoint] = dOrientation;
}

double CRWCoast::dGetBreakingWaveAngle(int const nCoastPoint) const
{
   // TODO 055 No check to see if nCoastPoint < m_VdBreakingWaveAngle.size()
   return m_VdBreakingWaveAngle[nCoastPoint];
}

void CRWCoast::SetDepthOfBreaking(int const nCoastPoint, double const dDepth)
{
   // TODO 055 No check to see if nCoastPoint < m_VdDepthOfBreaking.size()
   m_VdDepthOfBreaking[nCoastPoint] = dDepth;
}

double CRWCoast::dGetDepthOfBreaking(int const nCoastPoint) const
{
   // TODO 055 No check to see if nCoastPoint < m_VdDepthOfBreaking.size()
   return m_VdDepthOfBreaking[nCoastPoint];
}

void CRWCoast::SetBreakingDistance(int const nCoastPoint, int const nDist)
{
   // TODO 055 No check to see if nCoastPoint < m_VnBreakingDistance.size()
   m_VnBreakingDistance[nCoastPoint] = nDist;
}

int CRWCoast::nGetBreakingDistance(int const nCoastPoint) const
{
   // TODO 055 No check to see if nCoastPoint < m_VnBreakingDistance.size()
   return m_VnBreakingDistance[nCoastPoint];
}

void CRWCoast::SetFluxOrientation(int const nCoastPoint, double const dOrientation)
{
   // TODO 055 No check to see if nCoastPoint < m_VdFluxOrientation.size()
   m_VdFluxOrientation[nCoastPoint] = dOrientation;
}

double CRWCoast::dGetFluxOrientation(int const nCoastPoint) const
{
   // TODO 055 No check to see if nCoastPoint < m_VdFluxOrientation.size()
   return m_VdFluxOrientation[nCoastPoint];
}

void CRWCoast::SetWaveEnergyAtBreaking(int const nCoastPoint, double const dEnergy)
{
   // TODO 055 No check to see if nCoastPoint < m_VdWaveEnergyAtBreaking.size()
   //    assert(isfinite(dEnergy));
   m_VdWaveEnergyAtBreaking[nCoastPoint] = dEnergy;
}

double CRWCoast::dGetWaveEnergyAtBreaking(int const nCoastPoint) const
{
   // TODO 055 No check to see if nCoastPoint < m_VdWaveEnergyAtBreaking.size()
   //    assert(isfinite(m_VdWaveEnergyAtBreaking[nCoastPoint]));
   return m_VdWaveEnergyAtBreaking[nCoastPoint];
}

void CRWCoast::CreateProfilesAtCoastPoints(void)
{
   m_pVNormalProfileDownAllCoastpointSeq.resize(m_LCoastlineExtCRS.nGetSize(), NULL);
}

void CRWCoast::InsertProfilesInProfileCoastPointIndex(void)
{
   for (int n = 0; n < static_cast<int>(m_pVProfile.size()); n++)
   {
      int nCoastPoint = m_pVProfile[n]->nGetCoastPoint();
 
      // Note no check to see whether nCoastPoint < m_pVNormalProfileDownAllCoastpointSeq.size()
      m_pVNormalProfileDownAllCoastpointSeq.at(nCoastPoint) = m_pVProfile[n];
   }
}

void CRWCoast::SetProfileAtCoastPoint(int const nCoastPoint, CGeomProfile* const pProfile)
{
   // Note no check to see whether nCoastPoint < m_pVNormalProfileDownAllCoastpointSeq.size()
   m_pVNormalProfileDownAllCoastpointSeq.at(nCoastPoint) = pProfile;
}

bool CRWCoast::bIsProfileAtCoastPoint(int const nCoastPoint) const
{
   if (m_pVNormalProfileDownAllCoastpointSeq.at(nCoastPoint) == NULL)
       return false;
 
   return true;
}

CGeomProfile* CRWCoast::pGetProfileAtCoastPoint(int const nCoastPoint) const
{
   return m_pVNormalProfileDownAllCoastpointSeq[nCoastPoint];
}

void CRWCoast::AppendCoastLandform(CACoastLandform* pCoastLandform)
{
   m_pVLandform.push_back(pCoastLandform);
}

CACoastLandform *CRWCoast::pGetCoastLandform(int const nCoastPoint)
{
   if (nCoastPoint < static_cast<int>(m_pVLandform.size()))
      return m_pVLandform[nCoastPoint];
 
   return NULL;
}

void CRWCoast::SetPolygonNode(int const nPoint, int const nNode)
{
   // TODO 055 No check to see if nPoint < m_VnPolygonNode.size()
   m_VnPolygonNode[nPoint] = nNode;
}

int CRWCoast::nGetPolygonNode(int const nPoint) const
{
   // TODO 055 No check to see if nPoint < m_VnPolygonNode.size()
   return m_VnPolygonNode[nPoint];
}

CGeomCoastPolygon* CRWCoast::pPolyCreatePolygon(int const nGlobalID, int const nCoastID, int const nCoastPoint, CGeom2DIPoint const* pPtiNode, CGeom2DIPoint const* pPtiAntiNode, int const nProfileUpCoast, int const nProfileDownCoast, vector<CGeom2DPoint> const* pVIn, int const nNumPointsUpCoastProfile, int const nNumPointsDownCoastProfile, bool const bStartCoast, bool const bEndCoast)
{
   CGeomCoastPolygon* pPolygon = new CGeomCoastPolygon(nGlobalID, nCoastID, nCoastPoint, nProfileUpCoast, nProfileDownCoast, pVIn, nNumPointsUpCoastProfile, nNumPointsDownCoastProfile, pPtiNode, pPtiAntiNode, bStartCoast, bEndCoast);
 
   return pPolygon;
}

int CRWCoast::nGetNumPolygons(void) const
{
   return pGetSim()->nGetCoastPolygonSize();
}

CGeomCoastPolygon* CRWCoast::pGetPolygon(int const nPoly) const
{
   // TODO 055 No check to see if nPoint < m_VnPolygon.size()
   return pGetSim()->pGetPolygon(nPoly);
}
 
// //! Appends to coast polygon length
// void CRWCoast::AppendPolygonLength(const double dLength)
// {
//    m_VdPolygonLength.push_back(dLength);
// }
//
// //! Gets coast polygon length
// double CRWCoast::dGetPolygonLength(int const nIndex) const
// {
//    // TODO 055 No check to see if nIndex < m_VdPolygonLength.size()
//    return m_VdPolygonLength[nIndex];
// }

int CRWCoast::nGetNumShadowBoundaries(void) const
{
   return static_cast<int>(m_LShadowBoundary.size());
}

void CRWCoast::AppendShadowBoundary(CGeomLine const* pLBoundary)
{
   m_LShadowBoundary.push_back(*pLBoundary);
}

CGeomLine *CRWCoast::pGetShadowBoundary(int const n)
{
   // TODO 055 No check to see if n < m_LShadowBoundary.size()
   return &m_LShadowBoundary[n];
}

int CRWCoast::nGetNumShadowDowndriftBoundaries(void) const
{
   return static_cast<int>(m_LShadowDowndriftBoundary.size());
}

void CRWCoast::AppendShadowDowndriftBoundary(CGeomLine const* pLBoundary)
{
   m_LShadowDowndriftBoundary.push_back(*pLBoundary);
}

CGeomLine* CRWCoast::pGetShadowDowndriftBoundary(int const n)
{
   // TODO 055 No check to see if n < m_LShadowDowndriftBoundary.size()
   return &m_LShadowDowndriftBoundary[n];
}