composite_condition.hpp

Go to the documentation of this file.

//
//   Project Name:        KratosDelaunayMeshingApplication $
//   Created by:          $Author:             JMCarbonell $
//   Last modified by:    $Co-Author:                      $
//   Date:                $Date:                April 2018 $
//   Revision:            $Revision:                   0.0 $
//
//
 
#if !defined(KRATOS_COMPOSITE_CONDITION_H_INCLUDED )
#define  KRATOS_COMPOSITE_CONDITION_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "includes/condition.h"
#include "includes/kratos_flags.h"
 
namespace Kratos
{
 
 
 
 
class KRATOS_API(DELAUNAY_MESHING_APPLICATION) CompositeCondition
    : public Condition
{
public:
 
 
    typedef Condition                                                ConditionType;
    typedef PointerVectorSet<ConditionType, IndexedObject> ConditionsContainerType;
    typedef ConditionsContainerType::iterator                    ConditionIterator;
    typedef ConditionsContainerType::const_iterator      ConditionConstantIterator;
    typedef GeometryData::SizeType                                        SizeType;
 
    KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION( CompositeCondition );
 
 
    CompositeCondition(IndexType NewId, GeometryType::Pointer pGeometry);
 
    CompositeCondition(IndexType NewId, GeometryType::Pointer pGeometry, PropertiesType::Pointer pProperties);
 
    CompositeCondition(CompositeCondition const& rOther);
 
    virtual ~CompositeCondition();
 
 
    CompositeCondition& operator=(CompositeCondition const& rOther);
 
 
 
    SizeType NumberOfChildren() const
    {
        return mChildConditions.size();
    }
 
    void AddChild(ConditionType::Pointer pNewChildCondition);
 
    ConditionType::Pointer pGetChild(IndexType ChildConditionId)
    {
        return (mChildConditions)(ChildConditionId);
    }
 
    ConditionType& GetChild(IndexType ChildConditionId)
    {
        return (mChildConditions)[ChildConditionId];
    }
 
    void RemoveChild(IndexType ChildConditionId)
    {
        mChildConditions.erase(ChildConditionId);
    }
 
    void RemoveChild(ConditionType& ThisChildCondition)
    {
        mChildConditions.erase(ThisChildCondition.Id());
    }
 
    void RemoveChild(ConditionType::Pointer pThisChildCondition)
    {
        mChildConditions.erase(pThisChildCondition->Id());
    }
 
    ConditionIterator ChildConditionsBegin()
    {
        return mChildConditions.begin();
    }
 
    ConditionConstantIterator ChildConditionsBegin() const
    {
        return mChildConditions.begin();
    }
 
    ConditionIterator ChildConditionsEnd()
    {
        return mChildConditions.end();
    }
 
    ConditionConstantIterator ChildConditionsEnd() const
    {
        return mChildConditions.end();
    }
 
    ConditionsContainerType& ChildConditions()
    {
        return mChildConditions;
    }
 
    ConditionsContainerType::Pointer pChildConditions()
    {
        return ConditionsContainerType::Pointer(&mChildConditions);
    }
 
    void SetChildConditions(ConditionsContainerType::Pointer pOtherChildConditions)
    {
        mChildConditions = (*pOtherChildConditions);
    }
 
    ConditionsContainerType::ContainerType& ChildConditionsArray()
    {
        return mChildConditions.GetContainer();
    }
 
 
    Condition::Pointer Create(IndexType NewId, NodesArrayType const& ThisNodes,
                  PropertiesType::Pointer pProperties) const override;
 
    Condition::Pointer Create(IndexType NewId,
                  GeometryType::Pointer pGeom,
                  PropertiesType::Pointer pProperties) const override;
 
    Condition::Pointer Clone(IndexType NewId, NodesArrayType const& ThisNodes) const override;
 
 
    //************* GETTING METHODS
 
    IntegrationMethod GetIntegrationMethod() const override;
 
    void GetDofList(DofsVectorType& rConditionalDofList, const ProcessInfo& rCurrentProcessInfo) const override;
 
    void EquationIdVector(EquationIdVectorType& rResult, const ProcessInfo& rCurrentProcessInfo) const override;
 
    void GetValuesVector(Vector& rValues, int Step = 0) const override;
 
    void GetFirstDerivativesVector(Vector& rValues, int Step = 0) const override;
 
    void GetSecondDerivativesVector(Vector& rValues, int Step = 0) const override;
 
 
 
    //on integration points:
    //SET
    void SetValuesOnIntegrationPoints(const Variable<Vector>& rVariable, const std::vector<Vector>& rValues, const ProcessInfo& rCurrentProcessInfo) override;
 
    void SetValuesOnIntegrationPoints(const Variable<Matrix>& rVariable, const std::vector<Matrix>& rValues, const ProcessInfo& rCurrentProcessInfo) override;
 
 
    //************* STARTING - ENDING  METHODS
 
    void Initialize(const ProcessInfo& rCurrentProcessInfo) override;
 
 
    void InitializeSolutionStep(const ProcessInfo& CurrentProcessInfo) override;
 
    void InitializeNonLinearIteration(const ProcessInfo& CurrentProcessInfo) override;
 
    void FinalizeSolutionStep(const ProcessInfo& CurrentProcessInfo) override;
 
 
    //************* COMPUTING  METHODS
 
    void CalculateLocalSystem(MatrixType& rLeftHandSideMatrix, VectorType& rRightHandSideVector, const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateRightHandSide(VectorType& rRightHandSideVector, const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateLeftHandSide (MatrixType& rLeftHandSideMatrix, const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateMassMatrix(MatrixType& rMassMatrix, const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateDampingMatrix(MatrixType& rDampingMatrix, const ProcessInfo& rCurrentProcessInfo) override;
 
 
    void AddExplicitContribution(const VectorType& rRHS, const Variable<VectorType>& rRHSVariable,
                 const Variable<array_1d<double,3> >& rDestinationVariable,
                 const ProcessInfo& rCurrentProcessInfo) override;
 
 
    //on integration points:
    void CalculateOnIntegrationPoints(const Variable<double>& rVariable, std::vector<double>& rOutput, const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateOnIntegrationPoints(const Variable<Vector>& rVariable, std::vector<Vector>& rOutput, const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateOnIntegrationPoints(const Variable<Matrix >& rVariable, std::vector< Matrix >& rOutput, const ProcessInfo& rCurrentProcessInfo) override;
 
 
    void Calculate(const Variable<double>& rVariable, double& rOutput, const ProcessInfo& rCurrentProcessInfo) override;
 
    //************************************************************************************
    //************************************************************************************
    int Check(const ProcessInfo& rCurrentProcessInfo) const override;
 
    //std::string Info() const;
 
 
 
 
    std::string Info() const override
    {
        std::stringstream buffer;
        buffer << "Condition CompositeCondition #" << Id();
        return buffer.str();
    }
 
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "Condition CompositeCondition #" << Id();
    }
 
 
protected:
 
private:
 
    ConditionsContainerType mChildConditions;
 
    bool mInitializedChildren;
 
 
 
    //initialize children from set value CHILDREN_CONDITIONS
    void InitializeChildren();
 
    //check problem type definition and if coincides return active true
    bool IsActive(const Condition& rChildCondition, const ProcessInfo& rCurrentProcessInfo) const;
 
    //set specific data value to condition children
    template<class TVariableType> void SetValueToChildren(const TVariableType& rThisVariable){
 
      for (ConditionIterator cn = mChildConditions.begin() ; cn != mChildConditions.end(); ++cn)
    {
      typename TVariableType::Type const& rValue = this->GetValue(rThisVariable);
      cn->SetValue(rThisVariable,rValue);
    }
 
    }
 
    virtual SizeType GetDofsSize(const ProcessInfo& rCurrentProcessInfo);
 
 
    friend class Serializer;
 
    // A private default constructor necessary for serialization
 
    CompositeCondition() : Condition()
    {
    }
 
    void save(Serializer& rSerializer) const override;
 
    void load(Serializer& rSerializer) override;
 
 
 
 
}; // Class CompositeCondition
 
/*  inline std::istream& operator >> (std::istream& rIStream,
    CompositeCondition& rThis);
*/
/*  inline std::ostream& operator << (std::ostream& rOStream,
    const CompositeCondition& rThis)
    {
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
    }*/
 
} // namespace Kratos.
#endif // KRATOS_COMPOSITE_CONDITION_H_INCLUDED  defined