sediment-deck41-db-logic-control.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 FLOOR_CONDITIONS_H
#define FLOOR_CONDITIONS_H
 
 
#ifdef WOSS_NETCDF_SUPPORT
 
#include <sediment-definitions.h>
 
 
namespace woss {
  
    
  static const int DECK41_FLOORTYPE_GRAVEL = 0; 
  static const int DECK41_FLOORTYPE_SAND = 1;  
  static const int DECK41_FLOORTYPE_SILT = 2; 
  static const int DECK41_FLOORTYPE_CLAY = 3; 
  static const int DECK41_FLOORTYPE_OOZE = 4; 
  static const int DECK41_FLOORTYPE_MUD = 5; 
  static const int DECK41_FLOORTYPE_ROCKS = 6; 
  static const int DECK41_FLOORTYPE_ORGANIC = 7; 
  static const int DECK41_FLOORTYPE_NODULES = 8; 
  static const int DECK41_FLOORTYPE_HARDBOTTOM = 9; 
  static const int DECK41_FLOORTYPE_NODATA = 11; 
  class Deck41TypeTests {
 
    
    public:
      
 
    Deck41TypeTests();
    
    virtual ~Deck41TypeTests();
 
    
    bool conditionFloorA( const Deck41Types& types ) const ; 
    
    bool conditionFloorB( const Deck41Types& types ) const ; 
    
    bool conditionFloorC( const Deck41Types& types ) const ; 
    
    bool conditionFloorD( const Deck41Types& types ) const ; 
    
    bool conditionFloorE( const Deck41Types& types ) const ; 
    
    bool conditionFloorF( const Deck41Types& types ) const ;
    
    bool conditionFloorG( const Deck41Types& types ) const ; 
    
 
    bool getConditionA() const { return condition_a; }
    
    bool getConditionB() const { return condition_b; }
    
    bool getConditionC() const { return condition_c; }
    
    bool getConditionD() const { return condition_d; }
    
    bool getConditionE() const { return condition_e; }
    
    bool getConditionF() const { return condition_f; }
    
    bool getConditionG() const { return condition_g; }
    
 
    void updateAllConditions( const Deck41Types& types );  
      
      
    private:
      
 
    bool condition_a;
    
    bool condition_b;
    
    bool condition_c;
    
    bool condition_d;
    
    bool condition_e;
    
    bool condition_f;
    
    bool condition_g;
    
    
  };
 
 
  //inline functions
  inline bool Deck41TypeTests::conditionFloorA(const Deck41Types& types) const { // first = return main type
    bool equal = (types.first == types.second);
    bool first = (types.first == DECK41_FLOORTYPE_GRAVEL) || (types.first == DECK41_FLOORTYPE_SAND) || (types.first == DECK41_FLOORTYPE_SILT)
                || (types.first == DECK41_FLOORTYPE_MUD) || (types.first == DECK41_FLOORTYPE_HARDBOTTOM);
    bool second = (types.second == DECK41_FLOORTYPE_ROCKS) || (types.second == DECK41_FLOORTYPE_ORGANIC) || 
                  (types.second == DECK41_FLOORTYPE_NODULES) || (types.second == DECK41_FLOORTYPE_NODATA) || 
                  (types.second == DECK41_FLOORTYPE_HARDBOTTOM);
 
    return ( (equal && first ) || (first && second));
  }
 
 
  inline bool Deck41TypeTests::conditionFloorB(const Deck41Types& types) const { // second = return secondary type
    bool first = (types.first == DECK41_FLOORTYPE_NODATA);
    bool second = (types.second == DECK41_FLOORTYPE_GRAVEL) || (types.second == DECK41_FLOORTYPE_SAND) || 
                  (types.second == DECK41_FLOORTYPE_SILT) || (types.second == DECK41_FLOORTYPE_MUD);
 
    return (first && second);
  }
 
 
  inline bool Deck41TypeTests::conditionFloorC(const Deck41Types& types) const { // first* = try other coords, if fails get main type
    bool first = (types.first == DECK41_FLOORTYPE_CLAY) || (types.first == DECK41_FLOORTYPE_OOZE) || (types.first == DECK41_FLOORTYPE_ORGANIC)
              || (types.first == DECK41_FLOORTYPE_ROCKS) || (types.first == DECK41_FLOORTYPE_NODULES);
    bool second = (types.second == DECK41_FLOORTYPE_ROCKS) || (types.second == DECK41_FLOORTYPE_ORGANIC) || 
                  (types.second == DECK41_FLOORTYPE_NODULES) || (types.second == DECK41_FLOORTYPE_NODATA) || 
                  (types.second == DECK41_FLOORTYPE_HARDBOTTOM);
 
    return (first && second);
  }
 
 
  inline bool Deck41TypeTests::conditionFloorD(const Deck41Types& types) const { // second* = try other coords, if fails get secondary type
    if ( types.first == DECK41_FLOORTYPE_ORGANIC ) return true;
    else {
        bool first = (types.first == DECK41_FLOORTYPE_ROCKS) || (types.first == DECK41_FLOORTYPE_NODULES) || 
                    (types.first == DECK41_FLOORTYPE_NODATA) ;
        bool second = (types.second == DECK41_FLOORTYPE_GRAVEL) || (types.second == DECK41_FLOORTYPE_SAND) || 
                      (types.second == DECK41_FLOORTYPE_SILT) || (types.second == DECK41_FLOORTYPE_MUD);
 
    return (first && second);
    }
  }
 
