#include <ForcingMovingReferenceFrame.h>

Public Member Functions
	Newmark_BetaSolver ()

	~Newmark_BetaSolver ()

void	SetNewmarkBeta (NekDouble beta, NekDouble gamma, NekDouble dt, Array< OneD, NekDouble > M, Array< OneD, NekDouble > C, Array< OneD, NekDouble > K, std::set< int > DirDoFs)

void	SolvePrescribed (Array< OneD, Array< OneD, NekDouble > > u, std::map< int, NekDouble > motionPrescribed)

void	SolveFree (Array< OneD, Array< OneD, NekDouble > > u, Array< OneD, NekDouble > force)

void	Solve (Array< OneD, Array< OneD, NekDouble > > u, Array< OneD, NekDouble > force, std::map< int, NekDouble > motionPrescribed)

Public Attributes
int	m_rows

int	m_motionDofs

std::vector< int >	m_index

Array< OneD, NekDouble >	m_coeffs

Array< OneD, Array< OneD, NekDouble > >	m_Matrix

Array< OneD, Array< OneD, NekDouble > >	m_M

Array< OneD, Array< OneD, NekDouble > >	m_C

Array< OneD, Array< OneD, NekDouble > >	m_K

Detailed Description

Definition at line 65 of file ForcingMovingReferenceFrame.h.

Constructor & Destructor Documentation

◆ Newmark_BetaSolver()

Nektar::SolverUtils::Newmark_BetaSolver::Newmark_BetaSolver ( )

inline

Definition at line 68 of file ForcingMovingReferenceFrame.h.

68{};

◆ ~Newmark_BetaSolver()

Nektar::SolverUtils::Newmark_BetaSolver::~Newmark_BetaSolver ( )

inline

Definition at line 69 of file ForcingMovingReferenceFrame.h.

69{};

Member Function Documentation

◆ SetNewmarkBeta()

void Nektar::SolverUtils::Newmark_BetaSolver::SetNewmarkBeta	(	NekDouble	beta,
		NekDouble	gamma,
		NekDouble	dt,
		Array< OneD, NekDouble >	M,
		Array< OneD, NekDouble >	C,
		Array< OneD, NekDouble >	K,
		std::set< int >	DirDoFs
	)

Definition at line 1008 of file ForcingMovingReferenceFrame.cpp.

