This processing module calculates the CFL and adds it as an extra-field to the output file. More...

#include <ProcessCFL.h>

Inheritance diagram for Nektar::FieldUtils::ProcessCFL:

Public Member Functions
	ProcessCFL (FieldSharedPtr f)

virtual	~ProcessCFL ()

virtual void	Process (po::variables_map &vm)
	Write mesh to output file. More...

virtual std::string	GetModuleName ()

virtual std::string	GetModuleDescription ()

virtual ModulePriority	GetModulePriority ()

Public Member Functions inherited from Nektar::FieldUtils::ProcessModule
	ProcessModule ()

	ProcessModule (FieldSharedPtr p_f)

Public Member Functions inherited from Nektar::FieldUtils::Module
FIELD_UTILS_EXPORT	Module (FieldSharedPtr p_f)

virtual	~Module ()=default

const ConfigOption &	GetConfigOption (const std::string &key) const

FIELD_UTILS_EXPORT void	RegisterConfig (std::string key, std::string value="")
	Register a configuration option with a module. More...

FIELD_UTILS_EXPORT void	PrintConfig ()
	Print out all configuration options for a module. More...

FIELD_UTILS_EXPORT void	SetDefaults ()
	Sets default configuration options for those which have not been set. More...

FIELD_UTILS_EXPORT void	AddFile (std::string fileType, std::string fileName)

FIELD_UTILS_EXPORT void	EvaluateTriFieldAtEquiSpacedPts (LocalRegions::ExpansionSharedPtr &exp, const Array< OneD, const NekDouble > &infield, Array< OneD, NekDouble > &outfield)

Static Public Member Functions
static std::shared_ptr< Module >	create (FieldSharedPtr f)
	Creates an instance of this class. More...

Static Public Attributes
static ModuleKey	className

Protected Member Functions
void	GetVelocity (Array< OneD, Array< OneD, NekDouble >> &vel, int strip=0)

Array< OneD, NekDouble >	GetMaxStdVelocity (const Array< OneD, Array< OneD, NekDouble >> &vel, int strip=0)

Protected Member Functions inherited from Nektar::FieldUtils::Module
	Module ()

Private Attributes
int	m_spacedim

Additional Inherited Members
Public Attributes inherited from Nektar::FieldUtils::Module
FieldSharedPtr	m_f
	Field object. More...

Protected Attributes inherited from Nektar::FieldUtils::Module
std::map< std::string, ConfigOption >	m_config
	List of configuration values. More...

std::set< std::string >	m_allowedFiles
	List of allowed file formats. More...

Detailed Description

This processing module calculates the CFL and adds it as an extra-field to the output file.

Definition at line 48 of file ProcessCFL.h.

Constructor & Destructor Documentation

◆ ProcessCFL()

Nektar::FieldUtils::ProcessCFL::ProcessCFL ( FieldSharedPtr f )

Definition at line 58 of file ProcessCFL.cpp.

                                        : ProcessModule(f)
 {
 }

◆ ~ProcessCFL()

Nektar::FieldUtils::ProcessCFL::~ProcessCFL ( )

virtual

Definition at line 62 of file ProcessCFL.cpp.

63 {

64 }

Member Function Documentation

◆ create()

static std::shared_ptr<Module> Nektar::FieldUtils::ProcessCFL::create ( FieldSharedPtr f )

inlinestatic

Creates an instance of this class.

Definition at line 52 of file ProcessCFL.h.

     {
         return MemoryManager<ProcessCFL>::AllocateSharedPtr(f);
     }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr().

◆ GetMaxStdVelocity()

Array< OneD, NekDouble > Nektar::FieldUtils::ProcessCFL::GetMaxStdVelocity	(	const Array< OneD, Array< OneD, NekDouble >> &	vel,
		int	strip = `0`
	)

protected

