IAccess.hpp

///=============================================================================
/// \file
/// \brief  By inheriting from IAcc, IGroup provides access to its members by name.
/// \author WK
/// \date   22.02.2020
///=============================================================================
 
namespace opals
{
  namespace opts
  {
 
    /// Defines global options
    namespace glob
    {
      /// Provides access method(s) to the first given option with name(s) according to that option's enumerator.
      /** \tparam name_   The enumerator of the option to provide access to.
          \tparam Opts    The parameter pack of the current and remaining options. IAccS derives from itself for the remaining options. */
      template<Names, class...>
      struct IAccS;
 
      /// For an empty parameter pack, IAcc_ defines IBase as its Type.
      template<class...>
      struct IAcc_
      {
        using Type = IBase;
      };
 
      /// For a non-empty parameter pack, IAcc_ defines IAccS as its Type, specialized for the first and remaining options.
      template<class Opt, class... Opts>
      struct IAcc_<Opt, Opts...>
      {
        using Type = IAccS<Opt::Name::value, Opt, Opts...>;
      };
 
      /// The specialization of IAcc_ according to the given options.
      template<class... Opts>
      using IAcc = typename IAcc_<Opts...>::Type;
 
      /// Partial specialization for Names::temp
      template<class Opt, class... Opts>
      struct IAccS<Names::temp , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& temp () const = 0;
        virtual       Opt& temp ()       = 0;
      };
 
      /// Partial specialization for Names::force_coord_ref_sys
      template<class Opt, class... Opts>
      struct IAccS<Names::force_coord_ref_sys , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& force_coord_ref_sys () const = 0;
        virtual       Opt& force_coord_ref_sys ()       = 0;
      };
 
