#include <ForcingAbsorption.h>

Inheritance diagram for Nektar::SolverUtils::ForcingAbsorption:

Static Public Member Functions
static SOLVER_UTILS_EXPORT ForcingSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< EquationSystem > &pEquation, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const unsigned int &pNumForcingFields, const TiXmlElement *pForce)
	Creates an instance of this class. More...

Static Public Member Functions inherited from Nektar::SolverUtils::Forcing
static SOLVER_UTILS_EXPORT std::vector< ForcingSharedPtr >	Load (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< EquationSystem > &pEquation, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const unsigned int &pNumForcingFields=0)

Static Public Attributes
static std::string	className
	Name of the class. More...

Protected Types
typedef bg::model::point< NekDouble, 3, bg::cs::cartesian >	BPoint

typedef std::pair< BPoint, unsigned int >	BPointPair

typedef bgi::rtree< BPointPair, bgi::rstar< 16 > >	BRTree

Protected Member Functions
void	CalculateForcing (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, const NekDouble &time)

virtual SOLVER_UTILS_EXPORT void	v_InitObject (const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const unsigned int &pNumForcingFields, const TiXmlElement *pForce)

virtual SOLVER_UTILS_EXPORT void	v_Apply (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble &time)

virtual SOLVER_UTILS_EXPORT void	v_ApplyCoeff (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble &time)

Protected Member Functions inherited from Nektar::SolverUtils::Forcing
SOLVER_UTILS_EXPORT	Forcing (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< EquationSystem > &pEquation)
	Constructor. More...

virtual SOLVER_UTILS_EXPORT void	v_PreApply (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble &time)

SOLVER_UTILS_EXPORT SessionFunctionSharedPtr	GetFunction (const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const LibUtilities::SessionReaderSharedPtr &pSession, std::string pName, bool pCache=false)
	Get a SessionFunction by name. More...

SOLVER_UTILS_EXPORT void	EvaluateTimeFunction (LibUtilities::SessionReaderSharedPtr pSession, std::string pFieldName, Array< OneD, NekDouble > &pArray, const std::string &pFunctionName, NekDouble pTime=NekDouble(0))

SOLVER_UTILS_EXPORT void	EvaluateTimeFunction (const NekDouble pTime, const LibUtilities::EquationSharedPtr &pEqn, Array< OneD, NekDouble > &pArray)

Protected Attributes
bool	m_hasRefFlow

bool	m_hasRefFlowTime

Array< OneD, Array< OneD, NekDouble > >	m_Absorption

Array< OneD, Array< OneD, NekDouble > >	m_Refflow

std::string	m_funcNameTime

std::vector< unsigned int >	m_bRegions

std::shared_ptr< BRTree >	m_rtree

Protected Attributes inherited from Nektar::SolverUtils::Forcing
LibUtilities::SessionReaderSharedPtr	m_session
	Session reader. More...

const std::weak_ptr< EquationSystem >	m_equ
	Weak pointer to equation system using this forcing. More...

Array< OneD, Array< OneD, NekDouble > >	m_Forcing
	Evaluated forcing function. More...

int	m_NumVariable
	Number of variables. More...

std::map< std::string, SolverUtils::SessionFunctionSharedPtr >	m_sessionFunctions
	Map of known SessionFunctions. More...

Private Member Functions
	ForcingAbsorption (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< EquationSystem > &pEquation)

virtual	~ForcingAbsorption (void)

void	CalcAbsorption (const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const TiXmlElement *pForce)

Friends
class	MemoryManager< ForcingAbsorption >

Additional Inherited Members
Public Member Functions inherited from Nektar::SolverUtils::Forcing
virtual SOLVER_UTILS_EXPORT	~Forcing ()

SOLVER_UTILS_EXPORT void	InitObject (const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const unsigned int &pNumForcingFields, const TiXmlElement *pForce)
	Initialise the forcing object. More...

SOLVER_UTILS_EXPORT void	Apply (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble &time)
	Apply the forcing. More...

SOLVER_UTILS_EXPORT void	PreApply (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble &time)
	Change the advection velocity before applying the forcing. For example, subtracting the frame velocity from the advection velocity in the MovingRefercenceFrame. More...

SOLVER_UTILS_EXPORT void	ApplyCoeff (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble &time)
	Apply the forcing. More...

SOLVER_UTILS_EXPORT const Array< OneD, const Array< OneD, NekDouble > > &	GetForces ()

SOLVER_UTILS_EXPORT Array< OneD, Array< OneD, NekDouble > > &	UpdateForces ()

