/import/home/rettenbs/src/SWE/src/scenarios/SWE_AsagiScenario.hh

Go to the documentation of this file.

#ifndef SWEASAGISCENARIO_HPP_
#define SWEASAGISCENARIO_HPP_

#include <cassert>
#include <cstring>
#include <string>
#include <iostream>
#include <map>
#include <asagi.h>
#include "SWE_Scenario.hh"

class SWE_AsagiGrid
{
private:
        asagi::Grid* _grid;
        unsigned int _refCount;
public:
        SWE_AsagiGrid()
        {
                _grid = asagi::Grid::create();
                _refCount = 0;
        }

        void open(const std::string &i_filename)
        {
                if (_refCount > 0)
                        return;

                int l_asagiOpen = _grid->open(i_filename.c_str());

                //open the grid
                if( l_asagiOpen != 0 ) {
                        std::cout << "Could not open bathymetry file: " << i_filename << std::endl;
                std::cout << "Error code: " << l_asagiOpen << std::endl;
                assert(false);
                }

                _refCount++;
        }

        void close()
        {
                _refCount--;

                if (_refCount > 0)
                        // At least one more scenario is using this grid
                        // -> do nothing
                        return;

                // This grid is no longer used
                delete _grid;
        }

        asagi::Grid& grid()
        {
                return *_grid;
        }
};

class SWE_AsagiScenario: public SWE_Scenario {
//private:
        static std::map<std::string, SWE_AsagiGrid> grids;

    SWE_AsagiGrid &bathymetryGrid;

    SWE_AsagiGrid &displacementGrid;

    const bool dynamicDisplacement;

    const float duration;

#ifndef NDEBUG

    float bathymetryRange[4];
#endif

    float displacementRange[4];

    float dynamicDisplacementTimeRange[2];

   float simulationArea[4];

  public:
   SWE_AsagiScenario ( const std::string i_bathymetryFile,
                       const std::string i_displacementFile,
                       const float i_duration,
                       const float i_simulationArea[4],
                       const bool i_dynamicDisplacement = false ):
                       bathymetryGrid(grids[i_bathymetryFile]),
                       displacementGrid(grids[i_displacementFile]),
                       dynamicDisplacement(i_dynamicDisplacement),
                       duration(i_duration)
  {

       // open bathymetry grid
           bathymetryGrid.open(i_bathymetryFile);

       // open displacement grid
      displacementGrid.open(i_displacementFile);

#ifndef NDEBUG
      //read grid information
      bathymetryRange[0] = bathymetryGrid.grid().getXMin();
      bathymetryRange[1] = bathymetryGrid.grid().getXMax();
      bathymetryRange[2] = bathymetryGrid.grid().getYMin();
      bathymetryRange[3] = bathymetryGrid.grid().getYMax();
#endif

      displacementRange[0] = displacementGrid.grid().getXMin();
      displacementRange[1] = displacementGrid.grid().getXMax();
      displacementRange[2] = displacementGrid.grid().getYMin();
      displacementRange[3] = displacementGrid.grid().getYMax();
      if(dynamicDisplacement == false) {
        dynamicDisplacementTimeRange[0] = dynamicDisplacementTimeRange[1] = 0;
      }
      else {
        dynamicDisplacementTimeRange[0] = displacementGrid.grid().getZMin();
        dynamicDisplacementTimeRange[1] = displacementGrid.grid().getZMax();
      }

      memcpy(simulationArea, i_simulationArea, sizeof(simulationArea));

#ifndef NDEBUG
#ifdef PRINT_ASAGI_INFORMATION
      //print information
      std::cout << "  *** scenarios::Asagi created" << std::endl
                << "    i_bathymetryFile=" << i_bathymetryFile << std::endl
                << "    i_displacementFile=" << i_displacementFile << std::endl
                << "    duration= " << duration << std::endl
                << "    bathymetryRange[0]=" << bathymetryRange[0] << std::endl
                << "    bathymetryRange[1]=" << bathymetryRange[1] << std::endl
                << "    bathymetryRange[2]=" << bathymetryRange[2] << std::endl
                << "    bathymetryRange[3]=" << bathymetryRange[3] << std::endl
                << "    displacementRange[0]=" << displacementRange[0] << std::endl
                << "    displacementRange[1]=" << displacementRange[1] << std::endl
                << "    displacementRange[2]=" << displacementRange[2] << std::endl
                << "    displacementRange[3]=" << displacementRange[3] << std::endl
                << "    dynamicDisplacementTimeRange[0]=" << dynamicDisplacementTimeRange[0] << std::endl
                << "    dynamicDisplacementTimeRange[1]=" << dynamicDisplacementTimeRange[1] << std::endl
                << "    simulationArea[0]=" << simulationArea[0] << std::endl
                << "    simulationArea[1]=" << simulationArea[1] << std::endl
                << "    simulationArea[2]=" << simulationArea[2] << std::endl
                << "    simulationArea[3]=" << simulationArea[3] << std::endl;
#endif
#endif

    }

