将不同函数的结果组合成单个向量的函数。所有重写的虚拟函数在function_base.h中都有文档。更多...

#include <composite_function.h>

类 libMesh::CompositeFunction< Output > 继承关系图:

Public 成员函数
	CompositeFunction ()=default
	默认构造函数。更多...

	CompositeFunction (CompositeFunction &&)=default
	该类可以使用默认的移动构造和分配。更多...

CompositeFunction &	operator= (CompositeFunction &&)=default

	CompositeFunction (const CompositeFunction &)=delete
	该类包含unique_ptr成员，因此不能默认复制或分配。更多...

CompositeFunction &	operator= (const CompositeFunction &)=delete

virtual	~CompositeFunction ()=default
	子函数向量会自动清理。更多...

void	attach_subfunction (const FunctionBase< Output > &f, std::vector< unsigned int > index_map)
	附加新的子函数，以及从附加的子函数的索引到组合函数的索引的映射。更多...

virtual Output	operator() (const Point &p, const Real time=0) override
	重载操作符，用于计算标量值。更多...

virtual void	operator() (const Point &p, const Real time, DenseVector< Output > &output) override
	重载操作符，用于计算矢量值。更多...

virtual Output	component (unsigned int i, const Point &p, Real time) override
	重载操作符，用于计算特定分量的值。更多...

virtual std::unique_ptr < FunctionBase< Output > >	clone () const override
	克隆函数。创建并返回一个与当前实例相同类型的新实例。更多...

unsigned int	n_subfunctions () const
	获取子函数的数量。更多...

unsigned int	n_components () const
	获取组件的数量。更多...

virtual void	init ()
	实际的初始化过程。更多...

virtual void	clear ()
	清除函数。更多...

void	operator() (const Point &p, DenseVector< Output > &output)
	Evaluation function for time-independent vector-valued functions. 更多...

bool	initialized () const

void	set_is_time_dependent (bool is_time_dependent)
	设置函数是否依赖时间的函数。这仅应该由无法本地确定时间依赖性的子类使用。在这种情况下，应在构造之后立即使用这个函数。更多...

bool	is_time_dependent () const

Protected 属性
const FunctionBase *	_master
	指向我们的主函数对象的const指针，初始化为 `nullptr。` 可能存在需要多个函数的情况，但为了节省内存，一个主函数对象可以处理一些集中的数据。更多...

bool	_initialized
	当 `init()` 被调用以确保一切都准备好后，可以调用 `operator()` (...) 时为 `true。` 更多...

bool	_is_time_dependent
	成员变量用于缓存函数是否真正依赖于时间。更多...

Private 属性
std::vector< std::unique_ptr < FunctionBase< Output > > >	subfunctions

std::vector< std::vector < unsigned int > >	index_maps
	对于每个子函数，存储从子函数的索引到全局函数索引的映射的列表。更多...

std::vector< std::pair < unsigned int, unsigned int > >	reverse_index_map
	对于每个全局指数，存储该指数是哪个子函数的本地指数。每个元素是一个std::pair<unsigned int, unsigned int>，表示子函数的索引和子函数中的本地指数。更多...

详细描述

template<typename Output = Number>
class libMesh::CompositeFunction< Output >

将不同函数的结果组合成单个向量的函数。所有重写的虚拟函数在function_base.h中都有文档。

作者: Roy Stogner

日期: 2012 Function函数的另一个函数。返回由多个函数定义的分量组成的向量的函数。

在文件 composite_function.h 第 44 行定义.

构造及析构函数说明

template<typename Output = Number>

libMesh::CompositeFunction< Output >::CompositeFunction ( )

explicitdefault

默认构造函数。

参考自 libMesh::CompositeFunction< Output >::clone().

template<typename Output = Number>

libMesh::CompositeFunction< Output >::CompositeFunction ( CompositeFunction< Output > && )

default

该类可以使用默认的移动构造和分配。

template<typename Output = Number>

libMesh::CompositeFunction< Output >::CompositeFunction ( const CompositeFunction< Output > & )

delete

该类包含unique_ptr成员，因此不能默认复制或分配。

template<typename Output = Number>

virtual libMesh::CompositeFunction< Output >::~CompositeFunction ( )

virtualdefault

子函数向量会自动清理。

成员函数说明

template<typename Output = Number>

void libMesh::CompositeFunction< Output >::attach_subfunction	(	const FunctionBase< Output > &	f,
		std::vector< unsigned int >	index_map
	)

inline

附加新的子函数，以及从附加的子函数的索引到组合函数的索引的映射。