      /// Partial specialization for Names::coord_ref_sys
      template<class Opt, class... Opts>
      struct IAccS<Names::coord_ref_sys , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& coord_ref_sys () const = 0;
        virtual       Opt& coord_ref_sys ()       = 0;
      };
 
      /// Partial specialization for Names::coord_system
      template<class Opt, class... Opts>
      struct IAccS<Names::coord_system , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& coord_system () const = 0;
        virtual       Opt& coord_system ()       = 0;
      };
 
      /// Partial specialization for Names::points_in_memory
      template<class Opt, class... Opts>
      struct IAccS<Names::points_in_memory , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& points_in_memory () const = 0;
        virtual       Opt& points_in_memory ()       = 0;
      };
 
      /// Partial specialization for Names::max_log_file_mb
      template<class Opt, class... Opts>
      struct IAccS<Names::max_log_file_mb , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& max_log_file_mb () const = 0;
        virtual       Opt& max_log_file_mb ()       = 0;
      };
 
      /// Partial specialization for Names::oformat_grid
      template<class Opt, class... Opts>
      struct IAccS<Names::oformat_grid , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& oformat_grid () const = 0;
        virtual       Opt& oformat_grid ()       = 0;
      };
 
      /// Partial specialization for Names::oformat_vector
      template<class Opt, class... Opts>
      struct IAccS<Names::oformat_vector , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& oformat_vector () const = 0;
        virtual       Opt& oformat_vector ()       = 0;
      };
 
      /// Partial specialization for Names::oformat_tin
      template<class Opt, class... Opts>
      struct IAccS<Names::oformat_tin , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& oformat_tin () const = 0;
        virtual       Opt& oformat_tin ()       = 0;
      };
 
      /// Partial specialization for Names::oformat_lidar
      template<class Opt, class... Opts>
      struct IAccS<Names::oformat_lidar , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& oformat_lidar () const = 0;
        virtual       Opt& oformat_lidar ()       = 0;
      };
 
      /// Partial specialization for Names::data_type_grid
      template<class Opt, class... Opts>
      struct IAccS<Names::data_type_grid , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& data_type_grid () const = 0;
        virtual       Opt& data_type_grid ()       = 0;
      };
 
      /// Partial specialization for Names::create_option
      template<class Opt, class... Opts>
      struct IAccS<Names::create_option , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& create_option () const = 0;
        virtual       Opt& create_option ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_z
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_z , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_z () const = 0;
        virtual       Opt& postfix_z ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_attribute
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_attribute , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_attribute () const = 0;
        virtual       Opt& postfix_attribute ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_min
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_min , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_min () const = 0;
        virtual       Opt& postfix_min ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_max
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_max , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_max () const = 0;
        virtual       Opt& postfix_max ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_range
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_range , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_range () const = 0;
        virtual       Opt& postfix_range ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_nmin
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_nmin , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_nmin () const = 0;
        virtual       Opt& postfix_nmin ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_nmax
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_nmax , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_nmax () const = 0;
        virtual       Opt& postfix_nmax ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_rms
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_rms , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_rms () const = 0;
        virtual       Opt& postfix_rms ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_stdDev
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_stdDev , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_stdDev () const = 0;
        virtual       Opt& postfix_stdDev ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_var
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_var , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_var () const = 0;
        virtual       Opt& postfix_var ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_stdDevMad
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_stdDevMad , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_stdDevMad () const = 0;
        virtual       Opt& postfix_stdDevMad ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_mean
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_mean , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_mean () const = 0;
        virtual       Opt& postfix_mean ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_median
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_median , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_median () const = 0;
        virtual       Opt& postfix_median ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_sum
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_sum , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_sum () const = 0;
        virtual       Opt& postfix_sum ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_minority
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_minority , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_minority () const = 0;
        virtual       Opt& postfix_minority ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_majority
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_majority , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_majority () const = 0;
        virtual       Opt& postfix_majority ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_shannon_entropy
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_shannon_entropy , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_shannon_entropy () const = 0;
        virtual       Opt& postfix_shannon_entropy ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_quadratic_entropy
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_quadratic_entropy , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_quadratic_entropy () const = 0;
        virtual       Opt& postfix_quadratic_entropy ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_center
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_center , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_center () const = 0;
        virtual       Opt& postfix_center ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_pdens
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_pdens , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_pdens () const = 0;
        virtual       Opt& postfix_pdens ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_pcount
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_pcount , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_pcount () const = 0;
        virtual       Opt& postfix_pcount ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_quantile
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_quantile , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_quantile () const = 0;
        virtual       Opt& postfix_quantile ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_sigmaz
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_sigmaz , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_sigmaz () const = 0;
        virtual       Opt& postfix_sigmaz ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_sigma0
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_sigma0 , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_sigma0 () const = 0;
        virtual       Opt& postfix_sigma0 ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_excen
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_excen , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_excen () const = 0;
        virtual       Opt& postfix_excen ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_slope
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_slope , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_slope () const = 0;
        virtual       Opt& postfix_slope ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_slpPerc
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_slpPerc , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_slpPerc () const = 0;
        virtual       Opt& postfix_slpPerc ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_slpDeg
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_slpDeg , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_slpDeg () const = 0;
        virtual       Opt& postfix_slpDeg ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_slpRad
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_slpRad , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_slpRad () const = 0;
        virtual       Opt& postfix_slpRad ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_expos
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_expos , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_expos () const = 0;
        virtual       Opt& postfix_expos ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_exposRad
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_exposRad , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_exposRad () const = 0;
        virtual       Opt& postfix_exposRad ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_exposDeg
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_exposDeg , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_exposDeg () const = 0;
        virtual       Opt& postfix_exposDeg ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_nx
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_nx , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_nx () const = 0;
        virtual       Opt& postfix_nx ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_ny
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_ny , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_ny () const = 0;
        virtual       Opt& postfix_ny ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_openness
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_openness , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_openness () const = 0;
        virtual       Opt& postfix_openness ()       = 0;
      };
 
      /// Partial specialization for Names::column_name_alias
      template<class Opt, class... Opts>
      struct IAccS<Names::column_name_alias , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& column_name_alias () const = 0;
        virtual       Opt& column_name_alias ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_kmin
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_kmin , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_kmin () const = 0;
        virtual       Opt& postfix_kmin ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_kmax
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_kmax , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_kmax () const = 0;
        virtual       Opt& postfix_kmax ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_kmean
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_kmean , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_kmean () const = 0;
        virtual       Opt& postfix_kmean ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_kgauss
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_kgauss , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_kgauss () const = 0;
        virtual       Opt& postfix_kgauss ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_kminDir
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_kminDir , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_kminDir () const = 0;
        virtual       Opt& postfix_kminDir ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_kmaxDir
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_kmaxDir , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_kmaxDir () const = 0;
        virtual       Opt& postfix_kmaxDir ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_absKmaxDir
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_absKmaxDir , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_absKmaxDir () const = 0;
        virtual       Opt& postfix_absKmaxDir ()       = 0;
      };
 
      /// Partial specialization for Names::postfix_precision
      template<class Opt, class... Opts>
      struct IAccS<Names::postfix_precision , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& postfix_precision () const = 0;
        virtual       Opt& postfix_precision ()       = 0;
      };
 
      /// Partial specialization for Names::tolerance_abs
      template<class Opt, class... Opts>
      struct IAccS<Names::tolerance_abs , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& tolerance_abs () const = 0;
        virtual       Opt& tolerance_abs ()       = 0;
      };
 
      /// Partial specialization for Names::tolerance_rel
      template<class Opt, class... Opts>
      struct IAccS<Names::tolerance_rel , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& tolerance_rel () const = 0;
        virtual       Opt& tolerance_rel ()       = 0;
      };
 
    }
 
    /// Defines common options
    namespace comm
    {
      /// Provides access method(s) to the first given option with name(s) according to that option's enumerator.
      /** \tparam name_   The enumerator of the option to provide access to.
          \tparam Opts    The parameter pack of the current and remaining options. IAccS derives from itself for the remaining options. */
      template<Names, class...>
      struct IAccS;
 
      /// For an empty parameter pack, IAcc_ defines IBase as its Type.
      template<class...>
      struct IAcc_
      {
        using Type = IBase;
      };
 
      /// For a non-empty parameter pack, IAcc_ defines IAccS as its Type, specialized for the first and remaining options.
      template<class Opt, class... Opts>
      struct IAcc_<Opt, Opts...>
      {
        using Type = IAccS<Opt::Name::value, Opt, Opts...>;
      };
 
      /// The specialization of IAcc_ according to the given options.
      template<class... Opts>
      using IAcc = typename IAcc_<Opts...>::Type;
 
      /// Partial specialization for Names::task
      template<class Opt, class... Opts>
      struct IAccS<Names::task , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& task () const = 0;
        virtual       Opt& task ()       = 0;
      };
 
      /// Partial specialization for Names::nbThreads
      template<class Opt, class... Opts>
      struct IAccS<Names::nbThreads , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& nbThreads () const = 0;
        virtual       Opt& nbThreads ()       = 0;
      };
 
      /// Partial specialization for Names::screenLogLevel
      template<class Opt, class... Opts>
      struct IAccS<Names::screenLogLevel , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& screenLogLevel () const = 0;
        virtual       Opt& screenLogLevel ()       = 0;
      };
 
      /// Partial specialization for Names::fileLogLevel
      template<class Opt, class... Opts>
      struct IAccS<Names::fileLogLevel , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& fileLogLevel () const = 0;
        virtual       Opt& fileLogLevel ()       = 0;
      };
 
      /// Partial specialization for Names::lineBufferedScreenLog
      template<class Opt, class... Opts>
      struct IAccS<Names::lineBufferedScreenLog , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& lineBufferedScreenLog () const = 0;
        virtual       Opt& lineBufferedScreenLog ()       = 0;
      };
 
      /// Partial specialization for Names::logFile
      template<class Opt, class... Opts>
      struct IAccS<Names::logFile , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& logFile () const = 0;
        virtual       Opt& logFile ()       = 0;
      };
 
      /// Partial specialization for Names::cfgFile
      template<class Opt, class... Opts>
      struct IAccS<Names::cfgFile , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& cfgFile () const = 0;
        virtual       Opt& cfgFile ()       = 0;
      };
 
      /// Partial specialization for Names::paramMapping
      template<class Opt, class... Opts>
      struct IAccS<Names::paramMapping , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& paramMapping () const = 0;
        virtual       Opt& paramMapping ()       = 0;
      };
 
      /// Partial specialization for Names::inParamFiles
      template<class Opt, class... Opts>
      struct IAccS<Names::inParamFiles , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& inParamFiles () const = 0;
        virtual       Opt& inParamFiles ()       = 0;
      };
 
      /// Partial specialization for Names::outParamFile
      template<class Opt, class... Opts>
      struct IAccS<Names::outParamFile , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& outParamFile () const = 0;
        virtual       Opt& outParamFile ()       = 0;
      };
 
      /// Partial specialization for Names::scope
      template<class Opt, class... Opts>
      struct IAccS<Names::scope , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& scope () const = 0;
        virtual       Opt& scope ()       = 0;
      };
 
      /// Partial specialization for Names::deleteUselessOutFile
      template<class Opt, class... Opts>
      struct IAccS<Names::deleteUselessOutFile , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& deleteUselessOutFile () const = 0;
        virtual       Opt& deleteUselessOutFile ()       = 0;
      };
 
      /// Partial specialization for Names::testErrorProbability
      template<class Opt, class... Opts>
      struct IAccS<Names::testErrorProbability , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& testErrorProbability () const = 0;
        virtual       Opt& testErrorProbability ()       = 0;
      };
 
      /// Partial specialization for Names::testErrorBeforeRun
      template<class Opt, class... Opts>
      struct IAccS<Names::testErrorBeforeRun , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& testErrorBeforeRun () const = 0;
        virtual       Opt& testErrorBeforeRun ()       = 0;
      };
 
    }
 
    /// Defines specific options
    namespace spec
    {
      /// Provides access method(s) to the first given option with name(s) according to that option's enumerator.
      /** \tparam name_   The enumerator of the option to provide access to.
          \tparam Opts    The parameter pack of the current and remaining options. IAccS derives from itself for the remaining options. */
      template<Names, class...>
      struct IAccS;
 
      /// For an empty parameter pack, IAcc_ defines IBase as its Type.
      template<class...>
      struct IAcc_
      {
        using Type = IBase;
      };
 
      /// For a non-empty parameter pack, IAcc_ defines IAccS as its Type, specialized for the first and remaining options.
      template<class Opt, class... Opts>
      struct IAcc_<Opt, Opts...>
      {
        using Type = IAccS<Opt::Name::value, Opt, Opts...>;
      };
 
      /// The specialization of IAcc_ according to the given options.
      template<class... Opts>
      using IAcc = typename IAcc_<Opts...>::Type;
 
      /// Partial specialization for Names::inFile
      template<class Opt, class... Opts>
      struct IAccS<Names::inFile , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& inFile () const = 0;
        virtual       Opt& inFile ()       = 0;
      };
 
      /// Partial specialization for Names::outFile
      template<class Opt, class... Opts>
      struct IAccS<Names::outFile , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& outFile () const = 0;
        virtual       Opt& outFile ()       = 0;
      };
 
      /// Partial specialization for Names::axisFile
      template<class Opt, class... Opts>
      struct IAccS<Names::axisFile , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& axisFile () const = 0;
        virtual       Opt& axisFile ()       = 0;
      };
 
      /// Partial specialization for Names::controlFile
      template<class Opt, class... Opts>
      struct IAccS<Names::controlFile , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& controlFile () const = 0;
        virtual       Opt& controlFile ()       = 0;
      };
 
      /// Partial specialization for Names::iFormat
      template<class Opt, class... Opts>
      struct IAccS<Names::iFormat , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& iFormat () const = 0;
        virtual       Opt& iFormat ()       = 0;
      };
 
      /// Partial specialization for Names::oFormat
      template<class Opt, class... Opts>
      struct IAccS<Names::oFormat , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& oFormat () const = 0;
        virtual       Opt& oFormat ()       = 0;
      };
 
      /// Partial specialization for Names::trjFile
      template<class Opt, class... Opts>
      struct IAccS<Names::trjFile , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& trjFile () const = 0;
        virtual       Opt& trjFile ()       = 0;
      };
 
      /// Partial specialization for Names::limit
      template<class Opt, class... Opts>
      struct IAccS<Names::limit , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& limit () const = 0;
        virtual       Opt& limit ()       = 0;
      };
 
      /// Partial specialization for Names::band _OPALS_COMMENT_AFTER_("raster band number/index in case of multi-layer rasters"
      template<class Opt, class... Opts>
      struct IAccS<Names::band  , Opt, Opts...> : ///< raster band number/index in case of multi-layer rasters
        IAcc<Opts...>
      {
        virtual const Opt& band  () const = 0; ///< raster band number/index in case of multi-layer rasters
        virtual       Opt& band  ()       = 0; ///< raster band number/index in case of multi-layer rasters
      };
 
      /// Partial specialization for Names::storeOrder
      template<class Opt, class... Opts>
      struct IAccS<Names::storeOrder , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& storeOrder () const = 0;
        virtual       Opt& storeOrder ()       = 0;
      };
 
      /// Partial specialization for Names::restoreOrder _OPALS_COMMENT_AFTER_("restore natural order of data (opalsExport
      template<class Opt, class... Opts>
      struct IAccS<Names::restoreOrder  , Opt, Opts...> : ///< restore natural order of data (opalsExport)
        IAcc<Opts...>
      {
        virtual const Opt& restoreOrder  () const = 0; ///< restore natural order of data (opalsExport)
        virtual       Opt& restoreOrder  ()       = 0; ///< restore natural order of data (opalsExport)
      };
 
      /// Partial specialization for Names::tilePointCount
      template<class Opt, class... Opts>
      struct IAccS<Names::tilePointCount , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& tilePointCount () const = 0;
        virtual       Opt& tilePointCount ()       = 0;
      };
 
      /// Partial specialization for Names::tileSize
      template<class Opt, class... Opts>
      struct IAccS<Names::tileSize , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& tileSize () const = 0;
        virtual       Opt& tileSize ()       = 0;
      };
 
      /// Partial specialization for Names::gridSize
      template<class Opt, class... Opts>
      struct IAccS<Names::gridSize , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& gridSize () const = 0;
        virtual       Opt& gridSize ()       = 0;
      };
 
      /// Partial specialization for Names::neighbours
      template<class Opt, class... Opts>
      struct IAccS<Names::neighbours , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& neighbours () const = 0;
        virtual       Opt& neighbours ()       = 0;
      };
 
      /// Partial specialization for Names::searchRadius
      template<class Opt, class... Opts>
      struct IAccS<Names::searchRadius , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& searchRadius () const = 0;
        virtual       Opt& searchRadius ()       = 0;
      };
 
      /// Partial specialization for Names::debugOutFile
      template<class Opt, class... Opts>
      struct IAccS<Names::debugOutFile , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& debugOutFile () const = 0;
        virtual       Opt& debugOutFile ()       = 0;
      };
 
      /// Partial specialization for Names::interpolation
      template<class Opt, class... Opts>
      struct IAccS<Names::interpolation , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& interpolation () const = 0;
        virtual       Opt& interpolation ()       = 0;
      };
 
      /// Partial specialization for Names::interval
      template<class Opt, class... Opts>
      struct IAccS<Names::interval , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& interval () const = 0;
        virtual       Opt& interval ()       = 0;
      };
 
      /// Partial specialization for Names::levels _OPALS_COMMENT_AFTER_("individual height levels (e.g. opalsIsolines
      template<class Opt, class... Opts>
      struct IAccS<Names::levels  , Opt, Opts...> : ///< individual height levels (e.g. opalsIsolines)
        IAcc<Opts...>
      {
        virtual const Opt& levels  () const = 0; ///< individual height levels (e.g. opalsIsolines)
        virtual       Opt& levels  ()       = 0; ///< individual height levels (e.g. opalsIsolines)
      };
 
      /// Partial specialization for Names::nClasses _OPALS_COMMENT_AFTER_("number of different classes (e.g. opalsZColor
      template<class Opt, class... Opts>
      struct IAccS<Names::nClasses  , Opt, Opts...> : ///< number of different classes (e.g. opalsZColor)
        IAcc<Opts...>
      {
        virtual const Opt& nClasses  () const = 0; ///< number of different classes (e.g. opalsZColor)
        virtual       Opt& nClasses  ()       = 0; ///< number of different classes (e.g. opalsZColor)
      };
 
      /// Partial specialization for Names::nBins _OPALS_COMMENT_AFTER_("number of different bins (e.g. opalsHisto
      template<class Opt, class... Opts>
      struct IAccS<Names::nBins  , Opt, Opts...> : ///< number of different bins (e.g. opalsHisto)
        IAcc<Opts...>
      {
        virtual const Opt& nBins  () const = 0; ///< number of different bins (e.g. opalsHisto)
        virtual       Opt& nBins  ()       = 0; ///< number of different bins (e.g. opalsHisto)
      };
 
      /// Partial specialization for Names::binWidth _OPALS_COMMENT_AFTER_("width of a single bin (e.g. opalsHisto
      template<class Opt, class... Opts>
      struct IAccS<Names::binWidth  , Opt, Opts...> : ///< width of a single bin (e.g. opalsHisto)
        IAcc<Opts...>
      {
        virtual const Opt& binWidth  () const = 0; ///< width of a single bin (e.g. opalsHisto)
        virtual       Opt& binWidth  ()       = 0; ///< width of a single bin (e.g. opalsHisto)
      };
 
      /// Partial specialization for Names::palFile _OPALS_COMMENT_AFTER_("palette file (opalsZcolor
      template<class Opt, class... Opts>
      struct IAccS<Names::palFile  , Opt, Opts...> : ///< palette file (opalsZcolor)
        IAcc<Opts...>
      {
        virtual const Opt& palFile  () const = 0; ///< palette file (opalsZcolor)
        virtual       Opt& palFile  ()       = 0; ///< palette file (opalsZcolor)
      };
 
      /// Partial specialization for Names::legend _OPALS_COMMENT_AFTER_("on / off / file=filename where legend in SVG format is to be written (opalsZcolor
      template<class Opt, class... Opts>
      struct IAccS<Names::legend  , Opt, Opts...> : ///< on / off / file=filename where legend in SVG format is to be written (opalsZcolor)
        IAcc<Opts...>
      {
        virtual const Opt& legend  () const = 0; ///< on / off / file=filename where legend in SVG format is to be written (opalsZcolor)
        virtual       Opt& legend  ()       = 0; ///< on / off / file=filename where legend in SVG format is to be written (opalsZcolor)
      };
 
      /// Partial specialization for Names::scalePal _OPALS_COMMENT_AFTER_("scale factor to be applied to the given palette (opalsZcolor
      template<class Opt, class... Opts>
      struct IAccS<Names::scalePal  , Opt, Opts...> : ///< scale factor to be applied to the given palette (opalsZcolor)
        IAcc<Opts...>
      {
        virtual const Opt& scalePal  () const = 0; ///< scale factor to be applied to the given palette (opalsZcolor)
        virtual       Opt& scalePal  ()       = 0; ///< scale factor to be applied to the given palette (opalsZcolor)
      };
 
      /// Partial specialization for Names::offsetPal _OPALS_COMMENT_AFTER_("offset value to be applied to the given palette (opalsZcolor
      template<class Opt, class... Opts>
      struct IAccS<Names::offsetPal  , Opt, Opts...> : ///< offset value to be applied to the given palette (opalsZcolor)
        IAcc<Opts...>
      {
        virtual const Opt& offsetPal  () const = 0; ///< offset value to be applied to the given palette (opalsZcolor)
        virtual       Opt& offsetPal  ()       = 0; ///< offset value to be applied to the given palette (opalsZcolor)
      };
 
      /// Partial specialization for Names::zRange _OPALS_COMMENT_AFTER_("range of z-values to be used for z-coloring (e.g. opalsZcolor
      template<class Opt, class... Opts>
      struct IAccS<Names::zRange  , Opt, Opts...> : ///< range of z-values to be used for z-coloring (e.g. opalsZcolor)
        IAcc<Opts...>
      {
        virtual const Opt& zRange  () const = 0; ///< range of z-values to be used for z-coloring (e.g. opalsZcolor)
        virtual       Opt& zRange  ()       = 0; ///< range of z-values to be used for z-coloring (e.g. opalsZcolor)
      };
 
      /// Partial specialization for Names::sampleRange _OPALS_COMMENT_AFTER_("sample (attribute
      template<class Opt, class... Opts>
      struct IAccS<Names::sampleRange  , Opt, Opts...> : ///< sample (attribute) range (e.g. opalsHisto)
        IAcc<Opts...>
      {
        virtual const Opt& sampleRange  () const = 0; ///< sample (attribute) range (e.g. opalsHisto)
        virtual       Opt& sampleRange  ()       = 0; ///< sample (attribute) range (e.g. opalsHisto)
      };
 
      /// Partial specialization for Names::densityRange _OPALS_COMMENT_AFTER_("density range (e.g. opalsHisto
      template<class Opt, class... Opts>
      struct IAccS<Names::densityRange  , Opt, Opts...> : ///< density range (e.g. opalsHisto)
        IAcc<Opts...>
      {
        virtual const Opt& densityRange  () const = 0; ///< density range (e.g. opalsHisto)
        virtual       Opt& densityRange  ()       = 0; ///< density range (e.g. opalsHisto)
      };
 
      /// Partial specialization for Names::resampling
      template<class Opt, class... Opts>
      struct IAccS<Names::resampling , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& resampling () const = 0;
        virtual       Opt& resampling ()       = 0;
      };
 
      /// Partial specialization for Names::rasterType
      template<class Opt, class... Opts>
      struct IAccS<Names::rasterType , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& rasterType () const = 0;
        virtual       Opt& rasterType ()       = 0;
      };
 
      /// Partial specialization for Names::selMode
      template<class Opt, class... Opts>
      struct IAccS<Names::selMode , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& selMode () const = 0;
        virtual       Opt& selMode ()       = 0;
      };
 
      /// Partial specialization for Names::feature
      template<class Opt, class... Opts>
      struct IAccS<Names::feature , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& feature () const = 0;
        virtual       Opt& feature ()       = 0;
      };
 
      /// Partial specialization for Names::calRegionFile
      template<class Opt, class... Opts>
      struct IAccS<Names::calRegionFile , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& calRegionFile () const = 0;
        virtual       Opt& calRegionFile ()       = 0;
      };
 
      /// Partial specialization for Names::reflectivityFile
      template<class Opt, class... Opts>
      struct IAccS<Names::reflectivityFile , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& reflectivityFile () const = 0;
        virtual       Opt& reflectivityFile ()       = 0;
      };
 
      /// Partial specialization for Names::atmosphericAtt
      template<class Opt, class... Opts>
      struct IAccS<Names::atmosphericAtt , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& atmosphericAtt () const = 0;
        virtual       Opt& atmosphericAtt ()       = 0;
      };
 
      /// Partial specialization for Names::beamDivergence
      template<class Opt, class... Opts>
      struct IAccS<Names::beamDivergence , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& beamDivergence () const = 0;
        virtual       Opt& beamDivergence ()       = 0;
      };
 
      /// Partial specialization for Names::echoWidthFlag
      template<class Opt, class... Opts>
      struct IAccS<Names::echoWidthFlag , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& echoWidthFlag () const = 0;
        virtual       Opt& echoWidthFlag ()       = 0;
      };
 
      /// Partial specialization for Names::radioCal
      template<class Opt, class... Opts>
      struct IAccS<Names::radioCal , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& radioCal () const = 0;
        virtual       Opt& radioCal ()       = 0;
      };
 
      /// Partial specialization for Names::cellSize
      template<class Opt, class... Opts>
      struct IAccS<Names::cellSize , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& cellSize () const = 0;
        virtual       Opt& cellSize ()       = 0;
      };
 
      /// Partial specialization for Names::pixelSize
      template<class Opt, class... Opts>
      struct IAccS<Names::pixelSize , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& pixelSize () const = 0;
        virtual       Opt& pixelSize ()       = 0;
      };
 
      /// Partial specialization for Names::patchSize
      template<class Opt, class... Opts>
      struct IAccS<Names::patchSize , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& patchSize () const = 0;
        virtual       Opt& patchSize ()       = 0;
      };
 
      /// Partial specialization for Names::voxelSize _OPALS_COMMENT_AFTER_("defines the size (edge length
      template<class Opt, class... Opts>
      struct IAccS<Names::voxelSize  , Opt, Opts...> : ///< defines the size (edge length) of voxel cube)
        IAcc<Opts...>
      {
        virtual const Opt& voxelSize  () const = 0; ///< defines the size (edge length) of voxel cube)
        virtual       Opt& voxelSize  ()       = 0; ///< defines the size (edge length) of voxel cube)
      };
 
      /// Partial specialization for Names::attribute
      template<class Opt, class... Opts>
      struct IAccS<Names::attribute , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& attribute () const = 0;
        virtual       Opt& attribute ()       = 0;
      };
 
      /// Partial specialization for Names::noData
      template<class Opt, class... Opts>
      struct IAccS<Names::noData , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& noData () const = 0;
        virtual       Opt& noData ()       = 0;
      };
 
      /// Partial specialization for Names::normalsAlg
      template<class Opt, class... Opts>
      struct IAccS<Names::normalsAlg , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& normalsAlg () const = 0;
        virtual       Opt& normalsAlg ()       = 0;
      };
 
      /// Partial specialization for Names::fullWaveAlg
      template<class Opt, class... Opts>
      struct IAccS<Names::fullWaveAlg , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& fullWaveAlg () const = 0;
        virtual       Opt& fullWaveAlg ()       = 0;
      };
 
      /// Partial specialization for Names::detectThrLow
      template<class Opt, class... Opts>
      struct IAccS<Names::detectThrLow , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& detectThrLow () const = 0;
        virtual       Opt& detectThrLow ()       = 0;
      };
 
      /// Partial specialization for Names::filter _OPALS_COMMENT_AFTER_("string to be parsed in construction of DM::IFilter (various modules
      template<class Opt, class... Opts>
      struct IAccS<Names::filter  , Opt, Opts...> : ///< string to be parsed in construction of DM::IFilter (various modules)
        IAcc<Opts...>
      {
        virtual const Opt& filter  () const = 0; ///< string to be parsed in construction of DM::IFilter (various modules)
        virtual       Opt& filter  ()       = 0; ///< string to be parsed in construction of DM::IFilter (various modules)
      };
 
      /// Partial specialization for Names::iFilter _OPALS_COMMENT_AFTER_("input filter (e.g. opalsTIN
      template<class Opt, class... Opts>
      struct IAccS<Names::iFilter  , Opt, Opts...> : ///< input filter (e.g. opalsTIN)
        IAcc<Opts...>
      {
        virtual const Opt& iFilter  () const = 0; ///< input filter (e.g. opalsTIN)
        virtual       Opt& iFilter  ()       = 0; ///< input filter (e.g. opalsTIN)
      };
 
      /// Partial specialization for Names::oFilter _OPALS_COMMENT_AFTER_("output filter (e.g. opalsTIN
      template<class Opt, class... Opts>
      struct IAccS<Names::oFilter  , Opt, Opts...> : ///< output filter (e.g. opalsTIN)
        IAcc<Opts...>
      {
        virtual const Opt& oFilter  () const = 0; ///< output filter (e.g. opalsTIN)
        virtual       Opt& oFilter  ()       = 0; ///< output filter (e.g. opalsTIN)
      };
 
      /// Partial specialization for Names::alphaFile _OPALS_COMMENT_AFTER_("output file path for alpha shape (opalsTIN
      template<class Opt, class... Opts>
      struct IAccS<Names::alphaFile  , Opt, Opts...> : ///< output file path for alpha shape (opalsTIN)
        IAcc<Opts...>
      {
        virtual const Opt& alphaFile  () const = 0; ///< output file path for alpha shape (opalsTIN)
        virtual       Opt& alphaFile  ()       = 0; ///< output file path for alpha shape (opalsTIN)
      };
 
      /// Partial specialization for Names::alphaRadius _OPALS_COMMENT_AFTER_("circumcircle radius for alpha shape (opalsBounds
      template<class Opt, class... Opts>
      struct IAccS<Names::alphaRadius  , Opt, Opts...> : ///< circumcircle radius for alpha shape (opalsBounds)
        IAcc<Opts...>
      {
        virtual const Opt& alphaRadius  () const = 0; ///< circumcircle radius for alpha shape (opalsBounds)
        virtual       Opt& alphaRadius  ()       = 0; ///< circumcircle radius for alpha shape (opalsBounds)
      };
 
      /// Partial specialization for Names::hollowingThresh _OPALS_COMMENT_AFTER_("point count above which to not triangulate all data but only their outer regions or borders (opalsBounds
      template<class Opt, class... Opts>
      struct IAccS<Names::hollowingThresh  , Opt, Opts...> : ///< point count above which to not triangulate all data but only their outer regions or borders (opalsBounds)
        IAcc<Opts...>
      {
        virtual const Opt& hollowingThresh  () const = 0; ///< point count above which to not triangulate all data but only their outer regions or borders (opalsBounds)
        virtual       Opt& hollowingThresh  ()       = 0; ///< point count above which to not triangulate all data but only their outer regions or borders (opalsBounds)
      };
 
      /// Partial specialization for Names::condition _OPALS_COMMENT_AFTER_("condition formula string for grid mask computation (opalsMask
      template<class Opt, class... Opts>
      struct IAccS<Names::condition  , Opt, Opts...> : ///< condition formula string for grid mask computation (opalsMask)
        IAcc<Opts...>
      {
        virtual const Opt& condition  () const = 0; ///< condition formula string for grid mask computation (opalsMask)
        virtual       Opt& condition  ()       = 0; ///< condition formula string for grid mask computation (opalsMask)
      };
 
      /// Partial specialization for Names::formula _OPALS_COMMENT_AFTER_("formula string for algebraic grid computations (opalsAlgebra
      template<class Opt, class... Opts>
      struct IAccS<Names::formula  , Opt, Opts...> : ///< formula string for algebraic grid computations (opalsAlgebra)
        IAcc<Opts...>
      {
        virtual const Opt& formula  () const = 0; ///< formula string for algebraic grid computations (opalsAlgebra)
        virtual       Opt& formula  ()       = 0; ///< formula string for algebraic grid computations (opalsAlgebra)
      };
 
      /// Partial specialization for Names::createAlpha _OPALS_COMMENT_AFTER_("indicator for grid mask creation as alpha channel (opalsMask
      template<class Opt, class... Opts>
      struct IAccS<Names::createAlpha  , Opt, Opts...> : ///< indicator for grid mask creation as alpha channel (opalsMask)
        IAcc<Opts...>
      {
        virtual const Opt& createAlpha  () const = 0; ///< indicator for grid mask creation as alpha channel (opalsMask)
        virtual       Opt& createAlpha  ()       = 0; ///< indicator for grid mask creation as alpha channel (opalsMask)
      };
 
      /// Partial specialization for Names::ratioMode _OPALS_COMMENT_AFTER_("echo ratio calculation mode"
      template<class Opt, class... Opts>
      struct IAccS<Names::ratioMode  , Opt, Opts...> : ///< echo ratio calculation mode
        IAcc<Opts...>
      {
        virtual const Opt& ratioMode  () const = 0; ///< echo ratio calculation mode
        virtual       Opt& ratioMode  ()       = 0; ///< echo ratio calculation mode
      };
 
      /// Partial specialization for Names::minArea _OPALS_COMMENT_AFTER_("minimum area"
      template<class Opt, class... Opts>
      struct IAccS<Names::minArea  , Opt, Opts...> : ///< minimum area
        IAcc<Opts...>
      {
        virtual const Opt& minArea  () const = 0; ///< minimum area
        virtual       Opt& minArea  ()       = 0; ///< minimum area
      };
 
      /// Partial specialization for Names::minLength _OPALS_COMMENT_AFTER_("minimum length"
      template<class Opt, class... Opts>
      struct IAccS<Names::minLength  , Opt, Opts...> : ///< minimum length
        IAcc<Opts...>
      {
        virtual const Opt& minLength  () const = 0; ///< minimum length
        virtual       Opt& minLength  ()       = 0; ///< minimum length
      };
 
      /// Partial specialization for Names::overlap _OPALS_COMMENT_AFTER_("specifies the overlap for sequential operations"
      template<class Opt, class... Opts>
      struct IAccS<Names::overlap  , Opt, Opts...> : ///< specifies the overlap for sequential operations
        IAcc<Opts...>
      {
        virtual const Opt& overlap  () const = 0; ///< specifies the overlap for sequential operations
        virtual       Opt& overlap  ()       = 0; ///< specifies the overlap for sequential operations
      };
 
      /// Partial specialization for Names::contours
      template<class Opt, class... Opts>
      struct IAccS<Names::contours , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& contours () const = 0;
        virtual       Opt& contours ()       = 0;
      };
 
      /// Partial specialization for Names::sections
      template<class Opt, class... Opts>
      struct IAccS<Names::sections , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& sections () const = 0;
        virtual       Opt& sections ()       = 0;
      };
 
      /// Partial specialization for Names::maxSigma
      template<class Opt, class... Opts>
      struct IAccS<Names::maxSigma , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& maxSigma () const = 0;
        virtual       Opt& maxSigma ()       = 0;
      };
 
      /// Partial specialization for Names::maxSigmaMAD _OPALS_COMMENT_AFTER_("correspondences.strip2strip.rejection group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::maxSigmaMAD  , Opt, Opts...> : ///< correspondences.strip2strip.rejection group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& maxSigmaMAD  () const = 0; ///< correspondences.strip2strip.rejection group(opalsStripAdjust)
        virtual       Opt& maxSigmaMAD  ()       = 0; ///< correspondences.strip2strip.rejection group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::maxDev
      template<class Opt, class... Opts>
      struct IAccS<Names::maxDev , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& maxDev () const = 0;
        virtual       Opt& maxDev ()       = 0;
      };
 
      /// Partial specialization for Names::maxAngleDev _OPALS_COMMENT_AFTER_("maximum angle between two elements (opalsICP, opalsLineTopology
      template<class Opt, class... Opts>
      struct IAccS<Names::maxAngleDev  , Opt, Opts...> : ///< maximum angle between two elements (opalsICP, opalsLineTopology)
        IAcc<Opts...>
      {
        virtual const Opt& maxAngleDev  () const = 0; ///< maximum angle between two elements (opalsICP, opalsLineTopology)
        virtual       Opt& maxAngleDev  ()       = 0; ///< maximum angle between two elements (opalsICP, opalsLineTopology)
      };
 
      /// Partial specialization for Names::maxMemory _OPALS_COMMENT_AFTER_("amount of memory [MB] to be used by (various
      template<class Opt, class... Opts>
      struct IAccS<Names::maxMemory  , Opt, Opts...> : ///< amount of memory [MB] to be used by (various) modules
        IAcc<Opts...>
      {
        virtual const Opt& maxMemory  () const = 0; ///< amount of memory [MB] to be used by (various) modules
        virtual       Opt& maxMemory  ()       = 0; ///< amount of memory [MB] to be used by (various) modules
      };
 
      /// Partial specialization for Names::maxTol _OPALS_COMMENT_AFTER_("maximum tolerance (e.g. opalsSimplify
      template<class Opt, class... Opts>
      struct IAccS<Names::maxTol  , Opt, Opts...> : ///< maximum tolerance (e.g. opalsSimplify)
        IAcc<Opts...>
      {
        virtual const Opt& maxTol  () const = 0; ///< maximum tolerance (e.g. opalsSimplify)
        virtual       Opt& maxTol  ()       = 0; ///< maximum tolerance (e.g. opalsSimplify)
      };
 
      /// Partial specialization for Names::maxDist _OPALS_COMMENT_AFTER_("maximum point distance (e.g. opalsSimplify, opalsSegmentation
      template<class Opt, class... Opts>
      struct IAccS<Names::maxDist  , Opt, Opts...> : ///< maximum point distance (e.g. opalsSimplify, opalsSegmentation)
        IAcc<Opts...>
      {
        virtual const Opt& maxDist  () const = 0; ///< maximum point distance (e.g. opalsSimplify, opalsSegmentation)
        virtual       Opt& maxDist  ()       = 0; ///< maximum point distance (e.g. opalsSimplify, opalsSegmentation)
      };
 
      /// Partial specialization for Names::maxIter _OPALS_COMMENT_AFTER_("maximum number of iterations (various modules
      template<class Opt, class... Opts>
      struct IAccS<Names::maxIter  , Opt, Opts...> : ///< maximum number of iterations (various modules)
        IAcc<Opts...>
      {
        virtual const Opt& maxIter  () const = 0; ///< maximum number of iterations (various modules)
        virtual       Opt& maxIter  ()       = 0; ///< maximum number of iterations (various modules)
      };
 
      /// Partial specialization for Names::gridMask _OPALS_COMMENT_AFTER_("grid mask file"
      template<class Opt, class... Opts>
      struct IAccS<Names::gridMask  , Opt, Opts...> : ///< grid mask file
        IAcc<Opts...>
      {
        virtual const Opt& gridMask  () const = 0; ///< grid mask file
        virtual       Opt& gridMask  ()       = 0; ///< grid mask file
      };
 
      /// Partial specialization for Names::gridFile _OPALS_COMMENT_AFTER_("grid model file"
      template<class Opt, class... Opts>
      struct IAccS<Names::gridFile  , Opt, Opts...> : ///< grid model file
        IAcc<Opts...>
      {
        virtual const Opt& gridFile  () const = 0; ///< grid model file
        virtual       Opt& gridFile  ()       = 0; ///< grid model file
      };
 
      /// Partial specialization for Names::spotData _OPALS_COMMENT_AFTER_("file containing (2D
      template<class Opt, class... Opts>
      struct IAccS<Names::spotData  , Opt, Opts...> : ///< file containing (2D) positions (opalsLSM))
        IAcc<Opts...>
      {
        virtual const Opt& spotData  () const = 0; ///< file containing (2D) positions (opalsLSM))
        virtual       Opt& spotData  ()       = 0; ///< file containing (2D) positions (opalsLSM))
      };
 
      /// Partial specialization for Names::lsmMode _OPALS_COMMENT_AFTER_("LSM processing mode (opalsLSM
      template<class Opt, class... Opts>
      struct IAccS<Names::lsmMode  , Opt, Opts...> : ///< LSM processing mode (opalsLSM)
        IAcc<Opts...>
      {
        virtual const Opt& lsmMode  () const = 0; ///< LSM processing mode (opalsLSM)
        virtual       Opt& lsmMode  ()       = 0; ///< LSM processing mode (opalsLSM)
      };
 
      /// Partial specialization for Names::lsmTrafo _OPALS_COMMENT_AFTER_("LSM transformation type (opalsLSM
      template<class Opt, class... Opts>
      struct IAccS<Names::lsmTrafo  , Opt, Opts...> : ///< LSM transformation type (opalsLSM)
        IAcc<Opts...>
      {
        virtual const Opt& lsmTrafo  () const = 0; ///< LSM transformation type (opalsLSM)
        virtual       Opt& lsmTrafo  ()       = 0; ///< LSM transformation type (opalsLSM)
      };
 
      /// Partial specialization for Names::trafoType _OPALS_COMMENT_AFTER_("transformation type (opalsICP
      template<class Opt, class... Opts>
      struct IAccS<Names::trafoType  , Opt, Opts...> : ///< transformation type (opalsICP)
        IAcc<Opts...>
      {
        virtual const Opt& trafoType  () const = 0; ///< transformation type (opalsICP)
        virtual       Opt& trafoType  ()       = 0; ///< transformation type (opalsICP)
      };
 
      /// Partial specialization for Names::robFactor _OPALS_COMMENT_AFTER_("factor used for robust estimation(opalsLSM
      template<class Opt, class... Opts>
      struct IAccS<Names::robFactor  , Opt, Opts...> : ///< factor used for robust estimation(opalsLSM)
        IAcc<Opts...>
      {
        virtual const Opt& robFactor  () const = 0; ///< factor used for robust estimation(opalsLSM)
        virtual       Opt& robFactor  ()       = 0; ///< factor used for robust estimation(opalsLSM)
      };
 
      /// Partial specialization for Names::outTrafPars _OPALS_COMMENT_AFTER_("output transformation parameters (opalsLSM, opalsGeorefApprox
      template<class Opt, class... Opts>
      struct IAccS<Names::outTrafPars  , Opt, Opts...> : ///< output transformation parameters (opalsLSM, opalsGeorefApprox)
        IAcc<Opts...>
      {
        virtual const Opt& outTrafPars  () const = 0; ///< output transformation parameters (opalsLSM, opalsGeorefApprox)
        virtual       Opt& outTrafPars  ()       = 0; ///< output transformation parameters (opalsLSM, opalsGeorefApprox)
      };
 
      /// Partial specialization for Names::navFrame _OPALS_COMMENT_AFTER_("navigation frame (opalsAddTraj
      template<class Opt, class... Opts>
      struct IAccS<Names::navFrame  , Opt, Opts...> : ///< navigation frame (opalsAddTraj)
        IAcc<Opts...>
      {
        virtual const Opt& navFrame  () const = 0; ///< navigation frame (opalsAddTraj)
        virtual       Opt& navFrame  ()       = 0; ///< navigation frame (opalsAddTraj)
      };
 
      /// Partial specialization for Names::mntCalFile _OPALS_COMMENT_AFTER_("mounting calibration file (opalsAddTraj
      template<class Opt, class... Opts>
      struct IAccS<Names::mntCalFile  , Opt, Opts...> : ///< mounting calibration file (opalsAddTraj)
        IAcc<Opts...>
      {
        virtual const Opt& mntCalFile  () const = 0; ///< mounting calibration file (opalsAddTraj)
        virtual       Opt& mntCalFile  ()       = 0; ///< mounting calibration file (opalsAddTraj)
      };
 
      /// Partial specialization for Names::obsTrafPars _OPALS_COMMENT_AFTER_("input transformation parameters (opalsGeorefApprox
      template<class Opt, class... Opts>
      struct IAccS<Names::obsTrafPars  , Opt, Opts...> : ///< input transformation parameters (opalsGeorefApprox)
        IAcc<Opts...>
      {
        virtual const Opt& obsTrafPars  () const = 0; ///< input transformation parameters (opalsGeorefApprox)
        virtual       Opt& obsTrafPars  ()       = 0; ///< input transformation parameters (opalsGeorefApprox)
      };
 
      /// Partial specialization for Names::stripList _OPALS_COMMENT_AFTER_("a list strip (opalsGeorefApprox
      template<class Opt, class... Opts>
      struct IAccS<Names::stripList  , Opt, Opts...> : ///< a list strip (opalsGeorefApprox)
        IAcc<Opts...>
      {
        virtual const Opt& stripList  () const = 0; ///< a list strip (opalsGeorefApprox)
        virtual       Opt& stripList  ()       = 0; ///< a list strip (opalsGeorefApprox)
      };
 
      /// Partial specialization for Names::pairList _OPALS_COMMENT_AFTER_("a list strip pairs (e.g. opalsOverlap
      template<class Opt, class... Opts>
      struct IAccS<Names::pairList  , Opt, Opts...> : ///< a list strip pairs (e.g. opalsOverlap)
        IAcc<Opts...>
      {
        virtual const Opt& pairList  () const = 0; ///< a list strip pairs (e.g. opalsOverlap)
        virtual       Opt& pairList  ()       = 0; ///< a list strip pairs (e.g. opalsOverlap)
      };
 
      /// Partial specialization for Names::fixedStrip _OPALS_COMMENT_AFTER_("fixed strip within the adjustment (opalsGeorefApprox
      template<class Opt, class... Opts>
      struct IAccS<Names::fixedStrip  , Opt, Opts...> : ///< fixed strip within the adjustment (opalsGeorefApprox)
        IAcc<Opts...>
      {
        virtual const Opt& fixedStrip  () const = 0; ///< fixed strip within the adjustment (opalsGeorefApprox)
        virtual       Opt& fixedStrip  ()       = 0; ///< fixed strip within the adjustment (opalsGeorefApprox)
      };
 
      /// Partial specialization for Names::sigmaShift _OPALS_COMMENT_AFTER_("sigma of additional  shift observations (opalsGeorefApprox
      template<class Opt, class... Opts>
      struct IAccS<Names::sigmaShift  , Opt, Opts...> : ///< sigma of additional  shift observations (opalsGeorefApprox)
        IAcc<Opts...>
      {
        virtual const Opt& sigmaShift  () const = 0; ///< sigma of additional  shift observations (opalsGeorefApprox)
        virtual       Opt& sigmaShift  ()       = 0; ///< sigma of additional  shift observations (opalsGeorefApprox)
      };
 
      /// Partial specialization for Names::storeMetaInfo _OPALS_COMMENT_AFTER_("level of meta info that are stored (opalsNormals
      template<class Opt, class... Opts>
      struct IAccS<Names::storeMetaInfo  , Opt, Opts...> : ///< level of meta info that are stored (opalsNormals)
        IAcc<Opts...>
      {
        virtual const Opt& storeMetaInfo  () const = 0; ///< level of meta info that are stored (opalsNormals)
        virtual       Opt& storeMetaInfo  ()       = 0; ///< level of meta info that are stored (opalsNormals)
      };
 
      /// Partial specialization for Names::searchMode _OPALS_COMMENT_AFTER_("dimension of nearest neighbor search (opalsNormals
      template<class Opt, class... Opts>
      struct IAccS<Names::searchMode  , Opt, Opts...> : ///< dimension of nearest neighbor search (opalsNormals)
        IAcc<Opts...>
      {
        virtual const Opt& searchMode  () const = 0; ///< dimension of nearest neighbor search (opalsNormals)
        virtual       Opt& searchMode  ()       = 0; ///< dimension of nearest neighbor search (opalsNormals)
      };
 
      /// Partial specialization for Names::division _OPALS_COMMENT_AFTER_("division mode for surface simplification (opalsSimplify
      template<class Opt, class... Opts>
      struct IAccS<Names::division  , Opt, Opts...> : ///< division mode for surface simplification (opalsSimplify)
        IAcc<Opts...>
      {
        virtual const Opt& division  () const = 0; ///< division mode for surface simplification (opalsSimplify)
        virtual       Opt& division  ()       = 0; ///< division mode for surface simplification (opalsSimplify)
      };
 
      /// Partial specialization for Names::operation _OPALS_COMMENT_AFTER_("coordinate operation for crs transformations (opalsTranslate
      template<class Opt, class... Opts>
      struct IAccS<Names::operation  , Opt, Opts...> : ///< coordinate operation for crs transformations (opalsTranslate)
        IAcc<Opts...>
      {
        virtual const Opt& operation  () const = 0; ///< coordinate operation for crs transformations (opalsTranslate)
        virtual       Opt& operation  ()       = 0; ///< coordinate operation for crs transformations (opalsTranslate)
      };
 
      /// Partial specialization for Names::kernel
      template<class Opt, class... Opts>
      struct IAccS<Names::kernel , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& kernel () const = 0;
        virtual       Opt& kernel ()       = 0;
      };
 
      /// Partial specialization for Names::kernelSize
      template<class Opt, class... Opts>
      struct IAccS<Names::kernelSize , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& kernelSize () const = 0;
        virtual       Opt& kernelSize ()       = 0;
      };
 
      /// Partial specialization for Names::kernelShape
      template<class Opt, class... Opts>
      struct IAccS<Names::kernelShape , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& kernelShape () const = 0;
        virtual       Opt& kernelShape ()       = 0;
      };
 
      /// Partial specialization for Names::histogram _OPALS_COMMENT_AFTER_("generic histogram (opalsHisto
      template<class Opt, class... Opts>
      struct IAccS<Names::histogram  , Opt, Opts...> : ///< generic histogram (opalsHisto)
        IAcc<Opts...>
      {
        virtual const Opt& histogram  () const = 0; ///< generic histogram (opalsHisto)
        virtual       Opt& histogram  ()       = 0; ///< generic histogram (opalsHisto)
      };
 
      /// Partial specialization for Names::plotFile _OPALS_COMMENT_AFTER_("name of plot file (e.g. opalsHisto
      template<class Opt, class... Opts>
      struct IAccS<Names::plotFile  , Opt, Opts...> : ///< name of plot file (e.g. opalsHisto)
        IAcc<Opts...>
      {
        virtual const Opt& plotFile  () const = 0; ///< name of plot file (e.g. opalsHisto)
        virtual       Opt& plotFile  ()       = 0; ///< name of plot file (e.g. opalsHisto)
      };
 
      /// Partial specialization for Names::boundsType _OPALS_COMMENT_AFTER_("boundary type to use (e.g. opalsBounds
      template<class Opt, class... Opts>
      struct IAccS<Names::boundsType  , Opt, Opts...> : ///< boundary type to use (e.g. opalsBounds)
        IAcc<Opts...>
      {
        virtual const Opt& boundsType  () const = 0; ///< boundary type to use (e.g. opalsBounds)
        virtual       Opt& boundsType  ()       = 0; ///< boundary type to use (e.g. opalsBounds)
      };
 
      /// Partial specialization for Names::fillMask _OPALS_COMMENT_AFTER_("input file (vector or raster
      template<class Opt, class... Opts>
      struct IAccS<Names::fillMask  , Opt, Opts...> : ///< input file (vector or raster) containing the data mask (e.g. result of opalsBounds) (opalsFillGaps)
        IAcc<Opts...>
      {
        virtual const Opt& fillMask  () const = 0; ///< input file (vector or raster) containing the data mask (e.g. result of opalsBounds) (opalsFillGaps)
        virtual       Opt& fillMask  ()       = 0; ///< input file (vector or raster) containing the data mask (e.g. result of opalsBounds) (opalsFillGaps)
      };
 
      /// Partial specialization for Names::adaptive _OPALS_COMMENT_AFTER_("group name for opalsFillGaps fill method 'adaptive'"
      template<class Opt, class... Opts>
      struct IAccS<Names::adaptive  , Opt, Opts...> : ///< group name for opalsFillGaps fill method 'adaptive'
        IAcc<Opts...>
      {
        virtual const Opt& adaptive  () const = 0; ///< group name for opalsFillGaps fill method 'adaptive'
        virtual       Opt& adaptive  ()       = 0; ///< group name for opalsFillGaps fill method 'adaptive'
      };
 
      /// Partial specialization for Names::shading _OPALS_COMMENT_AFTER_("shading algorithm (opalsShade
      template<class Opt, class... Opts>
      struct IAccS<Names::shading  , Opt, Opts...> : ///< shading algorithm (opalsShade)
        IAcc<Opts...>
      {
        virtual const Opt& shading  () const = 0; ///< shading algorithm (opalsShade)
        virtual       Opt& shading  ()       = 0; ///< shading algorithm (opalsShade)
      };
 
      /// Partial specialization for Names::sunPosition _OPALS_COMMENT_AFTER_("sun position (opalsShade
      template<class Opt, class... Opts>
      struct IAccS<Names::sunPosition  , Opt, Opts...> : ///< sun position (opalsShade)
        IAcc<Opts...>
      {
        virtual const Opt& sunPosition  () const = 0; ///< sun position (opalsShade)
        virtual       Opt& sunPosition  ()       = 0; ///< sun position (opalsShade)
      };
 
      /// Partial specialization for Names::systemEchoWidth _OPALS_COMMENT_AFTER_("echo width of system waveform - necessary for non FWF Data (opalsRadioCal
      template<class Opt, class... Opts>
      struct IAccS<Names::systemEchoWidth  , Opt, Opts...> : ///< echo width of system waveform - necessary for non FWF Data (opalsRadioCal)
        IAcc<Opts...>
      {
        virtual const Opt& systemEchoWidth  () const = 0; ///< echo width of system waveform - necessary for non FWF Data (opalsRadioCal)
        virtual       Opt& systemEchoWidth  ()       = 0; ///< echo width of system waveform - necessary for non FWF Data (opalsRadioCal)
      };
 
      /// Partial specialization for Names::trafo _OPALS_COMMENT_AFTER_("affine 3-d transformation (opalsExport
      template<class Opt, class... Opts>
      struct IAccS<Names::trafo  , Opt, Opts...> : ///< affine 3-d transformation (opalsExport)
        IAcc<Opts...>
      {
        virtual const Opt& trafo  () const = 0; ///< affine 3-d transformation (opalsExport)
        virtual       Opt& trafo  ()       = 0; ///< affine 3-d transformation (opalsExport)
      };
 
      /// Partial specialization for Names::ignoreNoData _OPALS_COMMENT_AFTER_("ignore no-data pixels within kernel neighbourhood (opalsConvolution
      template<class Opt, class... Opts>
      struct IAccS<Names::ignoreNoData  , Opt, Opts...> : ///< ignore no-data pixels within kernel neighbourhood (opalsConvolution)
        IAcc<Opts...>
      {
        virtual const Opt& ignoreNoData  () const = 0; ///< ignore no-data pixels within kernel neighbourhood (opalsConvolution)
        virtual       Opt& ignoreNoData  ()       = 0; ///< ignore no-data pixels within kernel neighbourhood (opalsConvolution)
      };
 
      /// Partial specialization for Names::edgeHandling _OPALS_COMMENT_AFTER_("controls pixel values beyond the image border (opalsConvolution
      template<class Opt, class... Opts>
      struct IAccS<Names::edgeHandling  , Opt, Opts...> : ///< controls pixel values beyond the image border (opalsConvolution)
        IAcc<Opts...>
      {
        virtual const Opt& edgeHandling  () const = 0; ///< controls pixel values beyond the image border (opalsConvolution)
        virtual       Opt& edgeHandling  ()       = 0; ///< controls pixel values beyond the image border (opalsConvolution)
      };
 
      /// Partial specialization for Names::normalize _OPALS_COMMENT_AFTER_("normalize results (e.g. opalsConvolution
      template<class Opt, class... Opts>
      struct IAccS<Names::normalize  , Opt, Opts...> : ///< normalize results (e.g. opalsConvolution)
        IAcc<Opts...>
      {
        virtual const Opt& normalize  () const = 0; ///< normalize results (e.g. opalsConvolution)
        virtual       Opt& normalize  ()       = 0; ///< normalize results (e.g. opalsConvolution)
      };
 
      /// Partial specialization for Names::mounting _OPALS_COMMENT_AFTER_("mounting calibration parameters (e.g. opalsDirectGeoref
      template<class Opt, class... Opts>
      struct IAccS<Names::mounting  , Opt, Opts...> : ///< mounting calibration parameters (e.g. opalsDirectGeoref))
        IAcc<Opts...>
      {
        virtual const Opt& mounting  () const = 0; ///< mounting calibration parameters (e.g. opalsDirectGeoref))
        virtual       Opt& mounting  ()       = 0; ///< mounting calibration parameters (e.g. opalsDirectGeoref))
      };
 
      /// Partial specialization for Names::resetSegId
      template<class Opt, class... Opts>
      struct IAccS<Names::resetSegId , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& resetSegId () const = 0;
        virtual       Opt& resetSegId ()       = 0;
      };
 
      /// Partial specialization for Names::minSegSize
      template<class Opt, class... Opts>
      struct IAccS<Names::minSegSize , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& minSegSize () const = 0;
        virtual       Opt& minSegSize ()       = 0;
      };
 
      /// Partial specialization for Names::weightFunc
      template<class Opt, class... Opts>
      struct IAccS<Names::weightFunc , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& weightFunc () const = 0;
        virtual       Opt& weightFunc ()       = 0;
      };
 
      /// Partial specialization for Names::sigmaApriori _OPALS_COMMENT_AFTER_("estimated accuracy of observations before adjustment (opalsRobFilter
      template<class Opt, class... Opts>
      struct IAccS<Names::sigmaApriori  , Opt, Opts...> : ///< estimated accuracy of observations before adjustment (opalsRobFilter)
        IAcc<Opts...>
      {
        virtual const Opt& sigmaApriori  () const = 0; ///< estimated accuracy of observations before adjustment (opalsRobFilter)
        virtual       Opt& sigmaApriori  ()       = 0; ///< estimated accuracy of observations before adjustment (opalsRobFilter)
      };
 
      /// Partial specialization for Names::robustWFAdpation _OPALS_COMMENT_AFTER_("adaptations of the robust weight function (opalsRobFilter
      template<class Opt, class... Opts>
      struct IAccS<Names::robustWFAdpation  , Opt, Opts...> : ///< adaptations of the robust weight function (opalsRobFilter)
        IAcc<Opts...>
      {
        virtual const Opt& robustWFAdpation  () const = 0; ///< adaptations of the robust weight function (opalsRobFilter)
        virtual       Opt& robustWFAdpation  ()       = 0; ///< adaptations of the robust weight function (opalsRobFilter)
      };
 
      /// Partial specialization for Names::penetration _OPALS_COMMENT_AFTER_("estimated penetration rate"
      template<class Opt, class... Opts>
      struct IAccS<Names::penetration  , Opt, Opts...> : ///< estimated penetration rate
        IAcc<Opts...>
      {
        virtual const Opt& penetration  () const = 0; ///< estimated penetration rate
        virtual       Opt& penetration  ()       = 0; ///< estimated penetration rate
      };
 
      /// Partial specialization for Names::direction _OPALS_COMMENT_AFTER_("normals direction (e.g. opalsNormals
      template<class Opt, class... Opts>
      struct IAccS<Names::direction  , Opt, Opts...> : ///< normals direction (e.g. opalsNormals)
        IAcc<Opts...>
      {
        virtual const Opt& direction  () const = 0; ///< normals direction (e.g. opalsNormals)
        virtual       Opt& direction  ()       = 0; ///< normals direction (e.g. opalsNormals)
      };
 
      /// Partial specialization for Names::snapRadius _OPALS_COMMENT_AFTER_("snap radius (e.g. opalsTIN: used for connecting close line endings
      template<class Opt, class... Opts>
      struct IAccS<Names::snapRadius  , Opt, Opts...> : ///< snap radius (e.g. opalsTIN: used for connecting close line endings)
        IAcc<Opts...>
      {
        virtual const Opt& snapRadius  () const = 0; ///< snap radius (e.g. opalsTIN: used for connecting close line endings)
        virtual       Opt& snapRadius  ()       = 0; ///< snap radius (e.g. opalsTIN: used for connecting close line endings)
      };
 
      /// Partial specialization for Names::borderFile _OPALS_COMMENT_AFTER_("border file path (e.g. opalsTIN
      template<class Opt, class... Opts>
      struct IAccS<Names::borderFile  , Opt, Opts...> : ///< border file path (e.g. opalsTIN)
        IAcc<Opts...>
      {
        virtual const Opt& borderFile  () const = 0; ///< border file path (e.g. opalsTIN)
        virtual       Opt& borderFile  ()       = 0; ///< border file path (e.g. opalsTIN)
      };
 
      /// Partial specialization for Names::overlapFile _OPALS_COMMENT_AFTER_("overlap file path (e.g. opalsOverlap
      template<class Opt, class... Opts>
      struct IAccS<Names::overlapFile  , Opt, Opts...> : ///< overlap file path (e.g. opalsOverlap )
        IAcc<Opts...>
      {
        virtual const Opt& overlapFile  () const = 0; ///< overlap file path (e.g. opalsOverlap )
        virtual       Opt& overlapFile  ()       = 0; ///< overlap file path (e.g. opalsOverlap )
      };
 
      /// Partial specialization for Names::compressCollinear _OPALS_COMMENT_AFTER_("export/store first and last vertices only of a series of collinear vertices (e.g. opalsContouring
      template<class Opt, class... Opts>
      struct IAccS<Names::compressCollinear  , Opt, Opts...> : ///< export/store first and last vertices only of a series of collinear vertices (e.g. opalsContouring)
        IAcc<Opts...>
      {
        virtual const Opt& compressCollinear  () const = 0; ///< export/store first and last vertices only of a series of collinear vertices (e.g. opalsContouring)
        virtual       Opt& compressCollinear  ()       = 0; ///< export/store first and last vertices only of a series of collinear vertices (e.g. opalsContouring)
      };
 
      /// Partial specialization for Names::statistic _OPALS_COMMENT_AFTER_("general statistic information about a given input file (opalsInfo
      template<class Opt, class... Opts>
      struct IAccS<Names::statistic  , Opt, Opts...> : ///< general statistic information about a given input file (opalsInfo)
        IAcc<Opts...>
      {
        virtual const Opt& statistic  () const = 0; ///< general statistic information about a given input file (opalsInfo)
        virtual       Opt& statistic  ()       = 0; ///< general statistic information about a given input file (opalsInfo)
      };
 
      /// Partial specialization for Names::convThreshold _OPALS_COMMENT_AFTER_("adjustment convergence threshold (opalsGeorefApprox
      template<class Opt, class... Opts>
      struct IAccS<Names::convThreshold  , Opt, Opts...> : ///< adjustment convergence threshold (opalsGeorefApprox)
        IAcc<Opts...>
      {
        virtual const Opt& convThreshold  () const = 0; ///< adjustment convergence threshold (opalsGeorefApprox)
        virtual       Opt& convThreshold  ()       = 0; ///< adjustment convergence threshold (opalsGeorefApprox)
      };
 
      /// Partial specialization for Names::refModel _OPALS_COMMENT_AFTER_("defines a reference model (e.g., horizontal/tilted plane or raster model
      template<class Opt, class... Opts>
      struct IAccS<Names::refModel  , Opt, Opts...> : ///< defines a reference model (e.g., horizontal/tilted plane or raster model)
        IAcc<Opts...>
      {
        virtual const Opt& refModel  () const = 0; ///< defines a reference model (e.g., horizontal/tilted plane or raster model)
        virtual       Opt& refModel  ()       = 0; ///< defines a reference model (e.g., horizontal/tilted plane or raster model)
      };
 
      /// Partial specialization for Names::inSRS _OPALS_COMMENT_AFTER_("input spatial reference system as WKT/proj4 description string or EPSG code (opalsReproject
      template<class Opt, class... Opts>
      struct IAccS<Names::inSRS  , Opt, Opts...> : ///< input spatial reference system as WKT/proj4 description string or EPSG code (opalsReproject)
        IAcc<Opts...>
      {
        virtual const Opt& inSRS  () const = 0; ///< input spatial reference system as WKT/proj4 description string or EPSG code (opalsReproject)
        virtual       Opt& inSRS  ()       = 0; ///< input spatial reference system as WKT/proj4 description string or EPSG code (opalsReproject)
      };
 
      /// Partial specialization for Names::outSRS _OPALS_COMMENT_AFTER_("output spatial reference system as WKT/proj4 description string or EPSG code (opalsReproject
      template<class Opt, class... Opts>
      struct IAccS<Names::outSRS  , Opt, Opts...> : ///< output spatial reference system as WKT/proj4 description string or EPSG code (opalsReproject)
        IAcc<Opts...>
      {
        virtual const Opt& outSRS  () const = 0; ///< output spatial reference system as WKT/proj4 description string or EPSG code (opalsReproject)
        virtual       Opt& outSRS  ()       = 0; ///< output spatial reference system as WKT/proj4 description string or EPSG code (opalsReproject)
      };
 
      /// Partial specialization for Names::inGeoid _OPALS_COMMENT_AFTER_("input geoid model raster file (opalsReproject
      template<class Opt, class... Opts>
      struct IAccS<Names::inGeoid  , Opt, Opts...> : ///< input geoid model raster file (opalsReproject)
        IAcc<Opts...>
      {
        virtual const Opt& inGeoid  () const = 0; ///< input geoid model raster file (opalsReproject)
        virtual       Opt& inGeoid  ()       = 0; ///< input geoid model raster file (opalsReproject)
      };
 
      /// Partial specialization for Names::outGeoid _OPALS_COMMENT_AFTER_("output geoid model raster file (opalsReproject
      template<class Opt, class... Opts>
      struct IAccS<Names::outGeoid  , Opt, Opts...> : ///< output geoid model raster file (opalsReproject)
        IAcc<Opts...>
      {
        virtual const Opt& outGeoid  () const = 0; ///< output geoid model raster file (opalsReproject)
        virtual       Opt& outGeoid  ()       = 0; ///< output geoid model raster file (opalsReproject)
      };
 
      /// Partial specialization for Names::inZOffset _OPALS_COMMENT_AFTER_("height offset of input SRS (opalsReproject
      template<class Opt, class... Opts>
      struct IAccS<Names::inZOffset  , Opt, Opts...> : ///< height offset of input SRS (opalsReproject)
        IAcc<Opts...>
      {
        virtual const Opt& inZOffset  () const = 0; ///< height offset of input SRS (opalsReproject)
        virtual       Opt& inZOffset  ()       = 0; ///< height offset of input SRS (opalsReproject)
      };
 
      /// Partial specialization for Names::outZOffset _OPALS_COMMENT_AFTER_("height offset of output SRS (opalsReproject
      template<class Opt, class... Opts>
      struct IAccS<Names::outZOffset  , Opt, Opts...> : ///< height offset of output SRS (opalsReproject)
        IAcc<Opts...>
      {
        virtual const Opt& outZOffset  () const = 0; ///< height offset of output SRS (opalsReproject)
        virtual       Opt& outZOffset  ()       = 0; ///< height offset of output SRS (opalsReproject)
      };
 
      /// Partial specialization for Names::debugNormalsLen _OPALS_COMMENT_AFTER_("length of the normal vectors (opalsNormals
      template<class Opt, class... Opts>
      struct IAccS<Names::debugNormalsLen  , Opt, Opts...> : ///< length of the normal vectors (opalsNormals)
        IAcc<Opts...>
      {
        virtual const Opt& debugNormalsLen  () const = 0; ///< length of the normal vectors (opalsNormals)
        virtual       Opt& debugNormalsLen  ()       = 0; ///< length of the normal vectors (opalsNormals)
      };
 
      /// Partial specialization for Names::refractiveIndex _OPALS_COMMENT_AFTER_("refractive index (e.g. opalsSnellius
      template<class Opt, class... Opts>
      struct IAccS<Names::refractiveIndex  , Opt, Opts...> : ///< refractive index (e.g. opalsSnellius)
        IAcc<Opts...>
      {
        virtual const Opt& refractiveIndex  () const = 0; ///< refractive index (e.g. opalsSnellius)
        virtual       Opt& refractiveIndex  ()       = 0; ///< refractive index (e.g. opalsSnellius)
      };
 
      /// Partial specialization for Names::mtaZone _OPALS_COMMENT_AFTER_("defines the MTA zone to resolve ambiguities of multiple-pluses-in-air-scanners (opalsFullwave
      template<class Opt, class... Opts>
      struct IAccS<Names::mtaZone  , Opt, Opts...> : ///< defines the MTA zone to resolve ambiguities of multiple-pluses-in-air-scanners (opalsFullwave)
        IAcc<Opts...>
      {
        virtual const Opt& mtaZone  () const = 0; ///< defines the MTA zone to resolve ambiguities of multiple-pluses-in-air-scanners (opalsFullwave)
        virtual       Opt& mtaZone  ()       = 0; ///< defines the MTA zone to resolve ambiguities of multiple-pluses-in-air-scanners (opalsFullwave)
      };
 
      /// Partial specialization for Names::timeRange _OPALS_COMMENT_AFTER_("process only a subset of the data the given time range (opalsFullwave
      template<class Opt, class... Opts>
      struct IAccS<Names::timeRange  , Opt, Opts...> : ///< process only a subset of the data the given time range (opalsFullwave)
        IAcc<Opts...>
      {
        virtual const Opt& timeRange  () const = 0; ///< process only a subset of the data the given time range (opalsFullwave)
        virtual       Opt& timeRange  ()       = 0; ///< process only a subset of the data the given time range (opalsFullwave)
      };
 
      /// Partial specialization for Names::skipVoidAreas _OPALS_COMMENT_AFTER_("skip all void parts of datasets for data processing (opalsALgebra
      template<class Opt, class... Opts>
      struct IAccS<Names::skipVoidAreas  , Opt, Opts...> : ///< skip all void parts of datasets for data processing (opalsALgebra)
        IAcc<Opts...>
      {
        virtual const Opt& skipVoidAreas  () const = 0; ///< skip all void parts of datasets for data processing (opalsALgebra)
        virtual       Opt& skipVoidAreas  ()       = 0; ///< skip all void parts of datasets for data processing (opalsALgebra)
      };
 
      /// Partial specialization for Names::tFormat _OPALS_COMMENT_AFTER_("file format of the trajectory file (opalsImport
      template<class Opt, class... Opts>
      struct IAccS<Names::tFormat  , Opt, Opts...> : ///< file format of the trajectory file (opalsImport)
        IAcc<Opts...>
      {
        virtual const Opt& tFormat  () const = 0; ///< file format of the trajectory file (opalsImport)
        virtual       Opt& tFormat  ()       = 0; ///< file format of the trajectory file (opalsImport)
      };
 
      /// Partial specialization for Names::storeBeamInfo _OPALS_COMMENT_AFTER_("defines beam information that is attached during import (opalsImport
      template<class Opt, class... Opts>
      struct IAccS<Names::storeBeamInfo  , Opt, Opts...> : ///< defines beam information that is attached during import (opalsImport)
        IAcc<Opts...>
      {
        virtual const Opt& storeBeamInfo  () const = 0; ///< defines beam information that is attached during import (opalsImport)
        virtual       Opt& storeBeamInfo  ()       = 0; ///< defines beam information that is attached during import (opalsImport)
      };
 
      /// Partial specialization for Names::inGeometry _OPALS_COMMENT_AFTER_("input (OGC
      template<class Opt, class... Opts>
      struct IAccS<Names::inGeometry  , Opt, Opts...> : ///< input (OGC) geometry
        IAcc<Opts...>
      {
        virtual const Opt& inGeometry  () const = 0; ///< input (OGC) geometry
        virtual       Opt& inGeometry  ()       = 0; ///< input (OGC) geometry
      };
 
      /// Partial specialization for Names::outGeometry _OPALS_COMMENT_AFTER_("output (OGC
      template<class Opt, class... Opts>
      struct IAccS<Names::outGeometry  , Opt, Opts...> : ///< output (OGC) geometry
        IAcc<Opts...>
      {
        virtual const Opt& outGeometry  () const = 0; ///< output (OGC) geometry
        virtual       Opt& outGeometry  ()       = 0; ///< output (OGC) geometry
      };
 
      /// Partial specialization for Names::probabilities _OPALS_COMMENT_AFTER_("(list of
      template<class Opt, class... Opts>
      struct IAccS<Names::probabilities  , Opt, Opts...> : ///< (list of) probability values [0..1] (opalsHisto))
        IAcc<Opts...>
      {
        virtual const Opt& probabilities  () const = 0; ///< (list of) probability values [0..1] (opalsHisto))
        virtual       Opt& probabilities  ()       = 0; ///< (list of) probability values [0..1] (opalsHisto))
      };
 
      /// Partial specialization for Names::sectionRange _OPALS_COMMENT_AFTER_("start/stop stationing along the axis(opalsSection
      template<class Opt, class... Opts>
      struct IAccS<Names::sectionRange  , Opt, Opts...> : ///< start/stop stationing along the axis(opalsSection))
        IAcc<Opts...>
      {
        virtual const Opt& sectionRange  () const = 0; ///< start/stop stationing along the axis(opalsSection))
        virtual       Opt& sectionRange  ()       = 0; ///< start/stop stationing along the axis(opalsSection))
      };
 
      /// Partial specialization for Names::aoi
      template<class Opt, class... Opts>
      struct IAccS<Names::aoi , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& aoi () const = 0;
        virtual       Opt& aoi ()       = 0;
      };
 
      /// Partial specialization for Names::inDimension
      template<class Opt, class... Opts>
      struct IAccS<Names::inDimension , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& inDimension () const = 0;
        virtual       Opt& inDimension ()       = 0;
      };
 
      /// Partial specialization for Names::outResults
      template<class Opt, class... Opts>
      struct IAccS<Names::outResults , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& outResults () const = 0;
        virtual       Opt& outResults ()       = 0;
      };
 
      /// Partial specialization for Names::geometryModel
      template<class Opt, class... Opts>
      struct IAccS<Names::geometryModel , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& geometryModel () const = 0;
        virtual       Opt& geometryModel ()       = 0;
      };
 
      /// Partial specialization for Names::calculationMode
      template<class Opt, class... Opts>
      struct IAccS<Names::calculationMode , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& calculationMode () const = 0;
        virtual       Opt& calculationMode ()       = 0;
      };
 
      /// Partial specialization for Names::perimeter
      template<class Opt, class... Opts>
      struct IAccS<Names::perimeter , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& perimeter () const = 0;
        virtual       Opt& perimeter ()       = 0;
      };
 
      /// Partial specialization for Names::area
      template<class Opt, class... Opts>
      struct IAccS<Names::area , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& area () const = 0;
        virtual       Opt& area ()       = 0;
      };
 
      /// Partial specialization for Names::initValue _OPALS_COMMENT_AFTER_("initialization value for specified cell (eg, opalsRasterize
      template<class Opt, class... Opts>
      struct IAccS<Names::initValue  , Opt, Opts...> : ///< initialization value for specified cell (eg, opalsRasterize)
        IAcc<Opts...>
      {
        virtual const Opt& initValue  () const = 0; ///< initialization value for specified cell (eg, opalsRasterize)
        virtual       Opt& initValue  ()       = 0; ///< initialization value for specified cell (eg, opalsRasterize)
      };
 
      /// Partial specialization for Names::samplingDist _OPALS_COMMENT_AFTER_("defines a uniform sampling distance (eg, opalsICP
      template<class Opt, class... Opts>
      struct IAccS<Names::samplingDist  , Opt, Opts...> : ///< defines a uniform sampling distance (eg, opalsICP)
        IAcc<Opts...>
      {
        virtual const Opt& samplingDist  () const = 0; ///< defines a uniform sampling distance (eg, opalsICP)
        virtual       Opt& samplingDist  ()       = 0; ///< defines a uniform sampling distance (eg, opalsICP)
      };
 
      /// Partial specialization for Names::lineVertexDist _OPALS_COMMENT_AFTER_("Regular distance for vertex spacing along linear geometries"
      template<class Opt, class... Opts>
      struct IAccS<Names::lineVertexDist  , Opt, Opts...> : ///< Regular distance for vertex spacing along linear geometries
        IAcc<Opts...>
      {
        virtual const Opt& lineVertexDist  () const = 0; ///< Regular distance for vertex spacing along linear geometries
        virtual       Opt& lineVertexDist  ()       = 0; ///< Regular distance for vertex spacing along linear geometries
      };
 
      /// Partial specialization for Names::lineBufferDist _OPALS_COMMENT_AFTER_("Line buffer distance "
      template<class Opt, class... Opts>
      struct IAccS<Names::lineBufferDist  , Opt, Opts...> : ///< Line buffer distance
        IAcc<Opts...>
      {
        virtual const Opt& lineBufferDist  () const = 0; ///< Line buffer distance
        virtual       Opt& lineBufferDist  ()       = 0; ///< Line buffer distance
      };
 
      /// Partial specialization for Names::modelPlaneThreshold _OPALS_COMMENT_AFTER_("defines a vertical distance threshold between a model and a plane (opalsModelFormAxis
      template<class Opt, class... Opts>
      struct IAccS<Names::modelPlaneThreshold  , Opt, Opts...> : ///< defines a vertical distance threshold between a model and a plane (opalsModelFormAxis)
        IAcc<Opts...>
      {
        virtual const Opt& modelPlaneThreshold  () const = 0; ///< defines a vertical distance threshold between a model and a plane (opalsModelFormAxis)
        virtual       Opt& modelPlaneThreshold  ()       = 0; ///< defines a vertical distance threshold between a model and a plane (opalsModelFormAxis)
      };
 
      /// Partial specialization for Names::redPoint _OPALS_COMMENT_AFTER_("defines the coordinates of a reduction point"
      template<class Opt, class... Opts>
      struct IAccS<Names::redPoint  , Opt, Opts...> : ///< defines the coordinates of a reduction point
        IAcc<Opts...>
      {
        virtual const Opt& redPoint  () const = 0; ///< defines the coordinates of a reduction point
        virtual       Opt& redPoint  ()       = 0; ///< defines the coordinates of a reduction point
      };
 
      /// Partial specialization for Names::plot
      template<class Opt, class... Opts>
      struct IAccS<Names::plot , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& plot () const = 0;
        virtual       Opt& plot ()       = 0;
      };
 
      /// Partial specialization for Names::subsetRadius
      template<class Opt, class... Opts>
      struct IAccS<Names::subsetRadius , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& subsetRadius () const = 0;
        virtual       Opt& subsetRadius ()       = 0;
      };
 
      /// Partial specialization for Names::outDirectory _OPALS_COMMENT_AFTER_("name of output directory"
      template<class Opt, class... Opts>
      struct IAccS<Names::outDirectory  , Opt, Opts...> : ///< name of output directory
        IAcc<Opts...>
      {
        virtual const Opt& outDirectory  () const = 0; ///< name of output directory
        virtual       Opt& outDirectory  ()       = 0; ///< name of output directory
      };
 
      /// Partial specialization for Names::tempDirectory _OPALS_COMMENT_AFTER_("name of temporary directory"
      template<class Opt, class... Opts>
      struct IAccS<Names::tempDirectory  , Opt, Opts...> : ///< name of temporary directory
        IAcc<Opts...>
      {
        virtual const Opt& tempDirectory  () const = 0; ///< name of temporary directory
        virtual       Opt& tempDirectory  ()       = 0; ///< name of temporary directory
      };
 
      /// Partial specialization for Names::transformData _OPALS_COMMENT_AFTER_("boolean flag indicating whether or not to transform the input data (eg. opalsICP
      template<class Opt, class... Opts>
      struct IAccS<Names::transformData  , Opt, Opts...> : ///< boolean flag indicating whether or not to transform the input data (eg. opalsICP)
        IAcc<Opts...>
      {
        virtual const Opt& transformData  () const = 0; ///< boolean flag indicating whether or not to transform the input data (eg. opalsICP)
        virtual       Opt& transformData  ()       = 0; ///< boolean flag indicating whether or not to transform the input data (eg. opalsICP)
      };
 
      /// Partial specialization for Names::fixedFile _OPALS_COMMENT_AFTER_("fixed dataset within adjustment (opalsICP
      template<class Opt, class... Opts>
      struct IAccS<Names::fixedFile  , Opt, Opts...> : ///< fixed dataset within adjustment (opalsICP)
        IAcc<Opts...>
      {
        virtual const Opt& fixedFile  () const = 0; ///< fixed dataset within adjustment (opalsICP)
        virtual       Opt& fixedFile  ()       = 0; ///< fixed dataset within adjustment (opalsICP)
      };
 
      /// Partial specialization for Names::normalSpaceSampling
      template<class Opt, class... Opts>
      struct IAccS<Names::normalSpaceSampling , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& normalSpaceSampling () const = 0;
        virtual       Opt& normalSpaceSampling ()       = 0;
      };
 
      /// Partial specialization for Names::maxLeverageSampling
      template<class Opt, class... Opts>
      struct IAccS<Names::maxLeverageSampling , Opt, Opts...> :
        IAcc<Opts...>
      {
        virtual const Opt& maxLeverageSampling () const = 0;
        virtual       Opt& maxLeverageSampling ()       = 0;
      };
 
      /// Partial specialization for Names::multiBand _OPALS_COMMENT_AFTER_("used by opalsGrid to enable or disable multibans instead of multiple files for features.."
      template<class Opt, class... Opts>
      struct IAccS<Names::multiBand  , Opt, Opts...> : ///< used by opalsGrid to enable or disable multibans instead of multiple files for features..
        IAcc<Opts...>
      {
        virtual const Opt& multiBand  () const = 0; ///< used by opalsGrid to enable or disable multibans instead of multiple files for features..
        virtual       Opt& multiBand  ()       = 0; ///< used by opalsGrid to enable or disable multibans instead of multiple files for features..
      };
 
      /// Partial specialization for Names::storeStatistics _OPALS_COMMENT_AFTER_("used by zonal fit to store statistics as attribute in ODM file."
      template<class Opt, class... Opts>
      struct IAccS<Names::storeStatistics  , Opt, Opts...> : ///< used by zonal fit to store statistics as attribute in ODM file.
        IAcc<Opts...>
      {
        virtual const Opt& storeStatistics  () const = 0; ///< used by zonal fit to store statistics as attribute in ODM file.
        virtual       Opt& storeStatistics  ()       = 0; ///< used by zonal fit to store statistics as attribute in ODM file.
      };
 
      /// Partial specialization for Names::approxFile _OPALS_COMMENT_AFTER_("File containing approximation info."
      template<class Opt, class... Opts>
      struct IAccS<Names::approxFile  , Opt, Opts...> : ///< File containing approximation info.
        IAcc<Opts...>
      {
        virtual const Opt& approxFile  () const = 0; ///< File containing approximation info.
        virtual       Opt& approxFile  ()       = 0; ///< File containing approximation info.
      };
 
      /// Partial specialization for Names::procMode _OPALS_COMMENT_AFTER_("processing mode"
      template<class Opt, class... Opts>
      struct IAccS<Names::procMode  , Opt, Opts...> : ///< processing mode
        IAcc<Opts...>
      {
        virtual const Opt& procMode  () const = 0; ///< processing mode
        virtual       Opt& procMode  ()       = 0; ///< processing mode
      };
 
      /// Partial specialization for Names::suppressRungs _OPALS_COMMENT_AFTER_("remove all one-pixel-diagonal line elements (opalsVectorize, toPolyline
      template<class Opt, class... Opts>
      struct IAccS<Names::suppressRungs  , Opt, Opts...> : ///< remove all one-pixel-diagonal line elements (opalsVectorize, toPolyline)
        IAcc<Opts...>
      {
        virtual const Opt& suppressRungs  () const = 0; ///< remove all one-pixel-diagonal line elements (opalsVectorize, toPolyline)
        virtual       Opt& suppressRungs  ()       = 0; ///< remove all one-pixel-diagonal line elements (opalsVectorize, toPolyline)
      };
 
      /// Partial specialization for Names::processId _OPALS_COMMENT_AFTER_("defining a list of ids to process (opalsLineModeler
      template<class Opt, class... Opts>
      struct IAccS<Names::processId  , Opt, Opts...> : ///< defining a list of ids to process (opalsLineModeler)
        IAcc<Opts...>
      {
        virtual const Opt& processId  () const = 0; ///< defining a list of ids to process (opalsLineModeler)
        virtual       Opt& processId  ()       = 0; ///< defining a list of ids to process (opalsLineModeler)
      };
 
      /// Partial specialization for Names::ignoreId _OPALS_COMMENT_AFTER_("defining a list of ids to be ignored (opalsLineModeler
      template<class Opt, class... Opts>
      struct IAccS<Names::ignoreId  , Opt, Opts...> : ///< defining a list of ids to be ignored (opalsLineModeler)
        IAcc<Opts...>
      {
        virtual const Opt& ignoreId  () const = 0; ///< defining a list of ids to be ignored (opalsLineModeler)
        virtual       Opt& ignoreId  ()       = 0; ///< defining a list of ids to be ignored (opalsLineModeler)
      };
 
      /// Partial specialization for Names::criterion _OPALS_COMMENT_AFTER_("defining the segment homogeneity criterion (opalsSegmentation
      template<class Opt, class... Opts>
      struct IAccS<Names::criterion  , Opt, Opts...> : ///< defining the segment homogeneity criterion (opalsSegmentation)
        IAcc<Opts...>
      {
        virtual const Opt& criterion  () const = 0; ///< defining the segment homogeneity criterion (opalsSegmentation)
        virtual       Opt& criterion  ()       = 0; ///< defining the segment homogeneity criterion (opalsSegmentation)
      };
 
      /// Partial specialization for Names::minHeight _OPALS_COMMENT_AFTER_("minimum (object
      template<class Opt, class... Opts>
      struct IAccS<Names::minHeight  , Opt, Opts...> : ///< minimum (object) height
        IAcc<Opts...>
      {
        virtual const Opt& minHeight  () const = 0; ///< minimum (object) height
        virtual       Opt& minHeight  ()       = 0; ///< minimum (object) height
      };
 
      /// Partial specialization for Names::maxWidth _OPALS_COMMENT_AFTER_("maximum (object
      template<class Opt, class... Opts>
      struct IAccS<Names::maxWidth  , Opt, Opts...> : ///< maximum (object) width
        IAcc<Opts...>
      {
        virtual const Opt& maxWidth  () const = 0; ///< maximum (object) width
        virtual       Opt& maxWidth  ()       = 0; ///< maximum (object) width
      };
 
      /// Partial specialization for Names::minConsensus _OPALS_COMMENT_AFTER_("minimum level of consensus"
      template<class Opt, class... Opts>
      struct IAccS<Names::minConsensus  , Opt, Opts...> : ///< minimum level of consensus
        IAcc<Opts...>
      {
        virtual const Opt& minConsensus  () const = 0; ///< minimum level of consensus
        virtual       Opt& minConsensus  ()       = 0; ///< minimum level of consensus
      };
 
      /// Partial specialization for Names::mergePolygon _OPALS_COMMENT_AFTER_("merge polygon method (eg. opalsImport
      template<class Opt, class... Opts>
      struct IAccS<Names::mergePolygon  , Opt, Opts...> : ///< merge polygon method (eg. opalsImport)
        IAcc<Opts...>
      {
        virtual const Opt& mergePolygon  () const = 0; ///< merge polygon method (eg. opalsImport)
        virtual       Opt& mergePolygon  ()       = 0; ///< merge polygon method (eg. opalsImport)
      };
 
      /// Partial specialization for Names::thinOut _OPALS_COMMENT_AFTER_("thin out contour lines (opalsIsolines
      template<class Opt, class... Opts>
      struct IAccS<Names::thinOut  , Opt, Opts...> : ///< thin out contour lines (opalsIsolines)
        IAcc<Opts...>
      {
        virtual const Opt& thinOut  () const = 0; ///< thin out contour lines (opalsIsolines)
        virtual       Opt& thinOut  ()       = 0; ///< thin out contour lines (opalsIsolines)
      };
 
      /// Partial specialization for Names::closeMin _OPALS_COMMENT_AFTER_("suppress closed contours with area < closeMin (opalsIsolines
      template<class Opt, class... Opts>
      struct IAccS<Names::closeMin  , Opt, Opts...> : ///< suppress closed contours with area < closeMin (opalsIsolines)
        IAcc<Opts...>
      {
        virtual const Opt& closeMin  () const = 0; ///< suppress closed contours with area < closeMin (opalsIsolines)
        virtual       Opt& closeMin  ()       = 0; ///< suppress closed contours with area < closeMin (opalsIsolines)
      };
 
      /// Partial specialization for Names::densification _OPALS_COMMENT_AFTER_("densification mode (opalsIsolines
      template<class Opt, class... Opts>
      struct IAccS<Names::densification  , Opt, Opts...> : ///< densification mode (opalsIsolines)
        IAcc<Opts...>
      {
        virtual const Opt& densification  () const = 0; ///< densification mode (opalsIsolines)
        virtual       Opt& densification  ()       = 0; ///< densification mode (opalsIsolines)
      };
 
      /// Partial specialization for Names::detector _OPALS_COMMENT_AFTER_("edge detection method (opalsEdgeDetect
      template<class Opt, class... Opts>
      struct IAccS<Names::detector  , Opt, Opts...> : ///< edge detection method (opalsEdgeDetect)
        IAcc<Opts...>
      {
        virtual const Opt& detector  () const = 0; ///< edge detection method (opalsEdgeDetect)
        virtual       Opt& detector  ()       = 0; ///< edge detection method (opalsEdgeDetect)
      };
 
      /// Partial specialization for Names::threshold _OPALS_COMMENT_AFTER_("threshold (opalsEdgeDetect
      template<class Opt, class... Opts>
      struct IAccS<Names::threshold  , Opt, Opts...> : ///< threshold (opalsEdgeDetect)
        IAcc<Opts...>
      {
        virtual const Opt& threshold  () const = 0; ///< threshold (opalsEdgeDetect)
        virtual       Opt& threshold  ()       = 0; ///< threshold (opalsEdgeDetect)
      };
 
      /// Partial specialization for Names::method _OPALS_COMMENT_AFTER_("method of computation (opalsFillGaps, opalsLineTopology
      template<class Opt, class... Opts>
      struct IAccS<Names::method  , Opt, Opts...> : ///< method of computation (opalsFillGaps, opalsLineTopology)
        IAcc<Opts...>
      {
        virtual const Opt& method  () const = 0; ///< method of computation (opalsFillGaps, opalsLineTopology)
        virtual       Opt& method  ()       = 0; ///< method of computation (opalsFillGaps, opalsLineTopology)
      };
 
      /// Partial specialization for Names::boundaryRatio _OPALS_COMMENT_AFTER_("ratio between the valid boundary pixel of a gap and the number of gap-pixel that lie on the image boundary (opalsFillGaps
      template<class Opt, class... Opts>
      struct IAccS<Names::boundaryRatio  , Opt, Opts...> : ///< ratio between the valid boundary pixel of a gap and the number of gap-pixel that lie on the image boundary (opalsFillGaps)
        IAcc<Opts...>
      {
        virtual const Opt& boundaryRatio  () const = 0; ///< ratio between the valid boundary pixel of a gap and the number of gap-pixel that lie on the image boundary (opalsFillGaps)
        virtual       Opt& boundaryRatio  ()       = 0; ///< ratio between the valid boundary pixel of a gap and the number of gap-pixel that lie on the image boundary (opalsFillGaps)
      };
 
      /// Partial specialization for Names::avgDist _OPALS_COMMENT_AFTER_("average distance (opalsLineTopology
      template<class Opt, class... Opts>
      struct IAccS<Names::avgDist  , Opt, Opts...> : ///< average distance (opalsLineTopology)
        IAcc<Opts...>
      {
        virtual const Opt& avgDist  () const = 0; ///< average distance (opalsLineTopology)
        virtual       Opt& avgDist  ()       = 0; ///< average distance (opalsLineTopology)
      };
 
      /// Partial specialization for Names::merge _OPALS_COMMENT_AFTER_("Parameter group 'merge' (opalsLineTopology
      template<class Opt, class... Opts>
      struct IAccS<Names::merge  , Opt, Opts...> : ///< Parameter group 'merge' (opalsLineTopology)
        IAcc<Opts...>
      {
        virtual const Opt& merge  () const = 0; ///< Parameter group 'merge' (opalsLineTopology)
        virtual       Opt& merge  ()       = 0; ///< Parameter group 'merge' (opalsLineTopology)
      };
 
      /// Partial specialization for Names::minWeight _OPALS_COMMENT_AFTER_("minimum weight (opalsLineTopology
      template<class Opt, class... Opts>
      struct IAccS<Names::minWeight  , Opt, Opts...> : ///< minimum weight (opalsLineTopology)
        IAcc<Opts...>
      {
        virtual const Opt& minWeight  () const = 0; ///< minimum weight (opalsLineTopology)
        virtual       Opt& minWeight  ()       = 0; ///< minimum weight (opalsLineTopology)
      };
 
      /// Partial specialization for Names::relWeightLead _OPALS_COMMENT_AFTER_("relative weight lead (opalsLineTopology
      template<class Opt, class... Opts>
      struct IAccS<Names::relWeightLead  , Opt, Opts...> : ///< relative weight lead (opalsLineTopology)
        IAcc<Opts...>
      {
        virtual const Opt& relWeightLead  () const = 0; ///< relative weight lead (opalsLineTopology)
        virtual       Opt& relWeightLead  ()       = 0; ///< relative weight lead (opalsLineTopology)
      };
 
      /// Partial specialization for Names::revertDist _OPALS_COMMENT_AFTER_("revert distance (opalsLineTopology
      template<class Opt, class... Opts>
      struct IAccS<Names::revertDist  , Opt, Opts...> : ///< revert distance (opalsLineTopology)
        IAcc<Opts...>
      {
        virtual const Opt& revertDist  () const = 0; ///< revert distance (opalsLineTopology)
        virtual       Opt& revertDist  ()       = 0; ///< revert distance (opalsLineTopology)
      };
 
      /// Partial specialization for Names::revertInterval _OPALS_COMMENT_AFTER_("revert interval (opalsLineTopology
      template<class Opt, class... Opts>
      struct IAccS<Names::revertInterval  , Opt, Opts...> : ///< revert interval (opalsLineTopology)
        IAcc<Opts...>
      {
        virtual const Opt& revertInterval  () const = 0; ///< revert interval (opalsLineTopology)
        virtual       Opt& revertInterval  ()       = 0; ///< revert interval (opalsLineTopology)
      };
 
      /// Partial specialization for Names::searchGeneration _OPALS_COMMENT_AFTER_("search generation (opalsLineTopology
      template<class Opt, class... Opts>
      struct IAccS<Names::searchGeneration  , Opt, Opts...> : ///< search generation (opalsLineTopology)
        IAcc<Opts...>
      {
        virtual const Opt& searchGeneration  () const = 0; ///< search generation (opalsLineTopology)
        virtual       Opt& searchGeneration  ()       = 0; ///< search generation (opalsLineTopology)
      };
 
      /// Partial specialization for Names::preventIntersection _OPALS_COMMENT_AFTER_("prevent intersection of lines (opalsLineTopology
      template<class Opt, class... Opts>
      struct IAccS<Names::preventIntersection  , Opt, Opts...> : ///< prevent intersection of lines (opalsLineTopology)
        IAcc<Opts...>
      {
        virtual const Opt& preventIntersection  () const = 0; ///< prevent intersection of lines (opalsLineTopology)
        virtual       Opt& preventIntersection  ()       = 0; ///< prevent intersection of lines (opalsLineTopology)
      };
 
      /// Partial specialization for Names::wf _OPALS_COMMENT_AFTER_("Parameter group 'wf' containing weight factor options (opalsLineTopology
      template<class Opt, class... Opts>
      struct IAccS<Names::wf  , Opt, Opts...> : ///< Parameter group 'wf' containing weight factor options (opalsLineTopology)
        IAcc<Opts...>
      {
        virtual const Opt& wf  () const = 0; ///< Parameter group 'wf' containing weight factor options (opalsLineTopology)
        virtual       Opt& wf  ()       = 0; ///< Parameter group 'wf' containing weight factor options (opalsLineTopology)
      };
 
      /// Partial specialization for Names::dist _OPALS_COMMENT_AFTER_("weight factor distance (opalsLineTopology
      template<class Opt, class... Opts>
      struct IAccS<Names::dist  , Opt, Opts...> : ///< weight factor distance (opalsLineTopology)
        IAcc<Opts...>
      {
        virtual const Opt& dist  () const = 0; ///< weight factor distance (opalsLineTopology)
        virtual       Opt& dist  ()       = 0; ///< weight factor distance (opalsLineTopology)
      };
 
      /// Partial specialization for Names::angle _OPALS_COMMENT_AFTER_("weight factor angle (Hz, V
      template<class Opt, class... Opts>
      struct IAccS<Names::angle  , Opt, Opts...> : ///< weight factor angle (Hz, V) (opalsLineTopology)
        IAcc<Opts...>
      {
        virtual const Opt& angle  () const = 0; ///< weight factor angle (Hz, V) (opalsLineTopology)
        virtual       Opt& angle  ()       = 0; ///< weight factor angle (Hz, V) (opalsLineTopology)
      };
 
      /// Partial specialization for Names::straightness _OPALS_COMMENT_AFTER_("weight factor straightness (opalsLineTopology
      template<class Opt, class... Opts>
      struct IAccS<Names::straightness  , Opt, Opts...> : ///< weight factor straightness (opalsLineTopology)
        IAcc<Opts...>
      {
        virtual const Opt& straightness  () const = 0; ///< weight factor straightness (opalsLineTopology)
        virtual       Opt& straightness  ()       = 0; ///< weight factor straightness (opalsLineTopology)
      };
 
      /// Partial specialization for Names::perpDist _OPALS_COMMENT_AFTER_("weight factor perpendicular distance (opalsLineTopology
      template<class Opt, class... Opts>
      struct IAccS<Names::perpDist  , Opt, Opts...> : ///< weight factor perpendicular distance (opalsLineTopology)
        IAcc<Opts...>
      {
        virtual const Opt& perpDist  () const = 0; ///< weight factor perpendicular distance (opalsLineTopology)
        virtual       Opt& perpDist  ()       = 0; ///< weight factor perpendicular distance (opalsLineTopology)
      };
 
      /// Partial specialization for Names::clean _OPALS_COMMENT_AFTER_("Parameter group 'clean' (opalsLineTopology
      template<class Opt, class... Opts>
      struct IAccS<Names::clean  , Opt, Opts...> : ///< Parameter group 'clean' (opalsLineTopology)
        IAcc<Opts...>
      {
        virtual const Opt& clean  () const = 0; ///< Parameter group 'clean' (opalsLineTopology)
        virtual       Opt& clean  ()       = 0; ///< Parameter group 'clean' (opalsLineTopology)
      };
 
      /// Partial specialization for Names::intersectSnapDist _OPALS_COMMENT_AFTER_("omit distance for missing intersections (opalsLineTopology
      template<class Opt, class... Opts>
      struct IAccS<Names::intersectSnapDist  , Opt, Opts...> : ///< omit distance for missing intersections (opalsLineTopology)
        IAcc<Opts...>
      {
        virtual const Opt& intersectSnapDist  () const = 0; ///< omit distance for missing intersections (opalsLineTopology)
        virtual       Opt& intersectSnapDist  ()       = 0; ///< omit distance for missing intersections (opalsLineTopology)
      };
 
      /// Partial specialization for Names::deleteTempData _OPALS_COMMENT_AFTER_("Delete temporary / intermediate data (opalsTerrainFilter
      template<class Opt, class... Opts>
      struct IAccS<Names::deleteTempData  , Opt, Opts...> : ///< Delete temporary / intermediate data (opalsTerrainFilter)
        IAcc<Opts...>
      {
        virtual const Opt& deleteTempData  () const = 0; ///< Delete temporary / intermediate data (opalsTerrainFilter)
        virtual       Opt& deleteTempData  ()       = 0; ///< Delete temporary / intermediate data (opalsTerrainFilter)
      };
 
      /// Partial specialization for Names::tempData _OPALS_COMMENT_AFTER_("Temporary / intermediate data group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::tempData  , Opt, Opts...> : ///< Temporary / intermediate data group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& tempData  () const = 0; ///< Temporary / intermediate data group (opalsStripAdjust)
        virtual       Opt& tempData  ()       = 0; ///< Temporary / intermediate data group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::directory _OPALS_COMMENT_AFTER_("Temporary / intermediate data directory path (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::directory  , Opt, Opts...> : ///< Temporary / intermediate data directory path (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& directory  () const = 0; ///< Temporary / intermediate data directory path (opalsStripAdjust)
        virtual       Opt& directory  ()       = 0; ///< Temporary / intermediate data directory path (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::cleanup _OPALS_COMMENT_AFTER_("Cleanup / delete temporary / intermediate data (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::cleanup  , Opt, Opts...> : ///< Cleanup / delete temporary / intermediate data (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& cleanup  () const = 0; ///< Cleanup / delete temporary / intermediate data (opalsStripAdjust)
        virtual       Opt& cleanup  ()       = 0; ///< Cleanup / delete temporary / intermediate data (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::compress _OPALS_COMMENT_AFTER_("Compress temporary / intermediate data (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::compress  , Opt, Opts...> : ///< Compress temporary / intermediate data (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& compress  () const = 0; ///< Compress temporary / intermediate data (opalsStripAdjust)
        virtual       Opt& compress  ()       = 0; ///< Compress temporary / intermediate data (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::utm _OPALS_COMMENT_AFTER_("UTM definition group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::utm  , Opt, Opts...> : ///< UTM definition group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& utm  () const = 0; ///< UTM definition group (opalsStripAdjust)
        virtual       Opt& utm  ()       = 0; ///< UTM definition group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::zone _OPALS_COMMENT_AFTER_("UTM definition group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::zone  , Opt, Opts...> : ///< UTM definition group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& zone  () const = 0; ///< UTM definition group (opalsStripAdjust)
        virtual       Opt& zone  ()       = 0; ///< UTM definition group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::hemisphere _OPALS_COMMENT_AFTER_("UTM definition group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::hemisphere  , Opt, Opts...> : ///< UTM definition group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& hemisphere  () const = 0; ///< UTM definition group (opalsStripAdjust)
        virtual       Opt& hemisphere  ()       = 0; ///< UTM definition group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::adjustment _OPALS_COMMENT_AFTER_("adjustment group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::adjustment  , Opt, Opts...> : ///< adjustment group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& adjustment  () const = 0; ///< adjustment group (opalsStripAdjust)
        virtual       Opt& adjustment  ()       = 0; ///< adjustment group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::covariance _OPALS_COMMENT_AFTER_("estimate covariance? (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::covariance  , Opt, Opts...> : ///< estimate covariance? (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& covariance  () const = 0; ///< estimate covariance? (opalsStripAdjust)
        virtual       Opt& covariance  ()       = 0; ///< estimate covariance? (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::strips _OPALS_COMMENT_AFTER_("strip group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::strips  , Opt, Opts...> : ///< strip group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& strips  () const = 0; ///< strip group (opalsStripAdjust)
        virtual       Opt& strips  ()       = 0; ///< strip group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::calcScanAngle _OPALS_COMMENT_AFTER_("strip group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::calcScanAngle  , Opt, Opts...> : ///< strip group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& calcScanAngle  () const = 0; ///< strip group (opalsStripAdjust)
        virtual       Opt& calcScanAngle  ()       = 0; ///< strip group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::scannerOrientation _OPALS_COMMENT_AFTER_("strip group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::scannerOrientation  , Opt, Opts...> : ///< strip group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& scannerOrientation  () const = 0; ///< strip group (opalsStripAdjust)
        virtual       Opt& scannerOrientation  ()       = 0; ///< strip group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::session _OPALS_COMMENT_AFTER_("strip group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::session  , Opt, Opts...> : ///< strip group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& session  () const = 0; ///< strip group (opalsStripAdjust)
        virtual       Opt& session  ()       = 0; ///< strip group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::sessions _OPALS_COMMENT_AFTER_("sessions group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::sessions  , Opt, Opts...> : ///< sessions group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& sessions  () const = 0; ///< sessions group (opalsStripAdjust)
        virtual       Opt& sessions  ()       = 0; ///< sessions group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::onlyLastEchoes _OPALS_COMMENT_AFTER_("strip group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::onlyLastEchoes  , Opt, Opts...> : ///< strip group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& onlyLastEchoes  () const = 0; ///< strip group (opalsStripAdjust)
        virtual       Opt& onlyLastEchoes  ()       = 0; ///< strip group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::echoWidthMax _OPALS_COMMENT_AFTER_("strip.filter group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::echoWidthMax  , Opt, Opts...> : ///< strip.filter group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& echoWidthMax  () const = 0; ///< strip.filter group (opalsStripAdjust)
        virtual       Opt& echoWidthMax  ()       = 0; ///< strip.filter group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::scanAngleMaxAbs _OPALS_COMMENT_AFTER_("strip.filter group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::scanAngleMaxAbs  , Opt, Opts...> : ///< strip.filter group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& scanAngleMaxAbs  () const = 0; ///< strip.filter group (opalsStripAdjust)
        virtual       Opt& scanAngleMaxAbs  ()       = 0; ///< strip.filter group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::trajectory _OPALS_COMMENT_AFTER_("strip.trajectory group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::trajectory  , Opt, Opts...> : ///< strip.trajectory group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& trajectory  () const = 0; ///< strip.trajectory group (opalsStripAdjust)
        virtual       Opt& trajectory  ()       = 0; ///< strip.trajectory group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::correctionModel _OPALS_COMMENT_AFTER_("strip.trajectory group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::correctionModel  , Opt, Opts...> : ///< strip.trajectory group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& correctionModel  () const = 0; ///< strip.trajectory group (opalsStripAdjust)
        virtual       Opt& correctionModel  ()       = 0; ///< strip.trajectory group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::samplingInterval _OPALS_COMMENT_AFTER_("trajectory sampling interval [s] strip.trajectory group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::samplingInterval  , Opt, Opts...> : ///< trajectory sampling interval [s] strip.trajectory group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& samplingInterval  () const = 0; ///< trajectory sampling interval [s] strip.trajectory group (opalsStripAdjust)
        virtual       Opt& samplingInterval  ()       = 0; ///< trajectory sampling interval [s] strip.trajectory group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::boundaryDerivativeIsZero _OPALS_COMMENT_AFTER_("strip.trajectory.boundaryDerivativeIsZero group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::boundaryDerivativeIsZero  , Opt, Opts...> : ///< strip.trajectory.boundaryDerivativeIsZero group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& boundaryDerivativeIsZero  () const = 0; ///< strip.trajectory.boundaryDerivativeIsZero group (opalsStripAdjust)
        virtual       Opt& boundaryDerivativeIsZero  ()       = 0; ///< strip.trajectory.boundaryDerivativeIsZero group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::first _OPALS_COMMENT_AFTER_("strip.trajectory.boundaryDerivativeIsZero group; first stage to be processed (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::first  , Opt, Opts...> : ///< strip.trajectory.boundaryDerivativeIsZero group; first stage to be processed (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& first  () const = 0; ///< strip.trajectory.boundaryDerivativeIsZero group; first stage to be processed (opalsStripAdjust)
        virtual       Opt& first  ()       = 0; ///< strip.trajectory.boundaryDerivativeIsZero group; first stage to be processed (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::second _OPALS_COMMENT_AFTER_("strip.trajectory.boundaryDerivativeIsZero group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::second  , Opt, Opts...> : ///< strip.trajectory.boundaryDerivativeIsZero group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& second  () const = 0; ///< strip.trajectory.boundaryDerivativeIsZero group (opalsStripAdjust)
        virtual       Opt& second  ()       = 0; ///< strip.trajectory.boundaryDerivativeIsZero group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::dX _OPALS_COMMENT_AFTER_("strip.trajectory group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::dX  , Opt, Opts...> : ///< strip.trajectory group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& dX  () const = 0; ///< strip.trajectory group (opalsStripAdjust)
        virtual       Opt& dX  ()       = 0; ///< strip.trajectory group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::dY _OPALS_COMMENT_AFTER_("strip.trajectory group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::dY  , Opt, Opts...> : ///< strip.trajectory group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& dY  () const = 0; ///< strip.trajectory group (opalsStripAdjust)
        virtual       Opt& dY  ()       = 0; ///< strip.trajectory group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::dZ _OPALS_COMMENT_AFTER_("strip.trajectory group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::dZ  , Opt, Opts...> : ///< strip.trajectory group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& dZ  () const = 0; ///< strip.trajectory group (opalsStripAdjust)
        virtual       Opt& dZ  ()       = 0; ///< strip.trajectory group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::dRoll _OPALS_COMMENT_AFTER_("strip.trajectory group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::dRoll  , Opt, Opts...> : ///< strip.trajectory group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& dRoll  () const = 0; ///< strip.trajectory group (opalsStripAdjust)
        virtual       Opt& dRoll  ()       = 0; ///< strip.trajectory group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::dPitch _OPALS_COMMENT_AFTER_("strip.trajectory group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::dPitch  , Opt, Opts...> : ///< strip.trajectory group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& dPitch  () const = 0; ///< strip.trajectory group (opalsStripAdjust)
        virtual       Opt& dPitch  ()       = 0; ///< strip.trajectory group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::dYaw _OPALS_COMMENT_AFTER_("strip.trajectory group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::dYaw  , Opt, Opts...> : ///< strip.trajectory group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& dYaw  () const = 0; ///< strip.trajectory group (opalsStripAdjust)
        virtual       Opt& dYaw  ()       = 0; ///< strip.trajectory group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::value _OPALS_COMMENT_AFTER_("strip.trajectory.dX/dY/dZ/dRoll/dPitch/dYaw groups (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::value  , Opt, Opts...> : ///< strip.trajectory.dX/dY/dZ/dRoll/dPitch/dYaw groups (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& value  () const = 0; ///< strip.trajectory.dX/dY/dZ/dRoll/dPitch/dYaw groups (opalsStripAdjust)
        virtual       Opt& value  ()       = 0; ///< strip.trajectory.dX/dY/dZ/dRoll/dPitch/dYaw groups (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::normals _OPALS_COMMENT_AFTER_("normals group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::normals  , Opt, Opts...> : ///< normals group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& normals  () const = 0; ///< normals group (opalsStripAdjust)
        virtual       Opt& normals  ()       = 0; ///< normals group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::maxPointDensity _OPALS_COMMENT_AFTER_("(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::maxPointDensity  , Opt, Opts...> : ///< (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& maxPointDensity  () const = 0; ///< (opalsStripAdjust)
        virtual       Opt& maxPointDensity  ()       = 0; ///< (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::controlPointClouds _OPALS_COMMENT_AFTER_("controlPointClouds group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::controlPointClouds  , Opt, Opts...> : ///< controlPointClouds group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& controlPointClouds  () const = 0; ///< controlPointClouds group(opalsStripAdjust)
        virtual       Opt& controlPointClouds  ()       = 0; ///< controlPointClouds group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::groundControlPoints _OPALS_COMMENT_AFTER_("groundControlPoints group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::groundControlPoints  , Opt, Opts...> : ///< groundControlPoints group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& groundControlPoints  () const = 0; ///< groundControlPoints group(opalsStripAdjust)
        virtual       Opt& groundControlPoints  ()       = 0; ///< groundControlPoints group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::timeLag _OPALS_COMMENT_AFTER_("sessions.trajectory group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::timeLag  , Opt, Opts...> : ///< sessions.trajectory group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& timeLag  () const = 0; ///< sessions.trajectory group(opalsStripAdjust)
        virtual       Opt& timeLag  ()       = 0; ///< sessions.trajectory group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::leverArm _OPALS_COMMENT_AFTER_("sessions.adjustment group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::leverArm  , Opt, Opts...> : ///< sessions.adjustment group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& leverArm  () const = 0; ///< sessions.adjustment group(opalsStripAdjust)
        virtual       Opt& leverArm  ()       = 0; ///< sessions.adjustment group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::X _OPALS_COMMENT_AFTER_("sessions.adjustment.leverArm group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::X  , Opt, Opts...> : ///< sessions.adjustment.leverArm group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& X  () const = 0; ///< sessions.adjustment.leverArm group(opalsStripAdjust)
        virtual       Opt& X  ()       = 0; ///< sessions.adjustment.leverArm group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::Y _OPALS_COMMENT_AFTER_("sessions.adjustment.leverArm group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::Y  , Opt, Opts...> : ///< sessions.adjustment.leverArm group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& Y  () const = 0; ///< sessions.adjustment.leverArm group(opalsStripAdjust)
        virtual       Opt& Y  ()       = 0; ///< sessions.adjustment.leverArm group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::Z _OPALS_COMMENT_AFTER_("sessions.adjustment.leverArm group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::Z  , Opt, Opts...> : ///< sessions.adjustment.leverArm group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& Z  () const = 0; ///< sessions.adjustment.leverArm group(opalsStripAdjust)
        virtual       Opt& Z  ()       = 0; ///< sessions.adjustment.leverArm group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::misalignment _OPALS_COMMENT_AFTER_("sessions.adjustment.misalignment group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::misalignment  , Opt, Opts...> : ///< sessions.adjustment.misalignment group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& misalignment  () const = 0; ///< sessions.adjustment.misalignment group(opalsStripAdjust)
        virtual       Opt& misalignment  ()       = 0; ///< sessions.adjustment.misalignment group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::omega _OPALS_COMMENT_AFTER_("sessions.adjustment.misalignment group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::omega  , Opt, Opts...> : ///< sessions.adjustment.misalignment group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& omega  () const = 0; ///< sessions.adjustment.misalignment group(opalsStripAdjust)
        virtual       Opt& omega  ()       = 0; ///< sessions.adjustment.misalignment group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::phi _OPALS_COMMENT_AFTER_("sessions.adjustment.misalignment group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::phi  , Opt, Opts...> : ///< sessions.adjustment.misalignment group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& phi  () const = 0; ///< sessions.adjustment.misalignment group(opalsStripAdjust)
        virtual       Opt& phi  ()       = 0; ///< sessions.adjustment.misalignment group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::kappa _OPALS_COMMENT_AFTER_("sessions.adjustment.misalignment group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::kappa  , Opt, Opts...> : ///< sessions.adjustment.misalignment group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& kappa  () const = 0; ///< sessions.adjustment.misalignment group(opalsStripAdjust)
        virtual       Opt& kappa  ()       = 0; ///< sessions.adjustment.misalignment group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::scanner _OPALS_COMMENT_AFTER_("sessions.adjustment.scanner group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::scanner  , Opt, Opts...> : ///< sessions.adjustment.scanner group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& scanner  () const = 0; ///< sessions.adjustment.scanner group(opalsStripAdjust)
        virtual       Opt& scanner  ()       = 0; ///< sessions.adjustment.scanner group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::range _OPALS_COMMENT_AFTER_("scanner range group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::range  , Opt, Opts...> : ///< scanner range group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& range  () const = 0; ///< scanner range group (opalsStripAdjust)
        virtual       Opt& range  ()       = 0; ///< scanner range group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::offset _OPALS_COMMENT_AFTER_("scanner range offset (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::offset  , Opt, Opts...> : ///< scanner range offset (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& offset  () const = 0; ///< scanner range offset (opalsStripAdjust)
        virtual       Opt& offset  ()       = 0; ///< scanner range offset (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::scale _OPALS_COMMENT_AFTER_("scanner range scale (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::scale  , Opt, Opts...> : ///< scanner range scale (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& scale  () const = 0; ///< scanner range scale (opalsStripAdjust)
        virtual       Opt& scale  ()       = 0; ///< scanner range scale (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::scanAngle _OPALS_COMMENT_AFTER_("sessions.adjustment.scanner.scanAngleOffset group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::scanAngle  , Opt, Opts...> : ///< sessions.adjustment.scanner.scanAngleOffset group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& scanAngle  () const = 0; ///< sessions.adjustment.scanner.scanAngleOffset group(opalsStripAdjust)
        virtual       Opt& scanAngle  ()       = 0; ///< sessions.adjustment.scanner.scanAngleOffset group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::tiltAngle _OPALS_COMMENT_AFTER_("sessions.adjustment.scanner.tiltAngleOffset group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::tiltAngle  , Opt, Opts...> : ///< sessions.adjustment.scanner.tiltAngleOffset group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& tiltAngle  () const = 0; ///< sessions.adjustment.scanner.tiltAngleOffset group(opalsStripAdjust)
        virtual       Opt& tiltAngle  ()       = 0; ///< sessions.adjustment.scanner.tiltAngleOffset group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::datum _OPALS_COMMENT_AFTER_("sessions.adjustment.datum group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::datum  , Opt, Opts...> : ///< sessions.adjustment.datum group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& datum  () const = 0; ///< sessions.adjustment.datum group(opalsStripAdjust)
        virtual       Opt& datum  ()       = 0; ///< sessions.adjustment.datum group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::correspondences _OPALS_COMMENT_AFTER_("correspondences group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::correspondences  , Opt, Opts...> : ///< correspondences group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& correspondences  () const = 0; ///< correspondences group(opalsStripAdjust)
        virtual       Opt& correspondences  ()       = 0; ///< correspondences group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::strip2strip _OPALS_COMMENT_AFTER_("correspondences.strip2strip group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::strip2strip  , Opt, Opts...> : ///< correspondences.strip2strip group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& strip2strip  () const = 0; ///< correspondences.strip2strip group(opalsStripAdjust)
        virtual       Opt& strip2strip  ()       = 0; ///< correspondences.strip2strip group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::selection _OPALS_COMMENT_AFTER_("correspondences.strip2strip.selection group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::selection  , Opt, Opts...> : ///< correspondences.strip2strip.selection group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& selection  () const = 0; ///< correspondences.strip2strip.selection group(opalsStripAdjust)
        virtual       Opt& selection  ()       = 0; ///< correspondences.strip2strip.selection group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::subsamplingPercentPoi _OPALS_COMMENT_AFTER_("correspondences.strip2strip.selection group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::subsamplingPercentPoi  , Opt, Opts...> : ///< correspondences.strip2strip.selection group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& subsamplingPercentPoi  () const = 0; ///< correspondences.strip2strip.selection group(opalsStripAdjust)
        virtual       Opt& subsamplingPercentPoi  ()       = 0; ///< correspondences.strip2strip.selection group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::weighting _OPALS_COMMENT_AFTER_("correspondences.strip2strip.weighting group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::weighting  , Opt, Opts...> : ///< correspondences.strip2strip.weighting group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& weighting  () const = 0; ///< correspondences.strip2strip.weighting group(opalsStripAdjust)
        virtual       Opt& weighting  ()       = 0; ///< correspondences.strip2strip.weighting group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::byDeltaAngle _OPALS_COMMENT_AFTER_("correspondences.strip2strip.weighting group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::byDeltaAngle  , Opt, Opts...> : ///< correspondences.strip2strip.weighting group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& byDeltaAngle  () const = 0; ///< correspondences.strip2strip.weighting group(opalsStripAdjust)
        virtual       Opt& byDeltaAngle  ()       = 0; ///< correspondences.strip2strip.weighting group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::byRoughness _OPALS_COMMENT_AFTER_("correspondences.strip2strip.weighting group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::byRoughness  , Opt, Opts...> : ///< correspondences.strip2strip.weighting group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& byRoughness  () const = 0; ///< correspondences.strip2strip.weighting group(opalsStripAdjust)
        virtual       Opt& byRoughness  ()       = 0; ///< correspondences.strip2strip.weighting group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::rejection _OPALS_COMMENT_AFTER_("correspondences.strip2strip.rejection group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::rejection  , Opt, Opts...> : ///< correspondences.strip2strip.rejection group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& rejection  () const = 0; ///< correspondences.strip2strip.rejection group(opalsStripAdjust)
        virtual       Opt& rejection  ()       = 0; ///< correspondences.strip2strip.rejection group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::maxRoughness _OPALS_COMMENT_AFTER_("correspondences.strip2strip.rejection group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::maxRoughness  , Opt, Opts...> : ///< correspondences.strip2strip.rejection group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& maxRoughness  () const = 0; ///< correspondences.strip2strip.rejection group(opalsStripAdjust)
        virtual       Opt& maxRoughness  ()       = 0; ///< correspondences.strip2strip.rejection group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::control2strip _OPALS_COMMENT_AFTER_("correspondences.control2strip group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::control2strip  , Opt, Opts...> : ///< correspondences.control2strip group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& control2strip  () const = 0; ///< correspondences.control2strip group(opalsStripAdjust)
        virtual       Opt& control2strip  ()       = 0; ///< correspondences.control2strip group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::dpSigPriori _OPALS_COMMENT_AFTER_("correspondences.control2strip group(opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::dpSigPriori  , Opt, Opts...> : ///< correspondences.control2strip group(opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& dpSigPriori  () const = 0; ///< correspondences.control2strip group(opalsStripAdjust)
        virtual       Opt& dpSigPriori  ()       = 0; ///< correspondences.control2strip group(opalsStripAdjust)
      };
 
      /// Partial specialization for Names::patchLength _OPALS_COMMENT_AFTER_("patch length for structure line modelling (opalsLineModeler
      template<class Opt, class... Opts>
      struct IAccS<Names::patchLength  , Opt, Opts...> : ///< patch length for structure line modelling (opalsLineModeler)
        IAcc<Opts...>
      {
        virtual const Opt& patchLength  () const = 0; ///< patch length for structure line modelling (opalsLineModeler)
        virtual       Opt& patchLength  ()       = 0; ///< patch length for structure line modelling (opalsLineModeler)
      };
 
      /// Partial specialization for Names::patchWidth _OPALS_COMMENT_AFTER_("patch width for structure line modelling (opalsLineModeler
      template<class Opt, class... Opts>
      struct IAccS<Names::patchWidth  , Opt, Opts...> : ///< patch width for structure line modelling (opalsLineModeler)
        IAcc<Opts...>
      {
        virtual const Opt& patchWidth  () const = 0; ///< patch width for structure line modelling (opalsLineModeler)
        virtual       Opt& patchWidth  ()       = 0; ///< patch width for structure line modelling (opalsLineModeler)
      };
 
      /// Partial specialization for Names::pointCount _OPALS_COMMENT_AFTER_("min und max point count for patches (opalsLineModeler
      template<class Opt, class... Opts>
      struct IAccS<Names::pointCount  , Opt, Opts...> : ///< min und max point count for patches (opalsLineModeler)
        IAcc<Opts...>
      {
        virtual const Opt& pointCount  () const = 0; ///< min und max point count for patches (opalsLineModeler)
        virtual       Opt& pointCount  ()       = 0; ///< min und max point count for patches (opalsLineModeler)
      };
 
      /// Partial specialization for Names::minAngle _OPALS_COMMENT_AFTER_("minimum intersection angle (opalsLineModeler
      template<class Opt, class... Opts>
      struct IAccS<Names::minAngle  , Opt, Opts...> : ///< minimum intersection angle (opalsLineModeler)
        IAcc<Opts...>
      {
        virtual const Opt& minAngle  () const = 0; ///< minimum intersection angle (opalsLineModeler)
        virtual       Opt& minAngle  ()       = 0; ///< minimum intersection angle (opalsLineModeler)
      };
 
      /// Partial specialization for Names::sigmaPoint _OPALS_COMMENT_AFTER_("height sigma of the point cloud data (opalsLineModeler
      template<class Opt, class... Opts>
      struct IAccS<Names::sigmaPoint  , Opt, Opts...> : ///< height sigma of the point cloud data (opalsLineModeler)
        IAcc<Opts...>
      {
        virtual const Opt& sigmaPoint  () const = 0; ///< height sigma of the point cloud data (opalsLineModeler)
        virtual       Opt& sigmaPoint  ()       = 0; ///< height sigma of the point cloud data (opalsLineModeler)
      };
 
      /// Partial specialization for Names::sigmaApprox _OPALS_COMMENT_AFTER_("2d sigma of the structure line approximation (opalsLineModeler
      template<class Opt, class... Opts>
      struct IAccS<Names::sigmaApprox  , Opt, Opts...> : ///< 2d sigma of the structure line approximation (opalsLineModeler)
        IAcc<Opts...>
      {
        virtual const Opt& sigmaApprox  () const = 0; ///< 2d sigma of the structure line approximation (opalsLineModeler)
        virtual       Opt& sigmaApprox  ()       = 0; ///< 2d sigma of the structure line approximation (opalsLineModeler)
      };
 
      /// Partial specialization for Names::approximative _OPALS_COMMENT_AFTER_("use precise(=slow
      template<class Opt, class... Opts>
      struct IAccS<Names::approximative  , Opt, Opts...> : ///< use precise(=slow) or approximative(=fast) computation (opalsBounds)
        IAcc<Opts...>
      {
        virtual const Opt& approximative  () const = 0; ///< use precise(=slow) or approximative(=fast) computation (opalsBounds)
        virtual       Opt& approximative  ()       = 0; ///< use precise(=slow) or approximative(=fast) computation (opalsBounds)
      };
 
      /// Partial specialization for Names::maxArea _OPALS_COMMENT_AFTER_("maximum area (opalsFillGaps
      template<class Opt, class... Opts>
      struct IAccS<Names::maxArea  , Opt, Opts...> : ///< maximum area (opalsFillGaps)
        IAcc<Opts...>
      {
        virtual const Opt& maxArea  () const = 0; ///< maximum area (opalsFillGaps)
        virtual       Opt& maxArea  ()       = 0; ///< maximum area (opalsFillGaps)
      };
 
      /// Partial specialization for Names::maxPixelRigorous _OPALS_COMMENT_AFTER_("maximum number of gap-pixel for rigorous adaptive fill (opalsFillGaps
      template<class Opt, class... Opts>
      struct IAccS<Names::maxPixelRigorous  , Opt, Opts...> : ///< maximum number of gap-pixel for rigorous adaptive fill (opalsFillGaps)
        IAcc<Opts...>
      {
        virtual const Opt& maxPixelRigorous  () const = 0; ///< maximum number of gap-pixel for rigorous adaptive fill (opalsFillGaps)
        virtual       Opt& maxPixelRigorous  ()       = 0; ///< maximum number of gap-pixel for rigorous adaptive fill (opalsFillGaps)
      };
 
      /// Partial specialization for Names::gapInfo _OPALS_COMMENT_AFTER_("write additional gap information to files (opalsFillGaps
      template<class Opt, class... Opts>
      struct IAccS<Names::gapInfo  , Opt, Opts...> : ///< write additional gap information to files (opalsFillGaps)
        IAcc<Opts...>
      {
        virtual const Opt& gapInfo  () const = 0; ///< write additional gap information to files (opalsFillGaps)
        virtual       Opt& gapInfo  ()       = 0; ///< write additional gap information to files (opalsFillGaps)
      };
 
      /// Partial specialization for Names::sigmaSmooth _OPALS_COMMENT_AFTER_("gaussian smoothing sigma (opalsEdgeDetect
      template<class Opt, class... Opts>
      struct IAccS<Names::sigmaSmooth  , Opt, Opts...> : ///< gaussian smoothing sigma (opalsEdgeDetect)
        IAcc<Opts...>
      {
        virtual const Opt& sigmaSmooth  () const = 0; ///< gaussian smoothing sigma (opalsEdgeDetect)
        virtual       Opt& sigmaSmooth  ()       = 0; ///< gaussian smoothing sigma (opalsEdgeDetect)
      };
 
      /// Partial specialization for Names::exportHeader _OPALS_COMMENT_AFTER_("export header features (opalsInfo
      template<class Opt, class... Opts>
      struct IAccS<Names::exportHeader  , Opt, Opts...> : ///< export header features (opalsInfo) -> deprecated
        IAcc<Opts...>
      {
        virtual const Opt& exportHeader  () const = 0; ///< export header features (opalsInfo) -> deprecated
        virtual       Opt& exportHeader  ()       = 0; ///< export header features (opalsInfo) -> deprecated
      };
 
      /// Partial specialization for Names::seedCalculator _OPALS_COMMENT_AFTER_("Calculator for seed point order (opalsSegmentation
      template<class Opt, class... Opts>
      struct IAccS<Names::seedCalculator  , Opt, Opts...> : ///< Calculator for seed point order (opalsSegmentation)
        IAcc<Opts...>
      {
        virtual const Opt& seedCalculator  () const = 0; ///< Calculator for seed point order (opalsSegmentation)
        virtual       Opt& seedCalculator  ()       = 0; ///< Calculator for seed point order (opalsSegmentation)
      };
 
      /// Partial specialization for Names::condClustering _OPALS_COMMENT_AFTER_("Parameter group 'condClustering' containing options for conditional clustering (opalsSegmentation
      template<class Opt, class... Opts>
      struct IAccS<Names::condClustering  , Opt, Opts...> : ///< Parameter group 'condClustering' containing options for conditional clustering (opalsSegmentation)
        IAcc<Opts...>
      {
        virtual const Opt& condClustering  () const = 0; ///< Parameter group 'condClustering' containing options for conditional clustering (opalsSegmentation)
        virtual       Opt& condClustering  ()       = 0; ///< Parameter group 'condClustering' containing options for conditional clustering (opalsSegmentation)
      };
 
      /// Partial specialization for Names::planeExtraction _OPALS_COMMENT_AFTER_("Parameter group 'planeExtraction' containing options for planar surface extraction (opalsSegmentation
      template<class Opt, class... Opts>
      struct IAccS<Names::planeExtraction  , Opt, Opts...> : ///< Parameter group 'planeExtraction' containing options for planar surface extraction (opalsSegmentation)
        IAcc<Opts...>
      {
        virtual const Opt& planeExtraction  () const = 0; ///< Parameter group 'planeExtraction' containing options for planar surface extraction (opalsSegmentation)
        virtual       Opt& planeExtraction  ()       = 0; ///< Parameter group 'planeExtraction' containing options for planar surface extraction (opalsSegmentation)
      };
 
      /// Partial specialization for Names::pyramidLevels _OPALS_COMMENT_AFTER_("Number of data/image pyramid levels (opalsTerrainFilter
      template<class Opt, class... Opts>
      struct IAccS<Names::pyramidLevels  , Opt, Opts...> : ///< Number of data/image pyramid levels (opalsTerrainFilter)
        IAcc<Opts...>
      {
        virtual const Opt& pyramidLevels  () const = 0; ///< Number of data/image pyramid levels (opalsTerrainFilter)
        virtual       Opt& pyramidLevels  ()       = 0; ///< Number of data/image pyramid levels (opalsTerrainFilter)
      };
 
      /// Partial specialization for Names::bulkPoints _OPALS_COMMENT_AFTER_("specific parameter for category bulk points (opalsTerrainFilter
      template<class Opt, class... Opts>
      struct IAccS<Names::bulkPoints  , Opt, Opts...> : ///< specific parameter for category bulk points (opalsTerrainFilter)
        IAcc<Opts...>
      {
        virtual const Opt& bulkPoints  () const = 0; ///< specific parameter for category bulk points (opalsTerrainFilter)
        virtual       Opt& bulkPoints  ()       = 0; ///< specific parameter for category bulk points (opalsTerrainFilter)
      };
 
      /// Partial specialization for Names::keyPoints _OPALS_COMMENT_AFTER_("specific parameter for category key points (opalsTerrainFilter
      template<class Opt, class... Opts>
      struct IAccS<Names::keyPoints  , Opt, Opts...> : ///< specific parameter for category key points (opalsTerrainFilter)
        IAcc<Opts...>
      {
        virtual const Opt& keyPoints  () const = 0; ///< specific parameter for category key points (opalsTerrainFilter)
        virtual       Opt& keyPoints  ()       = 0; ///< specific parameter for category key points (opalsTerrainFilter)
      };
 
      /// Partial specialization for Names::formLines _OPALS_COMMENT_AFTER_("specific parameter for category form lines (opalsTerrainFilter
      template<class Opt, class... Opts>
      struct IAccS<Names::formLines  , Opt, Opts...> : ///< specific parameter for category form lines (opalsTerrainFilter)
        IAcc<Opts...>
      {
        virtual const Opt& formLines  () const = 0; ///< specific parameter for category form lines (opalsTerrainFilter)
        virtual       Opt& formLines  ()       = 0; ///< specific parameter for category form lines (opalsTerrainFilter)
      };
 
      /// Partial specialization for Names::breakLines _OPALS_COMMENT_AFTER_("specific parameter for category break lines (opalsTerrainFilter
      template<class Opt, class... Opts>
      struct IAccS<Names::breakLines  , Opt, Opts...> : ///< specific parameter for category break lines (opalsTerrainFilter)
        IAcc<Opts...>
      {
        virtual const Opt& breakLines  () const = 0; ///< specific parameter for category break lines (opalsTerrainFilter)
        virtual       Opt& breakLines  ()       = 0; ///< specific parameter for category break lines (opalsTerrainFilter)
      };
 
      /// Partial specialization for Names::robustInterpolation _OPALS_COMMENT_AFTER_("group of specific parameters for robust interpolation (opalsTerrainFilter
      template<class Opt, class... Opts>
      struct IAccS<Names::robustInterpolation  , Opt, Opts...> : ///< group of specific parameters for robust interpolation (opalsTerrainFilter)
        IAcc<Opts...>
      {
        virtual const Opt& robustInterpolation  () const = 0; ///< group of specific parameters for robust interpolation (opalsTerrainFilter)
        virtual       Opt& robustInterpolation  ()       = 0; ///< group of specific parameters for robust interpolation (opalsTerrainFilter)
      };
 
      /// Partial specialization for Names::writeFilterInfo _OPALS_COMMENT_AFTER_("write filter information to odm (opalsTerrainFilter
      template<class Opt, class... Opts>
      struct IAccS<Names::writeFilterInfo  , Opt, Opts...> : ///< write filter information to odm (opalsTerrainFilter)
        IAcc<Opts...>
      {
        virtual const Opt& writeFilterInfo  () const = 0; ///< write filter information to odm (opalsTerrainFilter)
        virtual       Opt& writeFilterInfo  ()       = 0; ///< write filter information to odm (opalsTerrainFilter)
      };
 
      /// Partial specialization for Names::filterThresholds _OPALS_COMMENT_AFTER_("filter thresholds for hierarchical levels (opalsTerrainFilter
      template<class Opt, class... Opts>
      struct IAccS<Names::filterThresholds  , Opt, Opts...> : ///< filter thresholds for hierarchical levels (opalsTerrainFilter)
        IAcc<Opts...>
      {
        virtual const Opt& filterThresholds  () const = 0; ///< filter thresholds for hierarchical levels (opalsTerrainFilter)
        virtual       Opt& filterThresholds  ()       = 0; ///< filter thresholds for hierarchical levels (opalsTerrainFilter)
      };
 
      /// Partial specialization for Names::lowerThresholdScale _OPALS_COMMENT_AFTER_("scale for asymmetric filter thresholds (opalsTerrainFilter
      template<class Opt, class... Opts>
      struct IAccS<Names::lowerThresholdScale  , Opt, Opts...> : ///< scale for asymmetric filter thresholds (opalsTerrainFilter)
        IAcc<Opts...>
      {
        virtual const Opt& lowerThresholdScale  () const = 0; ///< scale for asymmetric filter thresholds (opalsTerrainFilter)
        virtual       Opt& lowerThresholdScale  ()       = 0; ///< scale for asymmetric filter thresholds (opalsTerrainFilter)
      };
 
      /// Partial specialization for Names::robustIter _OPALS_COMMENT_AFTER_("number of robust iterations (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::robustIter  , Opt, Opts...> : ///< number of robust iterations (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& robustIter  () const = 0; ///< number of robust iterations (opalsStripAdjust)
        virtual       Opt& robustIter  ()       = 0; ///< number of robust iterations (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::images _OPALS_COMMENT_AFTER_("images group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::images  , Opt, Opts...> : ///< images group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& images  () const = 0; ///< images group (opalsStripAdjust)
        virtual       Opt& images  ()       = 0; ///< images group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::camera _OPALS_COMMENT_AFTER_("camera ID (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::camera  , Opt, Opts...> : ///< camera ID (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& camera  () const = 0; ///< camera ID (opalsStripAdjust)
        virtual       Opt& camera  ()       = 0; ///< camera ID (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::cameras _OPALS_COMMENT_AFTER_("cameras group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::cameras  , Opt, Opts...> : ///< cameras group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& cameras  () const = 0; ///< cameras group (opalsStripAdjust)
        virtual       Opt& cameras  ()       = 0; ///< cameras group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::extOri _OPALS_COMMENT_AFTER_("exterior orientation (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::extOri  , Opt, Opts...> : ///< exterior orientation (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& extOri  () const = 0; ///< exterior orientation (opalsStripAdjust)
        virtual       Opt& extOri  ()       = 0; ///< exterior orientation (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::dExtOri _OPALS_COMMENT_AFTER_("delta exterior orientation (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::dExtOri  , Opt, Opts...> : ///< delta exterior orientation (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& dExtOri  () const = 0; ///< delta exterior orientation (opalsStripAdjust)
        virtual       Opt& dExtOri  ()       = 0; ///< delta exterior orientation (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::X0 _OPALS_COMMENT_AFTER_("Projection center's X-coordinate"
      template<class Opt, class... Opts>
      struct IAccS<Names::X0  , Opt, Opts...> : ///< Projection center's X-coordinate
        IAcc<Opts...>
      {
        virtual const Opt& X0  () const = 0; ///< Projection center's X-coordinate
        virtual       Opt& X0  ()       = 0; ///< Projection center's X-coordinate
      };
 
      /// Partial specialization for Names::Y0 _OPALS_COMMENT_AFTER_("Projection center's Y-coordinate"
      template<class Opt, class... Opts>
      struct IAccS<Names::Y0  , Opt, Opts...> : ///< Projection center's Y-coordinate
        IAcc<Opts...>
      {
        virtual const Opt& Y0  () const = 0; ///< Projection center's Y-coordinate
        virtual       Opt& Y0  ()       = 0; ///< Projection center's Y-coordinate
      };
 
      /// Partial specialization for Names::Z0 _OPALS_COMMENT_AFTER_("Projection center's Z-coordinate"
      template<class Opt, class... Opts>
      struct IAccS<Names::Z0  , Opt, Opts...> : ///< Projection center's Z-coordinate
        IAcc<Opts...>
      {
        virtual const Opt& Z0  () const = 0; ///< Projection center's Z-coordinate
        virtual       Opt& Z0  ()       = 0; ///< Projection center's Z-coordinate
      };
 
      /// Partial specialization for Names::dX0 _OPALS_COMMENT_AFTER_("Projection center's X-coordinate offset (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::dX0  , Opt, Opts...> : ///< Projection center's X-coordinate offset (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& dX0  () const = 0; ///< Projection center's X-coordinate offset (opalsStripAdjust)
        virtual       Opt& dX0  ()       = 0; ///< Projection center's X-coordinate offset (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::dY0 _OPALS_COMMENT_AFTER_("Projection center's Y-coordinate offset (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::dY0  , Opt, Opts...> : ///< Projection center's Y-coordinate offset (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& dY0  () const = 0; ///< Projection center's Y-coordinate offset (opalsStripAdjust)
        virtual       Opt& dY0  ()       = 0; ///< Projection center's Y-coordinate offset (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::dZ0 _OPALS_COMMENT_AFTER_("Projection center's Z-coordinate offset (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::dZ0  , Opt, Opts...> : ///< Projection center's Z-coordinate offset (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& dZ0  () const = 0; ///< Projection center's Z-coordinate offset (opalsStripAdjust)
        virtual       Opt& dZ0  ()       = 0; ///< Projection center's Z-coordinate offset (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::dOmega _OPALS_COMMENT_AFTER_("omega angle offset (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::dOmega  , Opt, Opts...> : ///< omega angle offset (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& dOmega  () const = 0; ///< omega angle offset (opalsStripAdjust)
        virtual       Opt& dOmega  ()       = 0; ///< omega angle offset (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::dPhi _OPALS_COMMENT_AFTER_("phi angle offset (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::dPhi  , Opt, Opts...> : ///< phi angle offset (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& dPhi  () const = 0; ///< phi angle offset (opalsStripAdjust)
        virtual       Opt& dPhi  ()       = 0; ///< phi angle offset (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::dKappa _OPALS_COMMENT_AFTER_("kappa angle offset (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::dKappa  , Opt, Opts...> : ///< kappa angle offset (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& dKappa  () const = 0; ///< kappa angle offset (opalsStripAdjust)
        virtual       Opt& dKappa  ()       = 0; ///< kappa angle offset (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::intOri _OPALS_COMMENT_AFTER_("interior orientation (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::intOri  , Opt, Opts...> : ///< interior orientation (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& intOri  () const = 0; ///< interior orientation (opalsStripAdjust)
        virtual       Opt& intOri  ()       = 0; ///< interior orientation (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::c _OPALS_COMMENT_AFTER_("focal length (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::c  , Opt, Opts...> : ///< focal length (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& c  () const = 0; ///< focal length (opalsStripAdjust)
        virtual       Opt& c  ()       = 0; ///< focal length (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::distortion _OPALS_COMMENT_AFTER_("lens distortion (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::distortion  , Opt, Opts...> : ///< lens distortion (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& distortion  () const = 0; ///< lens distortion (opalsStripAdjust)
        virtual       Opt& distortion  ()       = 0; ///< lens distortion (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::undistort _OPALS_COMMENT_AFTER_("create undistorted images (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::undistort  , Opt, Opts...> : ///< create undistorted images (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& undistort  () const = 0; ///< create undistorted images (opalsStripAdjust)
        virtual       Opt& undistort  ()       = 0; ///< create undistorted images (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::rho0 _OPALS_COMMENT_AFTER_("lens distortion normalization radius (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::rho0  , Opt, Opts...> : ///< lens distortion normalization radius (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& rho0  () const = 0; ///< lens distortion normalization radius (opalsStripAdjust)
        virtual       Opt& rho0  ()       = 0; ///< lens distortion normalization radius (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::a3 _OPALS_COMMENT_AFTER_("radial lens distortion, 3rd degree ORIENT:3 (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::a3  , Opt, Opts...> : ///< radial lens distortion, 3rd degree ORIENT:3 (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& a3  () const = 0; ///< radial lens distortion, 3rd degree ORIENT:3 (opalsStripAdjust)
        virtual       Opt& a3  ()       = 0; ///< radial lens distortion, 3rd degree ORIENT:3 (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::a4 _OPALS_COMMENT_AFTER_("radial lens distortion, 5th degree ORIENT:4 (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::a4  , Opt, Opts...> : ///< radial lens distortion, 5th degree ORIENT:4 (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& a4  () const = 0; ///< radial lens distortion, 5th degree ORIENT:4 (opalsStripAdjust)
        virtual       Opt& a4  ()       = 0; ///< radial lens distortion, 5th degree ORIENT:4 (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::a5 _OPALS_COMMENT_AFTER_("tangential lens distortion, bilinear in y ORIENT:5 (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::a5  , Opt, Opts...> : ///< tangential lens distortion, bilinear in y ORIENT:5 (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& a5  () const = 0; ///< tangential lens distortion, bilinear in y ORIENT:5 (opalsStripAdjust)
        virtual       Opt& a5  ()       = 0; ///< tangential lens distortion, bilinear in y ORIENT:5 (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::a6 _OPALS_COMMENT_AFTER_("tangential lens distortion, bilinear in x ORIENT:6 (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::a6  , Opt, Opts...> : ///< tangential lens distortion, bilinear in x ORIENT:6 (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& a6  () const = 0; ///< tangential lens distortion, bilinear in x ORIENT:6 (opalsStripAdjust)
        virtual       Opt& a6  ()       = 0; ///< tangential lens distortion, bilinear in x ORIENT:6 (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::oriFile _OPALS_COMMENT_AFTER_("file with a priori exterior image orientation (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::oriFile  , Opt, Opts...> : ///< file with a priori exterior image orientation (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& oriFile  () const = 0; ///< file with a priori exterior image orientation (opalsStripAdjust)
        virtual       Opt& oriFile  ()       = 0; ///< file with a priori exterior image orientation (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::obsFile _OPALS_COMMENT_AFTER_("file with image point observations (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::obsFile  , Opt, Opts...> : ///< file with image point observations (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& obsFile  () const = 0; ///< file with image point observations (opalsStripAdjust)
        virtual       Opt& obsFile  ()       = 0; ///< file with image point observations (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::forwardIntersect _OPALS_COMMENT_AFTER_("forward intersection of tie points group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::forwardIntersect  , Opt, Opts...> : ///< forward intersection of tie points group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& forwardIntersect  () const = 0; ///< forward intersection of tie points group (opalsStripAdjust)
        virtual       Opt& forwardIntersect  ()       = 0; ///< forward intersection of tie points group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::xSigPriori _OPALS_COMMENT_AFTER_("standard deviation a priori of x-coordinate (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::xSigPriori  , Opt, Opts...> : ///< standard deviation a priori of x-coordinate (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& xSigPriori  () const = 0; ///< standard deviation a priori of x-coordinate (opalsStripAdjust)
        virtual       Opt& xSigPriori  ()       = 0; ///< standard deviation a priori of x-coordinate (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::ySigPriori _OPALS_COMMENT_AFTER_("standard deviation a priori of x-coordinate (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::ySigPriori  , Opt, Opts...> : ///< standard deviation a priori of x-coordinate (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& ySigPriori  () const = 0; ///< standard deviation a priori of x-coordinate (opalsStripAdjust)
        virtual       Opt& ySigPriori  ()       = 0; ///< standard deviation a priori of x-coordinate (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::image2image _OPALS_COMMENT_AFTER_("image-to-image correspondences group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::image2image  , Opt, Opts...> : ///< image-to-image correspondences group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& image2image  () const = 0; ///< image-to-image correspondences group (opalsStripAdjust)
        virtual       Opt& image2image  ()       = 0; ///< image-to-image correspondences group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::minImageCount _OPALS_COMMENT_AFTER_("minimum number of image points for a tie point (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::minImageCount  , Opt, Opts...> : ///< minimum number of image points for a tie point (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& minImageCount  () const = 0; ///< minimum number of image points for a tie point (opalsStripAdjust)
        virtual       Opt& minImageCount  ()       = 0; ///< minimum number of image points for a tie point (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::image2strip _OPALS_COMMENT_AFTER_("image-to-strip correspondences group (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::image2strip  , Opt, Opts...> : ///< image-to-strip correspondences group (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& image2strip  () const = 0; ///< image-to-strip correspondences group (opalsStripAdjust)
        virtual       Opt& image2strip  ()       = 0; ///< image-to-strip correspondences group (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::extrapolationCheck _OPALS_COMMENT_AFTER_("check for extrapolation (opalsGrid
      template<class Opt, class... Opts>
      struct IAccS<Names::extrapolationCheck  , Opt, Opts...> : ///< check for extrapolation (opalsGrid)
        IAcc<Opts...>
      {
        virtual const Opt& extrapolationCheck  () const = 0; ///< check for extrapolation (opalsGrid)
        virtual       Opt& extrapolationCheck  ()       = 0; ///< check for extrapolation (opalsGrid)
      };
 
      /// Partial specialization for Names::splitByAttribute _OPALS_COMMENT_AFTER_("split data set by a certain (integer-valued
      template<class Opt, class... Opts>
      struct IAccS<Names::splitByAttribute  , Opt, Opts...> : ///< split data set by a certain (integer-valued) attribute(opalsTranslate)
        IAcc<Opts...>
      {
        virtual const Opt& splitByAttribute  () const = 0; ///< split data set by a certain (integer-valued) attribute(opalsTranslate)
        virtual       Opt& splitByAttribute  ()       = 0; ///< split data set by a certain (integer-valued) attribute(opalsTranslate)
      };
 
      /// Partial specialization for Names::applyTrafo _OPALS_COMMENT_AFTER_("determines whether to apply transformation to first or second input file(opalsDiff
      template<class Opt, class... Opts>
      struct IAccS<Names::applyTrafo  , Opt, Opts...> : ///< determines whether to apply transformation to first or second input file(opalsDiff)
        IAcc<Opts...>
      {
        virtual const Opt& applyTrafo  () const = 0; ///< determines whether to apply transformation to first or second input file(opalsDiff)
        virtual       Opt& applyTrafo  ()       = 0; ///< determines whether to apply transformation to first or second input file(opalsDiff)
      };
 
      /// Partial specialization for Names::exactComputation _OPALS_COMMENT_AFTER_("flag for exact median computation (opalsHisto
      template<class Opt, class... Opts>
      struct IAccS<Names::exactComputation  , Opt, Opts...> : ///< flag for exact median computation (opalsHisto)
        IAcc<Opts...>
      {
        virtual const Opt& exactComputation  () const = 0; ///< flag for exact median computation (opalsHisto)
        virtual       Opt& exactComputation  ()       = 0; ///< flag for exact median computation (opalsHisto)
      };
 
      /// Partial specialization for Names::spikeRemoval _OPALS_COMMENT_AFTER_("flag for removing spikes in the final modelling result (opalsLineModeler
      template<class Opt, class... Opts>
      struct IAccS<Names::spikeRemoval  , Opt, Opts...> : ///< flag for removing spikes in the final modelling result (opalsLineModeler)
        IAcc<Opts...>
      {
        virtual const Opt& spikeRemoval  () const = 0; ///< flag for removing spikes in the final modelling result (opalsLineModeler)
        virtual       Opt& spikeRemoval  ()       = 0; ///< flag for removing spikes in the final modelling result (opalsLineModeler)
      };
 
      /// Partial specialization for Names::oriFormat _OPALS_COMMENT_AFTER_("file format for image orientations (opalsSnellius
      template<class Opt, class... Opts>
      struct IAccS<Names::oriFormat  , Opt, Opts...> : ///< file format for image orientations (opalsSnellius)
        IAcc<Opts...>
      {
        virtual const Opt& oriFormat  () const = 0; ///< file format for image orientations (opalsSnellius)
        virtual       Opt& oriFormat  ()       = 0; ///< file format for image orientations (opalsSnellius)
      };
 
      /// Partial specialization for Names::workflow _OPALS_COMMENT_AFTER_("group for workflow control (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::workflow  , Opt, Opts...> : ///< group for workflow control (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& workflow  () const = 0; ///< group for workflow control (opalsStripAdjust)
        virtual       Opt& workflow  ()       = 0; ///< group for workflow control (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::stages _OPALS_COMMENT_AFTER_("group to limit the stages to be processed (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::stages  , Opt, Opts...> : ///< group to limit the stages to be processed (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& stages  () const = 0; ///< group to limit the stages to be processed (opalsStripAdjust)
        virtual       Opt& stages  ()       = 0; ///< group to limit the stages to be processed (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::last _OPALS_COMMENT_AFTER_("last stage to be processed (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::last  , Opt, Opts...> : ///< last stage to be processed (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& last  () const = 0; ///< last stage to be processed (opalsStripAdjust)
        virtual       Opt& last  ()       = 0; ///< last stage to be processed (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::strip _OPALS_COMMENT_AFTER_("strip ID of an image (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::strip  , Opt, Opts...> : ///< strip ID of an image (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& strip  () const = 0; ///< strip ID of an image (opalsStripAdjust)
        virtual       Opt& strip  ()       = 0; ///< strip ID of an image (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::checkPoints _OPALS_COMMENT_AFTER_("IDs of check points (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::checkPoints  , Opt, Opts...> : ///< IDs of check points (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& checkPoints  () const = 0; ///< IDs of check points (opalsStripAdjust)
        virtual       Opt& checkPoints  ()       = 0; ///< IDs of check points (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::maxReprojectionError _OPALS_COMMENT_AFTER_("maximum reprojection error (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::maxReprojectionError  , Opt, Opts...> : ///< maximum reprojection error (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& maxReprojectionError  () const = 0; ///< maximum reprojection error (opalsStripAdjust)
        virtual       Opt& maxReprojectionError  ()       = 0; ///< maximum reprojection error (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::segments _OPALS_COMMENT_AFTER_("segment manager (opalsSegmentation
      template<class Opt, class... Opts>
      struct IAccS<Names::segments  , Opt, Opts...> : ///< segment manager (opalsSegmentation)
        IAcc<Opts...>
      {
        virtual const Opt& segments  () const = 0; ///< segment manager (opalsSegmentation)
        virtual       Opt& segments  ()       = 0; ///< segment manager (opalsSegmentation)
      };
 
      /// Partial specialization for Names::alphaShapeRefPlane _OPALS_COMMENT_AFTER_("reference plane for alpha shapes (opalsSegmentation
      template<class Opt, class... Opts>
      struct IAccS<Names::alphaShapeRefPlane  , Opt, Opts...> : ///< reference plane for alpha shapes (opalsSegmentation)
        IAcc<Opts...>
      {
        virtual const Opt& alphaShapeRefPlane  () const = 0; ///< reference plane for alpha shapes (opalsSegmentation)
        virtual       Opt& alphaShapeRefPlane  ()       = 0; ///< reference plane for alpha shapes (opalsSegmentation)
      };
 
      /// Partial specialization for Names::sort _OPALS_COMMENT_AFTER_("sorting method (opalsSegmentation: sorting of segments
      template<class Opt, class... Opts>
      struct IAccS<Names::sort  , Opt, Opts...> : ///< sorting method (opalsSegmentation: sorting of segments)
        IAcc<Opts...>
      {
        virtual const Opt& sort  () const = 0; ///< sorting method (opalsSegmentation: sorting of segments)
        virtual       Opt& sort  ()       = 0; ///< sorting method (opalsSegmentation: sorting of segments)
      };
 
      /// Partial specialization for Names::byproduct _OPALS_COMMENT_AFTER_("optional output that is not the central result of a module run (opalsSegmentation: segment odm representation
      template<class Opt, class... Opts>
      struct IAccS<Names::byproduct  , Opt, Opts...> : ///< optional output that is not the central result of a module run (opalsSegmentation: segment odm representation)
        IAcc<Opts...>
      {
        virtual const Opt& byproduct  () const = 0; ///< optional output that is not the central result of a module run (opalsSegmentation: segment odm representation)
        virtual       Opt& byproduct  ()       = 0; ///< optional output that is not the central result of a module run (opalsSegmentation: segment odm representation)
      };
 
      /// Partial specialization for Names::crsTrafo _OPALS_COMMENT_AFTER_("crs transformation group (opalsTranslate
      template<class Opt, class... Opts>
      struct IAccS<Names::crsTrafo  , Opt, Opts...> : ///< crs transformation group (opalsTranslate)
        IAcc<Opts...>
      {
        virtual const Opt& crsTrafo  () const = 0; ///< crs transformation group (opalsTranslate)
        virtual       Opt& crsTrafo  ()       = 0; ///< crs transformation group (opalsTranslate)
      };
 
      /// Partial specialization for Names::inCRS _OPALS_COMMENT_AFTER_("input coordinate reference system as WKT/proj4 description string or EPSG code (opalsTranslate
      template<class Opt, class... Opts>
      struct IAccS<Names::inCRS  , Opt, Opts...> : ///< input coordinate reference system as WKT/proj4 description string or EPSG code (opalsTranslate)
        IAcc<Opts...>
      {
        virtual const Opt& inCRS  () const = 0; ///< input coordinate reference system as WKT/proj4 description string or EPSG code (opalsTranslate)
        virtual       Opt& inCRS  ()       = 0; ///< input coordinate reference system as WKT/proj4 description string or EPSG code (opalsTranslate)
      };
 
      /// Partial specialization for Names::outCRS _OPALS_COMMENT_AFTER_("output coordinate reference system as WKT/proj4 description string or EPSG code (opalsTranslate
      template<class Opt, class... Opts>
      struct IAccS<Names::outCRS  , Opt, Opts...> : ///< output coordinate reference system as WKT/proj4 description string or EPSG code (opalsTranslate)
        IAcc<Opts...>
      {
        virtual const Opt& outCRS  () const = 0; ///< output coordinate reference system as WKT/proj4 description string or EPSG code (opalsTranslate)
        virtual       Opt& outCRS  ()       = 0; ///< output coordinate reference system as WKT/proj4 description string or EPSG code (opalsTranslate)
      };
 
      /// Partial specialization for Names::groundTiePoints _OPALS_COMMENT_AFTER_("group for tie object points (opalsStripAdjust
      template<class Opt, class... Opts>
      struct IAccS<Names::groundTiePoints  , Opt, Opts...> : ///< group for tie object points (opalsStripAdjust)
        IAcc<Opts...>
      {
        virtual const Opt& groundTiePoints  () const = 0; ///< group for tie object points (opalsStripAdjust)
        virtual       Opt& groundTiePoints  ()       = 0; ///< group for tie object points (opalsStripAdjust)
      };
 
      /// Partial specialization for Names::aFormat _OPALS_COMMENT_AFTER_("format for approximate file (opalsDBH
      template<class Opt, class... Opts>
      struct IAccS<Names::aFormat  , Opt, Opts...> : ///< format for approximate file (opalsDBH)
        IAcc<Opts...>
      {
        virtual const Opt& aFormat  () const = 0; ///< format for approximate file (opalsDBH)
        virtual       Opt& aFormat  ()       = 0; ///< format for approximate file (opalsDBH)
      };
 
      /// Partial specialization for Names::trace _OPALS_COMMENT_AFTER_("for tracing a stem up and downwards (opalsDBH
      template<class Opt, class... Opts>
      struct IAccS<Names::trace  , Opt, Opts...> : ///< for tracing a stem up and downwards (opalsDBH)
        IAcc<Opts...>
      {
        virtual const Opt& trace  () const = 0; ///< for tracing a stem up and downwards (opalsDBH)
        virtual       Opt& trace  ()       = 0; ///< for tracing a stem up and downwards (opalsDBH)
      };
 
      /// Partial specialization for Names::classifyOverlap _OPALS_COMMENT_AFTER_("test option for opalsTerrainFiler"
      template<class Opt, class... Opts>
      struct IAccS<Names::classifyOverlap  , Opt, Opts...> : ///< test option for opalsTerrainFiler
        IAcc<Opts...>
      {
        virtual const Opt& classifyOverlap  () const = 0; ///< test option for opalsTerrainFiler
        virtual       Opt& classifyOverlap  ()       = 0; ///< test option for opalsTerrainFiler
      };
 
      /// Partial specialization for Names::valueFrequency _OPALS_COMMENT_AFTER_("option for opalsInfo for extracting the value frequencies for certain attributes/bands"
      template<class Opt, class... Opts>
      struct IAccS<Names::valueFrequency  , Opt, Opts...> : ///< option for opalsInfo for extracting the value frequencies for certain attributes/bands
        IAcc<Opts...>
      {
        virtual const Opt& valueFrequency  () const = 0; ///< option for opalsInfo for extracting the value frequencies for certain attributes/bands
        virtual       Opt& valueFrequency  ()       = 0; ///< option for opalsInfo for extracting the value frequencies for certain attributes/bands
      };
 
      /// Partial specialization for Names::skipEmptyBins _OPALS_COMMENT_AFTER_("skips empty bin entries in the histogram (opalsHisto
      template<class Opt, class... Opts>
      struct IAccS<Names::skipEmptyBins  , Opt, Opts...> : ///< skips empty bin entries in the histogram (opalsHisto)
        IAcc<Opts...>
      {
        virtual const Opt& skipEmptyBins  () const = 0; ///< skips empty bin entries in the histogram (opalsHisto)
        virtual       Opt& skipEmptyBins  ()       = 0; ///< skips empty bin entries in the histogram (opalsHisto)
      };
 
      /// Partial specialization for Names::exportOverview _OPALS_COMMENT_AFTER_("export overview features (opalsInfo
      template<class Opt, class... Opts>
      struct IAccS<Names::exportOverview  , Opt, Opts...> : ///< export overview features (opalsInfo)
        IAcc<Opts...>
      {
        virtual const Opt& exportOverview  () const = 0; ///< export overview features (opalsInfo)
        virtual       Opt& exportOverview  ()       = 0; ///< export overview features (opalsInfo)
      };
 
      /// Partial specialization for Names::mergeWidth _OPALS_COMMENT_AFTER_("merge width defining the band for blending multiple raster (opalsGridMerge
      template<class Opt, class... Opts>
      struct IAccS<Names::mergeWidth  , Opt, Opts...> : ///< merge width defining the band for blending multiple raster (opalsGridMerge)
        IAcc<Opts...>
      {
        virtual const Opt& mergeWidth  () const = 0; ///< merge width defining the band for blending multiple raster (opalsGridMerge)
        virtual       Opt& mergeWidth  ()       = 0; ///< merge width defining the band for blending multiple raster (opalsGridMerge)
      };
 
      /// Partial specialization for Names::nonOverlapMerge _OPALS_COMMENT_AFTER_("merging non-overlapping datasets (opalsGridMerge
      template<class Opt, class... Opts>
      struct IAccS<Names::nonOverlapMerge  , Opt, Opts...> : ///< merging non-overlapping datasets (opalsGridMerge)
        IAcc<Opts...>
      {
        virtual const Opt& nonOverlapMerge  () const = 0; ///< merging non-overlapping datasets (opalsGridMerge)
        virtual       Opt& nonOverlapMerge  ()       = 0; ///< merging non-overlapping datasets (opalsGridMerge)
      };
 
      /// Partial specialization for Names::mergeFunc _OPALS_COMMENT_AFTER_("merge function for blending multiple raster (opalsGridMerge
      template<class Opt, class... Opts>
      struct IAccS<Names::mergeFunc  , Opt, Opts...> : ///< merge function for blending multiple raster (opalsGridMerge)
        IAcc<Opts...>
      {
        virtual const Opt& mergeFunc  () const = 0; ///< merge function for blending multiple raster (opalsGridMerge)
        virtual       Opt& mergeFunc  ()       = 0; ///< merge function for blending multiple raster (opalsGridMerge)
      };
 
      /// Partial specialization for Names::activateBorderMerge _OPALS_COMMENT_AFTER_("flag if grid files should be merged at the border (opalsGridMerge
      template<class Opt, class... Opts>
      struct IAccS<Names::activateBorderMerge  , Opt, Opts...> : ///< flag if grid files should be merged at the border (opalsGridMerge)
        IAcc<Opts...>
      {
        virtual const Opt& activateBorderMerge  () const = 0; ///< flag if grid files should be merged at the border (opalsGridMerge)
        virtual       Opt& activateBorderMerge  ()       = 0; ///< flag if grid files should be merged at the border (opalsGridMerge)
      };
 
      /// Partial specialization for Names::style _OPALS_COMMENT_AFTER_("Parameter group 'style' containing styling-options for isolines (opalsIsolines
      template<class Opt, class... Opts>
      struct IAccS<Names::style  , Opt, Opts...> : ///< Parameter group 'style' containing styling-options for isolines (opalsIsolines)
        IAcc<Opts...>
      {
        virtual const Opt& style  () const = 0; ///< Parameter group 'style' containing styling-options for isolines (opalsIsolines)
        virtual       Opt& style  ()       = 0; ///< Parameter group 'style' containing styling-options for isolines (opalsIsolines)
      };
 
      /// Partial specialization for Names::maxSlope _OPALS_COMMENT_AFTER_("defines maximum slope to consider (opalsIsolines
      template<class Opt, class... Opts>
      struct IAccS<Names::maxSlope  , Opt, Opts...> : ///< defines maximum slope to consider (opalsIsolines)
        IAcc<Opts...>
      {
        virtual const Opt& maxSlope  () const = 0; ///< defines maximum slope to consider (opalsIsolines)
        virtual       Opt& maxSlope  ()       = 0; ///< defines maximum slope to consider (opalsIsolines)
      };
 
      /// Partial specialization for Names::deviation _OPALS_COMMENT_AFTER_("byproduct deviation file (opalsGridMerge
      template<class Opt, class... Opts>
      struct IAccS<Names::deviation  , Opt, Opts...> : ///< byproduct deviation file (opalsGridMerge)
        IAcc<Opts...>
      {
        virtual const Opt& deviation  () const = 0; ///< byproduct deviation file (opalsGridMerge)
        virtual       Opt& deviation  ()       = 0; ///< byproduct deviation file (opalsGridMerge)
      };
 
      /// Partial specialization for Names::processStructure _OPALS_COMMENT_AFTER_("byproduct structure file (opalsGridMerge
      template<class Opt, class... Opts>
      struct IAccS<Names::processStructure  , Opt, Opts...> : ///< byproduct structure file (opalsGridMerge)
        IAcc<Opts...>
      {
        virtual const Opt& processStructure  () const = 0; ///< byproduct structure file (opalsGridMerge)
        virtual       Opt& processStructure  ()       = 0; ///< byproduct structure file (opalsGridMerge)
      };
 
      /// Partial specialization for Names::maxBridgeDist _OPALS_COMMENT_AFTER_("defines maximum distance to be bridged (opalsIsolines
      template<class Opt, class... Opts>
      struct IAccS<Names::maxBridgeDist  , Opt, Opts...> : ///< defines maximum distance to be bridged (opalsIsolines)
        IAcc<Opts...>
      {
        virtual const Opt& maxBridgeDist  () const = 0; ///< defines maximum distance to be bridged (opalsIsolines)
        virtual       Opt& maxBridgeDist  ()       = 0; ///< defines maximum distance to be bridged (opalsIsolines)
      };
 
      /// Partial specialization for Names::generateOFD _OPALS_COMMENT_AFTER_("defines maximum distance to be bridged (opalsInfo
      template<class Opt, class... Opts>
      struct IAccS<Names::generateOFD  , Opt, Opts...> : ///< defines maximum distance to be bridged (opalsInfo)
        IAcc<Opts...>
      {
        virtual const Opt& generateOFD  () const = 0; ///< defines maximum distance to be bridged (opalsInfo)
        virtual       Opt& generateOFD  ()       = 0; ///< defines maximum distance to be bridged (opalsInfo)
      };
 
      /// Partial specialization for Names::file _OPALS_COMMENT_AFTER_("generic file parameter (opalsInfo
      template<class Opt, class... Opts>
      struct IAccS<Names::file  , Opt, Opts...> : ///< generic file parameter (opalsInfo)
        IAcc<Opts...>
      {
        virtual const Opt& file  () const = 0; ///< generic file parameter (opalsInfo)
        virtual       Opt& file  ()       = 0; ///< generic file parameter (opalsInfo)
      };
 
      /// Partial specialization for Names::format _OPALS_COMMENT_AFTER_("generic format parameter (opalsInfo
      template<class Opt, class... Opts>
      struct IAccS<Names::format  , Opt, Opts...> : ///< generic format parameter (opalsInfo)
        IAcc<Opts...>
      {
        virtual const Opt& format  () const = 0; ///< generic format parameter (opalsInfo)
        virtual       Opt& format  ()       = 0; ///< generic format parameter (opalsInfo)
      };
 
      /// Partial specialization for Names::distributionFunc _OPALS_COMMENT_AFTER_("definition of reference distribution (opalsHisto
      template<class Opt, class... Opts>
      struct IAccS<Names::distributionFunc  , Opt, Opts...> : ///< definition of reference distribution (opalsHisto)
        IAcc<Opts...>
      {
        virtual const Opt& distributionFunc  () const = 0; ///< definition of reference distribution (opalsHisto)
        virtual       Opt& distributionFunc  ()       = 0; ///< definition of reference distribution (opalsHisto)
      };
 
      /// Partial specialization for Names::cumulativeHistogram _OPALS_COMMENT_AFTER_("flag for activating the cumulative histogram (opalsHisto
      template<class Opt, class... Opts>
      struct IAccS<Names::cumulativeHistogram  , Opt, Opts...> : ///< flag for activating the cumulative histogram (opalsHisto)
        IAcc<Opts...>
      {
        virtual const Opt& cumulativeHistogram  () const = 0; ///< flag for activating the cumulative histogram (opalsHisto)
        virtual       Opt& cumulativeHistogram  ()       = 0; ///< flag for activating the cumulative histogram (opalsHisto)
      };
 
      /// Partial specialization for Names::setAttribute _OPALS_COMMENT_AFTER_("generic ground point calculator setting (opalsTerrainFilter
      template<class Opt, class... Opts>
      struct IAccS<Names::setAttribute  , Opt, Opts...> : ///< generic ground point calculator setting (opalsTerrainFilter)
        IAcc<Opts...>
      {
        virtual const Opt& setAttribute  () const = 0; ///< generic ground point calculator setting (opalsTerrainFilter)
        virtual       Opt& setAttribute  ()       = 0; ///< generic ground point calculator setting (opalsTerrainFilter)
      };
 
      /// Partial specialization for Names::enduranceMode _OPALS_COMMENT_AFTER_("force to continue processing (with next file/dataset
      template<class Opt, class... Opts>
      struct IAccS<Names::enduranceMode  , Opt, Opts...> : ///< force to continue processing (with next file/dataset) where normally an expcetions would be thrown (opalsInfo)
        IAcc<Opts...>
      {
        virtual const Opt& enduranceMode  () const = 0; ///< force to continue processing (with next file/dataset) where normally an expcetions would be thrown (opalsInfo)
        virtual       Opt& enduranceMode  ()       = 0; ///< force to continue processing (with next file/dataset) where normally an expcetions would be thrown (opalsInfo)
      };
 
      /// Partial specialization for Names::refinePlanes _OPALS_COMMENT_AFTER_("activates refining step for plane extraction (opalsSegementation
      template<class Opt, class... Opts>
      struct IAccS<Names::refinePlanes  , Opt, Opts...> : ///< activates refining step for plane extraction (opalsSegementation)
        IAcc<Opts...>
      {
        virtual const Opt& refinePlanes  () const = 0; ///< activates refining step for plane extraction (opalsSegementation)
        virtual       Opt& refinePlanes  ()       = 0; ///< activates refining step for plane extraction (opalsSegementation)
      };
 
      /// Partial specialization for Names::detailedAnalysis _OPALS_COMMENT_AFTER_("record detailed analysis while processing (opalsTerrainFilter
      template<class Opt, class... Opts>
      struct IAccS<Names::detailedAnalysis  , Opt, Opts...> : ///< record detailed analysis while processing (opalsTerrainFilter)
        IAcc<Opts...>
      {
        virtual const Opt& detailedAnalysis  () const = 0; ///< record detailed analysis while processing (opalsTerrainFilter)
        virtual       Opt& detailedAnalysis  ()       = 0; ///< record detailed analysis while processing (opalsTerrainFilter)
      };
 
    }
 
    /// Ultimately, defines the specialization of IAcc in the namespace according to Opt's enumerator.
    /** IAcc derives from another specialization of itself (in the same namespace) for the subsequent options, and finally from IBase.
        It does so by help of IAcc in that namespace.
        \tparam Opt     The first member of a group, the one to define the specialization of IAcc for.
        \tparam Opts    The other members of that group. */
    template<class... Opts>
    struct IAcc_
    {
      using Type = IBase;
    };
 
    template<class Opt, class... Opts>
    struct IAcc_<Opt, Opts...>
    {
      using Name = typename Opt::Name;
      using Type = std::conditional_t<
        Name::value <= Names::LastShared,
        std::conditional_t<
          Name::value <= Names::LastGlobal,
          glob::IAcc<Opt, Opts...>,
          comm::IAcc<Opt, Opts...>
        >,
        spec::IAcc<Opt, Opts...>
      >;
    };
 
    /// The specialization of IAcc for the first member of a group.
    /** \tparam Opts    The members of the group. */
    template<class... Opts>
    using IAcc = typename IAcc_<Opts...>::Type;
 
  }
}