periodic_condition_utilities.h

Go to the documentation of this file.

/*
==============================================================================
KratosFluidDynamicsApplication
A library based on:
Kratos
A General Purpose Software for Multi-Physics Finite Element Analysis
Version 1.0 (Released on march 05, 2007).
 
Copyright 2007
Pooyan Dadvand, Riccardo Rossi
pooyan@cimne.upc.edu
rrossi@cimne.upc.edu
- CIMNE (International Center for Numerical Methods in Engineering),
Gran Capita' s/n, 08034 Barcelona, Spain
 
 
Permission is hereby granted, free  of charge, to any person obtaining
a  copy  of this  software  and  associated  documentation files  (the
"Software"), to  deal in  the Software without  restriction, including
without limitation  the rights to  use, copy, modify,  merge, publish,
distribute,  sublicense and/or  sell copies  of the  Software,  and to
permit persons to whom the Software  is furnished to do so, subject to
the following condition:
 
Distribution of this code for  any  commercial purpose  is permissible
ONLY BY DIRECT ARRANGEMENT WITH THE COPYRIGHT OWNERS.
 
The  above  copyright  notice  and  this permission  notice  shall  be
included in all copies or substantial portions of the Software.
 
THE  SOFTWARE IS  PROVIDED  "AS  IS", WITHOUT  WARRANTY  OF ANY  KIND,
EXPRESS OR  IMPLIED, INCLUDING  BUT NOT LIMITED  TO THE  WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT  SHALL THE AUTHORS OR COPYRIGHT HOLDERS  BE LIABLE FOR ANY
CLAIM, DAMAGES OR  OTHER LIABILITY, WHETHER IN AN  ACTION OF CONTRACT,
TORT  OR OTHERWISE, ARISING  FROM, OUT  OF OR  IN CONNECTION  WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
==============================================================================
*/
 
/*
 * File:   periodic_condition_utilities.h
 * Author: jcotela
 *
 * Created on September 22, 2011, 3:22 PM
 */
 
#ifndef KRATOS_PERIODIC_CONDITION_UTILITIES_H
#define KRATOS_PERIODIC_CONDITION_UTILITIES_H
 
// System includes
#include <string>
#include <iostream>
#include <algorithm>
#include <cmath>
 
// External includes
 
 
// Project includes
#include "includes/define.h"
#include "includes/node.h"
#include "includes/model_part.h"
#include "includes/properties.h"
#include "geometries/point_3d.h"
#include "spatial_containers/spatial_containers.h"
#include "containers/variables_list.h"
#include "containers/periodic_variables_container.h"
 
#include "includes/variables.h"
 
namespace Kratos
{
 
 
 
 
 
 
 
 
class PeriodicConditionUtilities
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(PeriodicConditionUtilities);
 
    typedef std::size_t IndexType;
 
    typedef std::size_t SizeType;
 
    //defintions for spatial search
    typedef Node                                     PointType;
    typedef Node::Pointer                            PointTypePointer;
    typedef std::vector<PointType::Pointer>             PointVector;
    typedef std::vector<PointType::Pointer>::iterator   PointIterator;
    typedef std::vector<double>                         DistanceVector;
    typedef std::vector<double>::iterator               DistanceIterator;
 
    // Bucket types
//        typedef Bucket< 3, PointType, PointVector, PointTypePointer, PointIterator, DistanceIterator >       BucketType;
    typedef Bins< 3, PointType, PointVector, PointTypePointer, PointIterator, DistanceIterator >         StaticBins;
//        typedef BinsDynamic< 3, PointType, PointVector, PointTypePointer, PointIterator, DistanceIterator >  DynamicBins;
 
    // DynamicBins
//        typedef Tree< KDTreePartition<BucketType> > tree;         //Kdtree;
//        typedef Tree< OCTreePartition<BucketType> > tree;         //Octree;
    typedef Tree< StaticBins > tree;                    //Binstree;
//        typedef Tree< KDTreePartition<StaticBins> > tree;         //KdtreeBins;
 
 
 
    PeriodicConditionUtilities(ModelPart& ThisModelPart,
                               SizeType ThisDomainSize):
        mrModelPart(ThisModelPart),
      /*mDomainSize(ThisDomainSize),*/
        mpSearchStrategy()
    {}
 
    virtual ~PeriodicConditionUtilities()
    {}
 
 
 
 
 
 
 