组合函数将返回一个向量，其索引 index_map[i] 处的值是附加函数在索引 i 处的值，即， (*this)(x, t)(index_map[i]) 将返回 f(x, t)(i)。

参数

f	要附加的子函数。
index_map	从附加子函数的索引到组合函数索引的映射。

在文件 composite_function.h 第 79 行定义.

参考 libMesh::FunctionBase< Output >::_is_time_dependent, libMesh::FunctionBase< Output >::clone(), libMesh::CompositeFunction< Output >::index_maps, libMesh::invalid_uint, libMesh::FunctionBase< Output >::is_time_dependent(), libMesh::CompositeFunction< Output >::reverse_index_map , 以及 libMesh::CompositeFunction< Output >::subfunctions.

参考自 libMesh::CompositeFunction< Output >::clone().

   {
     const unsigned int subfunction_index =
       cast_int<unsigned int>(subfunctions.size());
     libmesh_assert_equal_to(subfunctions.size(), index_maps.size());
 
     subfunctions.push_back(f.clone());
 
     unsigned int max_index =
       *std::max_element(index_map.begin(), index_map.end());
 
     if (max_index >= reverse_index_map.size())
       reverse_index_map.resize
         (max_index+1, std::make_pair(libMesh::invalid_uint,
                                      libMesh::invalid_uint));
 
     for (auto j : index_range(index_map))
       {
         libmesh_assert_less(index_map[j], reverse_index_map.size());
         libmesh_assert_equal_to(reverse_index_map[index_map[j]].first,
                                 libMesh::invalid_uint);
         libmesh_assert_equal_to(reverse_index_map[index_map[j]].second,
                                 libMesh::invalid_uint);
         reverse_index_map[index_map[j]] =
           std::make_pair(subfunction_index, j);
       }
 
     // 检查是否有时间依赖性
     // 我们只检查刚刚添加的函数，而不是重新研究所有子函数
     // 如果这是第一个子函数，则确定时间依赖性。
     if (subfunctions.size() == 1)
       this->_is_time_dependent = subfunctions[0]->is_time_dependent();
 
     // 否则，我们已经有了多于1个函数。
     // 如果 _is_time_dependent 为 true，则之前的某个子函数是时间依赖的，因此此 CompositeFunction 是时间依赖的。
     // 如果 _is_time_dependent 为 false，则刚刚添加的子函数确定时间依赖性。
     else if (!this->_is_time_dependent)
       this->_is_time_dependent = (subfunctions.back())->is_time_dependent();
 
     index_maps.push_back(std::move(index_map));
   }

template<typename Output>

virtual void libMesh::FunctionBase< Output >::clear ( )

inlinevirtualinherited

清除函数。

这个函数可以用来清除函数对象的状态，以备重新使用。

被 libMesh::ParsedFunction< Output, OutputGradient >, libMesh::ParsedFunction< T > , 以及 libMesh::AnalyticFunction< Output > 重载.

在文件 function_base.h 第 95 行定义.

95 {}

template<typename Output = Number>

virtual std::unique_ptr<FunctionBase<Output> > libMesh::CompositeFunction< Output >::clone ( ) const

inlineoverridevirtual

克隆函数。创建并返回一个与当前实例相同类型的新实例。

返回: 新实例的指针。

实现了 libMesh::FunctionBase< Output >.

在文件 composite_function.h 第 187 行定义.

参考 libMesh::CompositeFunction< Output >::attach_subfunction(), libMesh::CompositeFunction< Output >::CompositeFunction(), libMesh::CompositeFunction< Output >::index_maps , 以及 libMesh::CompositeFunction< Output >::subfunctions.

   {
     CompositeFunction * returnval = new CompositeFunction();
     for (auto i : index_range(subfunctions))
       returnval->attach_subfunction(*subfunctions[i], index_maps[i]);
     return std::unique_ptr<FunctionBase<Output>> (returnval);
   }

template<typename Output = Number>

virtual Output libMesh::CompositeFunction< Output >::component	(	unsigned int	i,
		const Point &	p,
		Real	time
	)

inlineoverridevirtual

重载操作符，用于计算特定分量的值。

参数

i	要计算的分量的索引。
p	计算点的坐标。
time	时间值。

返回: 计算得到的值。

重载 libMesh::FunctionBase< Output > .

在文件 composite_function.h 第 167 行定义.

参考 libMesh::invalid_uint, libMesh::CompositeFunction< Output >::reverse_index_map , 以及 libMesh::CompositeFunction< Output >::subfunctions.

