aslFDElasticityBC.h

Go to the documentation of this file.

/*
 * Advanced Simulation Library <http://asl.org.il>
 * 
 * Copyright 2015 Avtech Scientific <http://avtechscientific.com>
 *
 *
 * This file is part of Advanced Simulation Library (ASL).
 *
 * ASL is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, version 3 of the License.
 *
 * ASL is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with ASL. If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
 
#ifndef ASLFDELASTICITYBC_H
#define ASLFDELASTICITYBC_H
 
#include "aslBCond.h"
#include "acl/aclMath/aclVectorOfElementsDef.h"
 
namespace acl{
  class Kernel;
  typedef std::shared_ptr<Kernel> SPKernel;
}
 
namespace asl
{
  class ElasticityCommonA;
  typedef std::shared_ptr<ElasticityCommonA> SPElasticityCommonA;
  class FDElasticityIncompressibleStatic;
  typedef std::shared_ptr<FDElasticityIncompressibleStatic> SPFDElasticityIncompressibleStatic;
  class FDElasticityRelaxation;
  typedef std::shared_ptr<FDElasticityRelaxation> SPFDElasticityRelaxation;
  class FDElasticity2;
  typedef std::shared_ptr<FDElasticity2> SPFDElasticity2;
    

  class BCRigidWall:public BCond
  {   
    protected:
      std::unique_ptr<acl::Kernel> kernel;      
      SPFDElasticityIncompressibleStatic num;
    public:
      BCRigidWall(SPFDElasticityIncompressibleStatic nm);
      virtual void execute();
      virtual void init();      
  };


 
  SPBCond generateBCRigidWall(SPFDElasticityIncompressibleStatic nm, 
                                 const std::vector<SlicesNames> & sl);


  class BCRigidWallRelaxation:public BCond
  {   
    protected:
      std::unique_ptr<acl::Kernel> kernel;      
      SPFDElasticityRelaxation num;
      acl::VectorOfElements value;
    public:
      BCRigidWallRelaxation(SPFDElasticityRelaxation nm);
      BCRigidWallRelaxation(SPFDElasticityRelaxation nm, acl::VectorOfElements v);
      virtual void execute();
      virtual void init();      
  };


 
  SPBCond generateBCRigidWall(SPFDElasticityRelaxation nm, 
                                 const std::vector<SlicesNames> & sl);
  

 
  SPBCond generateBCRigidWall(SPFDElasticity2 nm, 
                                 const std::vector<SlicesNames> & sl);
  

 
  SPBCond generateBCRigidWall(SPFDElasticity2 nm, 
                               const AVec<> & u0,
                                 const std::vector<SlicesNames> & sl);


 
  SPBCond generateBCRigidWall(SPFDElasticityRelaxation nm, 
                               const AVec<> & u0,
                                 const std::vector<SlicesNames> & sl);
  

  class BCFreeSurface:public BCond
  {   
    protected:
      std::unique_ptr<acl::Kernel> kernel;      
      FDElasticityIncompressibleStatic* num;
    public:
      BCFreeSurface(FDElasticityIncompressibleStatic* nm);
      virtual void execute();
      virtual void init();      
  };


  class BCFreeSurface2:public BCond
  {   
    protected:
      std::unique_ptr<acl::Kernel> kernel;      
      SPFDElasticity2 num;
    public:
      BCFreeSurface2(SPFDElasticity2 nm);
      ~BCFreeSurface2();      
      virtual void execute();
      virtual void init();      
  };


  class BCZeroStressMap: public BCondWithMap
  {   
    protected:
      SPAbstractDataWithGhostNodes displacement; 
      acl::VectorOfElements lambda;
      acl::VectorOfElements mu;
      acl::SPKernel kernel;
    public:
      BCZeroStressMap(SPAbstractDataWithGhostNodes displacement, 
                      acl::VectorOfElements lambda,
                      acl::VectorOfElements mu,
                      SPAbstractDataWithGhostNodes map,
                      const VectorTemplate *const t);
      ~BCZeroStressMap();     
      virtual void execute();
      virtual void init();      
  };


  SPNumMethod generateBCZeroStress(SPElasticityCommonA nm, 
                                   SPAbstractDataWithGhostNodes map);
 


//  SPNumMethod generateBCZeroStress(SPFDElasticityIncompressibleStatic nm, 
//                                   SPAbstractDataWithGhostNodes map);


//  SPNumMethod generateBCZeroStress(SPFDElasticityRelaxation nm, 
//                                   SPAbstractDataWithGhostNodes map);
  

  SPNumMethod generateBCZeroStressP(SPFDElasticityIncompressibleStatic nm, 
                                    SPAbstractDataWithGhostNodes map);


  SPNumMethod generateBCZeroStressP(SPFDElasticityRelaxation nm, 
                                    SPAbstractDataWithGhostNodes map);
  

  class BCImposedDisplacementVelocityValue:public BCond
  {   
    protected:
      std::unique_ptr<acl::Kernel> kernel;      
      SPFDElasticityIncompressibleStatic num;
      AVec<double> displacement;
      bool bDisplacement;
      AVec<double> velocity;
      bool bVelocity;
      bool initialized;
    public:
      BCImposedDisplacementVelocityValue(SPFDElasticityIncompressibleStatic nm);
      virtual void execute();
      virtual void init();      
      void setDisplacement(AVec<double> d);
      void setVelocity(AVec<double> v);
  };


  class BCAccelerationSource2: public BCond
  {   
    protected:
      std::unique_ptr<acl::Kernel> kernel;      
      FDElasticity2* num;
      acl::VectorOfElements acceleration;
      bool initialized;
    public:
      BCAccelerationSource2(FDElasticity2* nm);
      virtual void execute();
      virtual void init();      
      void setAcceleration(AVec<double> a);
  };
     
} //asl
 
#endif //ASLFDELASTICITYBC_H