{
    m_coeffs    = Array<OneD, NekDouble>(5, 0.);
    m_coeffs[0] = 1. / (gamma * dt);
    m_coeffs[1] = 1. / gamma - 1.;
    m_coeffs[2] = beta * dt / gamma;
    m_coeffs[3] = dt * (1. - beta / gamma);
    m_coeffs[4] = (0.5 - beta / gamma) * dt * dt;
 
    m_rows = sqrt(M.size());
    m_index.resize(m_rows, -1);
    m_motionDofs = 0;
    for (int i = 0; i < m_rows; ++i)
    {
        if (DirDoFs.find(i) == DirDoFs.end())
        {
            m_index[m_motionDofs++] = i;
        }
    }
    for (int i = 0, count = m_motionDofs; i < m_rows; ++i)
    {
        if (DirDoFs.find(i) != DirDoFs.end())
        {
            m_index[count++] = i;
        }
    }
    if (m_motionDofs)
    {
        Array<OneD, NekDouble> temp;
        m_Matrix = Array<OneD, Array<OneD, NekDouble>>(m_motionDofs);
        m_M      = Array<OneD, Array<OneD, NekDouble>>(m_motionDofs);
        m_C      = Array<OneD, Array<OneD, NekDouble>>(m_motionDofs);
        m_K      = Array<OneD, Array<OneD, NekDouble>>(m_motionDofs);
        DNekMatSharedPtr inverseMatrix =
            MemoryManager<DNekMat>::AllocateSharedPtr(m_motionDofs,
                                                      m_motionDofs, 0.0, eFULL);
        for (int i = 0; i < m_motionDofs; ++i)
        {
            m_Matrix[i] = Array<OneD, NekDouble>(m_motionDofs, 0.);
            m_M[i]      = Array<OneD, NekDouble>(m_rows, 0.);
            m_C[i]      = Array<OneD, NekDouble>(m_rows, 0.);
            m_K[i]      = Array<OneD, NekDouble>(m_rows, 0.);
            int offset  = m_index[i] * m_rows;
            for (int j = 0; j < m_rows; ++j)
            {
                int ind   = offset + m_index[j];
                m_M[i][j] = M[ind];
                m_C[i][j] = C[ind];
                m_K[i][j] = K[ind];
                NekDouble value =
                    m_coeffs[0] * M[ind] + C[ind] + m_coeffs[2] * K[ind];
                if (j < m_motionDofs)
                {
                    inverseMatrix->SetValue(i, j, value);
                }
            }
        }
        inverseMatrix->Invert();
        for (int i = 0; i < m_motionDofs; ++i)
        {
            for (int j = 0; j < m_rows; ++j)
            {
                if (j < m_motionDofs)
                {
                    m_Matrix[i][j] = inverseMatrix->GetValue(i, j);
                }
            }
        }
    }
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::beta, Nektar::eFULL, m_C, m_coeffs, m_index, m_K, m_M, m_Matrix, m_motionDofs, m_rows, and tinysimd::sqrt().

Referenced by Nektar::SolverUtils::ForcingMovingReferenceFrame::InitBodySolver().

◆ Solve()

void Nektar::SolverUtils::Newmark_BetaSolver::Solve	(	Array< OneD, Array< OneD, NekDouble > >	u,
		Array< OneD, NekDouble >	force,
		std::map< int, NekDouble >	motionPrescribed
	)

Definition at line 1124 of file ForcingMovingReferenceFrame.cpp.

{
    SolvePrescribed(u, motionPrescribed);
    SolveFree(u, force);
}

References SolveFree(), and SolvePrescribed().

Referenced by Nektar::SolverUtils::ForcingMovingReferenceFrame::SolveBodyMotion().

◆ SolveFree()

void Nektar::SolverUtils::Newmark_BetaSolver::SolveFree	(	Array< OneD, Array< OneD, NekDouble > >	u,
		Array< OneD, NekDouble >	force
	)

Definition at line 1132 of file ForcingMovingReferenceFrame.cpp.

{
    if (m_motionDofs)
    {
        Array<OneD, NekDouble> bm(m_motionDofs, 0.);
        Array<OneD, NekDouble> bk(m_motionDofs, 0.);
        for (int j = 0; j < m_motionDofs; ++j)
        {
            int j1 = m_index[j];
            bm[j]  = m_coeffs[0] * u[1][j1] + m_coeffs[1] * u[2][j1];
            bk[j]  = u[0][j1] + m_coeffs[3] * u[1][j1] + m_coeffs[4] * u[2][j1];
        }
        Array<OneD, NekDouble> rhs(m_motionDofs, 0.);
        for (int i = 0; i < m_motionDofs; ++i)
        {
            rhs[i] = force[m_index[i]];
            for (int j = 0; j < m_motionDofs; ++j)
            {
                rhs[i] += m_M[i][j] * bm[j] - m_K[i][j] * bk[j];
            }
            for (int j = m_motionDofs; j < m_rows; ++j)
            {
                int j1 = m_index[j];
                rhs[i] -= m_M[i][j] * u[2][j1] + m_C[i][j] * u[1][j1] +
                          m_K[i][j] * u[0][j1];
            }
        }
        for (int j = 0; j < m_motionDofs; ++j)
        {
            int j1   = m_index[j];
            u[1][j1] = Vmath::Dot(m_motionDofs, m_Matrix[j], 1, rhs, 1);
            u[0][j1] = m_coeffs[2] * u[1][j1] + bk[j];
            u[2][j1] = m_coeffs[0] * u[1][j1] - bm[j];
        }
    }
}

References Vmath::Dot(), m_C, m_coeffs, m_index, m_K, m_M, m_Matrix, m_motionDofs, and m_rows.

Referenced by Solve(), and Nektar::SolverUtils::ForcingMovingReferenceFrame::SolveBodyMotion().

◆ SolvePrescribed()

void Nektar::SolverUtils::Newmark_BetaSolver::SolvePrescribed	(	Array< OneD, Array< OneD, NekDouble > >	u,
		std::map< int, NekDouble >	motionPrescribed
	)

Definition at line 1083 of file ForcingMovingReferenceFrame.cpp.

{
    for (int i = 0; i < m_rows; ++i)
    {
        if (motionPrescribed.find(i) != motionPrescribed.end())
        {
            int i0       = i + m_rows;
            int i2       = i0 + m_rows;
            NekDouble bm = 0., bk = 0.;
            if (motionPrescribed.find(i2) == motionPrescribed.end())
            {
                bm = m_coeffs[0] * u[1][i] + m_coeffs[1] * u[2][i];
            }
            if (motionPrescribed.find(i0) == motionPrescribed.end())
            {
                bk = u[0][i] + m_coeffs[3] * u[1][i] + m_coeffs[4] * u[2][i];
            }
 
            u[1][i] = motionPrescribed[i];
            if (motionPrescribed.find(i2) == motionPrescribed.end())
            {
                u[2][i] = m_coeffs[0] * u[1][i] - bm;
            }
            else
            {
                u[2][i] = motionPrescribed[i2];
            }
            if (motionPrescribed.find(i0) == motionPrescribed.end())
            {
                u[0][i] = m_coeffs[2] * u[1][i] + bk;
            }
            else
            {
                u[0][i] = motionPrescribed[i0];
            }
        }
    }
}