参考自 libMesh::CompositeFunction< Output >::operator()().

   {
     if (i >= reverse_index_map.size() ||
         reverse_index_map[i].first == libMesh::invalid_uint)
       return 0;
 
     libmesh_assert_less(reverse_index_map[i].first,
                         subfunctions.size());
     libmesh_assert_not_equal_to(reverse_index_map[i].second,
                                 libMesh::invalid_uint);
     return subfunctions[reverse_index_map[i].first]->
       component(reverse_index_map[i].second,p,time);
   }

template<typename Output>

virtual void libMesh::FunctionBase< Output >::init ( )

inlinevirtualinherited

实际的初始化过程。

这个函数可以用来进行函数对象的初始化工作。

被 libMesh::ParsedFunction< Output, OutputGradient >, libMesh::ParsedFunction< T > , 以及 libMesh::AnalyticFunction< Output > 重载.

在文件 function_base.h 第 89 行定义.

89 {}

template<typename Output >

bool libMesh::FunctionBase< Output >::initialized ( ) const

inlineinherited

返回: 在坐标 p 和时间 time 处的向量的分量 i。

子类可以选择重写这个函数以提高效率，因为默认实现基于向量评估，通常是不必要的低效率。

参数

i	分量的索引。
p	坐标点。
time	时间。

注解: 默认实现调用带有大小为 i+1 的DenseVector的operator()，如果operator() 在该限制之外进行访问，将导致意外行为。

在文件 function_base.h 第 216 行定义.

 {
   return (this->_initialized);
 }

template<typename Output >

bool libMesh::FunctionBase< Output >::is_time_dependent ( ) const

inlineinherited

返回: 当前对象表示的函数是否实际上是时间相关的，是返回 true ，否则返回 false。

这个函数用于查询函数对象是否依赖于时间。有些函数对象的时间依赖性是从外部确定的，因此可以使用这个函数设置。

在文件 function_base.h 第 232 行定义.

参考自 libMesh::CompositeFunction< Output >::attach_subfunction().

 {
   return (this->_is_time_dependent);
 }

template<typename Output = Number>

unsigned int libMesh::CompositeFunction< Output >::n_components ( ) const

inline

获取组件的数量。

返回: 组件的数量。

在文件 composite_function.h 第 208 行定义.

参考 libMesh::CompositeFunction< Output >::reverse_index_map.

   {
     return reverse_index_map.size();
   }

template<typename Output = Number>

unsigned int libMesh::CompositeFunction< Output >::n_subfunctions ( ) const

inline

获取子函数的数量。

返回: 子函数的数量。

在文件 composite_function.h 第 199 行定义.

参考 libMesh::CompositeFunction< Output >::subfunctions.

   {
     return subfunctions.size();
   }

template<typename Output>

void libMesh::FunctionBase< Output >::operator()	(	const Point &	p,
		DenseVector< Output > &	output
	)

inlineinherited

Evaluation function for time-independent vector-valued functions.

Sets output values in the passed-in output DenseVector.

在文件 function_base.h 第 252 行定义.

 {
   // 调用时间相关的函数，时间设为0。
   this->operator()(p, 0., output);
 }

template<typename Output = Number>

virtual Output libMesh::CompositeFunction< Output >::operator()	(	const Point &	p,
		const Real	time = `0`
	)

inlineoverridevirtual

重载操作符，用于计算标量值。

参数

p	计算点的坐标。
time	时间值，默认为0。

返回: 计算得到的标量值。

实现了 libMesh::FunctionBase< Output >.

在文件 composite_function.h 第 128 行定义.

参考 libMesh::CompositeFunction< Output >::component().

   {
     return this->component(0,p,time);
   }

template<typename Output = Number>

virtual void libMesh::CompositeFunction< Output >::operator()	(	const Point &	p,
		const Real	time,
		DenseVector< Output > &	output
	)

inlineoverridevirtual

重载操作符，用于计算矢量值。

参数

p	计算点的坐标。
time	时间值。
output	计算得到的矢量值。

实现了 libMesh::FunctionBase< Output >.

在文件 composite_function.h 第 140 行定义.

参考 libMesh::CompositeFunction< Output >::index_maps, libMesh::DenseVector< T >::resize(), libMesh::CompositeFunction< Output >::reverse_index_map, libMesh::DenseVector< T >::size(), libMesh::CompositeFunction< Output >::subfunctions , 以及 libMesh::DenseVector< T >::zero().

   {
     libmesh_assert_greater_equal (output.size(),
                                   reverse_index_map.size());
 
     // 必要时，清零未被任何子函数覆盖的输出分量
     output.zero();
 
     DenseVector<Output> temp;
     for (auto i : index_range(subfunctions))
       {
         temp.resize(cast_int<unsigned int>(index_maps[i].size()));
         (*subfunctions[i])(p, time, temp);
         for (auto j : index_range(temp))
           output(index_maps[i][j]) = temp(j);
       }
   }

