environment.pb.h

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: netsim/acousticstoolbox/environment.proto
 
#ifndef GOOGLE_PROTOBUF_INCLUDED_netsim_2facousticstoolbox_2fenvironment_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_netsim_2facousticstoolbox_2fenvironment_2eproto
 
#include <limits>
#include <string>
 
#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
 
#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "goby/protobuf/option_extensions.pb.h"
#include <boost/units/quantity.hpp>
#include <boost/units/absolute.hpp>
#include <boost/units/dimensionless_type.hpp>
#include <boost/units/make_scaled_unit.hpp>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_netsim_2facousticstoolbox_2fenvironment_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE
 
// Internal implementation detail -- do not use these members.
struct TableStruct_netsim_2facousticstoolbox_2fenvironment_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_netsim_2facousticstoolbox_2fenvironment_2eproto;
namespace netsim {
namespace bellhop {
namespace protobuf {
class Environment;
struct EnvironmentDefaultTypeInternal;
extern EnvironmentDefaultTypeInternal _Environment_default_instance_;
class Environment_AdaptiveInfo;
struct Environment_AdaptiveInfoDefaultTypeInternal;
extern Environment_AdaptiveInfoDefaultTypeInternal _Environment_AdaptiveInfo_default_instance_;
class Environment_Beams;
struct Environment_BeamsDefaultTypeInternal;
extern Environment_BeamsDefaultTypeInternal _Environment_Beams_default_instance_;
class Environment_Bottom;
struct Environment_BottomDefaultTypeInternal;
extern Environment_BottomDefaultTypeInternal _Environment_Bottom_default_instance_;
class Environment_Medium;
struct Environment_MediumDefaultTypeInternal;
extern Environment_MediumDefaultTypeInternal _Environment_Medium_default_instance_;
class Environment_Medium_Attenuation;
struct Environment_Medium_AttenuationDefaultTypeInternal;
extern Environment_Medium_AttenuationDefaultTypeInternal _Environment_Medium_Attenuation_default_instance_;
class Environment_Medium_RCSample;
struct Environment_Medium_RCSampleDefaultTypeInternal;
extern Environment_Medium_RCSampleDefaultTypeInternal _Environment_Medium_RCSample_default_instance_;
class Environment_Output;
struct Environment_OutputDefaultTypeInternal;
extern Environment_OutputDefaultTypeInternal _Environment_Output_default_instance_;
class Environment_Receivers;
struct Environment_ReceiversDefaultTypeInternal;
extern Environment_ReceiversDefaultTypeInternal _Environment_Receivers_default_instance_;
class Environment_Receivers_ReceiverPosition;
struct Environment_Receivers_ReceiverPositionDefaultTypeInternal;
extern Environment_Receivers_ReceiverPositionDefaultTypeInternal _Environment_Receivers_ReceiverPosition_default_instance_;
class Environment_Sources;
struct Environment_SourcesDefaultTypeInternal;
extern Environment_SourcesDefaultTypeInternal _Environment_Sources_default_instance_;
class Environment_Sources_SourcePosition;
struct Environment_Sources_SourcePositionDefaultTypeInternal;
extern Environment_Sources_SourcePositionDefaultTypeInternal _Environment_Sources_SourcePosition_default_instance_;
class Environment_Surface;
struct Environment_SurfaceDefaultTypeInternal;
extern Environment_SurfaceDefaultTypeInternal _Environment_Surface_default_instance_;
class Environment_WaterColumn;
struct Environment_WaterColumnDefaultTypeInternal;
extern Environment_WaterColumnDefaultTypeInternal _Environment_WaterColumn_default_instance_;
class Environment_WaterColumn_SSPSample;
struct Environment_WaterColumn_SSPSampleDefaultTypeInternal;
extern Environment_WaterColumn_SSPSampleDefaultTypeInternal _Environment_WaterColumn_SSPSample_default_instance_;
}  // namespace protobuf
}  // namespace bellhop
}  // namespace netsim
PROTOBUF_NAMESPACE_OPEN
template<> ::netsim::bellhop::protobuf::Environment* Arena::CreateMaybeMessage<::netsim::bellhop::protobuf::Environment>(Arena*);
template<> ::netsim::bellhop::protobuf::Environment_AdaptiveInfo* Arena::CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_AdaptiveInfo>(Arena*);
template<> ::netsim::bellhop::protobuf::Environment_Beams* Arena::CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_Beams>(Arena*);
template<> ::netsim::bellhop::protobuf::Environment_Bottom* Arena::CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_Bottom>(Arena*);
template<> ::netsim::bellhop::protobuf::Environment_Medium* Arena::CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_Medium>(Arena*);
template<> ::netsim::bellhop::protobuf::Environment_Medium_Attenuation* Arena::CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_Medium_Attenuation>(Arena*);
template<> ::netsim::bellhop::protobuf::Environment_Medium_RCSample* Arena::CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_Medium_RCSample>(Arena*);
template<> ::netsim::bellhop::protobuf::Environment_Output* Arena::CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_Output>(Arena*);
template<> ::netsim::bellhop::protobuf::Environment_Receivers* Arena::CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_Receivers>(Arena*);
template<> ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* Arena::CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition>(Arena*);
template<> ::netsim::bellhop::protobuf::Environment_Sources* Arena::CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_Sources>(Arena*);
template<> ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* Arena::CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_Sources_SourcePosition>(Arena*);
template<> ::netsim::bellhop::protobuf::Environment_Surface* Arena::CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_Surface>(Arena*);
template<> ::netsim::bellhop::protobuf::Environment_WaterColumn* Arena::CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_WaterColumn>(Arena*);
template<> ::netsim::bellhop::protobuf::Environment_WaterColumn_SSPSample* Arena::CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_WaterColumn_SSPSample>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace netsim {
namespace bellhop {
namespace protobuf {
 
enum Environment_Output_OutputType : int {
  Environment_Output_OutputType_ARRIVAL_TIMES = 1,
  Environment_Output_OutputType_EIGENRAYS = 2,
  Environment_Output_OutputType_RAYS = 3,
  Environment_Output_OutputType_COHERENT_PRESSURE = 4,
  Environment_Output_OutputType_INCOHERENT_PRESSURE = 5,
  Environment_Output_OutputType_SEMICOHERENT_PRESSURE = 6
};
bool Environment_Output_OutputType_IsValid(int value);
constexpr Environment_Output_OutputType Environment_Output_OutputType_OutputType_MIN = Environment_Output_OutputType_ARRIVAL_TIMES;
constexpr Environment_Output_OutputType Environment_Output_OutputType_OutputType_MAX = Environment_Output_OutputType_SEMICOHERENT_PRESSURE;
constexpr int Environment_Output_OutputType_OutputType_ARRAYSIZE = Environment_Output_OutputType_OutputType_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Environment_Output_OutputType_descriptor();
template<typename T>
inline const std::string& Environment_Output_OutputType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Environment_Output_OutputType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Environment_Output_OutputType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Environment_Output_OutputType_descriptor(), enum_t_value);
}
inline bool Environment_Output_OutputType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Environment_Output_OutputType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Environment_Output_OutputType>(
    Environment_Output_OutputType_descriptor(), name, value);
}
enum Environment_Medium_Attenuation_Units : int {
  Environment_Medium_Attenuation_Units_DB_PER_M_KHZ = 1,
  Environment_Medium_Attenuation_Units_PARAMETER_LOSS = 2,
  Environment_Medium_Attenuation_Units_DB_PER_M = 3,
  Environment_Medium_Attenuation_Units_NEPERS_PER_M = 4,
  Environment_Medium_Attenuation_Units_Q_FACTOR = 5,
  Environment_Medium_Attenuation_Units_DB_PER_WAVELENGTH = 6
};
bool Environment_Medium_Attenuation_Units_IsValid(int value);
constexpr Environment_Medium_Attenuation_Units Environment_Medium_Attenuation_Units_Units_MIN = Environment_Medium_Attenuation_Units_DB_PER_M_KHZ;
constexpr Environment_Medium_Attenuation_Units Environment_Medium_Attenuation_Units_Units_MAX = Environment_Medium_Attenuation_Units_DB_PER_WAVELENGTH;
constexpr int Environment_Medium_Attenuation_Units_Units_ARRAYSIZE = Environment_Medium_Attenuation_Units_Units_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Environment_Medium_Attenuation_Units_descriptor();
template<typename T>
inline const std::string& Environment_Medium_Attenuation_Units_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Environment_Medium_Attenuation_Units>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Environment_Medium_Attenuation_Units_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Environment_Medium_Attenuation_Units_descriptor(), enum_t_value);
}
inline bool Environment_Medium_Attenuation_Units_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Environment_Medium_Attenuation_Units* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Environment_Medium_Attenuation_Units>(
    Environment_Medium_Attenuation_Units_descriptor(), name, value);
}
enum Environment_Medium_MediumType : int {
  Environment_Medium_MediumType_VACUUM = 1,
  Environment_Medium_MediumType_RIGID = 2,
  Environment_Medium_MediumType_HALF_SPACE = 3,
  Environment_Medium_MediumType_REFLECTION_COEFFICIENT = 4
};
bool Environment_Medium_MediumType_IsValid(int value);
constexpr Environment_Medium_MediumType Environment_Medium_MediumType_MediumType_MIN = Environment_Medium_MediumType_VACUUM;
constexpr Environment_Medium_MediumType Environment_Medium_MediumType_MediumType_MAX = Environment_Medium_MediumType_REFLECTION_COEFFICIENT;
constexpr int Environment_Medium_MediumType_MediumType_ARRAYSIZE = Environment_Medium_MediumType_MediumType_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Environment_Medium_MediumType_descriptor();
template<typename T>
inline const std::string& Environment_Medium_MediumType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Environment_Medium_MediumType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Environment_Medium_MediumType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Environment_Medium_MediumType_descriptor(), enum_t_value);
}
inline bool Environment_Medium_MediumType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Environment_Medium_MediumType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Environment_Medium_MediumType>(
    Environment_Medium_MediumType_descriptor(), name, value);
}
enum Environment_WaterColumn_SSPInterpolation : int {
  Environment_WaterColumn_SSPInterpolation_CUBIC_SPLINE = 1,
  Environment_WaterColumn_SSPInterpolation_C_LINEAR = 2,
  Environment_WaterColumn_SSPInterpolation_N2_LINEAR = 3
};
bool Environment_WaterColumn_SSPInterpolation_IsValid(int value);
constexpr Environment_WaterColumn_SSPInterpolation Environment_WaterColumn_SSPInterpolation_SSPInterpolation_MIN = Environment_WaterColumn_SSPInterpolation_CUBIC_SPLINE;
constexpr Environment_WaterColumn_SSPInterpolation Environment_WaterColumn_SSPInterpolation_SSPInterpolation_MAX = Environment_WaterColumn_SSPInterpolation_N2_LINEAR;
constexpr int Environment_WaterColumn_SSPInterpolation_SSPInterpolation_ARRAYSIZE = Environment_WaterColumn_SSPInterpolation_SSPInterpolation_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Environment_WaterColumn_SSPInterpolation_descriptor();
template<typename T>
inline const std::string& Environment_WaterColumn_SSPInterpolation_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Environment_WaterColumn_SSPInterpolation>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Environment_WaterColumn_SSPInterpolation_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Environment_WaterColumn_SSPInterpolation_descriptor(), enum_t_value);
}
inline bool Environment_WaterColumn_SSPInterpolation_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Environment_WaterColumn_SSPInterpolation* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Environment_WaterColumn_SSPInterpolation>(
    Environment_WaterColumn_SSPInterpolation_descriptor(), name, value);
}
enum Environment_Beams_ApproximationType : int {
  Environment_Beams_ApproximationType_GEOMETRIC = 1,
  Environment_Beams_ApproximationType_CARTESIAN = 2,
  Environment_Beams_ApproximationType_RAY_CENTERED = 3,
  Environment_Beams_ApproximationType_GAUSSIAN = 4
};
bool Environment_Beams_ApproximationType_IsValid(int value);
constexpr Environment_Beams_ApproximationType Environment_Beams_ApproximationType_ApproximationType_MIN = Environment_Beams_ApproximationType_GEOMETRIC;
constexpr Environment_Beams_ApproximationType Environment_Beams_ApproximationType_ApproximationType_MAX = Environment_Beams_ApproximationType_GAUSSIAN;
constexpr int Environment_Beams_ApproximationType_ApproximationType_ARRAYSIZE = Environment_Beams_ApproximationType_ApproximationType_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Environment_Beams_ApproximationType_descriptor();
template<typename T>
inline const std::string& Environment_Beams_ApproximationType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Environment_Beams_ApproximationType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Environment_Beams_ApproximationType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Environment_Beams_ApproximationType_descriptor(), enum_t_value);
}
inline bool Environment_Beams_ApproximationType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Environment_Beams_ApproximationType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Environment_Beams_ApproximationType>(
    Environment_Beams_ApproximationType_descriptor(), name, value);
}
// ===================================================================
 