Detailed Description

Definition at line 57 of file ForcingAbsorption.h.

Member Typedef Documentation

◆ BPoint

typedef bg::model::point<NekDouble, 3, bg::cs::cartesian> Nektar::SolverUtils::ForcingAbsorption::BPoint

protected

Definition at line 81 of file ForcingAbsorption.h.

◆ BPointPair

typedef std::pair<BPoint, unsigned int> Nektar::SolverUtils::ForcingAbsorption::BPointPair

protected

Definition at line 82 of file ForcingAbsorption.h.

◆ BRTree

typedef bgi::rtree<BPointPair, bgi::rstar<16> > Nektar::SolverUtils::ForcingAbsorption::BRTree

protected

Definition at line 83 of file ForcingAbsorption.h.

Constructor & Destructor Documentation

◆ ForcingAbsorption()

Nektar::SolverUtils::ForcingAbsorption::ForcingAbsorption	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const std::weak_ptr< EquationSystem > &	pEquation
	)

private

Definition at line 55 of file ForcingAbsorption.cpp.

             : Forcing(pSession, pEquation),
               m_hasRefFlow(false),
               m_hasRefFlowTime(false)
     {
     }

◆ ~ForcingAbsorption()

virtual Nektar::SolverUtils::ForcingAbsorption::~ForcingAbsorption ( void )

inlineprivatevirtual

Definition at line 117 of file ForcingAbsorption.h.

117 {};

Member Function Documentation

◆ CalcAbsorption()

void Nektar::SolverUtils::ForcingAbsorption::CalcAbsorption	(	const Array< OneD, MultiRegions::ExpListSharedPtr > &	pFields,
		const TiXmlElement *	pForce
	)

private

Definition at line 115 of file ForcingAbsorption.cpp.

     {
         const TiXmlElement *funcNameElmt = pForce->FirstChildElement("COEFF");
         ASSERTL0(funcNameElmt,
                 "Requires COEFF tag, specifying function "
                 "name which prescribes absorption layer coefficient.");
         string funcName = funcNameElmt->GetText();
         ASSERTL0(m_session->DefinesFunction(funcName),
                 "Function '" + funcName + "' not defined.");
  
         int npts = pFields[0]->GetTotPoints();
  
         m_Absorption = Array<OneD, Array<OneD, NekDouble> >(m_NumVariable);
         for (int i = 0; i < m_NumVariable; ++i)
         {
             m_Absorption[i] = Array<OneD, NekDouble>(npts, 0.0);
         }
  
         funcNameElmt = pForce->FirstChildElement("BOUNDARYREGIONS");
         if (funcNameElmt)
         {
             ASSERTL0(ParseUtils::GenerateVector(funcNameElmt->GetText(),
                                                     m_bRegions),
                     "Unable to process list of BOUNDARYREGIONS in Absorption "
                     "Forcing: " +
                         std::string(funcNameElmt->GetText()));
  
             // alter m_bRegions so that it contains the boundaryRegions of this rank
             std::vector<unsigned int>  localBRegions;
             SpatialDomains::BoundaryConditions bcs(m_session, pFields[0]->GetGraph());
             SpatialDomains::BoundaryRegionCollection regions = bcs.GetBoundaryRegions();
             SpatialDomains::BoundaryRegionCollection::iterator it1;
             int n = 0;
             for (it1 = regions.begin(); it1 != regions.end(); ++it1)
             {
                 if (std::find(m_bRegions.begin(), m_bRegions.end(), it1->first) != m_bRegions.end())
                 {
                     localBRegions.push_back(n);
                 }
                 n++;
             }
             m_bRegions = localBRegions;
  
             if (m_bRegions.size() == 0)
             {
                 return;
             }
  
             std::vector<Array<OneD, const NekDouble> > points;
  
             Array<OneD, Array<OneD, NekDouble> > x(3);
             for (int i = 0; i < 3; i++)
             {
                 x[i] = Array<OneD, NekDouble>(npts, 0.0);
             }
             pFields[0]->GetCoords(x[0], x[1], x[2]);
             for (int i = 0; i < 3; i++)
             {
                 points.push_back(x[i]);
             }
  
             Array<OneD, NekDouble> t(npts, 0.0);
             points.push_back(t);
  
             Array<OneD, NekDouble> r(npts, 0.0);
             std::vector<unsigned int>::iterator it;
             std::vector<BPointPair> inPoints;
             Array<OneD, Array<OneD, NekDouble> > b(3);
             for (it = m_bRegions.begin(); it != m_bRegions.end(); ++it)
             {
                 int bpts = pFields[0]->GetBndCondExpansions()[*it]->GetNpoints();
                 for (int i = 0; i < 3; i++)
                 {
                     b[i] = Array<OneD, NekDouble>(bpts, 0.0);
                 }
                 pFields[0]->GetBndCondExpansions()[*it]->GetCoords(
                     b[0], b[1], b[2]);
                 for (int i = 0;
                     i < pFields[0]->GetBndCondExpansions()[*it]->GetNpoints();
                     ++i)
                 {
                     inPoints.push_back(
                         BPointPair(BPoint(b[0][i], b[1][i], b[2][i]), i));
                 }
             }
             m_rtree = MemoryManager<BRTree>::AllocateSharedPtr();
             m_rtree->insert(inPoints.begin(), inPoints.end());
  
             for (int i = 0; i < npts; ++i)
             {
                 std::vector<BPointPair> result;
                 BPoint sPoint(x[0][i], x[1][i], x[2][i]);
                 m_rtree->query(bgi::nearest(sPoint, 1), std::back_inserter(result));
                 r[i] = bg::distance(sPoint, result[0].first);
             }
             points.push_back(r);
  
             std::string s_FieldStr;
             for (int i = 0; i < m_NumVariable; ++i)
             {
                 s_FieldStr = m_session->GetVariable(i);
                 ASSERTL0(m_session->DefinesFunction(funcName, s_FieldStr),
                         "Variable '" + s_FieldStr + "' not defined.");
  
                 LibUtilities::EquationSharedPtr ffunc =
                     m_session->GetFunction(funcName, s_FieldStr);
                 ASSERTL0(ffunc->GetVlist() == "x y z t r",
                         "EVARS of " + funcName + " must be 'r'");
  
                 ffunc->Evaluate(points, m_Absorption[i]);
             }
         }
         else
         {
             for (int i = 0; i < m_NumVariable; ++i)
             {
                 std::string s_FieldStr = m_session->GetVariable(i);
                 GetFunction(pFields, m_session, funcName)->Evaluate(s_FieldStr, m_Absorption[i]);
             }
         }
     }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::StdRegions::find(), Nektar::ParseUtils::GenerateVector(), Nektar::SpatialDomains::BoundaryConditions::GetBoundaryRegions(), Nektar::SolverUtils::Forcing::GetFunction(), m_Absorption, m_bRegions, Nektar::SolverUtils::Forcing::m_NumVariable, m_rtree, and Nektar::SolverUtils::Forcing::m_session.