    void SetUpSearchStructure(Variable<double> const& rFlagVar,
                              const double FlagValue)
    {
        KRATOS_TRY
 
        // Find candidate nodes for periodic conditions
        mCandidateNodes = PointVector();
 
        for(ModelPart::NodesContainerType::ptr_iterator itNode = mrModelPart.Nodes().ptr_begin();
                itNode != mrModelPart.Nodes().ptr_end(); itNode++)
        {
            if( (**itNode).FastGetSolutionStepValue(rFlagVar,0) == FlagValue)
                mCandidateNodes.push_back(*itNode);
        }
 
        if(mCandidateNodes.size() == 0) KRATOS_THROW_ERROR(std::invalid_argument,"No nodes found for periodic conditions generation","");
 
        // Initialize Search Strategy
        SizeType BucketSize = 20;
        mpSearchStrategy = Kratos::shared_ptr<tree>(new tree(mCandidateNodes.begin(),mCandidateNodes.end(),BucketSize));
 
//            std::cout << *mpSearchStrategy << std::endl;
 
        KRATOS_CATCH("")
    }
 
 
    template< class TReference >
    void GenerateConditions(const TReference& MovementRef,
                            Properties::Pointer pProperties,
                const std::string& rConditionLabel,
                            const double Tolerance = 1e-4)
    {
        KRATOS_TRY
 
        // check that the spatial seach structure was initialized
        if(mpSearchStrategy == 0)
            KRATOS_THROW_ERROR(std::logic_error,"PeriodicConditionUtilities error: GenerateConditions() called without a spatial search structure. Please call SetUpSearchStructure() first.","")
 
        // Get reference condition
    const Condition& rCondition = KratosComponents<Condition>::Get(rConditionLabel);
 
        // Create a geometry for new conditions
        ModelPart::ConditionsContainerType& rConditions = mrModelPart.Conditions();
        Geometry< Node >::PointsArrayType ConditionNodes(2);
 
        // Get Id for new conditions
        IndexType Id;
        if( mrModelPart.ConditionsArray().size() == 0)
            Id = 0;
        else
            Id = (mrModelPart.ConditionsEnd()-1)->Id();
 
        // Spatial search setup (for SearchNearestPoint)
        double ResultDistance = 0.0;
        PointTypePointer SecondNode;
        PointType ImageNode;
 
        // Spatial search, create new conditions with results
        unsigned int ConditionCount = 0;
        for(PointVector::iterator itNode = mCandidateNodes.begin(); itNode != mCandidateNodes.end(); itNode++)
        {
            this->MoveNode(**itNode,ImageNode,MovementRef); // * for iterator + * for pointer
 
            SecondNode = mpSearchStrategy->SearchNearestPoint(ImageNode,ResultDistance);
            if(ResultDistance < Tolerance)
            {
                ConditionNodes.GetContainer()[0] = *itNode;
                ConditionNodes.GetContainer()[1] = SecondNode;
                // Add condition to model part
                Condition::Pointer pNewCondition = rCondition.Create(++Id,ConditionNodes,pProperties);
                rConditions.push_back(pNewCondition);
                ++ConditionCount;
            }
 
        }
 
        std::cout << "Found " << ConditionCount << " node pairs in periodic boundary." << std::endl;
 
        KRATOS_CATCH("")
    }
 
 
 
    void DefinePeriodicBoundary(Properties::Pointer pNewProperties,
                const std::string& rConditionLabel,
                                const double TranslationX,
                                const double TranslationY,
                                const double TranslationZ = 0.0)
    {
        KRATOS_TRY
 
        // check that the spatial seach structure was initialized
        if(mpSearchStrategy == 0)
            KRATOS_THROW_ERROR(std::logic_error,"PeriodicConditionUtilities error: DefinePeriodicBoundary() called without a spatial search structure. Please call SetUpSearchStructure() first.","")
 
 
            const double Tolerance = 1e-4; // Relative tolerance when searching for node pairs
 
        array_1d<double,3> Translation;
        Translation[0] = TranslationX;
        Translation[1] = TranslationY;
        Translation[2] = TranslationZ;
 
    GenerateConditions(Translation,pNewProperties,rConditionLabel,Tolerance);
 
        KRATOS_CATCH("")
    }
 
    void AddPeriodicVariable(Properties& rProperties,
                             Variable<double>& rVariable)
    {
        rProperties.GetValue(PERIODIC_VARIABLES).Add(rVariable);
    }
 
 
 
 
 
 
    virtual std::string Info() const
    {
        return "PeriodicConditionUtilities";
    }
 
    virtual void PrintInfo(std::ostream& rOStream) const
    {
        rOStream << "PeriodicConditionUtilities";
    }
 
    virtual void PrintData(std::ostream& rOStream) const
    {}
 
 
 
 
 
protected:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
private:
 
 
 
    ModelPart& mrModelPart;
 
    //SizeType mDomainSize;
 
    PointVector mCandidateNodes;
 
    tree::Pointer mpSearchStrategy;
 
 
 
 
    void MoveNode( const Node& rInNode, Node& rOutNode, const array_1d<double,3>& rTranslation) const
    {
        rOutNode.Coordinates() = rInNode.Coordinates() + rTranslation;
    }
 
    void MoveNode( const Node& rInNode, Node& rOutNode, const Node& rCentreNode )
    {
        rOutNode.Coordinates() = rInNode.Coordinates() + 2.0 * ( rCentreNode.Coordinates() - rInNode.Coordinates() );
    }
 
 
 
 
 
 
 
 
 
}; // Class PeriodicConditionUtilities
 
 
 
 
 
 
inline std::istream& operator >> (std::istream& rIStream,
                                  PeriodicConditionUtilities& rThis)
{
    return rIStream;
}
 
inline std::ostream& operator << (std::ostream& rOStream,
                                  const PeriodicConditionUtilities& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
 
}  // namespace Kratos.
 
#endif  /* KRATOS_PERIODIC_CONDITION_UTILITIES_H */