altimetry-definitions.h

Go to the documentation of this file.

/* WOSS - World Ocean Simulation System -
 * 
 * Copyright (C) 2009 Federico Guerra
 * and regents of the SIGNET lab, University of Padova
 *
 * Author: Federico Guerra - federico@guerra-tlc.com
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */ 
 
/*
 * This software has been developed by Federico Guerra and SIGNET lab,
 * University of Padova, in collaboration with the NATO Centre for 
 * Maritime Research and Experimentation (http://www.cmre.nato.int ; 
 * E-mail: pao@cmre.nato.int), whose support is gratefully acknowledged.
 */
 
 
#ifndef ALTIMETRY_DEFINITIONS_H
#define ALTIMETRY_DEFINITIONS_H
 
 
#include <cassert>
#include <climits>
#include <map>
#include "custom-precision-double.h"
#include "time-definitions.h"
 
 
namespace woss {
  
 
  typedef std::map < PDouble , double > AltimetryMap; 
  typedef AltimetryMap::iterator AltIt;
  typedef AltimetryMap::const_iterator AltCIt;
  typedef AltimetryMap::reverse_iterator AltRIt;
  typedef AltimetryMap::const_reverse_iterator AltCRIt;
 
 
  #define ALTIMETRY_RANGE_STEPS (1)
 
 
  class Altimetry {
 
    
    public:
 
      
    Altimetry();
 
    Altimetry( AltimetryMap& map );
    
    Altimetry( double range, double altimetry );
    
    Altimetry( const Altimetry& copy );
 
    virtual ~Altimetry() { }
    
    
    virtual Altimetry* create() const { 
      return &((new Altimetry() )->updateMinMaxAltimetryValues()); ; }
 
    virtual Altimetry* create( AltimetryMap& map ) const {
      return &((new Altimetry( map ) )->updateMinMaxAltimetryValues()); }
    
    virtual Altimetry* create( const Altimetry& copy ) const { return new Altimetry( copy ); }
    
    virtual Altimetry* clone() const { return new Altimetry(*this); }
 
    static AltimetryMap& createNotValid();
    
    static AltimetryMap& createFlat(double altimetry = 0 );
 
                
    Altimetry& insertValue( double range, double altimetry );
 
    Altimetry& sumValue( double range, double altimetry );
    
    
    AltCIt findValue( double range ) const { return( altimetry_map.find(range) ); }
    
    
    Altimetry& eraseValue( double range ) { altimetry_map.erase(range); return *this; }
 
 
    virtual Altimetry* crop( double range_start, double range_end );            
 
    virtual Altimetry* randomize( double ratio_incr_value ) const;   
    
    AltCIt begin() const { return altimetry_map.begin(); }
    
    AltCIt end() const { return altimetry_map.end(); }
    
    AltCIt at( const int i ) const ;
 
    int size() const { return altimetry_map.size(); }
 
    bool empty() const { return altimetry_map.empty(); } 
 
 
    void clear() { altimetry_map.clear(); }
    
 
    static void setDebug( bool flag ) { debug = flag; }
 
    static bool getDebug( bool flag ) { return debug; }
 
    Altimetry& setEvolutionTimeQuantum( double quantum ) { evolution_time_quantum = quantum;  return *this;}
    
    Altimetry& setTotalRangeSteps( int r_s ) { total_range_steps = r_s;  return *this;}
    
    Altimetry& setRange( double r ) { range = r;  return *this; }
    
    Altimetry& setDepth( double d) { depth = d; return *this; }
    
    
    double getMaxRangeValue() const { return( altimetry_map.rbegin()->first ); }
 
    double getMinRangeValue() const { return( altimetry_map.begin()->first ); }
    
    double getMaxAltimetryValue() const { return( max_altimetry_value ); }
 
    double getMinAltimetryValue() const { return( min_altimetry_value ); }   
    
    long double getRangePrecision() const { return range_precision; }
 