Definition at line 188 of file ProcessCFL.cpp.

 {
     int nfields    = m_f->m_variables.size();
     int n_points_0 = m_f->m_exp[0]->GetExp(0)->GetTotPoints();
     int n_element  = m_f->m_exp[0]->GetExpSize();
     int nvel       = vel.size();
     int cnt;
  
     NekDouble pntVelocity;
  
     // Getting the standard velocity vector
     Array<OneD, Array<OneD, NekDouble>> stdVelocity(nvel);
     Array<OneD, NekDouble> tmp;
     Array<OneD, NekDouble> maxV(n_element, 0.0);
     LibUtilities::PointsKeyVector ptsKeys;
  
     for (int i = 0; i < nvel; ++i)
     {
         stdVelocity[i] = Array<OneD, NekDouble>(n_points_0);
     }
  
     cnt = 0.0;
     for (int el = 0; el < n_element; ++el)
     {
         int n_points = m_f->m_exp[0]->GetExp(el)->GetTotPoints();
         ptsKeys      = m_f->m_exp[0]->GetExp(el)->GetPointsKeys();
  
         // reset local space
         if (n_points != n_points_0)
         {
             for (int j = 0; j < nvel; ++j)
             {
                 stdVelocity[j] = Array<OneD, NekDouble>(n_points, 0.0);
             }
             n_points_0 = n_points;
         }
         else
         {
             for (int j = 0; j < nvel; ++j)
             {
                 Vmath::Zero(n_points, stdVelocity[j], 1);
             }
         }
  
         Array<TwoD, const NekDouble> gmat = m_f->m_exp[strip * nfields + 0]
                                                 ->GetExp(el)
                                                 ->GetGeom()
                                                 ->GetMetricInfo()
                                                 ->GetDerivFactors(ptsKeys);
  
         if (m_f->m_exp[strip * nfields + 0]
                 ->GetExp(el)
                 ->GetGeom()
                 ->GetMetricInfo()
                 ->GetGtype() == SpatialDomains::eDeformed)
         {
             for (int j = 0; j < nvel; ++j)
             {
                 for (int k = 0; k < nvel; ++k)
                 {
                     Vmath::Vvtvp(n_points, gmat[k * nvel + j], 1,
                                  tmp = vel[k] + cnt, 1, stdVelocity[j], 1,
                                  stdVelocity[j], 1);
                 }
             }
         }
         else
         {
             for (int j = 0; j < nvel; ++j)
             {
                 for (int k = 0; k < nvel; ++k)
                 {
                     Vmath::Svtvp(n_points, gmat[k * nvel + j][0],
                                  tmp = vel[k] + cnt, 1, stdVelocity[j], 1,
                                  stdVelocity[j], 1);
                 }
             }
         }
         cnt += n_points;
  
         // Calculate total velocity in stdVelocity[0]
         Vmath::Vmul(n_points, stdVelocity[0], 1, stdVelocity[0], 1,
                     stdVelocity[0], 1);
         for (int k = 1; k < nvel; ++k)
         {
             Vmath::Vvtvp(n_points, stdVelocity[k], 1, stdVelocity[k], 1,
                          stdVelocity[0], 1, stdVelocity[0], 1);
         }
         pntVelocity = Vmath::Vmax(n_points, stdVelocity[0], 1);
         maxV[el]    = sqrt(pntVelocity);
     }
  
     return maxV;
 }

References Nektar::SpatialDomains::eDeformed, Nektar::FieldUtils::Module::m_f, tinysimd::sqrt(), Vmath::Svtvp(), Vmath::Vmax(), Vmath::Vmul(), Vmath::Vvtvp(), and Vmath::Zero().

Referenced by Process().

◆ GetModuleDescription()

virtual std::string Nektar::FieldUtils::ProcessCFL::GetModuleDescription ( )

inlinevirtual

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 69 of file ProcessCFL.h.

     {
         return "Calculating CFL number over the domain for the Incompressible "
                "flow simulation";
     }

◆ GetModuleName()

virtual std::string Nektar::FieldUtils::ProcessCFL::GetModuleName ( )

inlinevirtual

Implements Nektar::FieldUtils::Module.

Definition at line 64 of file ProcessCFL.h.

     {
         return "ProcessCFL";
     }

◆ GetModulePriority()

virtual ModulePriority Nektar::FieldUtils::ProcessCFL::GetModulePriority ( )

inlinevirtual

Implements Nektar::FieldUtils::Module.

Definition at line 75 of file ProcessCFL.h.

     {
         return eModifyExp;
     }

References Nektar::FieldUtils::eModifyExp.

◆ GetVelocity()

void Nektar::FieldUtils::ProcessCFL::GetVelocity	(	Array< OneD, Array< OneD, NekDouble >> &	vel,
		int	strip = `0`
	)

protected

Definition at line 153 of file ProcessCFL.cpp.

 {
     int expdim  = m_f->m_graph->GetMeshDimension();
     int nfields = m_f->m_variables.size();
     int npoints = m_f->m_exp[0]->GetNpoints();
     if (boost::iequals(m_f->m_variables[0], "u"))
     {
         // IncNavierStokesSolver
         // Using expdim instead of spacedim
         // This is because for 3DH1D, only a 2D plane will be considered
         for (int i = 0; i < expdim; ++i)
         {
             vel[i] = Array<OneD, NekDouble>(npoints);
             Vmath::Vcopy(npoints, m_f->m_exp[strip * nfields + i]->GetPhys(), 1,
                          vel[i], 1);
         }
     }
     else if (boost::iequals(m_f->m_variables[0], "rho") &&
              boost::iequals(m_f->m_variables[1], "rhou"))
     {
         // CompressibleFlowSolver
         ASSERTL0(false, "CFL calculation is not supported for the compressible "
                         "flow simulations at the moment");
     }
     else
     {
         // Unknown
         ASSERTL0(false, "Could not identify velocity for ProcessCFL");
     }
 }