class Environment_Output final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:netsim.bellhop.protobuf.Environment.Output) */ {
 public:
  inline Environment_Output() : Environment_Output(nullptr) {}
  ~Environment_Output() override;
  explicit PROTOBUF_CONSTEXPR Environment_Output(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  Environment_Output(const Environment_Output& from);
  Environment_Output(Environment_Output&& from) noexcept
    : Environment_Output() {
    *this = ::std::move(from);
  }
 
  inline Environment_Output& operator=(const Environment_Output& from) {
    CopyFrom(from);
    return *this;
  }
  inline Environment_Output& operator=(Environment_Output&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Environment_Output& default_instance() {
    return *internal_default_instance();
  }
  static inline const Environment_Output* internal_default_instance() {
    return reinterpret_cast<const Environment_Output*>(
               &_Environment_Output_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;
 
  friend void swap(Environment_Output& a, Environment_Output& b) {
    a.Swap(&b);
  }
  inline void Swap(Environment_Output* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Environment_Output* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  Environment_Output* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Environment_Output>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Environment_Output& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Environment_Output& from) {
    Environment_Output::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Environment_Output* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "netsim.bellhop.protobuf.Environment.Output";
  }
  protected:
  explicit Environment_Output(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef Environment_Output_OutputType OutputType;
  static constexpr OutputType ARRIVAL_TIMES =
    Environment_Output_OutputType_ARRIVAL_TIMES;
  static constexpr OutputType EIGENRAYS =
    Environment_Output_OutputType_EIGENRAYS;
  static constexpr OutputType RAYS =
    Environment_Output_OutputType_RAYS;
  static constexpr OutputType COHERENT_PRESSURE =
    Environment_Output_OutputType_COHERENT_PRESSURE;
  static constexpr OutputType INCOHERENT_PRESSURE =
    Environment_Output_OutputType_INCOHERENT_PRESSURE;
  static constexpr OutputType SEMICOHERENT_PRESSURE =
    Environment_Output_OutputType_SEMICOHERENT_PRESSURE;
  static inline bool OutputType_IsValid(int value) {
    return Environment_Output_OutputType_IsValid(value);
  }
  static constexpr OutputType OutputType_MIN =
    Environment_Output_OutputType_OutputType_MIN;
  static constexpr OutputType OutputType_MAX =
    Environment_Output_OutputType_OutputType_MAX;
  static constexpr int OutputType_ARRAYSIZE =
    Environment_Output_OutputType_OutputType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  OutputType_descriptor() {
    return Environment_Output_OutputType_descriptor();
  }
  template<typename T>
  static inline const std::string& OutputType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, OutputType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function OutputType_Name.");
    return Environment_Output_OutputType_Name(enum_t_value);
  }
  static inline bool OutputType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      OutputType* value) {
    return Environment_Output_OutputType_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kTypeFieldNumber = 1,
  };
  // optional .netsim.bellhop.protobuf.Environment.Output.OutputType type = 1 [default = INCOHERENT_PRESSURE, (.goby.field) = {
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::netsim::bellhop::protobuf::Environment_Output_OutputType type() const;
  void set_type(::netsim::bellhop::protobuf::Environment_Output_OutputType value);
  private:
  ::netsim::bellhop::protobuf::Environment_Output_OutputType _internal_type() const;
  void _internal_set_type(::netsim::bellhop::protobuf::Environment_Output_OutputType value);
  public:
 
  // @@protoc_insertion_point(class_scope:netsim.bellhop.protobuf.Environment.Output)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netsim_2facousticstoolbox_2fenvironment_2eproto;
};
// -------------------------------------------------------------------
 
class Environment_Medium_RCSample final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:netsim.bellhop.protobuf.Environment.Medium.RCSample) */ {
 public:
  inline Environment_Medium_RCSample() : Environment_Medium_RCSample(nullptr) {}
  ~Environment_Medium_RCSample() override;
  explicit PROTOBUF_CONSTEXPR Environment_Medium_RCSample(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  Environment_Medium_RCSample(const Environment_Medium_RCSample& from);
  Environment_Medium_RCSample(Environment_Medium_RCSample&& from) noexcept
    : Environment_Medium_RCSample() {
    *this = ::std::move(from);
  }
 
  inline Environment_Medium_RCSample& operator=(const Environment_Medium_RCSample& from) {
    CopyFrom(from);
    return *this;
  }
  inline Environment_Medium_RCSample& operator=(Environment_Medium_RCSample&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Environment_Medium_RCSample& default_instance() {
    return *internal_default_instance();
  }
  static inline const Environment_Medium_RCSample* internal_default_instance() {
    return reinterpret_cast<const Environment_Medium_RCSample*>(
               &_Environment_Medium_RCSample_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;
 
  friend void swap(Environment_Medium_RCSample& a, Environment_Medium_RCSample& b) {
    a.Swap(&b);
  }
  inline void Swap(Environment_Medium_RCSample* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Environment_Medium_RCSample* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  Environment_Medium_RCSample* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Environment_Medium_RCSample>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Environment_Medium_RCSample& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Environment_Medium_RCSample& from) {
    Environment_Medium_RCSample::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Environment_Medium_RCSample* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "netsim.bellhop.protobuf.Environment.Medium.RCSample";
  }
  protected:
  explicit Environment_Medium_RCSample(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kAngleFieldNumber = 1,
    kRcFieldNumber = 2,
    kPhaseFieldNumber = 3,
  };
  // optional double angle = 1 [(.goby.field) = {
  bool has_angle() const;
  private:
  bool _internal_has_angle() const;
  public:
  void clear_angle();
  double angle() const;
  void set_angle(double value);
  private:
  double _internal_angle() const;
  void _internal_set_angle(double value);
  public:
 
  // optional double rc = 2 [(.goby.field) = {
  bool has_rc() const;
  private:
  bool _internal_has_rc() const;
  public:
  void clear_rc();
  double rc() const;
  void set_rc(double value);
  private:
  double _internal_rc() const;
  void _internal_set_rc(double value);
  public:
 
  // optional double phase = 3 [(.goby.field) = {
  bool has_phase() const;
  private:
  bool _internal_has_phase() const;
  public:
  void clear_phase();
  double phase() const;
  void set_phase(double value);
  private:
  double _internal_phase() const;
  void _internal_set_phase(double value);
  public:
 
  // @@protoc_insertion_point(class_scope:netsim.bellhop.protobuf.Environment.Medium.RCSample)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    double angle_;
    double rc_;
    double phase_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netsim_2facousticstoolbox_2fenvironment_2eproto;
};
// -------------------------------------------------------------------
 
class Environment_Medium_Attenuation final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:netsim.bellhop.protobuf.Environment.Medium.Attenuation) */ {
 public:
  inline Environment_Medium_Attenuation() : Environment_Medium_Attenuation(nullptr) {}
  ~Environment_Medium_Attenuation() override;
  explicit PROTOBUF_CONSTEXPR Environment_Medium_Attenuation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  Environment_Medium_Attenuation(const Environment_Medium_Attenuation& from);
  Environment_Medium_Attenuation(Environment_Medium_Attenuation&& from) noexcept
    : Environment_Medium_Attenuation() {
    *this = ::std::move(from);
  }
 
  inline Environment_Medium_Attenuation& operator=(const Environment_Medium_Attenuation& from) {
    CopyFrom(from);
    return *this;
  }
  inline Environment_Medium_Attenuation& operator=(Environment_Medium_Attenuation&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Environment_Medium_Attenuation& default_instance() {
    return *internal_default_instance();
  }
  static inline const Environment_Medium_Attenuation* internal_default_instance() {
    return reinterpret_cast<const Environment_Medium_Attenuation*>(
               &_Environment_Medium_Attenuation_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;
 
  friend void swap(Environment_Medium_Attenuation& a, Environment_Medium_Attenuation& b) {
    a.Swap(&b);
  }
  inline void Swap(Environment_Medium_Attenuation* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Environment_Medium_Attenuation* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  Environment_Medium_Attenuation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Environment_Medium_Attenuation>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Environment_Medium_Attenuation& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Environment_Medium_Attenuation& from) {
    Environment_Medium_Attenuation::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Environment_Medium_Attenuation* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "netsim.bellhop.protobuf.Environment.Medium.Attenuation";
  }
  protected:
  explicit Environment_Medium_Attenuation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef Environment_Medium_Attenuation_Units Units;
  static constexpr Units DB_PER_M_KHZ =
    Environment_Medium_Attenuation_Units_DB_PER_M_KHZ;
  static constexpr Units PARAMETER_LOSS =
    Environment_Medium_Attenuation_Units_PARAMETER_LOSS;
  static constexpr Units DB_PER_M =
    Environment_Medium_Attenuation_Units_DB_PER_M;
  static constexpr Units NEPERS_PER_M =
    Environment_Medium_Attenuation_Units_NEPERS_PER_M;
  static constexpr Units Q_FACTOR =
    Environment_Medium_Attenuation_Units_Q_FACTOR;
  static constexpr Units DB_PER_WAVELENGTH =
    Environment_Medium_Attenuation_Units_DB_PER_WAVELENGTH;
  static inline bool Units_IsValid(int value) {
    return Environment_Medium_Attenuation_Units_IsValid(value);
  }
  static constexpr Units Units_MIN =
    Environment_Medium_Attenuation_Units_Units_MIN;
  static constexpr Units Units_MAX =
    Environment_Medium_Attenuation_Units_Units_MAX;
  static constexpr int Units_ARRAYSIZE =
    Environment_Medium_Attenuation_Units_Units_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Units_descriptor() {
    return Environment_Medium_Attenuation_Units_descriptor();
  }
  template<typename T>
  static inline const std::string& Units_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Units>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Units_Name.");
    return Environment_Medium_Attenuation_Units_Name(enum_t_value);
  }
  static inline bool Units_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Units* value) {
    return Environment_Medium_Attenuation_Units_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kValueFieldNumber = 2,
    kUnitsFieldNumber = 1,
  };
  // optional double value = 2;
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  double value() const;
  void set_value(double value);
  private:
  double _internal_value() const;
  void _internal_set_value(double value);
  public:
 
  // optional .netsim.bellhop.protobuf.Environment.Medium.Attenuation.Units units = 1 [(.goby.field) = {
  bool has_units() const;
  private:
  bool _internal_has_units() const;
  public:
  void clear_units();
  ::netsim::bellhop::protobuf::Environment_Medium_Attenuation_Units units() const;
  void set_units(::netsim::bellhop::protobuf::Environment_Medium_Attenuation_Units value);
  private:
  ::netsim::bellhop::protobuf::Environment_Medium_Attenuation_Units _internal_units() const;
  void _internal_set_units(::netsim::bellhop::protobuf::Environment_Medium_Attenuation_Units value);
  public:
 
  // @@protoc_insertion_point(class_scope:netsim.bellhop.protobuf.Environment.Medium.Attenuation)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    double value_;
    int units_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netsim_2facousticstoolbox_2fenvironment_2eproto;
};
// -------------------------------------------------------------------
 
class Environment_Medium final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:netsim.bellhop.protobuf.Environment.Medium) */ {
 public:
  inline Environment_Medium() : Environment_Medium(nullptr) {}
  ~Environment_Medium() override;
  explicit PROTOBUF_CONSTEXPR Environment_Medium(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  Environment_Medium(const Environment_Medium& from);
  Environment_Medium(Environment_Medium&& from) noexcept
    : Environment_Medium() {
    *this = ::std::move(from);
  }
 
  inline Environment_Medium& operator=(const Environment_Medium& from) {
    CopyFrom(from);
    return *this;
  }
  inline Environment_Medium& operator=(Environment_Medium&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Environment_Medium& default_instance() {
    return *internal_default_instance();
  }
  static inline const Environment_Medium* internal_default_instance() {
    return reinterpret_cast<const Environment_Medium*>(
               &_Environment_Medium_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;
 
  friend void swap(Environment_Medium& a, Environment_Medium& b) {
    a.Swap(&b);
  }
  inline void Swap(Environment_Medium* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Environment_Medium* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  Environment_Medium* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Environment_Medium>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Environment_Medium& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Environment_Medium& from) {
    Environment_Medium::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Environment_Medium* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "netsim.bellhop.protobuf.Environment.Medium";
  }
  protected:
  explicit Environment_Medium(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef Environment_Medium_RCSample RCSample;
  typedef Environment_Medium_Attenuation Attenuation;
 
  typedef Environment_Medium_MediumType MediumType;
  static constexpr MediumType VACUUM =
    Environment_Medium_MediumType_VACUUM;
  static constexpr MediumType RIGID =
    Environment_Medium_MediumType_RIGID;
  static constexpr MediumType HALF_SPACE =
    Environment_Medium_MediumType_HALF_SPACE;
  static constexpr MediumType REFLECTION_COEFFICIENT =
    Environment_Medium_MediumType_REFLECTION_COEFFICIENT;
  static inline bool MediumType_IsValid(int value) {
    return Environment_Medium_MediumType_IsValid(value);
  }
  static constexpr MediumType MediumType_MIN =
    Environment_Medium_MediumType_MediumType_MIN;
  static constexpr MediumType MediumType_MAX =
    Environment_Medium_MediumType_MediumType_MAX;
  static constexpr int MediumType_ARRAYSIZE =
    Environment_Medium_MediumType_MediumType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  MediumType_descriptor() {
    return Environment_Medium_MediumType_descriptor();
  }
  template<typename T>
  static inline const std::string& MediumType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, MediumType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function MediumType_Name.");
    return Environment_Medium_MediumType_Name(enum_t_value);
  }
  static inline bool MediumType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      MediumType* value) {
    return Environment_Medium_MediumType_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kRcSampleFieldNumber = 7,
    kAttenuationFieldNumber = 2,
    kCpFieldNumber = 3,
    kCsFieldNumber = 4,
    kDensityFieldNumber = 5,
    kDepthFieldNumber = 6,
    kTypeFieldNumber = 1,
  };
  // repeated .netsim.bellhop.protobuf.Environment.Medium.RCSample rc_sample = 7 [(.goby.field) = {
  int rc_sample_size() const;
  private:
  int _internal_rc_sample_size() const;
  public:
  void clear_rc_sample();
  ::netsim::bellhop::protobuf::Environment_Medium_RCSample* mutable_rc_sample(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::netsim::bellhop::protobuf::Environment_Medium_RCSample >*
      mutable_rc_sample();
  private:
  const ::netsim::bellhop::protobuf::Environment_Medium_RCSample& _internal_rc_sample(int index) const;
  ::netsim::bellhop::protobuf::Environment_Medium_RCSample* _internal_add_rc_sample();
  public:
  const ::netsim::bellhop::protobuf::Environment_Medium_RCSample& rc_sample(int index) const;
  ::netsim::bellhop::protobuf::Environment_Medium_RCSample* add_rc_sample();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::netsim::bellhop::protobuf::Environment_Medium_RCSample >&
      rc_sample() const;
 
  // optional .netsim.bellhop.protobuf.Environment.Medium.Attenuation attenuation = 2 [(.goby.field) = {
  bool has_attenuation() const;
  private:
  bool _internal_has_attenuation() const;
  public:
  void clear_attenuation();
  const ::netsim::bellhop::protobuf::Environment_Medium_Attenuation& attenuation() const;
  PROTOBUF_NODISCARD ::netsim::bellhop::protobuf::Environment_Medium_Attenuation* release_attenuation();
  ::netsim::bellhop::protobuf::Environment_Medium_Attenuation* mutable_attenuation();
  void set_allocated_attenuation(::netsim::bellhop::protobuf::Environment_Medium_Attenuation* attenuation);
  private:
  const ::netsim::bellhop::protobuf::Environment_Medium_Attenuation& _internal_attenuation() const;
  ::netsim::bellhop::protobuf::Environment_Medium_Attenuation* _internal_mutable_attenuation();
  public:
  void unsafe_arena_set_allocated_attenuation(
      ::netsim::bellhop::protobuf::Environment_Medium_Attenuation* attenuation);
  ::netsim::bellhop::protobuf::Environment_Medium_Attenuation* unsafe_arena_release_attenuation();
 
  // optional double cp = 3 [(.goby.field) = {
  bool has_cp() const;
  private:
  bool _internal_has_cp() const;
  public:
  void clear_cp();
  double cp() const;
  void set_cp(double value);
  private:
  double _internal_cp() const;
  void _internal_set_cp(double value);
  public:
 
  // optional double cs = 4 [(.goby.field) = {
  bool has_cs() const;
  private:
  bool _internal_has_cs() const;
  public:
  void clear_cs();
  double cs() const;
  void set_cs(double value);
  private:
  double _internal_cs() const;
  void _internal_set_cs(double value);
  public:
 
  // optional double density = 5 [(.goby.field) = {
  bool has_density() const;
  private:
  bool _internal_has_density() const;
  public:
  void clear_density();
  double density() const;
  void set_density(double value);
  private:
  double _internal_density() const;
  void _internal_set_density(double value);
  public:
 
  // optional double depth = 6 [(.goby.field) = {
  bool has_depth() const;
  private:
  bool _internal_has_depth() const;
  public:
  void clear_depth();
  double depth() const;
  void set_depth(double value);
  private:
  double _internal_depth() const;
  void _internal_set_depth(double value);
  public:
 
  // optional .netsim.bellhop.protobuf.Environment.Medium.MediumType type = 1 [(.goby.field) = {
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::netsim::bellhop::protobuf::Environment_Medium_MediumType type() const;
  void set_type(::netsim::bellhop::protobuf::Environment_Medium_MediumType value);
  private:
  ::netsim::bellhop::protobuf::Environment_Medium_MediumType _internal_type() const;
  void _internal_set_type(::netsim::bellhop::protobuf::Environment_Medium_MediumType value);
  public:
 
  // @@protoc_insertion_point(class_scope:netsim.bellhop.protobuf.Environment.Medium)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::netsim::bellhop::protobuf::Environment_Medium_RCSample > rc_sample_;
    ::netsim::bellhop::protobuf::Environment_Medium_Attenuation* attenuation_;
    double cp_;
    double cs_;
    double density_;
    double depth_;
    int type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netsim_2facousticstoolbox_2fenvironment_2eproto;
};
// -------------------------------------------------------------------
 
class Environment_Surface final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:netsim.bellhop.protobuf.Environment.Surface) */ {
 public:
  inline Environment_Surface() : Environment_Surface(nullptr) {}
  ~Environment_Surface() override;
  explicit PROTOBUF_CONSTEXPR Environment_Surface(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  Environment_Surface(const Environment_Surface& from);
  Environment_Surface(Environment_Surface&& from) noexcept
    : Environment_Surface() {
    *this = ::std::move(from);
  }
 
  inline Environment_Surface& operator=(const Environment_Surface& from) {
    CopyFrom(from);
    return *this;
  }
  inline Environment_Surface& operator=(Environment_Surface&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Environment_Surface& default_instance() {
    return *internal_default_instance();
  }
  static inline const Environment_Surface* internal_default_instance() {
    return reinterpret_cast<const Environment_Surface*>(
               &_Environment_Surface_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;
 
  friend void swap(Environment_Surface& a, Environment_Surface& b) {
    a.Swap(&b);
  }
  inline void Swap(Environment_Surface* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Environment_Surface* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  Environment_Surface* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Environment_Surface>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Environment_Surface& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Environment_Surface& from) {
    Environment_Surface::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Environment_Surface* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "netsim.bellhop.protobuf.Environment.Surface";
  }
  protected:
  explicit Environment_Surface(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kMediumFieldNumber = 1,
  };
  // optional .netsim.bellhop.protobuf.Environment.Medium medium = 1;
  bool has_medium() const;
  private:
  bool _internal_has_medium() const;
  public:
  void clear_medium();
  const ::netsim::bellhop::protobuf::Environment_Medium& medium() const;
  PROTOBUF_NODISCARD ::netsim::bellhop::protobuf::Environment_Medium* release_medium();
  ::netsim::bellhop::protobuf::Environment_Medium* mutable_medium();
  void set_allocated_medium(::netsim::bellhop::protobuf::Environment_Medium* medium);
  private:
  const ::netsim::bellhop::protobuf::Environment_Medium& _internal_medium() const;
  ::netsim::bellhop::protobuf::Environment_Medium* _internal_mutable_medium();
  public:
  void unsafe_arena_set_allocated_medium(
      ::netsim::bellhop::protobuf::Environment_Medium* medium);
  ::netsim::bellhop::protobuf::Environment_Medium* unsafe_arena_release_medium();
 
  // @@protoc_insertion_point(class_scope:netsim.bellhop.protobuf.Environment.Surface)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::netsim::bellhop::protobuf::Environment_Medium* medium_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netsim_2facousticstoolbox_2fenvironment_2eproto;
};
// -------------------------------------------------------------------
 
class Environment_WaterColumn_SSPSample final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:netsim.bellhop.protobuf.Environment.WaterColumn.SSPSample) */ {
 public:
  inline Environment_WaterColumn_SSPSample() : Environment_WaterColumn_SSPSample(nullptr) {}
  ~Environment_WaterColumn_SSPSample() override;
  explicit PROTOBUF_CONSTEXPR Environment_WaterColumn_SSPSample(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  Environment_WaterColumn_SSPSample(const Environment_WaterColumn_SSPSample& from);
  Environment_WaterColumn_SSPSample(Environment_WaterColumn_SSPSample&& from) noexcept
    : Environment_WaterColumn_SSPSample() {
    *this = ::std::move(from);
  }
 
  inline Environment_WaterColumn_SSPSample& operator=(const Environment_WaterColumn_SSPSample& from) {
    CopyFrom(from);
    return *this;
  }
  inline Environment_WaterColumn_SSPSample& operator=(Environment_WaterColumn_SSPSample&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Environment_WaterColumn_SSPSample& default_instance() {
    return *internal_default_instance();
  }
  static inline const Environment_WaterColumn_SSPSample* internal_default_instance() {
    return reinterpret_cast<const Environment_WaterColumn_SSPSample*>(
               &_Environment_WaterColumn_SSPSample_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;
 
  friend void swap(Environment_WaterColumn_SSPSample& a, Environment_WaterColumn_SSPSample& b) {
    a.Swap(&b);
  }
  inline void Swap(Environment_WaterColumn_SSPSample* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Environment_WaterColumn_SSPSample* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  Environment_WaterColumn_SSPSample* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Environment_WaterColumn_SSPSample>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Environment_WaterColumn_SSPSample& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Environment_WaterColumn_SSPSample& from) {
    Environment_WaterColumn_SSPSample::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Environment_WaterColumn_SSPSample* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "netsim.bellhop.protobuf.Environment.WaterColumn.SSPSample";
  }
  protected:
  explicit Environment_WaterColumn_SSPSample(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kEofFieldNumber = 3,
    kDepthFieldNumber = 1,
    kCpFieldNumber = 2,
  };
  // repeated double eof = 3 [(.goby.field) = {
  int eof_size() const;
  private:
  int _internal_eof_size() const;
  public:
  void clear_eof();
  private:
  double _internal_eof(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_eof() const;
  void _internal_add_eof(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_eof();
  public:
  double eof(int index) const;
  void set_eof(int index, double value);
  void add_eof(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      eof() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_eof();
 
  // optional double depth = 1 [(.goby.field) = {
  bool has_depth() const;
  private:
  bool _internal_has_depth() const;
  public:
  void clear_depth();
  double depth() const;
  void set_depth(double value);
  private:
  double _internal_depth() const;
  void _internal_set_depth(double value);
  public:
 
  // optional double cp = 2 [(.goby.field) = {
  bool has_cp() const;
  private:
  bool _internal_has_cp() const;
  public:
  void clear_cp();
  double cp() const;
  void set_cp(double value);
  private:
  double _internal_cp() const;
  void _internal_set_cp(double value);
  public:
 
  // @@protoc_insertion_point(class_scope:netsim.bellhop.protobuf.Environment.WaterColumn.SSPSample)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > eof_;
    double depth_;
    double cp_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netsim_2facousticstoolbox_2fenvironment_2eproto;
};
// -------------------------------------------------------------------
 
class Environment_WaterColumn final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:netsim.bellhop.protobuf.Environment.WaterColumn) */ {
 public:
  inline Environment_WaterColumn() : Environment_WaterColumn(nullptr) {}
  ~Environment_WaterColumn() override;
  explicit PROTOBUF_CONSTEXPR Environment_WaterColumn(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  Environment_WaterColumn(const Environment_WaterColumn& from);
  Environment_WaterColumn(Environment_WaterColumn&& from) noexcept
    : Environment_WaterColumn() {
    *this = ::std::move(from);
  }
 
  inline Environment_WaterColumn& operator=(const Environment_WaterColumn& from) {
    CopyFrom(from);
    return *this;
  }
  inline Environment_WaterColumn& operator=(Environment_WaterColumn&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Environment_WaterColumn& default_instance() {
    return *internal_default_instance();
  }
  static inline const Environment_WaterColumn* internal_default_instance() {
    return reinterpret_cast<const Environment_WaterColumn*>(
               &_Environment_WaterColumn_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;
 
  friend void swap(Environment_WaterColumn& a, Environment_WaterColumn& b) {
    a.Swap(&b);
  }
  inline void Swap(Environment_WaterColumn* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Environment_WaterColumn* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  Environment_WaterColumn* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Environment_WaterColumn>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Environment_WaterColumn& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Environment_WaterColumn& from) {
    Environment_WaterColumn::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Environment_WaterColumn* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "netsim.bellhop.protobuf.Environment.WaterColumn";
  }
  protected:
  explicit Environment_WaterColumn(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef Environment_WaterColumn_SSPSample SSPSample;
 
  typedef Environment_WaterColumn_SSPInterpolation SSPInterpolation;
  static constexpr SSPInterpolation CUBIC_SPLINE =
    Environment_WaterColumn_SSPInterpolation_CUBIC_SPLINE;
  static constexpr SSPInterpolation C_LINEAR =
    Environment_WaterColumn_SSPInterpolation_C_LINEAR;
  static constexpr SSPInterpolation N2_LINEAR =
    Environment_WaterColumn_SSPInterpolation_N2_LINEAR;
  static inline bool SSPInterpolation_IsValid(int value) {
    return Environment_WaterColumn_SSPInterpolation_IsValid(value);
  }
  static constexpr SSPInterpolation SSPInterpolation_MIN =
    Environment_WaterColumn_SSPInterpolation_SSPInterpolation_MIN;
  static constexpr SSPInterpolation SSPInterpolation_MAX =
    Environment_WaterColumn_SSPInterpolation_SSPInterpolation_MAX;
  static constexpr int SSPInterpolation_ARRAYSIZE =
    Environment_WaterColumn_SSPInterpolation_SSPInterpolation_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  SSPInterpolation_descriptor() {
    return Environment_WaterColumn_SSPInterpolation_descriptor();
  }
  template<typename T>
  static inline const std::string& SSPInterpolation_Name(T enum_t_value) {
    static_assert(::std::is_same<T, SSPInterpolation>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function SSPInterpolation_Name.");
    return Environment_WaterColumn_SSPInterpolation_Name(enum_t_value);
  }
  static inline bool SSPInterpolation_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      SSPInterpolation* value) {
    return Environment_WaterColumn_SSPInterpolation_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kEofCoefFieldNumber = 2,
    kSampleFieldNumber = 4,
    kRangeFieldNumber = 5,
    kBathymetryFieldNumber = 6,
    kInterpolationTypeFieldNumber = 1,
    kUseAttenuationFieldNumber = 3,
  };
  // repeated double eof_coef = 2 [(.goby.field) = {
  int eof_coef_size() const;
  private:
  int _internal_eof_coef_size() const;
  public:
  void clear_eof_coef();
  private:
  double _internal_eof_coef(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_eof_coef() const;
  void _internal_add_eof_coef(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_eof_coef();
  public:
  double eof_coef(int index) const;
  void set_eof_coef(int index, double value);
  void add_eof_coef(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      eof_coef() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_eof_coef();
 
  // repeated .netsim.bellhop.protobuf.Environment.WaterColumn.SSPSample sample = 4;
  int sample_size() const;
  private:
  int _internal_sample_size() const;
  public:
  void clear_sample();
  ::netsim::bellhop::protobuf::Environment_WaterColumn_SSPSample* mutable_sample(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::netsim::bellhop::protobuf::Environment_WaterColumn_SSPSample >*
      mutable_sample();
  private:
  const ::netsim::bellhop::protobuf::Environment_WaterColumn_SSPSample& _internal_sample(int index) const;
  ::netsim::bellhop::protobuf::Environment_WaterColumn_SSPSample* _internal_add_sample();
  public:
  const ::netsim::bellhop::protobuf::Environment_WaterColumn_SSPSample& sample(int index) const;
  ::netsim::bellhop::protobuf::Environment_WaterColumn_SSPSample* add_sample();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::netsim::bellhop::protobuf::Environment_WaterColumn_SSPSample >&
      sample() const;
 
  // optional double range = 5 [default = 0, (.goby.field) = {
  bool has_range() const;
  private:
  bool _internal_has_range() const;
  public:
  void clear_range();
  double range() const;
  void set_range(double value);
  private:
  double _internal_range() const;
  void _internal_set_range(double value);
  public:
 
  // optional double bathymetry = 6 [default = 0, (.goby.field) = {
  bool has_bathymetry() const;
  private:
  bool _internal_has_bathymetry() const;
  public:
  void clear_bathymetry();
  double bathymetry() const;
  void set_bathymetry(double value);
  private:
  double _internal_bathymetry() const;
  void _internal_set_bathymetry(double value);
  public:
 
  // optional .netsim.bellhop.protobuf.Environment.WaterColumn.SSPInterpolation interpolation_type = 1 [default = CUBIC_SPLINE, (.goby.field) = {
  bool has_interpolation_type() const;
  private:
  bool _internal_has_interpolation_type() const;
  public:
  void clear_interpolation_type();
  ::netsim::bellhop::protobuf::Environment_WaterColumn_SSPInterpolation interpolation_type() const;
  void set_interpolation_type(::netsim::bellhop::protobuf::Environment_WaterColumn_SSPInterpolation value);
  private:
  ::netsim::bellhop::protobuf::Environment_WaterColumn_SSPInterpolation _internal_interpolation_type() const;
  void _internal_set_interpolation_type(::netsim::bellhop::protobuf::Environment_WaterColumn_SSPInterpolation value);
  public:
 
  // optional bool use_attenuation = 3 [default = true, (.goby.field) = {
  bool has_use_attenuation() const;
  private:
  bool _internal_has_use_attenuation() const;
  public:
  void clear_use_attenuation();
  bool use_attenuation() const;
  void set_use_attenuation(bool value);
  private:
  bool _internal_use_attenuation() const;
  void _internal_set_use_attenuation(bool value);
  public:
 
  // @@protoc_insertion_point(class_scope:netsim.bellhop.protobuf.Environment.WaterColumn)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > eof_coef_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::netsim::bellhop::protobuf::Environment_WaterColumn_SSPSample > sample_;
    double range_;
    double bathymetry_;
    int interpolation_type_;
    bool use_attenuation_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netsim_2facousticstoolbox_2fenvironment_2eproto;
};
// -------------------------------------------------------------------
 
class Environment_Bottom final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:netsim.bellhop.protobuf.Environment.Bottom) */ {
 public:
  inline Environment_Bottom() : Environment_Bottom(nullptr) {}
  ~Environment_Bottom() override;
  explicit PROTOBUF_CONSTEXPR Environment_Bottom(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  Environment_Bottom(const Environment_Bottom& from);
  Environment_Bottom(Environment_Bottom&& from) noexcept
    : Environment_Bottom() {
    *this = ::std::move(from);
  }
 
  inline Environment_Bottom& operator=(const Environment_Bottom& from) {
    CopyFrom(from);
    return *this;
  }
  inline Environment_Bottom& operator=(Environment_Bottom&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Environment_Bottom& default_instance() {
    return *internal_default_instance();
  }
  static inline const Environment_Bottom* internal_default_instance() {
    return reinterpret_cast<const Environment_Bottom*>(
               &_Environment_Bottom_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;
 
  friend void swap(Environment_Bottom& a, Environment_Bottom& b) {
    a.Swap(&b);
  }
  inline void Swap(Environment_Bottom* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Environment_Bottom* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  Environment_Bottom* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Environment_Bottom>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Environment_Bottom& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Environment_Bottom& from) {
    Environment_Bottom::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Environment_Bottom* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "netsim.bellhop.protobuf.Environment.Bottom";
  }
  protected:
  explicit Environment_Bottom(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kMediumFieldNumber = 1,
  };
  // optional .netsim.bellhop.protobuf.Environment.Medium medium = 1;
  bool has_medium() const;
  private:
  bool _internal_has_medium() const;
  public:
  void clear_medium();
  const ::netsim::bellhop::protobuf::Environment_Medium& medium() const;
  PROTOBUF_NODISCARD ::netsim::bellhop::protobuf::Environment_Medium* release_medium();
  ::netsim::bellhop::protobuf::Environment_Medium* mutable_medium();
  void set_allocated_medium(::netsim::bellhop::protobuf::Environment_Medium* medium);
  private:
  const ::netsim::bellhop::protobuf::Environment_Medium& _internal_medium() const;
  ::netsim::bellhop::protobuf::Environment_Medium* _internal_mutable_medium();
  public:
  void unsafe_arena_set_allocated_medium(
      ::netsim::bellhop::protobuf::Environment_Medium* medium);
  ::netsim::bellhop::protobuf::Environment_Medium* unsafe_arena_release_medium();
 
  // @@protoc_insertion_point(class_scope:netsim.bellhop.protobuf.Environment.Bottom)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::netsim::bellhop::protobuf::Environment_Medium* medium_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netsim_2facousticstoolbox_2fenvironment_2eproto;
};
// -------------------------------------------------------------------
 
class Environment_Sources_SourcePosition final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:netsim.bellhop.protobuf.Environment.Sources.SourcePosition) */ {
 public:
  inline Environment_Sources_SourcePosition() : Environment_Sources_SourcePosition(nullptr) {}
  ~Environment_Sources_SourcePosition() override;
  explicit PROTOBUF_CONSTEXPR Environment_Sources_SourcePosition(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  Environment_Sources_SourcePosition(const Environment_Sources_SourcePosition& from);
  Environment_Sources_SourcePosition(Environment_Sources_SourcePosition&& from) noexcept
    : Environment_Sources_SourcePosition() {
    *this = ::std::move(from);
  }
 
  inline Environment_Sources_SourcePosition& operator=(const Environment_Sources_SourcePosition& from) {
    CopyFrom(from);
    return *this;
  }
  inline Environment_Sources_SourcePosition& operator=(Environment_Sources_SourcePosition&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Environment_Sources_SourcePosition& default_instance() {
    return *internal_default_instance();
  }
  static inline const Environment_Sources_SourcePosition* internal_default_instance() {
    return reinterpret_cast<const Environment_Sources_SourcePosition*>(
               &_Environment_Sources_SourcePosition_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;
 
  friend void swap(Environment_Sources_SourcePosition& a, Environment_Sources_SourcePosition& b) {
    a.Swap(&b);
  }
  inline void Swap(Environment_Sources_SourcePosition* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Environment_Sources_SourcePosition* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  Environment_Sources_SourcePosition* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Environment_Sources_SourcePosition>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Environment_Sources_SourcePosition& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Environment_Sources_SourcePosition& from) {
    Environment_Sources_SourcePosition::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Environment_Sources_SourcePosition* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "netsim.bellhop.protobuf.Environment.Sources.SourcePosition";
  }
  protected:
  explicit Environment_Sources_SourcePosition(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kDepthFieldNumber = 1,
  };
  // optional double depth = 1;
  bool has_depth() const;
  private:
  bool _internal_has_depth() const;
  public:
  void clear_depth();
  double depth() const;
  void set_depth(double value);
  private:
  double _internal_depth() const;
  void _internal_set_depth(double value);
  public:
 
  // @@protoc_insertion_point(class_scope:netsim.bellhop.protobuf.Environment.Sources.SourcePosition)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    double depth_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netsim_2facousticstoolbox_2fenvironment_2eproto;
};
// -------------------------------------------------------------------
 
class Environment_Sources final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:netsim.bellhop.protobuf.Environment.Sources) */ {
 public:
  inline Environment_Sources() : Environment_Sources(nullptr) {}
  ~Environment_Sources() override;
  explicit PROTOBUF_CONSTEXPR Environment_Sources(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  Environment_Sources(const Environment_Sources& from);
  Environment_Sources(Environment_Sources&& from) noexcept
    : Environment_Sources() {
    *this = ::std::move(from);
  }
 
  inline Environment_Sources& operator=(const Environment_Sources& from) {
    CopyFrom(from);
    return *this;
  }
  inline Environment_Sources& operator=(Environment_Sources&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Environment_Sources& default_instance() {
    return *internal_default_instance();
  }
  static inline const Environment_Sources* internal_default_instance() {
    return reinterpret_cast<const Environment_Sources*>(
               &_Environment_Sources_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;
 
  friend void swap(Environment_Sources& a, Environment_Sources& b) {
    a.Swap(&b);
  }
  inline void Swap(Environment_Sources* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Environment_Sources* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  Environment_Sources* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Environment_Sources>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Environment_Sources& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Environment_Sources& from) {
    Environment_Sources::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Environment_Sources* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "netsim.bellhop.protobuf.Environment.Sources";
  }
  protected:
  explicit Environment_Sources(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef Environment_Sources_SourcePosition SourcePosition;
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kFirstFieldNumber = 2,
    kLastFieldNumber = 3,
    kNumberInDepthFieldNumber = 1,
  };
  // optional .netsim.bellhop.protobuf.Environment.Sources.SourcePosition first = 2 [(.goby.field) = {
  bool has_first() const;
  private:
  bool _internal_has_first() const;
  public:
  void clear_first();
  const ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition& first() const;
  PROTOBUF_NODISCARD ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* release_first();
  ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* mutable_first();
  void set_allocated_first(::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* first);
  private:
  const ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition& _internal_first() const;
  ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* _internal_mutable_first();
  public:
  void unsafe_arena_set_allocated_first(
      ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* first);
  ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* unsafe_arena_release_first();
 
  // optional .netsim.bellhop.protobuf.Environment.Sources.SourcePosition last = 3 [(.goby.field) = {
  bool has_last() const;
  private:
  bool _internal_has_last() const;
  public:
  void clear_last();
  const ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition& last() const;
  PROTOBUF_NODISCARD ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* release_last();
  ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* mutable_last();
  void set_allocated_last(::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* last);
  private:
  const ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition& _internal_last() const;
  ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* _internal_mutable_last();
  public:
  void unsafe_arena_set_allocated_last(
      ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* last);
  ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* unsafe_arena_release_last();
 
  // optional uint32 number_in_depth = 1 [(.goby.field) = {
  bool has_number_in_depth() const;
  private:
  bool _internal_has_number_in_depth() const;
  public:
  void clear_number_in_depth();
  uint32_t number_in_depth() const;
  void set_number_in_depth(uint32_t value);
  private:
  uint32_t _internal_number_in_depth() const;
  void _internal_set_number_in_depth(uint32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:netsim.bellhop.protobuf.Environment.Sources)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* first_;
    ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* last_;
    uint32_t number_in_depth_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netsim_2facousticstoolbox_2fenvironment_2eproto;
};
// -------------------------------------------------------------------
 
class Environment_Receivers_ReceiverPosition final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:netsim.bellhop.protobuf.Environment.Receivers.ReceiverPosition) */ {
 public:
  inline Environment_Receivers_ReceiverPosition() : Environment_Receivers_ReceiverPosition(nullptr) {}
  ~Environment_Receivers_ReceiverPosition() override;
  explicit PROTOBUF_CONSTEXPR Environment_Receivers_ReceiverPosition(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  Environment_Receivers_ReceiverPosition(const Environment_Receivers_ReceiverPosition& from);
  Environment_Receivers_ReceiverPosition(Environment_Receivers_ReceiverPosition&& from) noexcept
    : Environment_Receivers_ReceiverPosition() {
    *this = ::std::move(from);
  }
 
  inline Environment_Receivers_ReceiverPosition& operator=(const Environment_Receivers_ReceiverPosition& from) {
    CopyFrom(from);
    return *this;
  }
  inline Environment_Receivers_ReceiverPosition& operator=(Environment_Receivers_ReceiverPosition&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Environment_Receivers_ReceiverPosition& default_instance() {
    return *internal_default_instance();
  }
  static inline const Environment_Receivers_ReceiverPosition* internal_default_instance() {
    return reinterpret_cast<const Environment_Receivers_ReceiverPosition*>(
               &_Environment_Receivers_ReceiverPosition_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;
 
  friend void swap(Environment_Receivers_ReceiverPosition& a, Environment_Receivers_ReceiverPosition& b) {
    a.Swap(&b);
  }
  inline void Swap(Environment_Receivers_ReceiverPosition* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Environment_Receivers_ReceiverPosition* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  Environment_Receivers_ReceiverPosition* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Environment_Receivers_ReceiverPosition>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Environment_Receivers_ReceiverPosition& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Environment_Receivers_ReceiverPosition& from) {
    Environment_Receivers_ReceiverPosition::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Environment_Receivers_ReceiverPosition* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "netsim.bellhop.protobuf.Environment.Receivers.ReceiverPosition";
  }
  protected:
  explicit Environment_Receivers_ReceiverPosition(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kDepthFieldNumber = 1,
    kRangeFieldNumber = 2,
  };
  // optional double depth = 1;
  bool has_depth() const;
  private:
  bool _internal_has_depth() const;
  public:
  void clear_depth();
  double depth() const;
  void set_depth(double value);
  private:
  double _internal_depth() const;
  void _internal_set_depth(double value);
  public:
 
  // optional double range = 2;
  bool has_range() const;
  private:
  bool _internal_has_range() const;
  public:
  void clear_range();
  double range() const;
  void set_range(double value);
  private:
  double _internal_range() const;
  void _internal_set_range(double value);
  public:
 
  // @@protoc_insertion_point(class_scope:netsim.bellhop.protobuf.Environment.Receivers.ReceiverPosition)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    double depth_;
    double range_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netsim_2facousticstoolbox_2fenvironment_2eproto;
};
// -------------------------------------------------------------------
 
class Environment_Receivers final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:netsim.bellhop.protobuf.Environment.Receivers) */ {
 public:
  inline Environment_Receivers() : Environment_Receivers(nullptr) {}
  ~Environment_Receivers() override;
  explicit PROTOBUF_CONSTEXPR Environment_Receivers(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  Environment_Receivers(const Environment_Receivers& from);
  Environment_Receivers(Environment_Receivers&& from) noexcept
    : Environment_Receivers() {
    *this = ::std::move(from);
  }
 
  inline Environment_Receivers& operator=(const Environment_Receivers& from) {
    CopyFrom(from);
    return *this;
  }
  inline Environment_Receivers& operator=(Environment_Receivers&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Environment_Receivers& default_instance() {
    return *internal_default_instance();
  }
  static inline const Environment_Receivers* internal_default_instance() {
    return reinterpret_cast<const Environment_Receivers*>(
               &_Environment_Receivers_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;
 
  friend void swap(Environment_Receivers& a, Environment_Receivers& b) {
    a.Swap(&b);
  }
  inline void Swap(Environment_Receivers* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Environment_Receivers* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  Environment_Receivers* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Environment_Receivers>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Environment_Receivers& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Environment_Receivers& from) {
    Environment_Receivers::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Environment_Receivers* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "netsim.bellhop.protobuf.Environment.Receivers";
  }
  protected:
  explicit Environment_Receivers(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef Environment_Receivers_ReceiverPosition ReceiverPosition;
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kFirstFieldNumber = 3,
    kLastFieldNumber = 4,
    kNumberInDepthFieldNumber = 1,
    kNumberInRangeFieldNumber = 2,
  };
  // optional .netsim.bellhop.protobuf.Environment.Receivers.ReceiverPosition first = 3 [(.goby.field) = {
  bool has_first() const;
  private:
  bool _internal_has_first() const;
  public:
  void clear_first();
  const ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition& first() const;
  PROTOBUF_NODISCARD ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* release_first();
  ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* mutable_first();
  void set_allocated_first(::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* first);
  private:
  const ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition& _internal_first() const;
  ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* _internal_mutable_first();
  public:
  void unsafe_arena_set_allocated_first(
      ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* first);
  ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* unsafe_arena_release_first();
 
  // optional .netsim.bellhop.protobuf.Environment.Receivers.ReceiverPosition last = 4 [(.goby.field) = {
  bool has_last() const;
  private:
  bool _internal_has_last() const;
  public:
  void clear_last();
  const ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition& last() const;
  PROTOBUF_NODISCARD ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* release_last();
  ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* mutable_last();
  void set_allocated_last(::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* last);
  private:
  const ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition& _internal_last() const;
  ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* _internal_mutable_last();
  public:
  void unsafe_arena_set_allocated_last(
      ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* last);
  ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* unsafe_arena_release_last();
 
  // optional uint32 number_in_depth = 1 [(.goby.field) = {
  bool has_number_in_depth() const;
  private:
  bool _internal_has_number_in_depth() const;
  public:
  void clear_number_in_depth();
  uint32_t number_in_depth() const;
  void set_number_in_depth(uint32_t value);
  private:
  uint32_t _internal_number_in_depth() const;
  void _internal_set_number_in_depth(uint32_t value);
  public:
 
  // optional uint32 number_in_range = 2 [(.goby.field) = {
  bool has_number_in_range() const;
  private:
  bool _internal_has_number_in_range() const;
  public:
  void clear_number_in_range();
  uint32_t number_in_range() const;
  void set_number_in_range(uint32_t value);
  private:
  uint32_t _internal_number_in_range() const;
  void _internal_set_number_in_range(uint32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:netsim.bellhop.protobuf.Environment.Receivers)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* first_;
    ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* last_;
    uint32_t number_in_depth_;
    uint32_t number_in_range_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netsim_2facousticstoolbox_2fenvironment_2eproto;
};
// -------------------------------------------------------------------
 
class Environment_Beams final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:netsim.bellhop.protobuf.Environment.Beams) */ {
 public:
  inline Environment_Beams() : Environment_Beams(nullptr) {}
  ~Environment_Beams() override;
  explicit PROTOBUF_CONSTEXPR Environment_Beams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  Environment_Beams(const Environment_Beams& from);
  Environment_Beams(Environment_Beams&& from) noexcept
    : Environment_Beams() {
    *this = ::std::move(from);
  }
 
  inline Environment_Beams& operator=(const Environment_Beams& from) {
    CopyFrom(from);
    return *this;
  }
  inline Environment_Beams& operator=(Environment_Beams&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Environment_Beams& default_instance() {
    return *internal_default_instance();
  }
  static inline const Environment_Beams* internal_default_instance() {
    return reinterpret_cast<const Environment_Beams*>(
               &_Environment_Beams_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;
 
  friend void swap(Environment_Beams& a, Environment_Beams& b) {
    a.Swap(&b);
  }
  inline void Swap(Environment_Beams* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Environment_Beams* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  Environment_Beams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Environment_Beams>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Environment_Beams& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Environment_Beams& from) {
    Environment_Beams::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Environment_Beams* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "netsim.bellhop.protobuf.Environment.Beams";
  }
  protected:
  explicit Environment_Beams(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef Environment_Beams_ApproximationType ApproximationType;
  static constexpr ApproximationType GEOMETRIC =
    Environment_Beams_ApproximationType_GEOMETRIC;
  static constexpr ApproximationType CARTESIAN =
    Environment_Beams_ApproximationType_CARTESIAN;
  static constexpr ApproximationType RAY_CENTERED =
    Environment_Beams_ApproximationType_RAY_CENTERED;
  static constexpr ApproximationType GAUSSIAN =
    Environment_Beams_ApproximationType_GAUSSIAN;
  static inline bool ApproximationType_IsValid(int value) {
    return Environment_Beams_ApproximationType_IsValid(value);
  }
  static constexpr ApproximationType ApproximationType_MIN =
    Environment_Beams_ApproximationType_ApproximationType_MIN;
  static constexpr ApproximationType ApproximationType_MAX =
    Environment_Beams_ApproximationType_ApproximationType_MAX;
  static constexpr int ApproximationType_ARRAYSIZE =
    Environment_Beams_ApproximationType_ApproximationType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ApproximationType_descriptor() {
    return Environment_Beams_ApproximationType_descriptor();
  }
  template<typename T>
  static inline const std::string& ApproximationType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ApproximationType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ApproximationType_Name.");
    return Environment_Beams_ApproximationType_Name(enum_t_value);
  }
  static inline bool ApproximationType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ApproximationType* value) {
    return Environment_Beams_ApproximationType_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kNumberFieldNumber = 4,
    kThetaMaxFieldNumber = 3,
    kApproximationTypeFieldNumber = 1,
    kThetaMinFieldNumber = 2,
  };
  // optional uint32 number = 4 [default = 0, (.goby.field) = {
  bool has_number() const;
  private:
  bool _internal_has_number() const;
  public:
  void clear_number();
  uint32_t number() const;
  void set_number(uint32_t value);
  private:
  uint32_t _internal_number() const;
  void _internal_set_number(uint32_t value);
  public:
 
  // optional int32 theta_max = 3 [default = 90, (.goby.field) = {
  bool has_theta_max() const;
  private:
  bool _internal_has_theta_max() const;
  public:
  void clear_theta_max();
  int32_t theta_max() const;
  void set_theta_max(int32_t value);
  private:
  int32_t _internal_theta_max() const;
  void _internal_set_theta_max(int32_t value);
  public:
 
  // optional .netsim.bellhop.protobuf.Environment.Beams.ApproximationType approximation_type = 1 [(.goby.field) = {
  bool has_approximation_type() const;
  private:
  bool _internal_has_approximation_type() const;
  public:
  void clear_approximation_type();
  ::netsim::bellhop::protobuf::Environment_Beams_ApproximationType approximation_type() const;
  void set_approximation_type(::netsim::bellhop::protobuf::Environment_Beams_ApproximationType value);
  private:
  ::netsim::bellhop::protobuf::Environment_Beams_ApproximationType _internal_approximation_type() const;
  void _internal_set_approximation_type(::netsim::bellhop::protobuf::Environment_Beams_ApproximationType value);
  public:
 
  // optional int32 theta_min = 2 [default = -90, (.goby.field) = {
  bool has_theta_min() const;
  private:
  bool _internal_has_theta_min() const;
  public:
  void clear_theta_min();
  int32_t theta_min() const;
  void set_theta_min(int32_t value);
  private:
  int32_t _internal_theta_min() const;
  void _internal_set_theta_min(int32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:netsim.bellhop.protobuf.Environment.Beams)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t number_;
    int32_t theta_max_;
    int approximation_type_;
    int32_t theta_min_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netsim_2facousticstoolbox_2fenvironment_2eproto;
};
// -------------------------------------------------------------------
 
class Environment_AdaptiveInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:netsim.bellhop.protobuf.Environment.AdaptiveInfo) */ {
 public:
  inline Environment_AdaptiveInfo() : Environment_AdaptiveInfo(nullptr) {}
  ~Environment_AdaptiveInfo() override;
  explicit PROTOBUF_CONSTEXPR Environment_AdaptiveInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  Environment_AdaptiveInfo(const Environment_AdaptiveInfo& from);
  Environment_AdaptiveInfo(Environment_AdaptiveInfo&& from) noexcept
    : Environment_AdaptiveInfo() {
    *this = ::std::move(from);
  }
 
  inline Environment_AdaptiveInfo& operator=(const Environment_AdaptiveInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline Environment_AdaptiveInfo& operator=(Environment_AdaptiveInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Environment_AdaptiveInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const Environment_AdaptiveInfo* internal_default_instance() {
    return reinterpret_cast<const Environment_AdaptiveInfo*>(
               &_Environment_AdaptiveInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;
 
  friend void swap(Environment_AdaptiveInfo& a, Environment_AdaptiveInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(Environment_AdaptiveInfo* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Environment_AdaptiveInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  Environment_AdaptiveInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Environment_AdaptiveInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Environment_AdaptiveInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Environment_AdaptiveInfo& from) {
    Environment_AdaptiveInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Environment_AdaptiveInfo* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "netsim.bellhop.protobuf.Environment.AdaptiveInfo";
  }
  protected:
  explicit Environment_AdaptiveInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kContactFieldNumber = 1,
    kOwnshipFieldNumber = 2,
    kReadShdFieldNumber = 3,
    kFullShdMatrixFieldNumber = 10,
    kAutoReceiverRangesFieldNumber = 4,
    kAutoSourceDepthFieldNumber = 6,
    kLookAheadSecondsFieldNumber = 5,
    kAutoReceiverRangesDeltaFieldNumber = 7,
  };
  // optional string contact = 1 [(.goby.field) = {
  bool has_contact() const;
  private:
  bool _internal_has_contact() const;
  public:
  void clear_contact();
  const std::string& contact() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_contact(ArgT0&& arg0, ArgT... args);
  std::string* mutable_contact();
  PROTOBUF_NODISCARD std::string* release_contact();
  void set_allocated_contact(std::string* contact);
  private:
  const std::string& _internal_contact() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_contact(const std::string& value);
  std::string* _internal_mutable_contact();
  public:
 
  // optional string ownship = 2 [(.goby.field) = {
  bool has_ownship() const;
  private:
  bool _internal_has_ownship() const;
  public:
  void clear_ownship();
  const std::string& ownship() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_ownship(ArgT0&& arg0, ArgT... args);
  std::string* mutable_ownship();
  PROTOBUF_NODISCARD std::string* release_ownship();
  void set_allocated_ownship(std::string* ownship);
  private:
  const std::string& _internal_ownship() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ownship(const std::string& value);
  std::string* _internal_mutable_ownship();
  public:
 
  // optional bool read_shd = 3 [default = false, (.goby.field) = {
  bool has_read_shd() const;
  private:
  bool _internal_has_read_shd() const;
  public:
  void clear_read_shd();
  bool read_shd() const;
  void set_read_shd(bool value);
  private:
  bool _internal_read_shd() const;
  void _internal_set_read_shd(bool value);
  public:
 
  // optional bool full_shd_matrix = 10 [default = false, (.goby.field) = {
  bool has_full_shd_matrix() const;
  private:
  bool _internal_has_full_shd_matrix() const;
  public:
  void clear_full_shd_matrix();
  bool full_shd_matrix() const;
  void set_full_shd_matrix(bool value);
  private:
  bool _internal_full_shd_matrix() const;
  void _internal_set_full_shd_matrix(bool value);
  public:
 
  // optional bool auto_receiver_ranges = 4 [default = false, (.goby.field) = {
  bool has_auto_receiver_ranges() const;
  private:
  bool _internal_has_auto_receiver_ranges() const;
  public:
  void clear_auto_receiver_ranges();
  bool auto_receiver_ranges() const;
  void set_auto_receiver_ranges(bool value);
  private:
  bool _internal_auto_receiver_ranges() const;
  void _internal_set_auto_receiver_ranges(bool value);
  public:
 
  // optional bool auto_source_depth = 6 [default = false, (.goby.field) = {
  bool has_auto_source_depth() const;
  private:
  bool _internal_has_auto_source_depth() const;
  public:
  void clear_auto_source_depth();
  bool auto_source_depth() const;
  void set_auto_source_depth(bool value);
  private:
  bool _internal_auto_source_depth() const;
  void _internal_set_auto_source_depth(bool value);
  public:
 
  // optional uint32 look_ahead_seconds = 5 [default = 60, (.goby.field) = {
  bool has_look_ahead_seconds() const;
  private:
  bool _internal_has_look_ahead_seconds() const;
  public:
  void clear_look_ahead_seconds();
  uint32_t look_ahead_seconds() const;
  void set_look_ahead_seconds(uint32_t value);
  private:
  uint32_t _internal_look_ahead_seconds() const;
  void _internal_set_look_ahead_seconds(uint32_t value);
  public:
 
  // optional int32 auto_receiver_ranges_delta = 7 [default = 1, (.goby.field) = {
  bool has_auto_receiver_ranges_delta() const;
  private:
  bool _internal_has_auto_receiver_ranges_delta() const;
  public:
  void clear_auto_receiver_ranges_delta();
  int32_t auto_receiver_ranges_delta() const;
  void set_auto_receiver_ranges_delta(int32_t value);
  private:
  int32_t _internal_auto_receiver_ranges_delta() const;
  void _internal_set_auto_receiver_ranges_delta(int32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:netsim.bellhop.protobuf.Environment.AdaptiveInfo)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr contact_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ownship_;
    bool read_shd_;
    bool full_shd_matrix_;
    bool auto_receiver_ranges_;
    bool auto_source_depth_;
    uint32_t look_ahead_seconds_;
    int32_t auto_receiver_ranges_delta_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netsim_2facousticstoolbox_2fenvironment_2eproto;
};
// -------------------------------------------------------------------
 
class Environment final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:netsim.bellhop.protobuf.Environment) */ {
 public:
  inline Environment() : Environment(nullptr) {}
  ~Environment() override;
  explicit PROTOBUF_CONSTEXPR Environment(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  Environment(const Environment& from);
  Environment(Environment&& from) noexcept
    : Environment() {
    *this = ::std::move(from);
  }
 
  inline Environment& operator=(const Environment& from) {
    CopyFrom(from);
    return *this;
  }
  inline Environment& operator=(Environment&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Environment& default_instance() {
    return *internal_default_instance();
  }
  static inline const Environment* internal_default_instance() {
    return reinterpret_cast<const Environment*>(
               &_Environment_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;
 
  friend void swap(Environment& a, Environment& b) {
    a.Swap(&b);
  }
  inline void Swap(Environment* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Environment* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  Environment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Environment>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Environment& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Environment& from) {
    Environment::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Environment* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "netsim.bellhop.protobuf.Environment";
  }
  protected:
  explicit Environment(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef Environment_Output Output;
  typedef Environment_Medium Medium;
  typedef Environment_Surface Surface;
  typedef Environment_WaterColumn WaterColumn;
  typedef Environment_Bottom Bottom;
  typedef Environment_Sources Sources;
  typedef Environment_Receivers Receivers;
  typedef Environment_Beams Beams;
  typedef Environment_AdaptiveInfo AdaptiveInfo;
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kWaterColumnFieldNumber = 5,
    kTitleFieldNumber = 1,
    kOutputFieldNumber = 3,
    kSurfaceFieldNumber = 4,
    kBottomFieldNumber = 6,
    kSourcesFieldNumber = 7,
    kReceiversFieldNumber = 8,
    kBeamsFieldNumber = 9,
    kAdaptiveInfoFieldNumber = 100,
    kFreqFieldNumber = 2,
  };
  // repeated .netsim.bellhop.protobuf.Environment.WaterColumn water_column = 5 [(.goby.field) = {
  int water_column_size() const;
  private:
  int _internal_water_column_size() const;
  public:
  void clear_water_column();
  ::netsim::bellhop::protobuf::Environment_WaterColumn* mutable_water_column(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::netsim::bellhop::protobuf::Environment_WaterColumn >*
      mutable_water_column();
  private:
  const ::netsim::bellhop::protobuf::Environment_WaterColumn& _internal_water_column(int index) const;
  ::netsim::bellhop::protobuf::Environment_WaterColumn* _internal_add_water_column();
  public:
  const ::netsim::bellhop::protobuf::Environment_WaterColumn& water_column(int index) const;
  ::netsim::bellhop::protobuf::Environment_WaterColumn* add_water_column();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::netsim::bellhop::protobuf::Environment_WaterColumn >&
      water_column() const;
 
  // optional string title = 1 [default = "Environmental File", (.goby.field) = {
  bool has_title() const;
  private:
  bool _internal_has_title() const;
  public:
  void clear_title();
  const std::string& title() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_title(ArgT0&& arg0, ArgT... args);
  std::string* mutable_title();
  PROTOBUF_NODISCARD std::string* release_title();
  void set_allocated_title(std::string* title);
  private:
  const std::string& _internal_title() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value);
  std::string* _internal_mutable_title();
  public:
 
  // optional .netsim.bellhop.protobuf.Environment.Output output = 3 [(.goby.field) = {
  bool has_output() const;
  private:
  bool _internal_has_output() const;
  public:
  void clear_output();
  const ::netsim::bellhop::protobuf::Environment_Output& output() const;
  PROTOBUF_NODISCARD ::netsim::bellhop::protobuf::Environment_Output* release_output();
  ::netsim::bellhop::protobuf::Environment_Output* mutable_output();
  void set_allocated_output(::netsim::bellhop::protobuf::Environment_Output* output);
  private:
  const ::netsim::bellhop::protobuf::Environment_Output& _internal_output() const;
  ::netsim::bellhop::protobuf::Environment_Output* _internal_mutable_output();
  public:
  void unsafe_arena_set_allocated_output(
      ::netsim::bellhop::protobuf::Environment_Output* output);
  ::netsim::bellhop::protobuf::Environment_Output* unsafe_arena_release_output();
 
  // optional .netsim.bellhop.protobuf.Environment.Surface surface = 4 [(.goby.field) = {
  bool has_surface() const;
  private:
  bool _internal_has_surface() const;
  public:
  void clear_surface();
  const ::netsim::bellhop::protobuf::Environment_Surface& surface() const;
  PROTOBUF_NODISCARD ::netsim::bellhop::protobuf::Environment_Surface* release_surface();
  ::netsim::bellhop::protobuf::Environment_Surface* mutable_surface();
  void set_allocated_surface(::netsim::bellhop::protobuf::Environment_Surface* surface);
  private:
  const ::netsim::bellhop::protobuf::Environment_Surface& _internal_surface() const;
  ::netsim::bellhop::protobuf::Environment_Surface* _internal_mutable_surface();
  public:
  void unsafe_arena_set_allocated_surface(
      ::netsim::bellhop::protobuf::Environment_Surface* surface);
  ::netsim::bellhop::protobuf::Environment_Surface* unsafe_arena_release_surface();
 
  // optional .netsim.bellhop.protobuf.Environment.Bottom bottom = 6 [(.goby.field) = {
  bool has_bottom() const;
  private:
  bool _internal_has_bottom() const;
  public:
  void clear_bottom();
  const ::netsim::bellhop::protobuf::Environment_Bottom& bottom() const;
  PROTOBUF_NODISCARD ::netsim::bellhop::protobuf::Environment_Bottom* release_bottom();
  ::netsim::bellhop::protobuf::Environment_Bottom* mutable_bottom();
  void set_allocated_bottom(::netsim::bellhop::protobuf::Environment_Bottom* bottom);
  private:
  const ::netsim::bellhop::protobuf::Environment_Bottom& _internal_bottom() const;
  ::netsim::bellhop::protobuf::Environment_Bottom* _internal_mutable_bottom();
  public:
  void unsafe_arena_set_allocated_bottom(
      ::netsim::bellhop::protobuf::Environment_Bottom* bottom);
  ::netsim::bellhop::protobuf::Environment_Bottom* unsafe_arena_release_bottom();
 
  // optional .netsim.bellhop.protobuf.Environment.Sources sources = 7 [(.goby.field) = {
  bool has_sources() const;
  private:
  bool _internal_has_sources() const;
  public:
  void clear_sources();
  const ::netsim::bellhop::protobuf::Environment_Sources& sources() const;
  PROTOBUF_NODISCARD ::netsim::bellhop::protobuf::Environment_Sources* release_sources();
  ::netsim::bellhop::protobuf::Environment_Sources* mutable_sources();
  void set_allocated_sources(::netsim::bellhop::protobuf::Environment_Sources* sources);
  private:
  const ::netsim::bellhop::protobuf::Environment_Sources& _internal_sources() const;
  ::netsim::bellhop::protobuf::Environment_Sources* _internal_mutable_sources();
  public:
  void unsafe_arena_set_allocated_sources(
      ::netsim::bellhop::protobuf::Environment_Sources* sources);
  ::netsim::bellhop::protobuf::Environment_Sources* unsafe_arena_release_sources();
 
  // optional .netsim.bellhop.protobuf.Environment.Receivers receivers = 8 [(.goby.field) = {
  bool has_receivers() const;
  private:
  bool _internal_has_receivers() const;
  public:
  void clear_receivers();
  const ::netsim::bellhop::protobuf::Environment_Receivers& receivers() const;
  PROTOBUF_NODISCARD ::netsim::bellhop::protobuf::Environment_Receivers* release_receivers();
  ::netsim::bellhop::protobuf::Environment_Receivers* mutable_receivers();
  void set_allocated_receivers(::netsim::bellhop::protobuf::Environment_Receivers* receivers);
  private:
  const ::netsim::bellhop::protobuf::Environment_Receivers& _internal_receivers() const;
  ::netsim::bellhop::protobuf::Environment_Receivers* _internal_mutable_receivers();
  public:
  void unsafe_arena_set_allocated_receivers(
      ::netsim::bellhop::protobuf::Environment_Receivers* receivers);
  ::netsim::bellhop::protobuf::Environment_Receivers* unsafe_arena_release_receivers();
 
  // optional .netsim.bellhop.protobuf.Environment.Beams beams = 9 [(.goby.field) = {
  bool has_beams() const;
  private:
  bool _internal_has_beams() const;
  public:
  void clear_beams();
  const ::netsim::bellhop::protobuf::Environment_Beams& beams() const;
  PROTOBUF_NODISCARD ::netsim::bellhop::protobuf::Environment_Beams* release_beams();
  ::netsim::bellhop::protobuf::Environment_Beams* mutable_beams();
  void set_allocated_beams(::netsim::bellhop::protobuf::Environment_Beams* beams);
  private:
  const ::netsim::bellhop::protobuf::Environment_Beams& _internal_beams() const;
  ::netsim::bellhop::protobuf::Environment_Beams* _internal_mutable_beams();
  public:
  void unsafe_arena_set_allocated_beams(
      ::netsim::bellhop::protobuf::Environment_Beams* beams);
  ::netsim::bellhop::protobuf::Environment_Beams* unsafe_arena_release_beams();
 
  // optional .netsim.bellhop.protobuf.Environment.AdaptiveInfo adaptive_info = 100 [(.goby.field) = {
  bool has_adaptive_info() const;
  private:
  bool _internal_has_adaptive_info() const;
  public:
  void clear_adaptive_info();
  const ::netsim::bellhop::protobuf::Environment_AdaptiveInfo& adaptive_info() const;
  PROTOBUF_NODISCARD ::netsim::bellhop::protobuf::Environment_AdaptiveInfo* release_adaptive_info();
  ::netsim::bellhop::protobuf::Environment_AdaptiveInfo* mutable_adaptive_info();
  void set_allocated_adaptive_info(::netsim::bellhop::protobuf::Environment_AdaptiveInfo* adaptive_info);
  private:
  const ::netsim::bellhop::protobuf::Environment_AdaptiveInfo& _internal_adaptive_info() const;
  ::netsim::bellhop::protobuf::Environment_AdaptiveInfo* _internal_mutable_adaptive_info();
  public:
  void unsafe_arena_set_allocated_adaptive_info(
      ::netsim::bellhop::protobuf::Environment_AdaptiveInfo* adaptive_info);
  ::netsim::bellhop::protobuf::Environment_AdaptiveInfo* unsafe_arena_release_adaptive_info();
 
  // optional uint32 freq = 2 [default = 25000, (.goby.field) = {
  bool has_freq() const;
  private:
  bool _internal_has_freq() const;
  public:
  void clear_freq();
  uint32_t freq() const;
  void set_freq(uint32_t value);
  private:
  uint32_t _internal_freq() const;
  void _internal_set_freq(uint32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:netsim.bellhop.protobuf.Environment)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::netsim::bellhop::protobuf::Environment_WaterColumn > water_column_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_title_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_;
    ::netsim::bellhop::protobuf::Environment_Output* output_;
    ::netsim::bellhop::protobuf::Environment_Surface* surface_;
    ::netsim::bellhop::protobuf::Environment_Bottom* bottom_;
    ::netsim::bellhop::protobuf::Environment_Sources* sources_;
    ::netsim::bellhop::protobuf::Environment_Receivers* receivers_;
    ::netsim::bellhop::protobuf::Environment_Beams* beams_;
    ::netsim::bellhop::protobuf::Environment_AdaptiveInfo* adaptive_info_;
    uint32_t freq_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netsim_2facousticstoolbox_2fenvironment_2eproto;
};
// ===================================================================
 
 
// ===================================================================
 
#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// Environment_Output
 
// optional .netsim.bellhop.protobuf.Environment.Output.OutputType type = 1 [default = INCOHERENT_PRESSURE, (.goby.field) = {
inline bool Environment_Output::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Environment_Output::has_type() const {
  return _internal_has_type();
}
inline void Environment_Output::clear_type() {
  _impl_.type_ = 5;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::netsim::bellhop::protobuf::Environment_Output_OutputType Environment_Output::_internal_type() const {
  return static_cast< ::netsim::bellhop::protobuf::Environment_Output_OutputType >(_impl_.type_);
}
inline ::netsim::bellhop::protobuf::Environment_Output_OutputType Environment_Output::type() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Output.type)
  return _internal_type();
}
inline void Environment_Output::_internal_set_type(::netsim::bellhop::protobuf::Environment_Output_OutputType value) {
  assert(::netsim::bellhop::protobuf::Environment_Output_OutputType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.type_ = value;
}
inline void Environment_Output::set_type(::netsim::bellhop::protobuf::Environment_Output_OutputType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.Output.type)
}
 
// -------------------------------------------------------------------
 
// Environment_Medium_RCSample
 
// optional double angle = 1 [(.goby.field) = {
inline bool Environment_Medium_RCSample::_internal_has_angle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Environment_Medium_RCSample::has_angle() const {
  return _internal_has_angle();
}
inline void Environment_Medium_RCSample::clear_angle() {
  _impl_.angle_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline double Environment_Medium_RCSample::_internal_angle() const {
  return _impl_.angle_;
}
inline double Environment_Medium_RCSample::angle() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Medium.RCSample.angle)
  return _internal_angle();
}
inline void Environment_Medium_RCSample::_internal_set_angle(double value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.angle_ = value;
}
inline void Environment_Medium_RCSample::set_angle(double value) {
  _internal_set_angle(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.Medium.RCSample.angle)
}
 
// optional double rc = 2 [(.goby.field) = {
inline bool Environment_Medium_RCSample::_internal_has_rc() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Environment_Medium_RCSample::has_rc() const {
  return _internal_has_rc();
}
inline void Environment_Medium_RCSample::clear_rc() {
  _impl_.rc_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline double Environment_Medium_RCSample::_internal_rc() const {
  return _impl_.rc_;
}
inline double Environment_Medium_RCSample::rc() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Medium.RCSample.rc)
  return _internal_rc();
}
inline void Environment_Medium_RCSample::_internal_set_rc(double value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.rc_ = value;
}
inline void Environment_Medium_RCSample::set_rc(double value) {
  _internal_set_rc(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.Medium.RCSample.rc)
}
 
// optional double phase = 3 [(.goby.field) = {
inline bool Environment_Medium_RCSample::_internal_has_phase() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Environment_Medium_RCSample::has_phase() const {
  return _internal_has_phase();
}
inline void Environment_Medium_RCSample::clear_phase() {
  _impl_.phase_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline double Environment_Medium_RCSample::_internal_phase() const {
  return _impl_.phase_;
}
inline double Environment_Medium_RCSample::phase() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Medium.RCSample.phase)
  return _internal_phase();
}
inline void Environment_Medium_RCSample::_internal_set_phase(double value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.phase_ = value;
}
inline void Environment_Medium_RCSample::set_phase(double value) {
  _internal_set_phase(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.Medium.RCSample.phase)
}
 
// -------------------------------------------------------------------
 
// Environment_Medium_Attenuation
 
// optional .netsim.bellhop.protobuf.Environment.Medium.Attenuation.Units units = 1 [(.goby.field) = {
inline bool Environment_Medium_Attenuation::_internal_has_units() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Environment_Medium_Attenuation::has_units() const {
  return _internal_has_units();
}
inline void Environment_Medium_Attenuation::clear_units() {
  _impl_.units_ = 1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::netsim::bellhop::protobuf::Environment_Medium_Attenuation_Units Environment_Medium_Attenuation::_internal_units() const {
  return static_cast< ::netsim::bellhop::protobuf::Environment_Medium_Attenuation_Units >(_impl_.units_);
}
inline ::netsim::bellhop::protobuf::Environment_Medium_Attenuation_Units Environment_Medium_Attenuation::units() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Medium.Attenuation.units)
  return _internal_units();
}
inline void Environment_Medium_Attenuation::_internal_set_units(::netsim::bellhop::protobuf::Environment_Medium_Attenuation_Units value) {
  assert(::netsim::bellhop::protobuf::Environment_Medium_Attenuation_Units_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.units_ = value;
}
inline void Environment_Medium_Attenuation::set_units(::netsim::bellhop::protobuf::Environment_Medium_Attenuation_Units value) {
  _internal_set_units(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.Medium.Attenuation.units)
}
 
// optional double value = 2;
inline bool Environment_Medium_Attenuation::_internal_has_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Environment_Medium_Attenuation::has_value() const {
  return _internal_has_value();
}
inline void Environment_Medium_Attenuation::clear_value() {
  _impl_.value_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline double Environment_Medium_Attenuation::_internal_value() const {
  return _impl_.value_;
}
inline double Environment_Medium_Attenuation::value() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Medium.Attenuation.value)
  return _internal_value();
}
inline void Environment_Medium_Attenuation::_internal_set_value(double value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.value_ = value;
}
inline void Environment_Medium_Attenuation::set_value(double value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.Medium.Attenuation.value)
}
 
// -------------------------------------------------------------------
 
// Environment_Medium
 
// optional .netsim.bellhop.protobuf.Environment.Medium.MediumType type = 1 [(.goby.field) = {
inline bool Environment_Medium::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Environment_Medium::has_type() const {
  return _internal_has_type();
}
inline void Environment_Medium::clear_type() {
  _impl_.type_ = 1;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline ::netsim::bellhop::protobuf::Environment_Medium_MediumType Environment_Medium::_internal_type() const {
  return static_cast< ::netsim::bellhop::protobuf::Environment_Medium_MediumType >(_impl_.type_);
}
inline ::netsim::bellhop::protobuf::Environment_Medium_MediumType Environment_Medium::type() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Medium.type)
  return _internal_type();
}
inline void Environment_Medium::_internal_set_type(::netsim::bellhop::protobuf::Environment_Medium_MediumType value) {
  assert(::netsim::bellhop::protobuf::Environment_Medium_MediumType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.type_ = value;
}
inline void Environment_Medium::set_type(::netsim::bellhop::protobuf::Environment_Medium_MediumType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.Medium.type)
}
 
// optional .netsim.bellhop.protobuf.Environment.Medium.Attenuation attenuation = 2 [(.goby.field) = {
inline bool Environment_Medium::_internal_has_attenuation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.attenuation_ != nullptr);
  return value;
}
inline bool Environment_Medium::has_attenuation() const {
  return _internal_has_attenuation();
}
inline void Environment_Medium::clear_attenuation() {
  if (_impl_.attenuation_ != nullptr) _impl_.attenuation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::netsim::bellhop::protobuf::Environment_Medium_Attenuation& Environment_Medium::_internal_attenuation() const {
  const ::netsim::bellhop::protobuf::Environment_Medium_Attenuation* p = _impl_.attenuation_;
  return p != nullptr ? *p : reinterpret_cast<const ::netsim::bellhop::protobuf::Environment_Medium_Attenuation&>(
      ::netsim::bellhop::protobuf::_Environment_Medium_Attenuation_default_instance_);
}
inline const ::netsim::bellhop::protobuf::Environment_Medium_Attenuation& Environment_Medium::attenuation() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Medium.attenuation)
  return _internal_attenuation();
}
inline void Environment_Medium::unsafe_arena_set_allocated_attenuation(
    ::netsim::bellhop::protobuf::Environment_Medium_Attenuation* attenuation) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.attenuation_);
  }
  _impl_.attenuation_ = attenuation;
  if (attenuation) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:netsim.bellhop.protobuf.Environment.Medium.attenuation)
}
inline ::netsim::bellhop::protobuf::Environment_Medium_Attenuation* Environment_Medium::release_attenuation() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::netsim::bellhop::protobuf::Environment_Medium_Attenuation* temp = _impl_.attenuation_;
  _impl_.attenuation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Medium_Attenuation* Environment_Medium::unsafe_arena_release_attenuation() {
  // @@protoc_insertion_point(field_release:netsim.bellhop.protobuf.Environment.Medium.attenuation)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::netsim::bellhop::protobuf::Environment_Medium_Attenuation* temp = _impl_.attenuation_;
  _impl_.attenuation_ = nullptr;
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Medium_Attenuation* Environment_Medium::_internal_mutable_attenuation() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.attenuation_ == nullptr) {
    auto* p = CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_Medium_Attenuation>(GetArenaForAllocation());
    _impl_.attenuation_ = p;
  }
  return _impl_.attenuation_;
}
inline ::netsim::bellhop::protobuf::Environment_Medium_Attenuation* Environment_Medium::mutable_attenuation() {
  ::netsim::bellhop::protobuf::Environment_Medium_Attenuation* _msg = _internal_mutable_attenuation();
  // @@protoc_insertion_point(field_mutable:netsim.bellhop.protobuf.Environment.Medium.attenuation)
  return _msg;
}
inline void Environment_Medium::set_allocated_attenuation(::netsim::bellhop::protobuf::Environment_Medium_Attenuation* attenuation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.attenuation_;
  }
  if (attenuation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(attenuation);
    if (message_arena != submessage_arena) {
      attenuation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, attenuation, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.attenuation_ = attenuation;
  // @@protoc_insertion_point(field_set_allocated:netsim.bellhop.protobuf.Environment.Medium.attenuation)
}
 
// optional double cp = 3 [(.goby.field) = {
inline bool Environment_Medium::_internal_has_cp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Environment_Medium::has_cp() const {
  return _internal_has_cp();
}
inline void Environment_Medium::clear_cp() {
  _impl_.cp_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline double Environment_Medium::_internal_cp() const {
  return _impl_.cp_;
}
inline double Environment_Medium::cp() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Medium.cp)
  return _internal_cp();
}
inline void Environment_Medium::_internal_set_cp(double value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.cp_ = value;
}
inline void Environment_Medium::set_cp(double value) {
  _internal_set_cp(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.Medium.cp)
}
 
// optional double cs = 4 [(.goby.field) = {
inline bool Environment_Medium::_internal_has_cs() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Environment_Medium::has_cs() const {
  return _internal_has_cs();
}
inline void Environment_Medium::clear_cs() {
  _impl_.cs_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline double Environment_Medium::_internal_cs() const {
  return _impl_.cs_;
}
inline double Environment_Medium::cs() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Medium.cs)
  return _internal_cs();
}
inline void Environment_Medium::_internal_set_cs(double value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.cs_ = value;
}
inline void Environment_Medium::set_cs(double value) {
  _internal_set_cs(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.Medium.cs)
}
 
// optional double density = 5 [(.goby.field) = {
inline bool Environment_Medium::_internal_has_density() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Environment_Medium::has_density() const {
  return _internal_has_density();
}
inline void Environment_Medium::clear_density() {
  _impl_.density_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline double Environment_Medium::_internal_density() const {
  return _impl_.density_;
}
inline double Environment_Medium::density() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Medium.density)
  return _internal_density();
}
inline void Environment_Medium::_internal_set_density(double value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.density_ = value;
}
inline void Environment_Medium::set_density(double value) {
  _internal_set_density(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.Medium.density)
}
 
// optional double depth = 6 [(.goby.field) = {
inline bool Environment_Medium::_internal_has_depth() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Environment_Medium::has_depth() const {
  return _internal_has_depth();
}
inline void Environment_Medium::clear_depth() {
  _impl_.depth_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline double Environment_Medium::_internal_depth() const {
  return _impl_.depth_;
}
inline double Environment_Medium::depth() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Medium.depth)
  return _internal_depth();
}
inline void Environment_Medium::_internal_set_depth(double value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.depth_ = value;
}
inline void Environment_Medium::set_depth(double value) {
  _internal_set_depth(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.Medium.depth)
}
 
// repeated .netsim.bellhop.protobuf.Environment.Medium.RCSample rc_sample = 7 [(.goby.field) = {
inline int Environment_Medium::_internal_rc_sample_size() const {
  return _impl_.rc_sample_.size();
}
inline int Environment_Medium::rc_sample_size() const {
  return _internal_rc_sample_size();
}
inline void Environment_Medium::clear_rc_sample() {
  _impl_.rc_sample_.Clear();
}
inline ::netsim::bellhop::protobuf::Environment_Medium_RCSample* Environment_Medium::mutable_rc_sample(int index) {
  // @@protoc_insertion_point(field_mutable:netsim.bellhop.protobuf.Environment.Medium.rc_sample)
  return _impl_.rc_sample_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::netsim::bellhop::protobuf::Environment_Medium_RCSample >*
Environment_Medium::mutable_rc_sample() {
  // @@protoc_insertion_point(field_mutable_list:netsim.bellhop.protobuf.Environment.Medium.rc_sample)
  return &_impl_.rc_sample_;
}
inline const ::netsim::bellhop::protobuf::Environment_Medium_RCSample& Environment_Medium::_internal_rc_sample(int index) const {
  return _impl_.rc_sample_.Get(index);
}
inline const ::netsim::bellhop::protobuf::Environment_Medium_RCSample& Environment_Medium::rc_sample(int index) const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Medium.rc_sample)
  return _internal_rc_sample(index);
}
inline ::netsim::bellhop::protobuf::Environment_Medium_RCSample* Environment_Medium::_internal_add_rc_sample() {
  return _impl_.rc_sample_.Add();
}
inline ::netsim::bellhop::protobuf::Environment_Medium_RCSample* Environment_Medium::add_rc_sample() {
  ::netsim::bellhop::protobuf::Environment_Medium_RCSample* _add = _internal_add_rc_sample();
  // @@protoc_insertion_point(field_add:netsim.bellhop.protobuf.Environment.Medium.rc_sample)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::netsim::bellhop::protobuf::Environment_Medium_RCSample >&
Environment_Medium::rc_sample() const {
  // @@protoc_insertion_point(field_list:netsim.bellhop.protobuf.Environment.Medium.rc_sample)
  return _impl_.rc_sample_;
}
 
// -------------------------------------------------------------------
 
// Environment_Surface
 
// optional .netsim.bellhop.protobuf.Environment.Medium medium = 1;
inline bool Environment_Surface::_internal_has_medium() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.medium_ != nullptr);
  return value;
}
inline bool Environment_Surface::has_medium() const {
  return _internal_has_medium();
}
inline void Environment_Surface::clear_medium() {
  if (_impl_.medium_ != nullptr) _impl_.medium_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::netsim::bellhop::protobuf::Environment_Medium& Environment_Surface::_internal_medium() const {
  const ::netsim::bellhop::protobuf::Environment_Medium* p = _impl_.medium_;
  return p != nullptr ? *p : reinterpret_cast<const ::netsim::bellhop::protobuf::Environment_Medium&>(
      ::netsim::bellhop::protobuf::_Environment_Medium_default_instance_);
}
inline const ::netsim::bellhop::protobuf::Environment_Medium& Environment_Surface::medium() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Surface.medium)
  return _internal_medium();
}
inline void Environment_Surface::unsafe_arena_set_allocated_medium(
    ::netsim::bellhop::protobuf::Environment_Medium* medium) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.medium_);
  }
  _impl_.medium_ = medium;
  if (medium) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:netsim.bellhop.protobuf.Environment.Surface.medium)
}
inline ::netsim::bellhop::protobuf::Environment_Medium* Environment_Surface::release_medium() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::netsim::bellhop::protobuf::Environment_Medium* temp = _impl_.medium_;
  _impl_.medium_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Medium* Environment_Surface::unsafe_arena_release_medium() {
  // @@protoc_insertion_point(field_release:netsim.bellhop.protobuf.Environment.Surface.medium)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::netsim::bellhop::protobuf::Environment_Medium* temp = _impl_.medium_;
  _impl_.medium_ = nullptr;
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Medium* Environment_Surface::_internal_mutable_medium() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.medium_ == nullptr) {
    auto* p = CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_Medium>(GetArenaForAllocation());
    _impl_.medium_ = p;
  }
  return _impl_.medium_;
}
inline ::netsim::bellhop::protobuf::Environment_Medium* Environment_Surface::mutable_medium() {
  ::netsim::bellhop::protobuf::Environment_Medium* _msg = _internal_mutable_medium();
  // @@protoc_insertion_point(field_mutable:netsim.bellhop.protobuf.Environment.Surface.medium)
  return _msg;
}
inline void Environment_Surface::set_allocated_medium(::netsim::bellhop::protobuf::Environment_Medium* medium) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.medium_;
  }
  if (medium) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(medium);
    if (message_arena != submessage_arena) {
      medium = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, medium, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.medium_ = medium;
  // @@protoc_insertion_point(field_set_allocated:netsim.bellhop.protobuf.Environment.Surface.medium)
}
 
// -------------------------------------------------------------------
 
// Environment_WaterColumn_SSPSample
 
// optional double depth = 1 [(.goby.field) = {
inline bool Environment_WaterColumn_SSPSample::_internal_has_depth() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Environment_WaterColumn_SSPSample::has_depth() const {
  return _internal_has_depth();
}
inline void Environment_WaterColumn_SSPSample::clear_depth() {
  _impl_.depth_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline double Environment_WaterColumn_SSPSample::_internal_depth() const {
  return _impl_.depth_;
}
inline double Environment_WaterColumn_SSPSample::depth() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.WaterColumn.SSPSample.depth)
  return _internal_depth();
}
inline void Environment_WaterColumn_SSPSample::_internal_set_depth(double value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.depth_ = value;
}
inline void Environment_WaterColumn_SSPSample::set_depth(double value) {
  _internal_set_depth(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.WaterColumn.SSPSample.depth)
}
 
// optional double cp = 2 [(.goby.field) = {
inline bool Environment_WaterColumn_SSPSample::_internal_has_cp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Environment_WaterColumn_SSPSample::has_cp() const {
  return _internal_has_cp();
}
inline void Environment_WaterColumn_SSPSample::clear_cp() {
  _impl_.cp_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline double Environment_WaterColumn_SSPSample::_internal_cp() const {
  return _impl_.cp_;
}
inline double Environment_WaterColumn_SSPSample::cp() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.WaterColumn.SSPSample.cp)
  return _internal_cp();
}
inline void Environment_WaterColumn_SSPSample::_internal_set_cp(double value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.cp_ = value;
}
inline void Environment_WaterColumn_SSPSample::set_cp(double value) {
  _internal_set_cp(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.WaterColumn.SSPSample.cp)
}
 
// repeated double eof = 3 [(.goby.field) = {
inline int Environment_WaterColumn_SSPSample::_internal_eof_size() const {
  return _impl_.eof_.size();
}
inline int Environment_WaterColumn_SSPSample::eof_size() const {
  return _internal_eof_size();
}
inline void Environment_WaterColumn_SSPSample::clear_eof() {
  _impl_.eof_.Clear();
}
inline double Environment_WaterColumn_SSPSample::_internal_eof(int index) const {
  return _impl_.eof_.Get(index);
}
inline double Environment_WaterColumn_SSPSample::eof(int index) const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.WaterColumn.SSPSample.eof)
  return _internal_eof(index);
}
inline void Environment_WaterColumn_SSPSample::set_eof(int index, double value) {
  _impl_.eof_.Set(index, value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.WaterColumn.SSPSample.eof)
}
inline void Environment_WaterColumn_SSPSample::_internal_add_eof(double value) {
  _impl_.eof_.Add(value);
}
inline void Environment_WaterColumn_SSPSample::add_eof(double value) {
  _internal_add_eof(value);
  // @@protoc_insertion_point(field_add:netsim.bellhop.protobuf.Environment.WaterColumn.SSPSample.eof)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
Environment_WaterColumn_SSPSample::_internal_eof() const {
  return _impl_.eof_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
Environment_WaterColumn_SSPSample::eof() const {
  // @@protoc_insertion_point(field_list:netsim.bellhop.protobuf.Environment.WaterColumn.SSPSample.eof)
  return _internal_eof();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
Environment_WaterColumn_SSPSample::_internal_mutable_eof() {
  return &_impl_.eof_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
Environment_WaterColumn_SSPSample::mutable_eof() {
  // @@protoc_insertion_point(field_mutable_list:netsim.bellhop.protobuf.Environment.WaterColumn.SSPSample.eof)
  return _internal_mutable_eof();
}
 
// -------------------------------------------------------------------
 
// Environment_WaterColumn
 
// optional .netsim.bellhop.protobuf.Environment.WaterColumn.SSPInterpolation interpolation_type = 1 [default = CUBIC_SPLINE, (.goby.field) = {
inline bool Environment_WaterColumn::_internal_has_interpolation_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Environment_WaterColumn::has_interpolation_type() const {
  return _internal_has_interpolation_type();
}
inline void Environment_WaterColumn::clear_interpolation_type() {
  _impl_.interpolation_type_ = 1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::netsim::bellhop::protobuf::Environment_WaterColumn_SSPInterpolation Environment_WaterColumn::_internal_interpolation_type() const {
  return static_cast< ::netsim::bellhop::protobuf::Environment_WaterColumn_SSPInterpolation >(_impl_.interpolation_type_);
}
inline ::netsim::bellhop::protobuf::Environment_WaterColumn_SSPInterpolation Environment_WaterColumn::interpolation_type() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.WaterColumn.interpolation_type)
  return _internal_interpolation_type();
}
inline void Environment_WaterColumn::_internal_set_interpolation_type(::netsim::bellhop::protobuf::Environment_WaterColumn_SSPInterpolation value) {
  assert(::netsim::bellhop::protobuf::Environment_WaterColumn_SSPInterpolation_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.interpolation_type_ = value;
}
inline void Environment_WaterColumn::set_interpolation_type(::netsim::bellhop::protobuf::Environment_WaterColumn_SSPInterpolation value) {
  _internal_set_interpolation_type(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.WaterColumn.interpolation_type)
}
 
// repeated double eof_coef = 2 [(.goby.field) = {
inline int Environment_WaterColumn::_internal_eof_coef_size() const {
  return _impl_.eof_coef_.size();
}
inline int Environment_WaterColumn::eof_coef_size() const {
  return _internal_eof_coef_size();
}
inline void Environment_WaterColumn::clear_eof_coef() {
  _impl_.eof_coef_.Clear();
}
inline double Environment_WaterColumn::_internal_eof_coef(int index) const {
  return _impl_.eof_coef_.Get(index);
}
inline double Environment_WaterColumn::eof_coef(int index) const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.WaterColumn.eof_coef)
  return _internal_eof_coef(index);
}
inline void Environment_WaterColumn::set_eof_coef(int index, double value) {
  _impl_.eof_coef_.Set(index, value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.WaterColumn.eof_coef)
}
inline void Environment_WaterColumn::_internal_add_eof_coef(double value) {
  _impl_.eof_coef_.Add(value);
}
inline void Environment_WaterColumn::add_eof_coef(double value) {
  _internal_add_eof_coef(value);
  // @@protoc_insertion_point(field_add:netsim.bellhop.protobuf.Environment.WaterColumn.eof_coef)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
Environment_WaterColumn::_internal_eof_coef() const {
  return _impl_.eof_coef_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
Environment_WaterColumn::eof_coef() const {
  // @@protoc_insertion_point(field_list:netsim.bellhop.protobuf.Environment.WaterColumn.eof_coef)
  return _internal_eof_coef();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
Environment_WaterColumn::_internal_mutable_eof_coef() {
  return &_impl_.eof_coef_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
Environment_WaterColumn::mutable_eof_coef() {
  // @@protoc_insertion_point(field_mutable_list:netsim.bellhop.protobuf.Environment.WaterColumn.eof_coef)
  return _internal_mutable_eof_coef();
}
 
// optional bool use_attenuation = 3 [default = true, (.goby.field) = {
inline bool Environment_WaterColumn::_internal_has_use_attenuation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Environment_WaterColumn::has_use_attenuation() const {
  return _internal_has_use_attenuation();
}
inline void Environment_WaterColumn::clear_use_attenuation() {
  _impl_.use_attenuation_ = true;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool Environment_WaterColumn::_internal_use_attenuation() const {
  return _impl_.use_attenuation_;
}
inline bool Environment_WaterColumn::use_attenuation() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.WaterColumn.use_attenuation)
  return _internal_use_attenuation();
}
inline void Environment_WaterColumn::_internal_set_use_attenuation(bool value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.use_attenuation_ = value;
}
inline void Environment_WaterColumn::set_use_attenuation(bool value) {
  _internal_set_use_attenuation(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.WaterColumn.use_attenuation)
}
 
// repeated .netsim.bellhop.protobuf.Environment.WaterColumn.SSPSample sample = 4;
inline int Environment_WaterColumn::_internal_sample_size() const {
  return _impl_.sample_.size();
}
inline int Environment_WaterColumn::sample_size() const {
  return _internal_sample_size();
}
inline void Environment_WaterColumn::clear_sample() {
  _impl_.sample_.Clear();
}
inline ::netsim::bellhop::protobuf::Environment_WaterColumn_SSPSample* Environment_WaterColumn::mutable_sample(int index) {
  // @@protoc_insertion_point(field_mutable:netsim.bellhop.protobuf.Environment.WaterColumn.sample)
  return _impl_.sample_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::netsim::bellhop::protobuf::Environment_WaterColumn_SSPSample >*
Environment_WaterColumn::mutable_sample() {
  // @@protoc_insertion_point(field_mutable_list:netsim.bellhop.protobuf.Environment.WaterColumn.sample)
  return &_impl_.sample_;
}
inline const ::netsim::bellhop::protobuf::Environment_WaterColumn_SSPSample& Environment_WaterColumn::_internal_sample(int index) const {
  return _impl_.sample_.Get(index);
}
inline const ::netsim::bellhop::protobuf::Environment_WaterColumn_SSPSample& Environment_WaterColumn::sample(int index) const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.WaterColumn.sample)
  return _internal_sample(index);
}
inline ::netsim::bellhop::protobuf::Environment_WaterColumn_SSPSample* Environment_WaterColumn::_internal_add_sample() {
  return _impl_.sample_.Add();
}
inline ::netsim::bellhop::protobuf::Environment_WaterColumn_SSPSample* Environment_WaterColumn::add_sample() {
  ::netsim::bellhop::protobuf::Environment_WaterColumn_SSPSample* _add = _internal_add_sample();
  // @@protoc_insertion_point(field_add:netsim.bellhop.protobuf.Environment.WaterColumn.sample)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::netsim::bellhop::protobuf::Environment_WaterColumn_SSPSample >&
Environment_WaterColumn::sample() const {
  // @@protoc_insertion_point(field_list:netsim.bellhop.protobuf.Environment.WaterColumn.sample)
  return _impl_.sample_;
}
 
// optional double range = 5 [default = 0, (.goby.field) = {
inline bool Environment_WaterColumn::_internal_has_range() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Environment_WaterColumn::has_range() const {
  return _internal_has_range();
}
inline void Environment_WaterColumn::clear_range() {
  _impl_.range_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline double Environment_WaterColumn::_internal_range() const {
  return _impl_.range_;
}
inline double Environment_WaterColumn::range() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.WaterColumn.range)
  return _internal_range();
}
inline void Environment_WaterColumn::_internal_set_range(double value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.range_ = value;
}
inline void Environment_WaterColumn::set_range(double value) {
  _internal_set_range(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.WaterColumn.range)
}
 
// optional double bathymetry = 6 [default = 0, (.goby.field) = {
inline bool Environment_WaterColumn::_internal_has_bathymetry() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Environment_WaterColumn::has_bathymetry() const {
  return _internal_has_bathymetry();
}
inline void Environment_WaterColumn::clear_bathymetry() {
  _impl_.bathymetry_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline double Environment_WaterColumn::_internal_bathymetry() const {
  return _impl_.bathymetry_;
}
inline double Environment_WaterColumn::bathymetry() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.WaterColumn.bathymetry)
  return _internal_bathymetry();
}
inline void Environment_WaterColumn::_internal_set_bathymetry(double value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.bathymetry_ = value;
}
inline void Environment_WaterColumn::set_bathymetry(double value) {
  _internal_set_bathymetry(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.WaterColumn.bathymetry)
}
 
// -------------------------------------------------------------------
 
// Environment_Bottom
 
// optional .netsim.bellhop.protobuf.Environment.Medium medium = 1;
inline bool Environment_Bottom::_internal_has_medium() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.medium_ != nullptr);
  return value;
}
inline bool Environment_Bottom::has_medium() const {
  return _internal_has_medium();
}
inline void Environment_Bottom::clear_medium() {
  if (_impl_.medium_ != nullptr) _impl_.medium_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::netsim::bellhop::protobuf::Environment_Medium& Environment_Bottom::_internal_medium() const {
  const ::netsim::bellhop::protobuf::Environment_Medium* p = _impl_.medium_;
  return p != nullptr ? *p : reinterpret_cast<const ::netsim::bellhop::protobuf::Environment_Medium&>(
      ::netsim::bellhop::protobuf::_Environment_Medium_default_instance_);
}
inline const ::netsim::bellhop::protobuf::Environment_Medium& Environment_Bottom::medium() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Bottom.medium)
  return _internal_medium();
}
inline void Environment_Bottom::unsafe_arena_set_allocated_medium(
    ::netsim::bellhop::protobuf::Environment_Medium* medium) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.medium_);
  }
  _impl_.medium_ = medium;
  if (medium) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:netsim.bellhop.protobuf.Environment.Bottom.medium)
}
inline ::netsim::bellhop::protobuf::Environment_Medium* Environment_Bottom::release_medium() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::netsim::bellhop::protobuf::Environment_Medium* temp = _impl_.medium_;
  _impl_.medium_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Medium* Environment_Bottom::unsafe_arena_release_medium() {
  // @@protoc_insertion_point(field_release:netsim.bellhop.protobuf.Environment.Bottom.medium)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::netsim::bellhop::protobuf::Environment_Medium* temp = _impl_.medium_;
  _impl_.medium_ = nullptr;
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Medium* Environment_Bottom::_internal_mutable_medium() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.medium_ == nullptr) {
    auto* p = CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_Medium>(GetArenaForAllocation());
    _impl_.medium_ = p;
  }
  return _impl_.medium_;
}
inline ::netsim::bellhop::protobuf::Environment_Medium* Environment_Bottom::mutable_medium() {
  ::netsim::bellhop::protobuf::Environment_Medium* _msg = _internal_mutable_medium();
  // @@protoc_insertion_point(field_mutable:netsim.bellhop.protobuf.Environment.Bottom.medium)
  return _msg;
}
inline void Environment_Bottom::set_allocated_medium(::netsim::bellhop::protobuf::Environment_Medium* medium) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.medium_;
  }
  if (medium) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(medium);
    if (message_arena != submessage_arena) {
      medium = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, medium, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.medium_ = medium;
  // @@protoc_insertion_point(field_set_allocated:netsim.bellhop.protobuf.Environment.Bottom.medium)
}
 
// -------------------------------------------------------------------
 
// Environment_Sources_SourcePosition
 
// optional double depth = 1;
inline bool Environment_Sources_SourcePosition::_internal_has_depth() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Environment_Sources_SourcePosition::has_depth() const {
  return _internal_has_depth();
}
inline void Environment_Sources_SourcePosition::clear_depth() {
  _impl_.depth_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline double Environment_Sources_SourcePosition::_internal_depth() const {
  return _impl_.depth_;
}
inline double Environment_Sources_SourcePosition::depth() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Sources.SourcePosition.depth)
  return _internal_depth();
}
inline void Environment_Sources_SourcePosition::_internal_set_depth(double value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.depth_ = value;
}
inline void Environment_Sources_SourcePosition::set_depth(double value) {
  _internal_set_depth(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.Sources.SourcePosition.depth)
}
 
// -------------------------------------------------------------------
 
// Environment_Sources
 
// optional uint32 number_in_depth = 1 [(.goby.field) = {
inline bool Environment_Sources::_internal_has_number_in_depth() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Environment_Sources::has_number_in_depth() const {
  return _internal_has_number_in_depth();
}
inline void Environment_Sources::clear_number_in_depth() {
  _impl_.number_in_depth_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t Environment_Sources::_internal_number_in_depth() const {
  return _impl_.number_in_depth_;
}
inline uint32_t Environment_Sources::number_in_depth() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Sources.number_in_depth)
  return _internal_number_in_depth();
}
inline void Environment_Sources::_internal_set_number_in_depth(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.number_in_depth_ = value;
}
inline void Environment_Sources::set_number_in_depth(uint32_t value) {
  _internal_set_number_in_depth(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.Sources.number_in_depth)
}
 
// optional .netsim.bellhop.protobuf.Environment.Sources.SourcePosition first = 2 [(.goby.field) = {
inline bool Environment_Sources::_internal_has_first() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.first_ != nullptr);
  return value;
}
inline bool Environment_Sources::has_first() const {
  return _internal_has_first();
}
inline void Environment_Sources::clear_first() {
  if (_impl_.first_ != nullptr) _impl_.first_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition& Environment_Sources::_internal_first() const {
  const ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* p = _impl_.first_;
  return p != nullptr ? *p : reinterpret_cast<const ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition&>(
      ::netsim::bellhop::protobuf::_Environment_Sources_SourcePosition_default_instance_);
}
inline const ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition& Environment_Sources::first() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Sources.first)
  return _internal_first();
}
inline void Environment_Sources::unsafe_arena_set_allocated_first(
    ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* first) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.first_);
  }
  _impl_.first_ = first;
  if (first) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:netsim.bellhop.protobuf.Environment.Sources.first)
}
inline ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* Environment_Sources::release_first() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* temp = _impl_.first_;
  _impl_.first_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* Environment_Sources::unsafe_arena_release_first() {
  // @@protoc_insertion_point(field_release:netsim.bellhop.protobuf.Environment.Sources.first)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* temp = _impl_.first_;
  _impl_.first_ = nullptr;
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* Environment_Sources::_internal_mutable_first() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.first_ == nullptr) {
    auto* p = CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_Sources_SourcePosition>(GetArenaForAllocation());
    _impl_.first_ = p;
  }
  return _impl_.first_;
}
inline ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* Environment_Sources::mutable_first() {
  ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* _msg = _internal_mutable_first();
  // @@protoc_insertion_point(field_mutable:netsim.bellhop.protobuf.Environment.Sources.first)
  return _msg;
}
inline void Environment_Sources::set_allocated_first(::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* first) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.first_;
  }
  if (first) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(first);
    if (message_arena != submessage_arena) {
      first = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, first, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.first_ = first;
  // @@protoc_insertion_point(field_set_allocated:netsim.bellhop.protobuf.Environment.Sources.first)
}
 