    virtual ~SWE_AsagiScenario() {
    }

    void deleteGrids() {
      bathymetryGrid.close();
      displacementGrid.close();
    }

    //methods from SWE_SCENARIO

    float getWaterHeight( float i_positionX,
                          float i_positionY ) {
      assert(i_positionX > bathymetryRange[0]);
      assert(i_positionX < bathymetryRange[1]);
      assert(i_positionY > bathymetryRange[2]);
      assert(i_positionY < bathymetryRange[3]);

      float bathymetryValue = bathymetryGrid.grid().getFloat2D(i_positionX, i_positionY);

      if( bathymetryValue > (float)0. ) {
        return 0.;
      }
      else {
        return -bathymetryValue;
      }
    }

    float getBathymetry( const float i_positionX,
                         const float i_positionY ) {
      //assert that the 2D wrapper is not used for 3D displacements
      //assert(dynamicDisplacement == false);
      // no assertation for compability

      return getBathymetryAndDynamicDisplacement(i_positionX, i_positionY, 0);
    }

    float getBathymetryAndDynamicDisplacement( const float i_positionX,
                                               const float i_positionY,
                                               const float i_time ) {
      assert(i_positionX > bathymetryRange[0]);
      assert(i_positionX < bathymetryRange[1]);
      assert(i_positionY > bathymetryRange[2]);
      assert(i_positionY < bathymetryRange[3]);

      float bathymetryValue = bathymetryGrid.grid().getFloat2D(i_positionX, i_positionY);

      //bathymetryValue = (float) 0.; //TODO: remove: old file format

      float displacementValue = (float) 0.;

      if ( i_positionX > displacementRange[0] &&
           i_positionX < displacementRange[1] &&
           i_positionY > displacementRange[2] &&
           i_positionY < displacementRange[3] ) {
        if(dynamicDisplacement == false)
          displacementValue = displacementGrid.grid().getFloat2D(i_positionX, i_positionY);
        else
          displacementValue = displacementGrid.grid().getFloat3D(i_positionX, i_positionY, i_time);
      }

      return bathymetryValue + displacementValue;
    }

    bool dynamicDisplacementAvailable(const float i_time) {
      if( i_time > dynamicDisplacementTimeRange[0] &&
          i_time < dynamicDisplacementTimeRange[1] )
        return true;
      else
        return false;
    }

    float endSimulation() {
      return duration;
    };

    BoundaryType getBoundaryType( BoundaryEdge i_edge ) {
      //nothing other than outflow/transparent boundary conditions makes sense in a real simulation
      return OUTFLOW;
    }

    float getBoundaryPos(BoundaryEdge i_edge) {
       if ( i_edge == BND_LEFT )
         return simulationArea[0];
       else if ( i_edge == BND_RIGHT)
         return simulationArea[1];
       else if ( i_edge == BND_BOTTOM )
         return simulationArea[2];
       else
         return simulationArea[3];
    };
};

#endif /* SWEASAGISCENARIO_HPP_ */