multiRotatingAxis.hpp

Go to the documentation of this file.

/*------------------------------- phasicFlow ---------------------------------
      O        C enter of
     O O       E ngineering and
    O   O      M ultiscale modeling of
   OOOOOOO     F luid flow       
------------------------------------------------------------------------------
  Copyright (C): www.cemf.ir
  email: hamid.r.norouzi AT gmail.com
------------------------------------------------------------------------------  
Licence:
  This file is part of phasicFlow code. It is a free software for simulating 
  granular and multiphase flows. You can redistribute it and/or modify it under
  the terms of GNU General Public License v3 or any other later versions. 
 
  phasicFlow is distributed to help others in their research in the field of 
  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
-----------------------------------------------------------------------------*/
 
#ifndef __multiRotatingAxis_hpp__
#define __multiRotatingAxis_hpp__
 
 
#include "rotatingAxis.hpp"
#include "KokkosTypes.hpp"
 
 
namespace pFlow
{
 
class dictionary;
class multiRotatingAxisMotion;
 
class multiRotatingAxis
:
    public rotatingAxis
{
protected:
 
    multiRotatingAxis*      axisList_;
 
    int32                   parentAxisIndex_ = -1;
 
public:
 
    // - Constructors
 
        INLINE_FUNCTION_HD
        multiRotatingAxis(){}
 
        FUNCTION_H
        multiRotatingAxis(multiRotatingAxisMotion* axisMotion);
 
        FUNCTION_H
        multiRotatingAxis(multiRotatingAxisMotion* axisMotion, const dictionary& dict);
        
        FUNCTION_HD
        multiRotatingAxis(const multiRotatingAxis&) = default;
 
        FUNCTION_HD
        multiRotatingAxis& operator=(const multiRotatingAxis&) = default;
 
        ~multiRotatingAxis() = default;
 
 
        INLINE_FUNCTION_HD
        realx3 pointTangentialVel(const realx3& p)const
        {
            realx3 parentVel(0);
            auto parIndex = parentAxisIndex();
 
            while(parIndex != -1)
            {
                auto& ax = axisList_[parIndex];
                parentVel += ax.linTangentialVelocityPoint(p);
                parIndex = ax.parentAxisIndex();
            }
 
            return parentVel + rotatingAxis::linTangentialVelocityPoint(p);
        }
 
        INLINE_FUNCTION_HD
        realx3 transferPoint(const realx3& p, real dt)const
        {
            auto newP = p;
 
            // rotation around this axis
            if(isRotating())
            {
                newP = pFlow::rotate(p, *this, dt);
            }
 
            auto parIndex = parentAxisIndex_;
            while(parIndex != -1)
            {
                auto& ax = axisList_[parIndex];
                newP = pFlow::rotate(newP, ax, dt);
                parIndex = ax.parentAxisIndex();
            }
 
            return newP;
        }
 
        INLINE_FUNCTION_HD
        bool hasParent()const
        {
            return parentAxisIndex_ > -1;
        }
 
        INLINE_FUNCTION_HD
        int32 parentAxisIndex()const
        {
            return parentAxisIndex_;
        }
 
        INLINE_FUNCTION_H
        void setAxisListPtr(multiRotatingAxis* axisList)
        {
            axisList_ = axisList;
        }
 
        void move(real dt)
        {
            
            if( !hasParent() ) return;
            
            auto lp1 = point1();
            auto lp2 = point2();
 
            lp1 = axisList_[parentAxisIndex()].transferPoint(lp1, dt);
            lp2 = axisList_[parentAxisIndex()].transferPoint(lp2, dt);
 
            set(lp1, lp2);
        }
 
 
    // - IO operation
 
        FUNCTION_H 
        bool read(multiRotatingAxisMotion* axisMotion, const dictionary& dict);
 
        FUNCTION_H
        bool write(const multiRotatingAxisMotion* axisMotion, dictionary& dict) const;
 
};
 
 
}
 
 
#endif