Referenced by v_InitObject().

◆ CalculateForcing()

void Nektar::SolverUtils::ForcingAbsorption::CalculateForcing	(	const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		const Array< OneD, Array< OneD, NekDouble > > &	inarray,
		const NekDouble &	time
	)

protected

Definition at line 273 of file ForcingAbsorption.cpp.

     {
         boost::ignore_unused(fields);
         int nq = m_Forcing[0].size();
        
         std::string s_FieldStr;
         Array<OneD, NekDouble> TimeScale(1);
         Array<OneD, Array<OneD, NekDouble> > RefflowScaled(m_NumVariable);
  
         if (m_hasRefFlow)
         {
             for (int i = 0; i < m_NumVariable; i++)
             {
                 RefflowScaled[i] = Array<OneD, NekDouble> (nq);
                 if (m_hasRefFlowTime)
                 {
                     s_FieldStr = m_session->GetVariable(i);
  
                     std::string s_FieldStr = m_session->GetVariable(i);
                     GetFunction(fields, m_session, m_funcNameTime)->
                         Evaluate(s_FieldStr, m_Refflow[i], time);
                     Vmath::Vcopy(nq, m_Refflow[i], 1, RefflowScaled[i], 1);
                 }
                 else
                 {
                     Vmath::Vcopy(nq, m_Refflow[i],1, RefflowScaled[i],1);
                 }
                 
  
                 Vmath::Vsub(nq, inarray[i], 1,
                             RefflowScaled[i], 1, m_Forcing[i], 1);
                 Vmath::Vmul(nq, m_Absorption[i], 1,
                             m_Forcing[i], 1, m_Forcing[i], 1);
             }
         }
         else
         {
             for (int i = 0; i < m_NumVariable; i++)
             {
                 Vmath::Vmul(nq, m_Absorption[i], 1,
                             inarray[i], 1, m_Forcing[i], 1);
             }
         }
     }

