dem_wall.h

Go to the documentation of this file.

//
// Author: Miquel Santasusana msantasusana@cimne.upc.edu
//
 
#if !defined(KRATOS_DEM_WALL_H_INCLUDED )
#define  KRATOS_DEM_WALL_H_INCLUDED
 
// System includes
 
 
// External includes
 
 
// Project includes
#include "includes/define.h"
#include "includes/element.h"
#include "includes/serializer.h"
#include "includes/condition.h"
//#include "includes/variables.h"
//#include "custom_elements/spheric_particle.h"
// #include "custom_strategies/schemes/glued_to_wall_scheme.h"
 
class GluedToWallScheme;
 
namespace Kratos
{
class SphericParticle;
class KRATOS_API(DEM_APPLICATION) DEMWall : public Condition
{
public:
 
    // Counted pointer of DEMWall
    KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION( DEMWall );
 
 
    typedef GlobalPointersVector<Element> ParticleWeakVectorType;
    typedef ParticleWeakVectorType::ptr_iterator ParticleWeakIteratorType_ptr;
    typedef GlobalPointersVector<Element >::iterator ParticleWeakIteratorType;
 
    typedef GlobalPointersVector<Condition> ConditionWeakVectorType;
    typedef GlobalPointersVector<Condition >::iterator ConditionWeakIteratorType;
 
 
    // Constructor void
    DEMWall();
 
    // Constructor using an array of nodes
    DEMWall( IndexType NewId, GeometryType::Pointer pGeometry );
 
    // Constructor using an array of nodes with properties
    DEMWall( IndexType NewId, GeometryType::Pointer pGeometry, PropertiesType::Pointer pProperties );
 
    // Destructor
    virtual ~DEMWall();
 
 
    // Name Operations
 
    virtual Condition::Pointer Create(
        IndexType NewId,
        NodesArrayType const& ThisNodes,
        PropertiesType::Pointer pProperties ) const override;
 
 
    void Initialize(const ProcessInfo& rCurrentProcessInfo) override;
    virtual void CalculateRightHandSide(VectorType& rRightHandSideVector, const ProcessInfo& r_process_info) override;
    virtual void ComputeForceAndWeightsOfSphereOnThisFace(SphericParticle* p_particle, array_1d<double, 3>& force, std::vector<double>& weights_vector);
    virtual void CalculateElasticForces(VectorType& rRightHandSideVector, const ProcessInfo& r_process_info );
    virtual void InitializeSolutionStep(const ProcessInfo& r_process_info) override;
    virtual void FinalizeSolutionStep(const ProcessInfo& r_process_info) override;
    virtual void CalculateNormal(array_1d<double, 3>& rnormal);
    virtual void AddExplicitContribution(const VectorType& rRHS,
                                        const Variable<VectorType>& rRHSVariable,
                                        const Variable<array_1d<double,3> >& rDestinationVariable,
                                        const ProcessInfo& r_process_info) override;
 
    virtual void GetDeltaDisplacement( array_1d<double, 3> & delta_displacement, int inode);
    virtual void ComputeConditionRelativeData(int rigid_neighbour_index,
                                            SphericParticle* const particle,
                                            double LocalCoordSystem[3][3],
                                            double& DistPToB,
                                            array_1d<double, 4>& Weight,
                                            array_1d<double, 3>& wall_delta_disp_at_contact_point,
                                            array_1d<double, 3>& wall_velocity_at_contact_point,
                                            int& ContactType){
        KRATOS_ERROR << "Base class DemWall method ComputeConditionRelativeData was called!" << std::endl;
    }
    virtual bool IsPhantom(){return false;}
    virtual int CheckSide(SphericParticle* p_particle){return 1.0;}
 
    double GetYoung() const;
    double GetPoisson() const;
 
    std::vector<SphericParticle*> mNeighbourSphericParticles;
    std::vector<array_1d <double, 3> > mRightHandSideVector;
 
    virtual void GetRightHadSideVector(std::vector<array_1d <double, 3> >& rRightHandSideVector);
    virtual void SetRightHadSideVector(const std::vector<array_1d <double, 3> >& rRightHandSideVector);
    virtual void AddToRightHadSideVector(const std::vector<array_1d <double, 3> >& rRightHandSideVector);
    std::vector<SphericParticle*>& GetVectorOfGluedParticles() {
        return mVectorOfGluedParticles;
    }
 
 
protected:
 
 
 
private:
    std::vector<SphericParticle*> mVectorOfGluedParticles;
 
 
    // private name Operations
 
 
 
    friend class Serializer;
 
    virtual void save( Serializer& rSerializer ) const override
    {
        KRATOS_SERIALIZE_SAVE_BASE_CLASS( rSerializer, Condition );
        //rSerializer.save("mRightHandSideVector", mRightHandSideVector);
    }
 
    virtual void load( Serializer& rSerializer ) override
    {
        KRATOS_SERIALIZE_LOAD_BASE_CLASS( rSerializer, Condition );
        //rSerializer.load("mRightHandSideVector", mRightHandSideVector);
    }
 
 
}; // class DEMWall.
 
} // namespace Kratos.
 
#endif // KRATOS_DEM_WALL_H_INCLUDED  defined