LiftDragModel.hh

Go to the documentation of this file.

// Copyright (c) 2016 The UUV Simulator Authors.
// All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.


#ifndef __UUV_GAZEBO_PLUGINS_LIFT_DRAG_MODEL_HH__
#define __UUV_GAZEBO_PLUGINS_LIFT_DRAG_MODEL_HH__

#include <map>
#include <string>

#include <gazebo/gazebo.hh>

#include <sdf/sdf.hh>

namespace gazebo
{
class LiftDrag
{
  protected: LiftDrag() : prevTime(-10.), state(0.) {}

  public: static bool CheckForElement(sdf::ElementPtr _sdf,
                                      const std::string& element);

  public: virtual ~LiftDrag() {}

  public: virtual std::string GetType() = 0;

  public: virtual ignition::math::Vector3d compute(
    const ignition::math::Vector3d &_velL) = 0;

  public: virtual bool GetParam(std::string _tag,
    double& _output) = 0;

  public: virtual std::map<std::string, double> GetListParams() = 0;

  protected: double prevTime;

  protected: double state;
};

typedef LiftDrag* (*LiftDragCreator)(sdf::ElementPtr);

class LiftDragFactory
{
  public: LiftDrag* CreateLiftDrag(sdf::ElementPtr _sdf);

  public: static LiftDragFactory& GetInstance();

  public: bool RegisterCreator(const std::string& _identifier,
                               LiftDragCreator _creator);

  private: LiftDragFactory() {}

  private: std::map<std::string, LiftDragCreator> creators_;
};

#define REGISTER_LIFTDRAG(type) static const bool registeredWithFactory

#define REGISTER_LIFTDRAG_CREATOR(type, creator) \
  const bool type::registeredWithFactory = \
  LiftDragFactory::GetInstance().RegisterCreator( \
  type::IDENTIFIER, creator);


class LiftDragQuadratic : public LiftDrag
{
  public: static LiftDrag* create(sdf::ElementPtr _sdf);

  public: virtual std::string GetType() { return IDENTIFIER; }

  public: virtual ignition::math::Vector3d compute(const ignition::math::Vector3d &velL);

  private: REGISTER_LIFTDRAG(LiftDragQuadratic);

  public: virtual bool GetParam(std::string _tag, double& _output);

  public: virtual std::map<std::string, double> GetListParams();

  private: static const std::string IDENTIFIER;

  protected: double liftConstant;

  protected: double dragConstant;

  private: LiftDragQuadratic(double _liftConstant, double _dragConstant)
    : LiftDrag(), liftConstant(_liftConstant), dragConstant(_dragConstant) {}
};

class LiftDragTwoLines: public LiftDrag
{
  public: static LiftDrag* create(sdf::ElementPtr _sdf);

  public: virtual std::string GetType() { return IDENTIFIER; }

  public: virtual ignition::math::Vector3d compute(const ignition::math::Vector3d &_velL);

  private: REGISTER_LIFTDRAG(LiftDragTwoLines);

  private: static const std::string IDENTIFIER;

  public: virtual bool GetParam(std::string _tag, double& _output);

  public: virtual std::map<std::string, double> GetListParams();

  protected: double area;

  protected: double fluidDensity;

  protected: double a0;

  protected: double alphaStall;

  protected: double cla;

  protected: double claStall;

  protected: double cda;

  protected: double cdaStall;

  private: LiftDragTwoLines(double _area, double _fluidDensity, double _a0,
                            double _alphaStall, double _cla, double _claStall,
                            double _cda, double _cdaStall)
    : LiftDrag(), area(_area), fluidDensity(_fluidDensity),
      a0(_a0), alphaStall(_alphaStall),
      cla(_cla), claStall(_claStall),
      cda(_cda), cdaStall(_cdaStall) {}
};
}

#endif