coast.h

Go to the documentation of this file.

 
#ifndef COAST_H
#define COAST_H
/*===============================================================================================================================
 
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 "cme.h"
#include "profile.h"
#include "cell.h"
#include "coast_landform.h"
#include "coast_polygon.h"
 
class CGeomProfile;
class CACoastLandform;
class CGeomCoastPolygon;
 
class CRWCoast
{
private:
   int m_nSeaHandedness;

   int m_nStartEdge;

   int m_nEndEdge;

   double m_dCurvatureDetailedMean;

   double m_dCurvatureDetailedSTD;

   double m_dCurvatureSmoothMean;

   double m_dCurvatureSmoothSTD;

   CSimulation* m_pSim;

   CGeomLine m_LCoastlineExtCRS;

   CGeomLine m_LFloodWaveSetupExtCRS;

   CGeomLine m_LFloodWaveSetupSurgeExtCRS;

   CGeomLine m_LFloodWaveSetupSurgeRunupExtCRS;
 
   // The following have the same length as m_LCoastlineExtCRS (which may be different each timestep)

   CGeomILine m_ILCellsMarkedAsCoastline;

   vector<int> m_VnBreakingDistance;

   vector<int> m_VnPolygonNode;

   vector<double> m_VdCurvatureDetailed;

   vector<double> m_VdCurvatureSmooth;

   vector<double> m_VdDeepWaterWaveHeight;

   vector<double> m_VdDeepWaterWaveAngle;

   vector<double> m_VdDeepWaterWavePeriod;

   vector<double> m_VdBreakingWaveHeight;

   vector<double> m_VdWaveSetupSurge;
 
   // The storm surge on a normal drawn from each point on m_LCoastlineExtCRS
// vector<double> m_VdStormSurge;

   vector<double> m_VdRunUp;

   vector<double> m_VdCoastWaveHeight;

   vector<double> m_VdBreakingWaveAngle;

   vector<double> m_VdDepthOfBreaking;

   vector<double> m_VdFluxOrientation;

   vector<double> m_VdWaveEnergyAtBreaking;

   vector<CACoastLandform*> m_pVLandform;

   vector<CGeomProfile*> m_pVNormalProfileDownAllCoastpointSeq;
 
   // These do not have the same length as m_LCoastlineExtCRS

   vector<CGeomProfile*> m_pVProfile;

   vector<CGeomProfile*> m_pVProfileDownCoastSeq;

   vector<CGeomLine> m_LShadowBoundary;

   vector<CGeomLine> m_LShadowDowndriftBoundary;
 
protected:
 
public:
   explicit CRWCoast(CSimulation*);
   ~CRWCoast(void);
 
   CSimulation* pGetSim(void) const;
 
   void SetSeaHandedness(int const);
   int nGetSeaHandedness(void) const;
 
   void SetStartEdge(int const);
   int nGetStartEdge(void) const;
 
   void SetEndEdge(int const);
   int nGetEndEdge(void) const;
 
   void SetCoastlineExtCRS(CGeomLine const*);
   CGeomLine* pLGetCoastlineExtCRS(void);
// CGeomLine* pLGetFloodWaveSetupExtCRS(void);
// void SetFloodWaveSetupPointExtCRS(CGeomLine const*);
// void SetFloodWaveSetupSurgePointExtCRS(CGeomLine const*);
// void SetFloodWaveSetupSurgeRunupPointExtCRS(CGeomLine const*);
   CGeom2DPoint* pPtGetCoastlinePointExtCRS(int const);
// CGeom2DPoint* pPtGetFloodWaveSetupPointExtCRS(int const);
// CGeom2DPoint* pPtGetFloodWaveSetupSurgePointExtCRS(int const);
// CGeom2DPoint* pPtGetFloodWaveSetupSurgeRunupPointExtCRS(int const);
 
   int nGetCoastlineSize(void) const;
//    double dGetCoastlineSegmentLength(int const, int const);
//    double dGetCoastlineLengthSoFar(int const);
//    void DisplayCoastline(void);
 
   void SetCoastlineGridCRS(CGeomILine const*);
//    void AppendCellMarkedAsCoastline(CGeom2DIPoint const*);
//    void AppendCellMarkedAsCoastline(int const, int const);
   CGeom2DIPoint* pPtiGetCellMarkedAsCoastline(int const);
//    int nGetNCellsMarkedAsCoastline(void) const;
   int nGetCoastPointGivenCell(CGeom2DIPoint*);
 
   double dGetDetailedCurvature(int const) const;
   void SetDetailedCurvature(int const, double const);
   vector<double>* pVGetDetailedCurvature(void);
   double dGetSmoothCurvature(int const) const;
   void SetSmoothCurvature(int const, double const);
   vector<double>* pVGetSmoothCurvature(void);
   void SetDetailedCurvatureMean(double const);
   // double dGetDetailedCurvatureMean(void) const;
   void SetDetailedCurvatureSTD(double const);
   // double dGetDetailedCurvatureSTD(void) const;
   void SetSmoothCurvatureMean(double const);
   double dGetSmoothCurvatureMean(void) const;
   void SetSmoothCurvatureSTD(double const);
   double dGetSmoothCurvatureSTD(void) const;
 
   void AppendProfile(CGeomProfile*);
   CGeomProfile* pGetProfile(int const);
   CGeomProfile* pGetLastProfile(void);
//    void ReplaceProfile(int const, vector<CGeom2DPoint> const*);
   int nGetNumProfiles(void) const;
   void CreateProfileDownCoastIndex(void);
   void InsertProfilesInProfileCoastPointIndex(void);
 
   CGeomProfile* pGetDownCoastProfile(CGeomProfile const* pProfile);
   CGeomProfile* pGetDownCoastProfileNotIncLastProfile(CGeomProfile const* pProfile);
   CGeomProfile* pGetUpCoastProfile(CGeomProfile const* pProfile);
 
   void CreateProfilesAtCoastPoints(void);
   void SetProfileAtCoastPoint(int const, CGeomProfile* const);
   bool bIsProfileAtCoastPoint(int const) const;
   CGeomProfile* pGetProfileAtCoastPoint(int const) const;
   CGeomProfile* pGetProfileWithDownCoastSeq(int const) const;
   CGeomProfile* pGetProfileWithUpCoastSeq(int const) const;
 
   void SetCoastDeepWaterWaveHeight(int const, double const);
   // double dGetCoastDeepWaterWaveHeight(int const) const;
 
   void SetCoastDeepWaterWaveAngle(int const, double const);
   double dGetCoastDeepWaterWaveAngle(int const) const;
 
   void SetCoastDeepWaterWavePeriod(int const, double const);
   double dGetCoastDeepWaterWavePeriod(int const) const;
 
   void SetBreakingWaveHeight(int const, double const);
   double dGetBreakingWaveHeight(int const) const;
 
   void SetCoastWaveHeight(int const, double const);
   double dGetCoastWaveHeight(int const) const;
 
   void SetBreakingWaveAngle(int const, double const);
   double dGetBreakingWaveAngle(int const) const;
 
   void SetWaveSetupSurge(int const, double const);
   double dGetWaveSetupSurge(int const) const;
 
// void SetStormSurge(int const, double const);
// double dGetStormSurge(int const) const;
 
   void SetRunUp(int const, double const);
   double dGetRunUp(int const) const;
 
   double dGetLevel(int const, int const) const;
 
   void SetDepthOfBreaking(int const, double const);
   double dGetDepthOfBreaking(int const) const;
 
   void SetBreakingDistance(int const, int const);
   int nGetBreakingDistance(int const) const;
 
   void SetFluxOrientation(int const, double const);
   double dGetFluxOrientation(int const) const;
 
   void SetWaveEnergyAtBreaking(int const, double const);
   double dGetWaveEnergyAtBreaking(int const) const;
 
   void AppendCoastLandform(CACoastLandform*);
   CACoastLandform* pGetCoastLandform(int const);
 
   void SetPolygonNode(int const, int const);
   int nGetPolygonNode(int const) const;
   CGeomCoastPolygon* pPolyCreatePolygon(int const, int const, int const, CGeom2DIPoint const*, CGeom2DIPoint const*, int const, int const, vector<CGeom2DPoint> const*, int const, int const, bool const, bool const);
   int nGetNumPolygons(void) const;
   CGeomCoastPolygon* pGetPolygon(int const) const;
 
   // void AppendPolygonLength(const double);
   // double dGetPolygonLength(int const) const;
 
   int nGetNumShadowBoundaries(void) const;
   void AppendShadowBoundary(CGeomLine const*);
   CGeomLine* pGetShadowBoundary(int const);
 
   int nGetNumShadowDowndriftBoundaries(void) const;
   void AppendShadowDowndriftBoundary(CGeomLine const*);
   CGeomLine* pGetShadowDowndriftBoundary(int const);
};
#endif // COAST_H