mapper_vertex_morphing.h

Go to the documentation of this file.

// ==============================================================================
//  KratosShapeOptimizationApplication
//
//  License:         BSD License
//                   license: ShapeOptimizationApplication/license.txt
//
//  Main authors:    Baumgaertner Daniel, https://github.com/dbaumgaertner
//
// ==============================================================================
 
#ifndef MAPPER_VERTEX_MORPHING_H
#define MAPPER_VERTEX_MORPHING_H
 
// ------------------------------------------------------------------------------
// System includes
// ------------------------------------------------------------------------------
#include <iostream>
#include <string>
 
// ------------------------------------------------------------------------------
// Project includes
// ------------------------------------------------------------------------------
#include "includes/model_part.h"
#include "spatial_containers/spatial_containers.h"
#include "spaces/ublas_space.h"
#include "mapper_base.h"
#include "custom_utilities/filter_function.h"
 
// ==============================================================================
 
namespace Kratos
{
 
 
 
 
 
 
 
class KRATOS_API(SHAPE_OPTIMIZATION_APPLICATION) MapperVertexMorphing : public Mapper
{
public:
 
    // Type definitions for better reading later
    typedef Node NodeType;
    typedef Node ::Pointer NodeTypePointer;
    typedef std::vector<NodeType::Pointer> NodeVector;
    typedef std::vector<NodeType::Pointer>::iterator NodeIterator;
    typedef std::vector<double>::iterator DoubleVectorIterator;
    typedef ModelPart::ConditionsContainerType ConditionsArrayType;
    typedef array_1d<double,3> array_3d;
 
    // Type definitions for linear algebra including sparse systems
    typedef UblasSpace<double, CompressedMatrix, Vector> SparseSpaceType;
    typedef SparseSpaceType::MatrixType SparseMatrixType;
    typedef SparseSpaceType::VectorType VectorType;
 
    // Type definitions for tree-search
    typedef Bucket< 3, NodeType, NodeVector, NodeTypePointer, NodeIterator, DoubleVectorIterator > BucketType;
    typedef Tree< KDTreePartition<BucketType> > KDTree;
 
    KRATOS_CLASS_POINTER_DEFINITION(MapperVertexMorphing);
 
 
    MapperVertexMorphing( ModelPart& rOriginModelPart, ModelPart& rDestinationModelPart, Parameters MapperSettings )
        : mrOriginModelPart(rOriginModelPart),
          mrDestinationModelPart(rDestinationModelPart),
          mMapperSettings(MapperSettings),
          mFilterRadius(MapperSettings["filter_radius"].GetDouble())
    {
    }
 
    virtual ~MapperVertexMorphing()
    {
    }
 
 
 
 
    // --------------------------------------------------------------------------
    void Initialize() override;
 
    // --------------------------------------------------------------------------
    void Map( const Variable<array_3d> &rOriginVariable, const Variable<array_3d> &rDestinationVariable) override;
 
    // --------------------------------------------------------------------------
    void Map( const Variable<double> &rOriginVariable, const Variable<double> &rDestinationVariable) override;
 
    // --------------------------------------------------------------------------
    void InverseMap( const Variable<array_3d> &rDestinationVariable, const Variable<array_3d> &rOriginVariable) override;
 
    // --------------------------------------------------------------------------
    void InverseMap(const Variable<double> &rDestinationVariable, const Variable<double> &rOriginVariable) override;
 
    // --------------------------------------------------------------------------
    void Update() override;
 
    // --------------------------------------------------------------------------
 
 
 
 
 
 
    virtual std::string Info() const override
    {
        return "MapperVertexMorphing";
    }
 
    virtual void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "MapperVertexMorphing";
    }
 
    virtual void PrintData(std::ostream& rOStream) const override
    {
    }
 
 
 
 
 
protected:
 
 
 
    // Initialized by class constructor
    ModelPart& mrOriginModelPart;
    ModelPart& mrDestinationModelPart;
    Parameters mMapperSettings;
    FilterFunction::UniquePointer mpFilterFunction;
    bool mIsMappingInitialized = false;
 
 
 
 
    virtual void InitializeComputationOfMappingMatrix();
 
    double GetVertexMorphingRadius(const NodeType& rNode) const override
    {
        return mFilterRadius;
    }
 
 
 
 
 
 
 
 
private:
 
 
 
    // Variables for spatial search
    unsigned int mBucketSize = 100;
    NodeVector mListOfNodesInOriginModelPart;
    KDTree::Pointer mpSearchTree;
 
    // Variables for mapping
    SparseMatrixType mMappingMatrix;
    std::vector<Vector> mValuesOrigin;
    std::vector<Vector> mValuesDestination;
    double mFilterRadius;
 
 
 
 
    // --------------------------------------------------------------------------
    void CreateListOfNodesInOriginModelPart();
 
    // --------------------------------------------------------------------------
    void CreateFilterFunction();
 
    // --------------------------------------------------------------------------
    void InitializeMappingVariables();
 
    // --------------------------------------------------------------------------
    void AssignMappingIds();
 
    // --------------------------------------------------------------------------
    void CreateSearchTreeWithAllNodesInOriginModelPart();
 
    // --------------------------------------------------------------------------
    void ComputeMappingMatrix();
 
    // --------------------------------------------------------------------------
    virtual void ComputeWeightForAllNeighbors(  const ModelPart::NodeType& origin_node,
                                        const NodeVector& neighbor_nodes,
                                        const unsigned int number_of_neighbors,
                                        std::vector<double>& list_of_weights,
                                        double& sum_of_weights );
 
    // --------------------------------------------------------------------------
    void FillMappingMatrixWithWeights(  ModelPart::NodeType& origin_node,
                                        NodeVector& neighbor_nodes,
                                        unsigned int number_of_neighbors,
                                        std::vector<double>& list_of_weights,
                                        double& sum_of_weights );
 
    // --------------------------------------------------------------------------
 
 
 
 
 
 
//      MapperVertexMorphing& operator=(MapperVertexMorphing const& rOther);
 
//      MapperVertexMorphing(MapperVertexMorphing const& rOther);
 
 
 
}; // Class MapperVertexMorphing
 
 
 
 
 
 
 
}  // namespace Kratos.
 
#endif // MAPPER_VERTEX_MORPHING_H