InteractionParamsPy.h

Go to the documentation of this file.

//                                                         //
// Copyright (c) 2003-2014 by The University of Queensland //
// Centre for Geoscience Computing                         //
// http://earth.uq.edu.au/centre-geoscience-computing      //
//                                                         //
// Primary Business: Brisbane, Queensland, Australia       //
// Licensed under the Open Software License version 3.0    //
// http://www.opensource.org/licenses/osl-3.0.php          //
//                                                         //

#ifndef ESYS_LSMINTERACTIONPARAMSPY_H
#define ESYS_LSMINTERACTIONPARAMSPY_H

/*---------------------------------------------------
 *
 * wrapper classes for interaction parameters
 *
 *--------------------------------------------------*/

//--- project includes ---
#include "Model/BondedInteraction.h"
#include "Model/CappedBondedInteraction.h"
#include "Model/ElasticInteraction.h"
#include "Model/RotElasticInteraction.h"
#include "Model/FrictionInteraction.h"
#include "Model/RotBondedInteraction.h"
#include "Model/VWFrictionInteraction.h"
#include "Model/RotFricInteraction.h"
#include "Model/RotThermBondedInteraction.h"
#include "Model/RotThermFricInteraction.h"
#include "Model/RotThermElasticInteraction.h"
#include "Model/DampingIGP.h"
#include "Model/LocalDampingIGP.h"
#include "Model/ABCDampingIGP.h"
#include "Model/BodyForceGroup.h"
#include "Model/HertzianElasticInteraction.h"
#include "Model/HertzianViscoElasticFrictionInteraction.h"
#include "Model/HertzianViscoElasticInteraction.h"
#include "Model/LinearDashpotInteraction.h"

//--- STL includes ---
#include <string>

namespace esys
{
  namespace lsm
  {
    class Vec3Py;

    class InteractionPrmsPy
    {
    public:
      InteractionPrmsPy();
    };

    class DampingPrmsPy : public CDampingIGP
    {
    public:
      DampingPrmsPy(
         const std::string &type,
         const std::string &name,
         double viscosity,
         int maxIterations
      );
    };

    class LinDampingPrmsPy : public DampingPrmsPy
    {
    public:
      LinDampingPrmsPy(
         const std::string &name,
         double viscosity,
         int maxIterations
      );
    };

    class RotDampingPrmsPy : public DampingPrmsPy
    {
    public:
      RotDampingPrmsPy(
         const std::string &name,
         double viscosity,
         int maxIterations
      );
    };

    class LocalDampingPrmsPy : public CLocalDampingIGP
    {
    public:
      LocalDampingPrmsPy(
         const std::string &name,
         double viscosity
      );
    };

    class RotLocalDampingPrmsPy : public CLocalDampingIGP
    {
    public:
      RotLocalDampingPrmsPy(
         const std::string &name,
         double viscosity
      );
    };

    class ABCDampingPrmsPy : public ABCDampingIGP
    {
    public:
      ABCDampingPrmsPy(
         const std::string &type,
         const std::string &name,
         double viscosity,
         int maxIterations,
         const Vec3& vref,
         const Vec3& pos,
         const Vec3& normal,
         double c1
      );
    };

    class NRotBondPrmsPy : public CBondedIGP
    {
    public:
      NRotBondPrmsPy(const std::string&,double,double,int);
      NRotBondPrmsPy(const std::string&,double,double,int,bool);
    };

    class CappedNRotBondPrmsPy : public CCappedBondedIGP
    {
    public:
      CappedNRotBondPrmsPy(const std::string&,double,double,double,int);
    };

    class NRotShortBondPrmsPy : public CBondedIGP
    {
    public:
      NRotShortBondPrmsPy(const std::string&,double,double,int);
    };

    class NRotElasticPrmsPy : public CElasticIGP
    {
    public:
      NRotElasticPrmsPy(
        const  std::string &name,
        double normalK
      );

      NRotElasticPrmsPy(
        const  std::string &name,
        double normalK,
        bool   scaling
      );
    };

    class HertzianElasticPrmsPy : public CHertzianElasticIGP
    {
    public:
      HertzianElasticPrmsPy(const std::string&,double,double);
    };
 
    class HertzianViscoElasticFrictionPrmsPy
    : public CHertzianViscoElasticFrictionIGP
    {
    public:
      HertzianViscoElasticFrictionPrmsPy(
        const std::string&,
        double,
        double,
        double,
        double,
        double
      );
    };

    class HertzianViscoElasticPrmsPy : public CHertzianViscoElasticIGP
    {
    public:
      HertzianViscoElasticPrmsPy(const std::string&,double,double,double);
    };
 
    class LinearDashpotPrmsPy : public CLinearDashpotIGP
    {
    public:
      LinearDashpotPrmsPy(const std::string&,double,double);
    };

    class NRotFrictionPrmsPy : public CFrictionIGP
    {
    public: 
      NRotFrictionPrmsPy(
        const std::string &name,
        double normalK,
        double dynamicMu,
        double shearK,
        bool scaling
      );

      NRotFrictionPrmsPy(
        const std::string &name,
        double normalK,
        double dynamicMu,
        double shearK
      );
    };

    class BrittleBeamPrmsPy : public CRotBondedIGP
    {
    private:
      std::string m_name; // unused ??
    public:
      BrittleBeamPrmsPy(
        const  std::string &name,
        double youngsModulus,
        double poissonsRatio,
        double cohesion,
        double tanAngle,
        int    aTag
      );

      BrittleBeamPrmsPy(
        const  std::string &name,
        double youngsModulus,
        double poissonsRatio,
        double cohesion,
        double tanAngle,
        int    aTag,
        bool   meanR_scaling
      );