  inline bool Deck41TypeTests::conditionFloorE(const Deck41Types& types) const { // 65%/35% = weighted avg
    bool nequal = types.first != types.second;
    bool first = (types.first == DECK41_FLOORTYPE_GRAVEL) || (types.first == DECK41_FLOORTYPE_SAND) || (types.first == DECK41_FLOORTYPE_SILT)
                || (types.first == DECK41_FLOORTYPE_MUD);
    bool second = first || (types.second == DECK41_FLOORTYPE_OOZE) || (types.second == DECK41_FLOORTYPE_CLAY);
    bool special = (types.first == DECK41_FLOORTYPE_OOZE) && (types.second == DECK41_FLOORTYPE_CLAY);
 
    return ( (first && second && nequal) || special );
  }
 
 
  inline bool Deck41TypeTests::conditionFloorF(const Deck41Types& types) const { // 40%/60% = weighted avg
    bool nequal = types.first != types.second;
    bool first = (types.first == DECK41_FLOORTYPE_CLAY) || (types.first == DECK41_FLOORTYPE_OOZE);
    bool second = (types.second == DECK41_FLOORTYPE_GRAVEL) || (types.second == DECK41_FLOORTYPE_SAND) || (types.second == DECK41_FLOORTYPE_SILT)
                || (types.second == DECK41_FLOORTYPE_MUD) || (types.second == DECK41_FLOORTYPE_OOZE);
 
    return (first && second && nequal);
  }
 
 
  inline bool Deck41TypeTests::conditionFloorG(const Deck41Types& types) const { // exit* = try other coords, if fails exit program
    return ( (types.first == DECK41_FLOORTYPE_NODATA) && (types.second == DECK41_FLOORTYPE_NODATA));
  }
 
 
  inline void Deck41TypeTests::updateAllConditions(const Deck41Types& types) {
    condition_a = conditionFloorA(types); // first = return main type
    condition_b = conditionFloorB(types); // second = return secondary type
    condition_c = conditionFloorC(types); // first* = try other coords, if fails get main type
    condition_d = conditionFloorD(types); // second* = try other coords, if fails get secondary type
    condition_e = conditionFloorE(types); // 65%/35% = weighted avg
    condition_f = conditionFloorF(types); // 40%/60% = weighted avg
    condition_g = conditionFloorG(types); 
  }
 
 
}
 
#endif // WOSS_NETCDF_SUPPORT
 
#endif /* FLOOR_CONDITIONS_H */