// optional .netsim.bellhop.protobuf.Environment.Sources.SourcePosition last = 3 [(.goby.field) = {
inline bool Environment_Sources::_internal_has_last() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.last_ != nullptr);
  return value;
}
inline bool Environment_Sources::has_last() const {
  return _internal_has_last();
}
inline void Environment_Sources::clear_last() {
  if (_impl_.last_ != nullptr) _impl_.last_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition& Environment_Sources::_internal_last() const {
  const ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* p = _impl_.last_;
  return p != nullptr ? *p : reinterpret_cast<const ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition&>(
      ::netsim::bellhop::protobuf::_Environment_Sources_SourcePosition_default_instance_);
}
inline const ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition& Environment_Sources::last() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Sources.last)
  return _internal_last();
}
inline void Environment_Sources::unsafe_arena_set_allocated_last(
    ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* last) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.last_);
  }
  _impl_.last_ = last;
  if (last) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:netsim.bellhop.protobuf.Environment.Sources.last)
}
inline ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* Environment_Sources::release_last() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* temp = _impl_.last_;
  _impl_.last_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* Environment_Sources::unsafe_arena_release_last() {
  // @@protoc_insertion_point(field_release:netsim.bellhop.protobuf.Environment.Sources.last)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* temp = _impl_.last_;
  _impl_.last_ = nullptr;
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* Environment_Sources::_internal_mutable_last() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.last_ == nullptr) {
    auto* p = CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_Sources_SourcePosition>(GetArenaForAllocation());
    _impl_.last_ = p;
  }
  return _impl_.last_;
}
inline ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* Environment_Sources::mutable_last() {
  ::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* _msg = _internal_mutable_last();
  // @@protoc_insertion_point(field_mutable:netsim.bellhop.protobuf.Environment.Sources.last)
  return _msg;
}
inline void Environment_Sources::set_allocated_last(::netsim::bellhop::protobuf::Environment_Sources_SourcePosition* last) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.last_;
  }
  if (last) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(last);
    if (message_arena != submessage_arena) {
      last = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, last, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.last_ = last;
  // @@protoc_insertion_point(field_set_allocated:netsim.bellhop.protobuf.Environment.Sources.last)
}
 