      BrittleBeamPrmsPy(
        const  std::string &name,
        double youngsModulus,
        double poissonsRatio,
        double cohesion,
        double tanAngle,
        int    aTag,
        bool   meanR_scaling,
        double truncated,
        double beta1,
        double beta2
      );
    };

    class RotBondPrmsPy : public CRotBondedIGP
    {
    private:
      std::string m_name; // unused ??
    public:
      RotBondPrmsPy(
        const  std::string &name,
        double normalK,
        double shearK,
        double torsionK,
        double bendingK,
        double normalBrkForce,
        double shearBrkForce,
        double torsionBrkForce,
        double bendingBrkForce,
        int    aTag
      );

      RotBondPrmsPy(
        const  std::string &name,
        double normalK,
        double shearK,
        double torsionK,
        double bendingK,
        double normalBrkForce,
        double shearBrkForce,
        double torsionBrkForce,
        double bendingBrkForce,
        int    aTag,
        bool   scaling
      );

      RotBondPrmsPy(
        const  std::string &name,
        double normalK,
        double shearK,
        double torsionK,
        double bendingK,
        double normalBrkForce,
        double shearBrkForce,
        double torsionBrkForce,
        double bendingBrkForce,
        int    aTag,
        bool   scaling,
        bool   meanR_scaling
      );

      RotBondPrmsPy(
        const  std::string &name,
        double normalK,
        double shearK,
        double torsionK,
        double bendingK,
        double normalBrkForce,
        double shearBrkForce,
        double torsionBrkForce,
        double bendingBrkForce,
        int    aTag,
        bool   scaling,
        bool   meanR_scaling,
        double truncated
      );
    };

    class FrictionPrmsPy : public CRotFrictionIGP
    {
    public:
      FrictionPrmsPy(
        const  std::string &name,
        double youngsModulus,
        double poissonsRatio,
        double dynamicMu,    // sliding frictional coefficient
        double staticMu,     // max static frictional coefficient
        bool   rigid,
        bool   meanR_scaling
      );

      FrictionPrmsPy(
        const  std::string &name,
        double youngsModulus,
        double poissonsRatio,
        double dynamicMu,    // sliding frictional coefficient
        double staticMu     // max static frictional coefficient
      );

      FrictionPrmsPy(
        const  std::string &name,
        double youngsModulus,
        double poissonsRatio,
        double dynamicMu,    // sliding frictional coefficient
        double staticMu,     // max static frictional coefficient
        bool   rigid
      );
    };
    
    class RotFrictionPrmsPy : public CRotFrictionIGP
    {
    public:
      RotFrictionPrmsPy(
        const  std::string &name,
        double normalK,
        double dynamicMu,    // sliding frictional coefficient
        double staticMu,     // max static frictional coefficient
        double shearK
      );

      RotFrictionPrmsPy(
        const  std::string &name,
        double normalK,
        double dynamicMu,    // sliding frictional coefficient
        double staticMu,     // max static frictional coefficient
        double shearK,
        bool   scaling
      );

      RotFrictionPrmsPy(
        const  std::string &name,
        double normalK,
        double dynamicMu,    // sliding frictional coefficient
        double staticMu,     // max static frictional coefficient
        double shearK,
        bool   scaling,
        bool   rigid
      );

      RotFrictionPrmsPy(
        const  std::string &name,
        double normalK,
        double dynamicMu,    // sliding frictional coefficient
        double staticMu,     // max static frictional coefficient
        double shearK,
        bool   scaling,
        bool   rigid,
        bool   meanR_scaling
      );
    };

    class RotElasticPrmsPy : public CRotElasticIGP
    {
    public:
      RotElasticPrmsPy(
        const  std::string& name,
        double normalK
      );

      RotElasticPrmsPy(
        const  std::string& name,
        double normalK,
        bool   scaling
      );
    };

    class RotThermElasticPrmsPy : public CRotThermElasticIGP
    {
    public:
      RotThermElasticPrmsPy(
        const  std::string &name,
        double normalK,
        double diffusivity
      );
    };

    class RotThermFrictionPrmsPy : public CRotThermFrictionIGP
    {
    public:
      RotThermFrictionPrmsPy(
        const std::string &name,
        double normalK,
        double dynamicMu,    // sliding frictional coefficient
        double staticMu,     // max static frictional coefficient
        double shearK,
        double diffusivity
      );
    };

    class RotThermBondPrmsPy : public CRotThermBondedIGP
    {
    public:
      static const int INVALID_BOND_TAG;
      RotThermBondPrmsPy(
        const std::string &name,
        double normalK,
        double shearK,
        double torsionK,
        double bendingK,
        double normalBrkForce,
        double shearBrkForce,
        double torsionBrkForce,
        double bendingBrkForce,
        double diffusivity,
        int    aTag
      );
    };
    
    class GravityPrmsPy : public GravityIGP
    {
    public:
      GravityPrmsPy(
        const std::string &name,
        const Vec3Py &acceleration
      );
    };

    class BuoyancyPrmsPy : public BuoyancyIGP
    {
    public:
      BuoyancyPrmsPy(
        const std::string &name,
        const Vec3Py &acceleration,
        const double &fluidDensity,
        const double &fluidHeight
      );
    };

    class VWFrictionPrmsPy : public VWFrictionIGP
    {
    public:
      VWFrictionPrmsPy(
        const  std::string &name,
        double normalK,
        double dynamicMu,
        double shearK,
        double alpha
      );
    };

    void exportInteractionPrms();
    
  } // namespace lsm
} // namespace esys

#endif // ESYS_LSMINTERACTIONPARAMSPY_H