References ASSERTL0, Nektar::FieldUtils::Module::m_f, and Vmath::Vcopy().

Referenced by Process().

◆ Process()

void Nektar::FieldUtils::ProcessCFL::Process ( po::variables_map & vm )

virtual

Write mesh to output file.

Implements Nektar::FieldUtils::Module.

Definition at line 66 of file ProcessCFL.cpp.

 {
     m_f->SetUpExp(vm);
  
     int expdim    = m_f->m_graph->GetMeshDimension();
     int nelmt     = m_f->m_exp[0]->GetExpSize();
     int nfields   = m_f->m_variables.size();
     int addfields = 1;
     m_spacedim    = expdim;
  
     NekDouble timeStep = m_f->m_session->GetParameter("TimeStep");
     NekDouble cLambda  = 0.2; // Spencer's book
  
     if (m_f->m_numHomogeneousDir == 1)
     {
         m_spacedim = 3;
     }
     ASSERTL0(m_f->m_numHomogeneousDir != 2,
              "CFL for 3DH2D simulations is not supported");
     ASSERTL0(m_spacedim != 1, "Error: CFL for a 1D problem is not supported");
  
     // Append field names
     m_f->m_variables.push_back("CFL");
  
     // Skip in case of empty partition
     if (m_f->m_exp[0]->GetNumElmts() == 0)
     {
         return;
     }
     int npoints = m_f->m_exp[0]->GetNpoints();
     Array<OneD, NekDouble> outfield(npoints);
  
     int nstrips;
     m_f->m_session->LoadParameter("Strip_Z", nstrips, 1);
  
     vector<MultiRegions::ExpListSharedPtr> Exp(nstrips * addfields);
  
     for (int s = 0; s < nstrips; ++s) // homogeneous strip varient
     {
         Array<OneD, Array<OneD, NekDouble>> velocityField(expdim);
  
         // Get the velocity field
         GetVelocity(velocityField, s);
  
         // compute the max velocity in the std regions
         Array<OneD, NekDouble> stdVel = GetMaxStdVelocity(velocityField);
  
         // get the maximum expansion order in each element
         Array<OneD, int> expOrder =
             m_f->m_exp[s * nfields + 0]->EvalBasisNumModesMaxPerExp();
  
         // compute the CFL number
         Array<OneD, NekDouble> cfl(nelmt);
         for (int el = 0; el < nelmt; ++el)
         {
             int order = std::max(expOrder[el] - 1, 1);
             cfl[el]   = timeStep * stdVel[el] * cLambda * order * order;
         }
  
         int cnt = 0;
         for (int el = 0; el < nelmt; ++el)
         {
             // using the field[0]==m_exp[s*nfields + 0]
             int nquad = m_f->m_exp[s * nfields + 0]->GetExp(el)->GetTotPoints();
             Vmath::Fill(nquad, cfl[el], &outfield[cnt], 1);
             cnt += nquad;
         }
  
         // temporary store the CFL number field for each strip
         int n  = s * addfields;
         Exp[n] = m_f->AppendExpList(m_f->m_numHomogeneousDir);
         Vmath::Vcopy(npoints, outfield, 1, Exp[n]->UpdatePhys(), 1);
         Exp[n]->FwdTransLocalElmt(outfield, Exp[n]->UpdateCoeffs());
     }
  
     // update the fields
     for (int s = 0; s < nstrips; ++s)
     {
         for (int i = 0; i < addfields; ++i)
         {
             m_f->m_exp.insert(m_f->m_exp.begin() + s * (nfields + addfields) +
                                   nfields + i,
                               Exp[s * addfields + i]);
         }
     }
 }

References ASSERTL0, Vmath::Fill(), GetMaxStdVelocity(), GetVelocity(), Nektar::FieldUtils::Module::m_f, m_spacedim, and Vmath::Vcopy().

Member Data Documentation

◆ className

ModuleKey Nektar::FieldUtils::ProcessCFL::className

static

Initial value:

= GetModuleFactory().RegisterCreatorFunction(
    ModuleKey(eProcessModule, "CFL"), ProcessCFL::create,
    "Computes CFL number for the entire domain for Incompressible flow.")

Definition at line 56 of file ProcessCFL.h.

◆ m_spacedim

int Nektar::FieldUtils::ProcessCFL::m_spacedim

private

Definition at line 86 of file ProcessCFL.h.

Referenced by Process().

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ProcessCFL()

◆ ~ProcessCFL()

Member Function Documentation

◆ create()

◆ GetMaxStdVelocity()

◆ GetModuleDescription()

◆ GetModuleName()

◆ GetModulePriority()

◆ GetVelocity()

◆ Process()

Member Data Documentation

◆ className

◆ m_spacedim