// -------------------------------------------------------------------
 
// Environment_Receivers_ReceiverPosition
 
// optional double depth = 1;
inline bool Environment_Receivers_ReceiverPosition::_internal_has_depth() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Environment_Receivers_ReceiverPosition::has_depth() const {
  return _internal_has_depth();
}
inline void Environment_Receivers_ReceiverPosition::clear_depth() {
  _impl_.depth_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline double Environment_Receivers_ReceiverPosition::_internal_depth() const {
  return _impl_.depth_;
}
inline double Environment_Receivers_ReceiverPosition::depth() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Receivers.ReceiverPosition.depth)
  return _internal_depth();
}
inline void Environment_Receivers_ReceiverPosition::_internal_set_depth(double value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.depth_ = value;
}
inline void Environment_Receivers_ReceiverPosition::set_depth(double value) {
  _internal_set_depth(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.Receivers.ReceiverPosition.depth)
}
 
// optional double range = 2;
inline bool Environment_Receivers_ReceiverPosition::_internal_has_range() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Environment_Receivers_ReceiverPosition::has_range() const {
  return _internal_has_range();
}
inline void Environment_Receivers_ReceiverPosition::clear_range() {
  _impl_.range_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline double Environment_Receivers_ReceiverPosition::_internal_range() const {
  return _impl_.range_;
}
inline double Environment_Receivers_ReceiverPosition::range() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Receivers.ReceiverPosition.range)
  return _internal_range();
}
inline void Environment_Receivers_ReceiverPosition::_internal_set_range(double value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.range_ = value;
}
inline void Environment_Receivers_ReceiverPosition::set_range(double value) {
  _internal_set_range(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.Receivers.ReceiverPosition.range)
}
 