    double getEvolutionTimeQuantum() const { return evolution_time_quantum; }
 
    double getRange() const { return range; }
    
    int getTotalRangeSteps() const { return total_range_steps; }
    
    double getDepth() const { return depth; }    
    
    
    virtual bool isValid() const; 
 
    virtual bool initialize(); 
    
    virtual Altimetry* timeEvolve( const Time& time_value );
    
    
    Altimetry& operator=( const Altimetry& copy ) ;
 
 
    friend bool operator==( const Altimetry& left, const Altimetry& right ) ;
 
    friend bool operator!=( const Altimetry& left, const Altimetry& right );
 
 
    friend const Altimetry operator+( const Altimetry& left, const Altimetry& right );
 
    friend const Altimetry operator-( const Altimetry& left, const Altimetry& right );
 
    
    friend const Altimetry operator+( const Altimetry& left, const double right );
 
    friend const Altimetry operator-( const Altimetry& left, const double right );  
 
    friend const Altimetry operator/( const Altimetry& left, const double right );
 
    friend const Altimetry operator*( const Altimetry& left, const double right );
 
    
    friend const Altimetry operator+( const double left, const Altimetry& right );
 
    friend const Altimetry operator-( const double left, const Altimetry& right );  
 
    friend const Altimetry operator/( const double left, const Altimetry& right );
 
    friend const Altimetry operator*( const double left, const Altimetry& right );  
    
 
    friend Altimetry& operator+=( Altimetry& left, const Altimetry& right );
 
    friend Altimetry& operator-=( Altimetry& left, const Altimetry& right );
 
    
    friend Altimetry& operator+=( Altimetry& left, double right );
 
    friend Altimetry& operator-=( Altimetry& left, double right );
    
    friend Altimetry& operator/=( Altimetry& left, double right );
 
    friend Altimetry& operator*=( Altimetry& left, double right );
  
 
    friend std::ostream& operator<<( std::ostream& os, const Altimetry& instance );
 
      
    protected:
 
      
    virtual Altimetry& updateMinMaxAltimetryValues();
    
    static bool debug;
    
    double range;
    
    int total_range_steps;   
     
    double min_altimetry_value;
 
    double max_altimetry_value;
    
    long double range_precision;
 
    Time last_evolution_time;
    
    double evolution_time_quantum;
    
    double depth;
    
    AltimetryMap altimetry_map;
    
    
  };
 
  
  class AltimBretschneider : public Altimetry {
    
    public:
      
    AltimBretschneider();
 
    AltimBretschneider( AltimetryMap& map );
    
    AltimBretschneider( double ch_height, double avg_per, int total_range_steps, double depth );
    
    AltimBretschneider( const AltimBretschneider& copy );
 
    virtual ~AltimBretschneider() { }
    
    
    virtual AltimBretschneider* create() const { 
      AltimBretschneider* ret_val = new AltimBretschneider();
      ret_val->updateMinMaxAltimetryValues();
      return ret_val; }
 
    virtual AltimBretschneider* create( AltimetryMap& map ) const {
      AltimBretschneider* ret_val = new AltimBretschneider( map );
      ret_val->updateMinMaxAltimetryValues();
      return ret_val;  }
    
    virtual AltimBretschneider* create( const AltimBretschneider& copy ) const { 
      return new AltimBretschneider( copy ); }
 
    virtual AltimBretschneider* create( const Altimetry& copy ) const { 
      AltimBretschneider const* dyn_ptr = dynamic_cast<AltimBretschneider const*>(&copy);
      if (dyn_ptr) {
        return new AltimBretschneider( *dyn_ptr );
      }
      return create();
    }
 
    virtual AltimBretschneider* create( double ch_height, double avg_per, int total_range_steps, double depth ) const {
      return new AltimBretschneider( ch_height, avg_per, total_range_steps, depth);
    }
    