References Nektar::SolverUtils::Forcing::GetFunction(), m_Absorption, Nektar::SolverUtils::Forcing::m_Forcing, m_funcNameTime, m_hasRefFlow, m_hasRefFlowTime, Nektar::SolverUtils::Forcing::m_NumVariable, m_Refflow, Nektar::SolverUtils::Forcing::m_session, Vmath::Vcopy(), Vmath::Vmul(), and Vmath::Vsub().

Referenced by v_Apply(), and v_ApplyCoeff().

◆ create()

static SOLVER_UTILS_EXPORT ForcingSharedPtr Nektar::SolverUtils::ForcingAbsorption::create	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const std::weak_ptr< EquationSystem > &	pEquation,
		const Array< OneD, MultiRegions::ExpListSharedPtr > &	pFields,
		const unsigned int &	pNumForcingFields,
		const TiXmlElement *	pForce
	)

inlinestatic

Creates an instance of this class.

Definition at line 63 of file ForcingAbsorption.h.

             {
                 ForcingSharedPtr p = MemoryManager<ForcingAbsorption>::
                                         AllocateSharedPtr(pSession, pEquation);
                 p->InitObject(pFields, pNumForcingFields, pForce);
                 return p;
             }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::SolverUtils::ForcingSharedPtr, and CellMLToNektar.cellml_metadata::p.

◆ v_Apply()

void Nektar::SolverUtils::ForcingAbsorption::v_Apply	(	const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		const Array< OneD, Array< OneD, NekDouble > > &	inarray,
		Array< OneD, Array< OneD, NekDouble > > &	outarray,
		const NekDouble &	time
	)

protectedvirtual

Implements Nektar::SolverUtils::Forcing.

Definition at line 240 of file ForcingAbsorption.cpp.

     {
         int nq = m_Forcing[0].size();
         CalculateForcing(fields, inarray, time);
         for (int i = 0; i < m_NumVariable; ++i)
         {
             Vmath::Vadd(nq, m_Forcing[i], 1,
                         outarray[i], 1, outarray[i], 1);
         }
     }

References CalculateForcing(), Nektar::SolverUtils::Forcing::m_Forcing, Nektar::SolverUtils::Forcing::m_NumVariable, and Vmath::Vadd().

◆ v_ApplyCoeff()

void Nektar::SolverUtils::ForcingAbsorption::v_ApplyCoeff	(	const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		const Array< OneD, Array< OneD, NekDouble > > &	inarray,
		Array< OneD, Array< OneD, NekDouble > > &	outarray,
		const NekDouble &	time
	)

protectedvirtual

Reimplemented from Nektar::SolverUtils::Forcing.

Definition at line 255 of file ForcingAbsorption.cpp.

     {
         int ncoeff = outarray[m_NumVariable - 1].size();
         Array<OneD, NekDouble> tmp(ncoeff, 0.0);
         CalculateForcing(fields, inarray, time);
  
         for (int i = 0; i < m_NumVariable; ++i)
         {
             fields[i]->FwdTrans(m_Forcing[i], tmp);
             Vmath::Vadd(ncoeff, tmp, 1,
                         outarray[i], 1, outarray[i], 1);
         }
     }

References CalculateForcing(), Nektar::SolverUtils::Forcing::m_Forcing, Nektar::SolverUtils::Forcing::m_NumVariable, and Vmath::Vadd().

◆ v_InitObject()

void Nektar::SolverUtils::ForcingAbsorption::v_InitObject	(	const Array< OneD, MultiRegions::ExpListSharedPtr > &	pFields,
		const unsigned int &	pNumForcingFields,
		const TiXmlElement *	pForce
	)

protectedvirtual

Implements Nektar::SolverUtils::Forcing.