// -------------------------------------------------------------------
 
// Environment_Receivers
 
// optional uint32 number_in_depth = 1 [(.goby.field) = {
inline bool Environment_Receivers::_internal_has_number_in_depth() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Environment_Receivers::has_number_in_depth() const {
  return _internal_has_number_in_depth();
}
inline void Environment_Receivers::clear_number_in_depth() {
  _impl_.number_in_depth_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t Environment_Receivers::_internal_number_in_depth() const {
  return _impl_.number_in_depth_;
}
inline uint32_t Environment_Receivers::number_in_depth() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Receivers.number_in_depth)
  return _internal_number_in_depth();
}
inline void Environment_Receivers::_internal_set_number_in_depth(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.number_in_depth_ = value;
}
inline void Environment_Receivers::set_number_in_depth(uint32_t value) {
  _internal_set_number_in_depth(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.Receivers.number_in_depth)
}
 
// optional uint32 number_in_range = 2 [(.goby.field) = {
inline bool Environment_Receivers::_internal_has_number_in_range() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Environment_Receivers::has_number_in_range() const {
  return _internal_has_number_in_range();
}
inline void Environment_Receivers::clear_number_in_range() {
  _impl_.number_in_range_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t Environment_Receivers::_internal_number_in_range() const {
  return _impl_.number_in_range_;
}
inline uint32_t Environment_Receivers::number_in_range() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Receivers.number_in_range)
  return _internal_number_in_range();
}
inline void Environment_Receivers::_internal_set_number_in_range(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.number_in_range_ = value;
}
inline void Environment_Receivers::set_number_in_range(uint32_t value) {
  _internal_set_number_in_range(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.Receivers.number_in_range)
}
 