    virtual AltimBretschneider* clone() const { return new AltimBretschneider(*this); }
  
  
    AltimBretschneider& operator=( const AltimBretschneider& copy ) ;
    
    
    virtual bool initialize();
    
    
    virtual bool isValid() const;
  
    
    virtual AltimBretschneider* timeEvolve( const Time& time_value );
    
    
    virtual AltimBretschneider* randomize( double ratio_incr_value ) const;     
 
    AltimBretschneider& setCharacteristicHeight( double h ) { char_height = h; return *this; }
 
    AltimBretschneider& setAveragePeriod( double p ) { average_period = p; return *this; }
 
    double getCharacteristicHeight() const { return char_height; }
 
    double getAveragePeriod() const { return average_period; }
      
    
    protected:
    
    
    virtual AltimBretschneider& createWaveSpectrum();
    
    double char_height;
    
    double average_period;
 
  };
  
  //non-inline operator declarations
  const Altimetry operator+( const Altimetry& left, const Altimetry& right ); 
 
  const Altimetry operator-( const Altimetry& left, const Altimetry& right );  
 
 
  const Altimetry operator+( const Altimetry& left, const double right );  
 
  const Altimetry operator-( const Altimetry& left, const double right );  
 
  const Altimetry operator/( const Altimetry& left, const double right );  
 
  const Altimetry operator*( const Altimetry& left, const double right );  
 
 
  const Altimetry operator+( const double left, const Altimetry& right );  
 
  const Altimetry operator-( const double left, const Altimetry& right );  
 
  const Altimetry operator/( const double left, const Altimetry& right );  
 
  const Altimetry operator*( const double left, const Altimetry& right );  
 
 
  Altimetry& operator+=( Altimetry& left, const Altimetry& right );  
 
  Altimetry& operator-=( Altimetry& left, const Altimetry& right );  
 
  Altimetry& operator+=( Altimetry& left, double right );  
 
 
  Altimetry& operator-=( Altimetry& left, double right ); 
 
  Altimetry& operator/=( Altimetry& left, double right ); 
 
  Altimetry& operator*=( Altimetry& left, double right ); 
  
  //inline functions
  inline AltimetryMap& Altimetry::createNotValid() {
    static AltimetryMap altimetry_map;
    altimetry_map.clear();
    return altimetry_map;
  }
 
 
  inline AltimetryMap& Altimetry::createFlat( double altimetry ) {
    static AltimetryMap altimetry_map;
    altimetry_map.clear();
    altimetry_map[0.0] = altimetry;
    return altimetry_map;
  }
 
 
  inline Altimetry& Altimetry::sumValue( double range, double altimetry ) {  
    if ( altimetry < min_altimetry_value ) min_altimetry_value = altimetry;
    if ( altimetry > max_altimetry_value ) max_altimetry_value = altimetry;
    
    AltIt it = altimetry_map.find( range );
    if ( it == altimetry_map.end() ) altimetry_map.insert( std::make_pair( range, altimetry ) );
    else it->second += altimetry; 
    return *this;
  }
 
 
  inline std::ostream& operator<<( std::ostream& os, const Altimetry& instance ) {
    if ( !instance.altimetry_map.empty() ) {
      os << "size = " << instance.altimetry_map.size() << "; min range = " << instance.altimetry_map.begin()->first 
                      << "; altimetry = " << instance.begin()->second 
                      << "; max range = " << instance.altimetry_map.rbegin()->first 
                      << "; altimetry = " << instance.altimetry_map.rbegin()->second;
    }
    else {
      os << "is empty.";
    }
    return os;
  }
 
 
  inline bool operator==( const Altimetry& left, const Altimetry& right ) { 
    if ( &left == &right ) return true; 
    return( left.altimetry_map == right.altimetry_map );
  }
 
 
  inline bool operator!=( const Altimetry& left, const Altimetry& right ) { 
    if ( &left == &right ) return false; 
    return( left.altimetry_map != right.altimetry_map );
  }
 
}
 
 
#endif /* ALTIMETRY_DEFINITIONS_H */