Definition at line 64 of file ForcingAbsorption.cpp.

     {
         m_NumVariable = pNumForcingFields;
         int npts      = pFields[0]->GetTotPoints();
  
         CalcAbsorption(pFields, pForce);
  
         m_Forcing = Array<OneD, Array<OneD, NekDouble> >(m_NumVariable);
         for (int i = 0; i < m_NumVariable; ++i)
         {
             m_Forcing[i] = Array<OneD, NekDouble>(npts, 0.0);
         }
  
         const TiXmlElement* funcNameElmt = pForce->FirstChildElement("REFFLOW");
         if (funcNameElmt)
         {
             string funcName = funcNameElmt->GetText();
             ASSERTL0(m_session->DefinesFunction(funcName),
                      "Function '" + funcName + "' not defined.");
             m_Refflow = Array<OneD, Array<OneD, NekDouble> > (m_NumVariable);
             for (int i = 0; i < m_NumVariable; ++i)
             {
                 std::string s_FieldStr = m_session->GetVariable(i);
                 ASSERTL0(m_session->DefinesFunction(funcName, s_FieldStr),
                          "Variable '" + s_FieldStr + "' not defined.");
                 m_Refflow[i] = Array<OneD, NekDouble> (npts, 0.0);
                 GetFunction(pFields, m_session, funcName)->Evaluate(s_FieldStr, m_Refflow[i]);
             }
             m_hasRefFlow = true;
         }
  
         funcNameElmt = pForce->FirstChildElement("REFFLOWTIME");
         if (funcNameElmt)
         {
             m_funcNameTime = funcNameElmt->GetText();
             m_hasRefFlowTime = true;
             m_hasRefFlow = true;
             m_Refflow = Array<OneD, Array<OneD, NekDouble> > (m_NumVariable);
             for (int i = 0; i < m_NumVariable; ++i)
             {
                 std::string s_FieldStr = m_session->GetVariable(i);
                 ASSERTL0(m_session->DefinesFunction(m_funcNameTime, s_FieldStr),
                             "Variable '" + s_FieldStr + "' not defined.");
                 m_Refflow[i] = Array<OneD, NekDouble> (npts, 0.0);
             }
         }
     }

References ASSERTL0, CalcAbsorption(), Nektar::SolverUtils::Forcing::GetFunction(), Nektar::SolverUtils::Forcing::m_Forcing, m_funcNameTime, m_hasRefFlow, m_hasRefFlowTime, Nektar::SolverUtils::Forcing::m_NumVariable, m_Refflow, and Nektar::SolverUtils::Forcing::m_session.

Friends And Related Function Documentation

◆ MemoryManager< ForcingAbsorption >

friend class MemoryManager< ForcingAbsorption >

friend

Definition at line 1 of file ForcingAbsorption.h.

Member Data Documentation

◆ className

std::string Nektar::SolverUtils::ForcingAbsorption::className

static

Initial value:

= GetForcingFactory().
                                RegisterCreatorFunction("Absorption",
                                                        ForcingAbsorption::create,
                                                        "Forcing Absorption")

Name of the class.

Definition at line 77 of file ForcingAbsorption.h.

◆ m_Absorption

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::ForcingAbsorption::m_Absorption

protected

Definition at line 87 of file ForcingAbsorption.h.

Referenced by CalcAbsorption(), and CalculateForcing().

◆ m_bRegions

std::vector<unsigned int> Nektar::SolverUtils::ForcingAbsorption::m_bRegions

protected

Definition at line 90 of file ForcingAbsorption.h.

Referenced by CalcAbsorption().

◆ m_funcNameTime

std::string Nektar::SolverUtils::ForcingAbsorption::m_funcNameTime

protected

Definition at line 89 of file ForcingAbsorption.h.

Referenced by CalculateForcing(), and v_InitObject().

◆ m_hasRefFlow

bool Nektar::SolverUtils::ForcingAbsorption::m_hasRefFlow

protected

Definition at line 85 of file ForcingAbsorption.h.

Referenced by CalculateForcing(), and v_InitObject().

◆ m_hasRefFlowTime

bool Nektar::SolverUtils::ForcingAbsorption::m_hasRefFlowTime

protected

Definition at line 86 of file ForcingAbsorption.h.

Referenced by CalculateForcing(), and v_InitObject().

◆ m_Refflow

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::ForcingAbsorption::m_Refflow

protected

Definition at line 88 of file ForcingAbsorption.h.

Referenced by CalculateForcing(), and v_InitObject().

◆ m_rtree

std::shared_ptr<BRTree> Nektar::SolverUtils::ForcingAbsorption::m_rtree

protected

Definition at line 91 of file ForcingAbsorption.h.

Referenced by CalcAbsorption().

Static Public Member Functions

Static Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Private Member Functions

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ BPoint

◆ BPointPair

◆ BRTree

Constructor & Destructor Documentation

◆ ForcingAbsorption()

◆ ~ForcingAbsorption()

Member Function Documentation

◆ CalcAbsorption()

◆ CalculateForcing()

◆ create()

◆ v_Apply()

◆ v_ApplyCoeff()

◆ v_InitObject()

Friends And Related Function Documentation

◆ MemoryManager< ForcingAbsorption >

Member Data Documentation

◆ className

◆ m_Absorption

◆ m_bRegions

◆ m_funcNameTime

◆ m_hasRefFlow

◆ m_hasRefFlowTime

◆ m_Refflow

◆ m_rtree