// optional .netsim.bellhop.protobuf.Environment.Receivers.ReceiverPosition first = 3 [(.goby.field) = {
inline bool Environment_Receivers::_internal_has_first() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.first_ != nullptr);
  return value;
}
inline bool Environment_Receivers::has_first() const {
  return _internal_has_first();
}
inline void Environment_Receivers::clear_first() {
  if (_impl_.first_ != nullptr) _impl_.first_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition& Environment_Receivers::_internal_first() const {
  const ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* p = _impl_.first_;
  return p != nullptr ? *p : reinterpret_cast<const ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition&>(
      ::netsim::bellhop::protobuf::_Environment_Receivers_ReceiverPosition_default_instance_);
}
inline const ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition& Environment_Receivers::first() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Receivers.first)
  return _internal_first();
}
inline void Environment_Receivers::unsafe_arena_set_allocated_first(
    ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* first) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.first_);
  }
  _impl_.first_ = first;
  if (first) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:netsim.bellhop.protobuf.Environment.Receivers.first)
}
inline ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* Environment_Receivers::release_first() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* temp = _impl_.first_;
  _impl_.first_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* Environment_Receivers::unsafe_arena_release_first() {
  // @@protoc_insertion_point(field_release:netsim.bellhop.protobuf.Environment.Receivers.first)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* temp = _impl_.first_;
  _impl_.first_ = nullptr;
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* Environment_Receivers::_internal_mutable_first() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.first_ == nullptr) {
    auto* p = CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition>(GetArenaForAllocation());
    _impl_.first_ = p;
  }
  return _impl_.first_;
}
inline ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* Environment_Receivers::mutable_first() {
  ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* _msg = _internal_mutable_first();
  // @@protoc_insertion_point(field_mutable:netsim.bellhop.protobuf.Environment.Receivers.first)
  return _msg;
}
inline void Environment_Receivers::set_allocated_first(::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* first) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.first_;
  }
  if (first) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(first);
    if (message_arena != submessage_arena) {
      first = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, first, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.first_ = first;
  // @@protoc_insertion_point(field_set_allocated:netsim.bellhop.protobuf.Environment.Receivers.first)
}
 