template<typename Output = Number>

CompositeFunction& libMesh::CompositeFunction< Output >::operator= ( CompositeFunction< Output > && )

default

template<typename Output = Number>

CompositeFunction& libMesh::CompositeFunction< Output >::operator= ( const CompositeFunction< Output > & )

delete

template<typename Output >

void libMesh::FunctionBase< Output >::set_is_time_dependent ( bool is_time_dependent )

inlineinherited

设置函数是否依赖时间的函数。这仅应该由无法本地确定时间依赖性的子类使用。在这种情况下，应在构造之后立即使用这个函数。

在文件 function_base.h 第 224 行定义.

 {
   this->_is_time_dependent = is_time_dependent;
 }

类成员变量说明

template<typename Output>

bool libMesh::FunctionBase< Output >::_initialized

protectedinherited

当 init() 被调用以确保一切都准备好后，可以调用 operator() (...) 时为 true。

这个成员变量用于跟踪函数对象是否已经完成初始化，如果已经准备好进行评估，则为 true。

在文件 function_base.h 第 191 行定义.

参考自 libMesh::AnalyticFunction< Output >::AnalyticFunction(), libMesh::ConstFunction< Output >::ConstFunction(), libMesh::ParsedFunction< Output, OutputGradient >::ParsedFunction() , 以及 libMesh::WrappedFunction< Output >::WrappedFunction().

template<typename Output>

bool libMesh::FunctionBase< Output >::_is_time_dependent

protectedinherited

成员变量用于缓存函数是否真正依赖于时间。

在文件 function_base.h 第 197 行定义.

参考自 libMesh::CompositeFunction< Output >::attach_subfunction() , 以及 libMesh::ConstFunction< Output >::ConstFunction().

template<typename Output>

const FunctionBase* libMesh::FunctionBase< Output >::_master

protectedinherited

指向我们的主函数对象的const指针，初始化为 nullptr。 可能存在需要多个函数的情况，但为了节省内存，一个主函数对象可以处理一些集中的数据。

这个成员变量用于指向主函数对象的指针，有时候多个函数对象需要共享一些数据，可以通过主函数对象来管理。

在文件 function_base.h 第 184 行定义.

template<typename Output = Number>

std::vector<std::vector<unsigned int> > libMesh::CompositeFunction< Output >::index_maps

private

对于每个子函数，存储从子函数的索引到全局函数索引的映射的列表。

index_maps[i] 存储第 i 个子函数的索引映射。

在文件 composite_function.h 第 222 行定义.

参考自 libMesh::CompositeFunction< Output >::attach_subfunction(), libMesh::CompositeFunction< Output >::clone() , 以及 libMesh::CompositeFunction< Output >::operator()().

template<typename Output = Number>

std::vector<std::pair<unsigned int, unsigned int> > libMesh::CompositeFunction< Output >::reverse_index_map

private

对于每个全局指数，存储该指数是哪个子函数的本地指数。每个元素是一个std::pair<unsigned int, unsigned int>，表示子函数的索引和子函数中的本地指数。

在文件 composite_function.h 第 229 行定义.

参考自 libMesh::CompositeFunction< Output >::attach_subfunction(), libMesh::CompositeFunction< Output >::component(), libMesh::CompositeFunction< Output >::n_components() , 以及 libMesh::CompositeFunction< Output >::operator()().

template<typename Output = Number>

std::vector<std::unique_ptr<FunctionBase<Output> > > libMesh::CompositeFunction< Output >::subfunctions

private

在文件 composite_function.h 第 215 行定义.

参考自 libMesh::CompositeFunction< Output >::attach_subfunction(), libMesh::CompositeFunction< Output >::clone(), libMesh::CompositeFunction< Output >::component(), libMesh::CompositeFunction< Output >::n_subfunctions() , 以及 libMesh::CompositeFunction< Output >::operator()().

该类的文档由以下文件生成:

/home/lwz/libmesh/include/numerics/composite_function.h

Public 成员函数

Protected 属性

Private 属性

详细描述

template<typename Output = Number> class libMesh::CompositeFunction< Output >

构造及析构函数说明

成员函数说明

类成员变量说明

template<typename Output = Number>
class libMesh::CompositeFunction< Output >