// optional .netsim.bellhop.protobuf.Environment.Receivers.ReceiverPosition last = 4 [(.goby.field) = {
inline bool Environment_Receivers::_internal_has_last() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.last_ != nullptr);
  return value;
}
inline bool Environment_Receivers::has_last() const {
  return _internal_has_last();
}
inline void Environment_Receivers::clear_last() {
  if (_impl_.last_ != nullptr) _impl_.last_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition& Environment_Receivers::_internal_last() const {
  const ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* p = _impl_.last_;
  return p != nullptr ? *p : reinterpret_cast<const ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition&>(
      ::netsim::bellhop::protobuf::_Environment_Receivers_ReceiverPosition_default_instance_);
}
inline const ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition& Environment_Receivers::last() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Receivers.last)
  return _internal_last();
}
inline void Environment_Receivers::unsafe_arena_set_allocated_last(
    ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* last) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.last_);
  }
  _impl_.last_ = last;
  if (last) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:netsim.bellhop.protobuf.Environment.Receivers.last)
}
inline ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* Environment_Receivers::release_last() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* temp = _impl_.last_;
  _impl_.last_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* Environment_Receivers::unsafe_arena_release_last() {
  // @@protoc_insertion_point(field_release:netsim.bellhop.protobuf.Environment.Receivers.last)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* temp = _impl_.last_;
  _impl_.last_ = nullptr;
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* Environment_Receivers::_internal_mutable_last() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.last_ == nullptr) {
    auto* p = CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition>(GetArenaForAllocation());
    _impl_.last_ = p;
  }
  return _impl_.last_;
}
inline ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* Environment_Receivers::mutable_last() {
  ::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* _msg = _internal_mutable_last();
  // @@protoc_insertion_point(field_mutable:netsim.bellhop.protobuf.Environment.Receivers.last)
  return _msg;
}
inline void Environment_Receivers::set_allocated_last(::netsim::bellhop::protobuf::Environment_Receivers_ReceiverPosition* last) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.last_;
  }
  if (last) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(last);
    if (message_arena != submessage_arena) {
      last = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, last, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.last_ = last;
  // @@protoc_insertion_point(field_set_allocated:netsim.bellhop.protobuf.Environment.Receivers.last)
}
 
// -------------------------------------------------------------------
 
// Environment_Beams
 
// optional .netsim.bellhop.protobuf.Environment.Beams.ApproximationType approximation_type = 1 [(.goby.field) = {
inline bool Environment_Beams::_internal_has_approximation_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Environment_Beams::has_approximation_type() const {
  return _internal_has_approximation_type();
}
inline void Environment_Beams::clear_approximation_type() {
  _impl_.approximation_type_ = 1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::netsim::bellhop::protobuf::Environment_Beams_ApproximationType Environment_Beams::_internal_approximation_type() const {
  return static_cast< ::netsim::bellhop::protobuf::Environment_Beams_ApproximationType >(_impl_.approximation_type_);
}
inline ::netsim::bellhop::protobuf::Environment_Beams_ApproximationType Environment_Beams::approximation_type() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Beams.approximation_type)
  return _internal_approximation_type();
}
inline void Environment_Beams::_internal_set_approximation_type(::netsim::bellhop::protobuf::Environment_Beams_ApproximationType value) {
  assert(::netsim::bellhop::protobuf::Environment_Beams_ApproximationType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.approximation_type_ = value;
}
inline void Environment_Beams::set_approximation_type(::netsim::bellhop::protobuf::Environment_Beams_ApproximationType value) {
  _internal_set_approximation_type(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.Beams.approximation_type)
}
 
// optional int32 theta_min = 2 [default = -90, (.goby.field) = {
inline bool Environment_Beams::_internal_has_theta_min() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Environment_Beams::has_theta_min() const {
  return _internal_has_theta_min();
}
inline void Environment_Beams::clear_theta_min() {
  _impl_.theta_min_ = -90;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t Environment_Beams::_internal_theta_min() const {
  return _impl_.theta_min_;
}
inline int32_t Environment_Beams::theta_min() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Beams.theta_min)
  return _internal_theta_min();
}
inline void Environment_Beams::_internal_set_theta_min(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.theta_min_ = value;
}
inline void Environment_Beams::set_theta_min(int32_t value) {
  _internal_set_theta_min(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.Beams.theta_min)
}
 
// optional int32 theta_max = 3 [default = 90, (.goby.field) = {
inline bool Environment_Beams::_internal_has_theta_max() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Environment_Beams::has_theta_max() const {
  return _internal_has_theta_max();
}
inline void Environment_Beams::clear_theta_max() {
  _impl_.theta_max_ = 90;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t Environment_Beams::_internal_theta_max() const {
  return _impl_.theta_max_;
}
inline int32_t Environment_Beams::theta_max() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Beams.theta_max)
  return _internal_theta_max();
}
inline void Environment_Beams::_internal_set_theta_max(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.theta_max_ = value;
}
inline void Environment_Beams::set_theta_max(int32_t value) {
  _internal_set_theta_max(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.Beams.theta_max)
}
 
// optional uint32 number = 4 [default = 0, (.goby.field) = {
inline bool Environment_Beams::_internal_has_number() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Environment_Beams::has_number() const {
  return _internal_has_number();
}
inline void Environment_Beams::clear_number() {
  _impl_.number_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t Environment_Beams::_internal_number() const {
  return _impl_.number_;
}
inline uint32_t Environment_Beams::number() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.Beams.number)
  return _internal_number();
}
inline void Environment_Beams::_internal_set_number(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.number_ = value;
}
inline void Environment_Beams::set_number(uint32_t value) {
  _internal_set_number(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.Beams.number)
}
 
// -------------------------------------------------------------------
 
// Environment_AdaptiveInfo
 
// optional string contact = 1 [(.goby.field) = {
inline bool Environment_AdaptiveInfo::_internal_has_contact() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Environment_AdaptiveInfo::has_contact() const {
  return _internal_has_contact();
}
inline void Environment_AdaptiveInfo::clear_contact() {
  _impl_.contact_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Environment_AdaptiveInfo::contact() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.AdaptiveInfo.contact)
  return _internal_contact();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Environment_AdaptiveInfo::set_contact(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.contact_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.AdaptiveInfo.contact)
}
inline std::string* Environment_AdaptiveInfo::mutable_contact() {
  std::string* _s = _internal_mutable_contact();
  // @@protoc_insertion_point(field_mutable:netsim.bellhop.protobuf.Environment.AdaptiveInfo.contact)
  return _s;
}
inline const std::string& Environment_AdaptiveInfo::_internal_contact() const {
  return _impl_.contact_.Get();
}
inline void Environment_AdaptiveInfo::_internal_set_contact(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.contact_.Set(value, GetArenaForAllocation());
}
inline std::string* Environment_AdaptiveInfo::_internal_mutable_contact() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.contact_.Mutable(GetArenaForAllocation());
}
inline std::string* Environment_AdaptiveInfo::release_contact() {
  // @@protoc_insertion_point(field_release:netsim.bellhop.protobuf.Environment.AdaptiveInfo.contact)
  if (!_internal_has_contact()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.contact_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.contact_.IsDefault()) {
    _impl_.contact_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Environment_AdaptiveInfo::set_allocated_contact(std::string* contact) {
  if (contact != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.contact_.SetAllocated(contact, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.contact_.IsDefault()) {
    _impl_.contact_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:netsim.bellhop.protobuf.Environment.AdaptiveInfo.contact)
}
 
// optional string ownship = 2 [(.goby.field) = {
inline bool Environment_AdaptiveInfo::_internal_has_ownship() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Environment_AdaptiveInfo::has_ownship() const {
  return _internal_has_ownship();
}
inline void Environment_AdaptiveInfo::clear_ownship() {
  _impl_.ownship_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Environment_AdaptiveInfo::ownship() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.AdaptiveInfo.ownship)
  return _internal_ownship();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Environment_AdaptiveInfo::set_ownship(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.ownship_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.AdaptiveInfo.ownship)
}
inline std::string* Environment_AdaptiveInfo::mutable_ownship() {
  std::string* _s = _internal_mutable_ownship();
  // @@protoc_insertion_point(field_mutable:netsim.bellhop.protobuf.Environment.AdaptiveInfo.ownship)
  return _s;
}
inline const std::string& Environment_AdaptiveInfo::_internal_ownship() const {
  return _impl_.ownship_.Get();
}
inline void Environment_AdaptiveInfo::_internal_set_ownship(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.ownship_.Set(value, GetArenaForAllocation());
}
inline std::string* Environment_AdaptiveInfo::_internal_mutable_ownship() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.ownship_.Mutable(GetArenaForAllocation());
}
inline std::string* Environment_AdaptiveInfo::release_ownship() {
  // @@protoc_insertion_point(field_release:netsim.bellhop.protobuf.Environment.AdaptiveInfo.ownship)
  if (!_internal_has_ownship()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.ownship_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.ownship_.IsDefault()) {
    _impl_.ownship_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Environment_AdaptiveInfo::set_allocated_ownship(std::string* ownship) {
  if (ownship != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.ownship_.SetAllocated(ownship, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.ownship_.IsDefault()) {
    _impl_.ownship_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:netsim.bellhop.protobuf.Environment.AdaptiveInfo.ownship)
}
 
// optional bool read_shd = 3 [default = false, (.goby.field) = {
inline bool Environment_AdaptiveInfo::_internal_has_read_shd() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Environment_AdaptiveInfo::has_read_shd() const {
  return _internal_has_read_shd();
}
inline void Environment_AdaptiveInfo::clear_read_shd() {
  _impl_.read_shd_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool Environment_AdaptiveInfo::_internal_read_shd() const {
  return _impl_.read_shd_;
}
inline bool Environment_AdaptiveInfo::read_shd() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.AdaptiveInfo.read_shd)
  return _internal_read_shd();
}
inline void Environment_AdaptiveInfo::_internal_set_read_shd(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.read_shd_ = value;
}
inline void Environment_AdaptiveInfo::set_read_shd(bool value) {
  _internal_set_read_shd(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.AdaptiveInfo.read_shd)
}
 
// optional bool full_shd_matrix = 10 [default = false, (.goby.field) = {
inline bool Environment_AdaptiveInfo::_internal_has_full_shd_matrix() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Environment_AdaptiveInfo::has_full_shd_matrix() const {
  return _internal_has_full_shd_matrix();
}
inline void Environment_AdaptiveInfo::clear_full_shd_matrix() {
  _impl_.full_shd_matrix_ = false;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool Environment_AdaptiveInfo::_internal_full_shd_matrix() const {
  return _impl_.full_shd_matrix_;
}
inline bool Environment_AdaptiveInfo::full_shd_matrix() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.AdaptiveInfo.full_shd_matrix)
  return _internal_full_shd_matrix();
}
inline void Environment_AdaptiveInfo::_internal_set_full_shd_matrix(bool value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.full_shd_matrix_ = value;
}
inline void Environment_AdaptiveInfo::set_full_shd_matrix(bool value) {
  _internal_set_full_shd_matrix(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.AdaptiveInfo.full_shd_matrix)
}
 
// optional bool auto_receiver_ranges = 4 [default = false, (.goby.field) = {
inline bool Environment_AdaptiveInfo::_internal_has_auto_receiver_ranges() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Environment_AdaptiveInfo::has_auto_receiver_ranges() const {
  return _internal_has_auto_receiver_ranges();
}
inline void Environment_AdaptiveInfo::clear_auto_receiver_ranges() {
  _impl_.auto_receiver_ranges_ = false;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline bool Environment_AdaptiveInfo::_internal_auto_receiver_ranges() const {
  return _impl_.auto_receiver_ranges_;
}
inline bool Environment_AdaptiveInfo::auto_receiver_ranges() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.AdaptiveInfo.auto_receiver_ranges)
  return _internal_auto_receiver_ranges();
}
inline void Environment_AdaptiveInfo::_internal_set_auto_receiver_ranges(bool value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.auto_receiver_ranges_ = value;
}
inline void Environment_AdaptiveInfo::set_auto_receiver_ranges(bool value) {
  _internal_set_auto_receiver_ranges(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.AdaptiveInfo.auto_receiver_ranges)
}
 
// optional int32 auto_receiver_ranges_delta = 7 [default = 1, (.goby.field) = {
inline bool Environment_AdaptiveInfo::_internal_has_auto_receiver_ranges_delta() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Environment_AdaptiveInfo::has_auto_receiver_ranges_delta() const {
  return _internal_has_auto_receiver_ranges_delta();
}
inline void Environment_AdaptiveInfo::clear_auto_receiver_ranges_delta() {
  _impl_.auto_receiver_ranges_delta_ = 1;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline int32_t Environment_AdaptiveInfo::_internal_auto_receiver_ranges_delta() const {
  return _impl_.auto_receiver_ranges_delta_;
}
inline int32_t Environment_AdaptiveInfo::auto_receiver_ranges_delta() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.AdaptiveInfo.auto_receiver_ranges_delta)
  return _internal_auto_receiver_ranges_delta();
}
inline void Environment_AdaptiveInfo::_internal_set_auto_receiver_ranges_delta(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.auto_receiver_ranges_delta_ = value;
}
inline void Environment_AdaptiveInfo::set_auto_receiver_ranges_delta(int32_t value) {
  _internal_set_auto_receiver_ranges_delta(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.AdaptiveInfo.auto_receiver_ranges_delta)
}
 
// optional uint32 look_ahead_seconds = 5 [default = 60, (.goby.field) = {
inline bool Environment_AdaptiveInfo::_internal_has_look_ahead_seconds() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Environment_AdaptiveInfo::has_look_ahead_seconds() const {
  return _internal_has_look_ahead_seconds();
}
inline void Environment_AdaptiveInfo::clear_look_ahead_seconds() {
  _impl_.look_ahead_seconds_ = 60u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t Environment_AdaptiveInfo::_internal_look_ahead_seconds() const {
  return _impl_.look_ahead_seconds_;
}
inline uint32_t Environment_AdaptiveInfo::look_ahead_seconds() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.AdaptiveInfo.look_ahead_seconds)
  return _internal_look_ahead_seconds();
}
inline void Environment_AdaptiveInfo::_internal_set_look_ahead_seconds(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.look_ahead_seconds_ = value;
}
inline void Environment_AdaptiveInfo::set_look_ahead_seconds(uint32_t value) {
  _internal_set_look_ahead_seconds(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.AdaptiveInfo.look_ahead_seconds)
}
 
// optional bool auto_source_depth = 6 [default = false, (.goby.field) = {
inline bool Environment_AdaptiveInfo::_internal_has_auto_source_depth() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Environment_AdaptiveInfo::has_auto_source_depth() const {
  return _internal_has_auto_source_depth();
}
inline void Environment_AdaptiveInfo::clear_auto_source_depth() {
  _impl_.auto_source_depth_ = false;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline bool Environment_AdaptiveInfo::_internal_auto_source_depth() const {
  return _impl_.auto_source_depth_;
}
inline bool Environment_AdaptiveInfo::auto_source_depth() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.AdaptiveInfo.auto_source_depth)
  return _internal_auto_source_depth();
}
inline void Environment_AdaptiveInfo::_internal_set_auto_source_depth(bool value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.auto_source_depth_ = value;
}
inline void Environment_AdaptiveInfo::set_auto_source_depth(bool value) {
  _internal_set_auto_source_depth(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.AdaptiveInfo.auto_source_depth)
}
 
// -------------------------------------------------------------------
 
// Environment
 
// optional string title = 1 [default = "Environmental File", (.goby.field) = {
inline bool Environment::_internal_has_title() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Environment::has_title() const {
  return _internal_has_title();
}
inline void Environment::clear_title() {
  _impl_.title_.ClearToDefault(::netsim::bellhop::protobuf::Environment::Impl_::_i_give_permission_to_break_this_code_default_title_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Environment::title() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.title)
  if (_impl_.title_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_title_.get();
  return _internal_title();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Environment::set_title(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.title)
}
inline std::string* Environment::mutable_title() {
  std::string* _s = _internal_mutable_title();
  // @@protoc_insertion_point(field_mutable:netsim.bellhop.protobuf.Environment.title)
  return _s;
}
inline const std::string& Environment::_internal_title() const {
  return _impl_.title_.Get();
}
inline void Environment::_internal_set_title(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.title_.Set(value, GetArenaForAllocation());
}
inline std::string* Environment::_internal_mutable_title() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.title_.Mutable(::netsim::bellhop::protobuf::Environment::Impl_::_i_give_permission_to_break_this_code_default_title_, GetArenaForAllocation());
}
inline std::string* Environment::release_title() {
  // @@protoc_insertion_point(field_release:netsim.bellhop.protobuf.Environment.title)
  if (!_internal_has_title()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.title_.Release();
  return p;
}
inline void Environment::set_allocated_title(std::string* title) {
  if (title != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.title_.SetAllocated(title, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:netsim.bellhop.protobuf.Environment.title)
}
 
// optional uint32 freq = 2 [default = 25000, (.goby.field) = {
inline bool Environment::_internal_has_freq() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool Environment::has_freq() const {
  return _internal_has_freq();
}
inline void Environment::clear_freq() {
  _impl_.freq_ = 25000u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t Environment::_internal_freq() const {
  return _impl_.freq_;
}
inline uint32_t Environment::freq() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.freq)
  return _internal_freq();
}
inline void Environment::_internal_set_freq(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.freq_ = value;
}
inline void Environment::set_freq(uint32_t value) {
  _internal_set_freq(value);
  // @@protoc_insertion_point(field_set:netsim.bellhop.protobuf.Environment.freq)
}
 
// optional .netsim.bellhop.protobuf.Environment.Output output = 3 [(.goby.field) = {
inline bool Environment::_internal_has_output() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.output_ != nullptr);
  return value;
}
inline bool Environment::has_output() const {
  return _internal_has_output();
}
inline void Environment::clear_output() {
  if (_impl_.output_ != nullptr) _impl_.output_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::netsim::bellhop::protobuf::Environment_Output& Environment::_internal_output() const {
  const ::netsim::bellhop::protobuf::Environment_Output* p = _impl_.output_;
  return p != nullptr ? *p : reinterpret_cast<const ::netsim::bellhop::protobuf::Environment_Output&>(
      ::netsim::bellhop::protobuf::_Environment_Output_default_instance_);
}
inline const ::netsim::bellhop::protobuf::Environment_Output& Environment::output() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.output)
  return _internal_output();
}
inline void Environment::unsafe_arena_set_allocated_output(
    ::netsim::bellhop::protobuf::Environment_Output* output) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.output_);
  }
  _impl_.output_ = output;
  if (output) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:netsim.bellhop.protobuf.Environment.output)
}
inline ::netsim::bellhop::protobuf::Environment_Output* Environment::release_output() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::netsim::bellhop::protobuf::Environment_Output* temp = _impl_.output_;
  _impl_.output_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Output* Environment::unsafe_arena_release_output() {
  // @@protoc_insertion_point(field_release:netsim.bellhop.protobuf.Environment.output)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::netsim::bellhop::protobuf::Environment_Output* temp = _impl_.output_;
  _impl_.output_ = nullptr;
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Output* Environment::_internal_mutable_output() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.output_ == nullptr) {
    auto* p = CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_Output>(GetArenaForAllocation());
    _impl_.output_ = p;
  }
  return _impl_.output_;
}
inline ::netsim::bellhop::protobuf::Environment_Output* Environment::mutable_output() {
  ::netsim::bellhop::protobuf::Environment_Output* _msg = _internal_mutable_output();
  // @@protoc_insertion_point(field_mutable:netsim.bellhop.protobuf.Environment.output)
  return _msg;
}
inline void Environment::set_allocated_output(::netsim::bellhop::protobuf::Environment_Output* output) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.output_;
  }
  if (output) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(output);
    if (message_arena != submessage_arena) {
      output = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, output, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.output_ = output;
  // @@protoc_insertion_point(field_set_allocated:netsim.bellhop.protobuf.Environment.output)
}
 
// optional .netsim.bellhop.protobuf.Environment.Surface surface = 4 [(.goby.field) = {
inline bool Environment::_internal_has_surface() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.surface_ != nullptr);
  return value;
}
inline bool Environment::has_surface() const {
  return _internal_has_surface();
}
inline void Environment::clear_surface() {
  if (_impl_.surface_ != nullptr) _impl_.surface_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::netsim::bellhop::protobuf::Environment_Surface& Environment::_internal_surface() const {
  const ::netsim::bellhop::protobuf::Environment_Surface* p = _impl_.surface_;
  return p != nullptr ? *p : reinterpret_cast<const ::netsim::bellhop::protobuf::Environment_Surface&>(
      ::netsim::bellhop::protobuf::_Environment_Surface_default_instance_);
}
inline const ::netsim::bellhop::protobuf::Environment_Surface& Environment::surface() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.surface)
  return _internal_surface();
}
inline void Environment::unsafe_arena_set_allocated_surface(
    ::netsim::bellhop::protobuf::Environment_Surface* surface) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.surface_);
  }
  _impl_.surface_ = surface;
  if (surface) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:netsim.bellhop.protobuf.Environment.surface)
}
inline ::netsim::bellhop::protobuf::Environment_Surface* Environment::release_surface() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::netsim::bellhop::protobuf::Environment_Surface* temp = _impl_.surface_;
  _impl_.surface_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Surface* Environment::unsafe_arena_release_surface() {
  // @@protoc_insertion_point(field_release:netsim.bellhop.protobuf.Environment.surface)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::netsim::bellhop::protobuf::Environment_Surface* temp = _impl_.surface_;
  _impl_.surface_ = nullptr;
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Surface* Environment::_internal_mutable_surface() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.surface_ == nullptr) {
    auto* p = CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_Surface>(GetArenaForAllocation());
    _impl_.surface_ = p;
  }
  return _impl_.surface_;
}
inline ::netsim::bellhop::protobuf::Environment_Surface* Environment::mutable_surface() {
  ::netsim::bellhop::protobuf::Environment_Surface* _msg = _internal_mutable_surface();
  // @@protoc_insertion_point(field_mutable:netsim.bellhop.protobuf.Environment.surface)
  return _msg;
}
inline void Environment::set_allocated_surface(::netsim::bellhop::protobuf::Environment_Surface* surface) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.surface_;
  }
  if (surface) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(surface);
    if (message_arena != submessage_arena) {
      surface = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, surface, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.surface_ = surface;
  // @@protoc_insertion_point(field_set_allocated:netsim.bellhop.protobuf.Environment.surface)
}
 
// repeated .netsim.bellhop.protobuf.Environment.WaterColumn water_column = 5 [(.goby.field) = {
inline int Environment::_internal_water_column_size() const {
  return _impl_.water_column_.size();
}
inline int Environment::water_column_size() const {
  return _internal_water_column_size();
}
inline void Environment::clear_water_column() {
  _impl_.water_column_.Clear();
}
inline ::netsim::bellhop::protobuf::Environment_WaterColumn* Environment::mutable_water_column(int index) {
  // @@protoc_insertion_point(field_mutable:netsim.bellhop.protobuf.Environment.water_column)
  return _impl_.water_column_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::netsim::bellhop::protobuf::Environment_WaterColumn >*
Environment::mutable_water_column() {
  // @@protoc_insertion_point(field_mutable_list:netsim.bellhop.protobuf.Environment.water_column)
  return &_impl_.water_column_;
}
inline const ::netsim::bellhop::protobuf::Environment_WaterColumn& Environment::_internal_water_column(int index) const {
  return _impl_.water_column_.Get(index);
}
inline const ::netsim::bellhop::protobuf::Environment_WaterColumn& Environment::water_column(int index) const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.water_column)
  return _internal_water_column(index);
}
inline ::netsim::bellhop::protobuf::Environment_WaterColumn* Environment::_internal_add_water_column() {
  return _impl_.water_column_.Add();
}
inline ::netsim::bellhop::protobuf::Environment_WaterColumn* Environment::add_water_column() {
  ::netsim::bellhop::protobuf::Environment_WaterColumn* _add = _internal_add_water_column();
  // @@protoc_insertion_point(field_add:netsim.bellhop.protobuf.Environment.water_column)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::netsim::bellhop::protobuf::Environment_WaterColumn >&
Environment::water_column() const {
  // @@protoc_insertion_point(field_list:netsim.bellhop.protobuf.Environment.water_column)
  return _impl_.water_column_;
}
 
// optional .netsim.bellhop.protobuf.Environment.Bottom bottom = 6 [(.goby.field) = {
inline bool Environment::_internal_has_bottom() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.bottom_ != nullptr);
  return value;
}
inline bool Environment::has_bottom() const {
  return _internal_has_bottom();
}
inline void Environment::clear_bottom() {
  if (_impl_.bottom_ != nullptr) _impl_.bottom_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::netsim::bellhop::protobuf::Environment_Bottom& Environment::_internal_bottom() const {
  const ::netsim::bellhop::protobuf::Environment_Bottom* p = _impl_.bottom_;
  return p != nullptr ? *p : reinterpret_cast<const ::netsim::bellhop::protobuf::Environment_Bottom&>(
      ::netsim::bellhop::protobuf::_Environment_Bottom_default_instance_);
}
inline const ::netsim::bellhop::protobuf::Environment_Bottom& Environment::bottom() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.bottom)
  return _internal_bottom();
}
inline void Environment::unsafe_arena_set_allocated_bottom(
    ::netsim::bellhop::protobuf::Environment_Bottom* bottom) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.bottom_);
  }
  _impl_.bottom_ = bottom;
  if (bottom) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:netsim.bellhop.protobuf.Environment.bottom)
}
inline ::netsim::bellhop::protobuf::Environment_Bottom* Environment::release_bottom() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::netsim::bellhop::protobuf::Environment_Bottom* temp = _impl_.bottom_;
  _impl_.bottom_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Bottom* Environment::unsafe_arena_release_bottom() {
  // @@protoc_insertion_point(field_release:netsim.bellhop.protobuf.Environment.bottom)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::netsim::bellhop::protobuf::Environment_Bottom* temp = _impl_.bottom_;
  _impl_.bottom_ = nullptr;
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Bottom* Environment::_internal_mutable_bottom() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.bottom_ == nullptr) {
    auto* p = CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_Bottom>(GetArenaForAllocation());
    _impl_.bottom_ = p;
  }
  return _impl_.bottom_;
}
inline ::netsim::bellhop::protobuf::Environment_Bottom* Environment::mutable_bottom() {
  ::netsim::bellhop::protobuf::Environment_Bottom* _msg = _internal_mutable_bottom();
  // @@protoc_insertion_point(field_mutable:netsim.bellhop.protobuf.Environment.bottom)
  return _msg;
}
inline void Environment::set_allocated_bottom(::netsim::bellhop::protobuf::Environment_Bottom* bottom) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.bottom_;
  }
  if (bottom) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(bottom);
    if (message_arena != submessage_arena) {
      bottom = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, bottom, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.bottom_ = bottom;
  // @@protoc_insertion_point(field_set_allocated:netsim.bellhop.protobuf.Environment.bottom)
}
 
// optional .netsim.bellhop.protobuf.Environment.Sources sources = 7 [(.goby.field) = {
inline bool Environment::_internal_has_sources() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.sources_ != nullptr);
  return value;
}
inline bool Environment::has_sources() const {
  return _internal_has_sources();
}
inline void Environment::clear_sources() {
  if (_impl_.sources_ != nullptr) _impl_.sources_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::netsim::bellhop::protobuf::Environment_Sources& Environment::_internal_sources() const {
  const ::netsim::bellhop::protobuf::Environment_Sources* p = _impl_.sources_;
  return p != nullptr ? *p : reinterpret_cast<const ::netsim::bellhop::protobuf::Environment_Sources&>(
      ::netsim::bellhop::protobuf::_Environment_Sources_default_instance_);
}
inline const ::netsim::bellhop::protobuf::Environment_Sources& Environment::sources() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.sources)
  return _internal_sources();
}
inline void Environment::unsafe_arena_set_allocated_sources(
    ::netsim::bellhop::protobuf::Environment_Sources* sources) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.sources_);
  }
  _impl_.sources_ = sources;
  if (sources) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:netsim.bellhop.protobuf.Environment.sources)
}
inline ::netsim::bellhop::protobuf::Environment_Sources* Environment::release_sources() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::netsim::bellhop::protobuf::Environment_Sources* temp = _impl_.sources_;
  _impl_.sources_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Sources* Environment::unsafe_arena_release_sources() {
  // @@protoc_insertion_point(field_release:netsim.bellhop.protobuf.Environment.sources)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::netsim::bellhop::protobuf::Environment_Sources* temp = _impl_.sources_;
  _impl_.sources_ = nullptr;
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Sources* Environment::_internal_mutable_sources() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.sources_ == nullptr) {
    auto* p = CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_Sources>(GetArenaForAllocation());
    _impl_.sources_ = p;
  }
  return _impl_.sources_;
}
inline ::netsim::bellhop::protobuf::Environment_Sources* Environment::mutable_sources() {
  ::netsim::bellhop::protobuf::Environment_Sources* _msg = _internal_mutable_sources();
  // @@protoc_insertion_point(field_mutable:netsim.bellhop.protobuf.Environment.sources)
  return _msg;
}
inline void Environment::set_allocated_sources(::netsim::bellhop::protobuf::Environment_Sources* sources) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.sources_;
  }
  if (sources) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(sources);
    if (message_arena != submessage_arena) {
      sources = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, sources, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.sources_ = sources;
  // @@protoc_insertion_point(field_set_allocated:netsim.bellhop.protobuf.Environment.sources)
}
 
// optional .netsim.bellhop.protobuf.Environment.Receivers receivers = 8 [(.goby.field) = {
inline bool Environment::_internal_has_receivers() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.receivers_ != nullptr);
  return value;
}
inline bool Environment::has_receivers() const {
  return _internal_has_receivers();
}
inline void Environment::clear_receivers() {
  if (_impl_.receivers_ != nullptr) _impl_.receivers_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::netsim::bellhop::protobuf::Environment_Receivers& Environment::_internal_receivers() const {
  const ::netsim::bellhop::protobuf::Environment_Receivers* p = _impl_.receivers_;
  return p != nullptr ? *p : reinterpret_cast<const ::netsim::bellhop::protobuf::Environment_Receivers&>(
      ::netsim::bellhop::protobuf::_Environment_Receivers_default_instance_);
}
inline const ::netsim::bellhop::protobuf::Environment_Receivers& Environment::receivers() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.receivers)
  return _internal_receivers();
}
inline void Environment::unsafe_arena_set_allocated_receivers(
    ::netsim::bellhop::protobuf::Environment_Receivers* receivers) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.receivers_);
  }
  _impl_.receivers_ = receivers;
  if (receivers) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:netsim.bellhop.protobuf.Environment.receivers)
}
inline ::netsim::bellhop::protobuf::Environment_Receivers* Environment::release_receivers() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::netsim::bellhop::protobuf::Environment_Receivers* temp = _impl_.receivers_;
  _impl_.receivers_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Receivers* Environment::unsafe_arena_release_receivers() {
  // @@protoc_insertion_point(field_release:netsim.bellhop.protobuf.Environment.receivers)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::netsim::bellhop::protobuf::Environment_Receivers* temp = _impl_.receivers_;
  _impl_.receivers_ = nullptr;
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Receivers* Environment::_internal_mutable_receivers() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.receivers_ == nullptr) {
    auto* p = CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_Receivers>(GetArenaForAllocation());
    _impl_.receivers_ = p;
  }
  return _impl_.receivers_;
}
inline ::netsim::bellhop::protobuf::Environment_Receivers* Environment::mutable_receivers() {
  ::netsim::bellhop::protobuf::Environment_Receivers* _msg = _internal_mutable_receivers();
  // @@protoc_insertion_point(field_mutable:netsim.bellhop.protobuf.Environment.receivers)
  return _msg;
}
inline void Environment::set_allocated_receivers(::netsim::bellhop::protobuf::Environment_Receivers* receivers) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.receivers_;
  }
  if (receivers) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(receivers);
    if (message_arena != submessage_arena) {
      receivers = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, receivers, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.receivers_ = receivers;
  // @@protoc_insertion_point(field_set_allocated:netsim.bellhop.protobuf.Environment.receivers)
}
 
// optional .netsim.bellhop.protobuf.Environment.Beams beams = 9 [(.goby.field) = {
inline bool Environment::_internal_has_beams() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.beams_ != nullptr);
  return value;
}
inline bool Environment::has_beams() const {
  return _internal_has_beams();
}
inline void Environment::clear_beams() {
  if (_impl_.beams_ != nullptr) _impl_.beams_->Clear();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const ::netsim::bellhop::protobuf::Environment_Beams& Environment::_internal_beams() const {
  const ::netsim::bellhop::protobuf::Environment_Beams* p = _impl_.beams_;
  return p != nullptr ? *p : reinterpret_cast<const ::netsim::bellhop::protobuf::Environment_Beams&>(
      ::netsim::bellhop::protobuf::_Environment_Beams_default_instance_);
}
inline const ::netsim::bellhop::protobuf::Environment_Beams& Environment::beams() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.beams)
  return _internal_beams();
}
inline void Environment::unsafe_arena_set_allocated_beams(
    ::netsim::bellhop::protobuf::Environment_Beams* beams) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.beams_);
  }
  _impl_.beams_ = beams;
  if (beams) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:netsim.bellhop.protobuf.Environment.beams)
}
inline ::netsim::bellhop::protobuf::Environment_Beams* Environment::release_beams() {
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::netsim::bellhop::protobuf::Environment_Beams* temp = _impl_.beams_;
  _impl_.beams_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Beams* Environment::unsafe_arena_release_beams() {
  // @@protoc_insertion_point(field_release:netsim.bellhop.protobuf.Environment.beams)
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::netsim::bellhop::protobuf::Environment_Beams* temp = _impl_.beams_;
  _impl_.beams_ = nullptr;
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_Beams* Environment::_internal_mutable_beams() {
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.beams_ == nullptr) {
    auto* p = CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_Beams>(GetArenaForAllocation());
    _impl_.beams_ = p;
  }
  return _impl_.beams_;
}
inline ::netsim::bellhop::protobuf::Environment_Beams* Environment::mutable_beams() {
  ::netsim::bellhop::protobuf::Environment_Beams* _msg = _internal_mutable_beams();
  // @@protoc_insertion_point(field_mutable:netsim.bellhop.protobuf.Environment.beams)
  return _msg;
}
inline void Environment::set_allocated_beams(::netsim::bellhop::protobuf::Environment_Beams* beams) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.beams_;
  }
  if (beams) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(beams);
    if (message_arena != submessage_arena) {
      beams = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, beams, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.beams_ = beams;
  // @@protoc_insertion_point(field_set_allocated:netsim.bellhop.protobuf.Environment.beams)
}
 
// optional .netsim.bellhop.protobuf.Environment.AdaptiveInfo adaptive_info = 100 [(.goby.field) = {
inline bool Environment::_internal_has_adaptive_info() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.adaptive_info_ != nullptr);
  return value;
}
inline bool Environment::has_adaptive_info() const {
  return _internal_has_adaptive_info();
}
inline void Environment::clear_adaptive_info() {
  if (_impl_.adaptive_info_ != nullptr) _impl_.adaptive_info_->Clear();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const ::netsim::bellhop::protobuf::Environment_AdaptiveInfo& Environment::_internal_adaptive_info() const {
  const ::netsim::bellhop::protobuf::Environment_AdaptiveInfo* p = _impl_.adaptive_info_;
  return p != nullptr ? *p : reinterpret_cast<const ::netsim::bellhop::protobuf::Environment_AdaptiveInfo&>(
      ::netsim::bellhop::protobuf::_Environment_AdaptiveInfo_default_instance_);
}
inline const ::netsim::bellhop::protobuf::Environment_AdaptiveInfo& Environment::adaptive_info() const {
  // @@protoc_insertion_point(field_get:netsim.bellhop.protobuf.Environment.adaptive_info)
  return _internal_adaptive_info();
}
inline void Environment::unsafe_arena_set_allocated_adaptive_info(
    ::netsim::bellhop::protobuf::Environment_AdaptiveInfo* adaptive_info) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.adaptive_info_);
  }
  _impl_.adaptive_info_ = adaptive_info;
  if (adaptive_info) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:netsim.bellhop.protobuf.Environment.adaptive_info)
}
inline ::netsim::bellhop::protobuf::Environment_AdaptiveInfo* Environment::release_adaptive_info() {
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::netsim::bellhop::protobuf::Environment_AdaptiveInfo* temp = _impl_.adaptive_info_;
  _impl_.adaptive_info_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_AdaptiveInfo* Environment::unsafe_arena_release_adaptive_info() {
  // @@protoc_insertion_point(field_release:netsim.bellhop.protobuf.Environment.adaptive_info)
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::netsim::bellhop::protobuf::Environment_AdaptiveInfo* temp = _impl_.adaptive_info_;
  _impl_.adaptive_info_ = nullptr;
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment_AdaptiveInfo* Environment::_internal_mutable_adaptive_info() {
  _impl_._has_bits_[0] |= 0x00000080u;
  if (_impl_.adaptive_info_ == nullptr) {
    auto* p = CreateMaybeMessage<::netsim::bellhop::protobuf::Environment_AdaptiveInfo>(GetArenaForAllocation());
    _impl_.adaptive_info_ = p;
  }
  return _impl_.adaptive_info_;
}
inline ::netsim::bellhop::protobuf::Environment_AdaptiveInfo* Environment::mutable_adaptive_info() {
  ::netsim::bellhop::protobuf::Environment_AdaptiveInfo* _msg = _internal_mutable_adaptive_info();
  // @@protoc_insertion_point(field_mutable:netsim.bellhop.protobuf.Environment.adaptive_info)
  return _msg;
}
inline void Environment::set_allocated_adaptive_info(::netsim::bellhop::protobuf::Environment_AdaptiveInfo* adaptive_info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.adaptive_info_;
  }
  if (adaptive_info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(adaptive_info);
    if (message_arena != submessage_arena) {
      adaptive_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, adaptive_info, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.adaptive_info_ = adaptive_info;
  // @@protoc_insertion_point(field_set_allocated:netsim.bellhop.protobuf.Environment.adaptive_info)
}
 
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
 
// @@protoc_insertion_point(namespace_scope)
 
}  // namespace protobuf
}  // namespace bellhop
}  // namespace netsim
 
PROTOBUF_NAMESPACE_OPEN
 
template <> struct is_proto_enum< ::netsim::bellhop::protobuf::Environment_Output_OutputType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::netsim::bellhop::protobuf::Environment_Output_OutputType>() {
  return ::netsim::bellhop::protobuf::Environment_Output_OutputType_descriptor();
}
template <> struct is_proto_enum< ::netsim::bellhop::protobuf::Environment_Medium_Attenuation_Units> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::netsim::bellhop::protobuf::Environment_Medium_Attenuation_Units>() {
  return ::netsim::bellhop::protobuf::Environment_Medium_Attenuation_Units_descriptor();
}
template <> struct is_proto_enum< ::netsim::bellhop::protobuf::Environment_Medium_MediumType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::netsim::bellhop::protobuf::Environment_Medium_MediumType>() {
  return ::netsim::bellhop::protobuf::Environment_Medium_MediumType_descriptor();
}
template <> struct is_proto_enum< ::netsim::bellhop::protobuf::Environment_WaterColumn_SSPInterpolation> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::netsim::bellhop::protobuf::Environment_WaterColumn_SSPInterpolation>() {
  return ::netsim::bellhop::protobuf::Environment_WaterColumn_SSPInterpolation_descriptor();
}
template <> struct is_proto_enum< ::netsim::bellhop::protobuf::Environment_Beams_ApproximationType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::netsim::bellhop::protobuf::Environment_Beams_ApproximationType>() {
  return ::netsim::bellhop::protobuf::Environment_Beams_ApproximationType_descriptor();
}
 
PROTOBUF_NAMESPACE_CLOSE
 
// @@protoc_insertion_point(global_scope)
 
#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_netsim_2facousticstoolbox_2fenvironment_2eproto