====== XResultComponent ======

**//Inherited from//**  [[class::domain::nitem|NItem]],

**//Inherited by//**  NULL

**//Friend class//**  NULL

**//Description//**

XResultComponent封装了结果分量数据对象， 它是结果数据对象的基本组成部分。结果分量数据或者在节点上、或者在单元中心上、或者在单元节点上、或者在单元积分点上，因此对于给定模型，它的长度会因为位置不一样而不一样；此外，某些结果只在模型的部分区域（比如板壳结果或者杆梁结果），它的数据长度会做相应的调整。为了节约内存并提高和统一结果分量的数据的访问方式， XT会对模型的网格数据做预处理，首先构造模型的表面几何数据（这是后处理轻量化的关键处理方法之一），然后对节点、单元排序，使得节点、单元按照杆梁、板壳、实体的顺序排列，结果分量的数据都将直接参考该顺序而不用另外保存结果的索引。\\
后处理的结果在某些场合往往巨大，远远超出可用内存的大小，因此此时将所有数据放在内存中不可行，XT使用了文件缓冲系统，在运行中仅仅在内存中载入当前要使用的结果分量数据，其它的分量数据按二进制数据库写入到文件中，切换结果的时候也只需读入相应的数据块。\\
此外，结果分量数据对象还记录了该分量数据的极值以及该分量在源文件中的起始位置。

**//Members//**
  * int [[xresultcomponent#m_icount|m_iCount]]
  * TypeID [[xresultcomponent#m_idatatype|m_iDataType]]
  * TypeID [[xresultcomponent#m_icomptype|m_iCompType]]
  * int64 [[xresultcomponent#m_lloffset|m_llOffset]]
  * ExtremeValue [[xresultcomponent#m_max|m_Max]]
  * ExtremeValue [[xresultcomponent#m_min|m_Min]]
  * void * [[xresultcomponent#m_pdataarray|m_pDataArray]]
  * const XResult * [[xresultcomponent#m_prlt|m_pRlt]]
**//Public interface//**
  * [[xresultcomponent#xresultcomponent2|XResultComponent]](ulong id, const char * name = "")
  * TypeID [[xresultcomponent#getcomponenttype|getComponentType]]() const
  * void [[xresultcomponent#setcomponenttype|setComponentType]](TypeID t)
  * void [[xresultcomponent#setresult|setResult]](const XResult * rlt)
  * const XResult * [[xresultcomponent#getresult|getResult]]() const
  * [[xresultcomponent#~xresultcomponent|~XResultComponent]]()
  * void operator [[xresultcomponent#copy|=]] (const XResultComponent & rc)
  * void [[xresultcomponent#init|init]](const char * name, TypeID type = Result_Component_Unknown)
  * void [[xresultcomponent#updateextreme|updateExtreme]](float v, ulong id)
  * int64 [[xresultcomponent#getsourcelocation|getSourceLocation]]() const
  * void [[xresultcomponent#setsourcelocation|setSourceLocation]](int64 fpos = 0)
  * ExtremeValue & [[xresultcomponent#getmax|getMax]]()
  * ExtremeValue & [[xresultcomponent#getmin|getMin]]()
  * const ExtremeValue & [[xresultcomponent#getmax|getMax]]() const
  * const ExtremeValue & [[xresultcomponent#getmin|getMin]]() const
  * void [[xresultcomponent#setcount|setCount]](int cnt)
  * void [[xresultcomponent#alloc|alloc]]()
  * void [[xresultcomponent#dump|dump]]()
  * void [[xresultcomponent#clear|clear]]()
  * void [[xresultcomponent#copydata|copyData]](const void * data)
  * void [[xresultcomponent#reset|reset]]()
  * float [[xresultcomponent#getnoderesultvalue|getNodeResultValue]](const XNode * n) const
  * float [[xresultcomponent#getelementresultvalue|getElementResultValue]](const XElement * n) const
  * float [[xresultcomponent#getelementnoderesultvalue|getElementNodeResultValue]](const XElement * n, int nodeIndex, const int * elemNodeIndexArray) const
  * float [[xresultcomponent#getintegralpointresultvalue|getIntegralPointResultValue]](const XElement * n, int ipIndex, const int * elemNodeIndexArray) const
  * float [[xresultcomponent#getaveragefromelemnodalvalue|getAverageFromElemNodalValue]](const XElement * n, const int * elemNodeIndexArray) const
  * void [[xresultcomponent#setnoderesultvalue|setNodeResultValue]](const XNode * n, float v)
  * void [[xresultcomponent#setelementresultvalue|setElementResultValue]](const XElement * n, float v)
  * void [[xresultcomponent#setelementnoderesultvalue|setElementNodeResultValue]](const XElement * n, const int * elemNodeIndexArray, const double * v, bool bFromLocalCSYS = false)
  * void [[xresultcomponent#setintegralpointresultvalue|setIntegralPointResultValue]](const XElement * n, const int * elemNodeIndexArray, const double * v)
  * void [[xresultcomponent#setintegralpointresultvalue|setIntegralPointResultValue]](const XElement * n, const int * elemNodeIndexArray, const float * v)
  * flo[[xresultcomponent#at|at]] & [[xresultcomponent#at|at]](int i)
  * const flo[[xresultcomponent#at|at]] & [[xresultcomponent#at|at]](int i) const
  * float * [[xresultcomponent#data|data]]()
  * const float * [[xresultcomponent#data|data]]() const
  * int [[xresultcomponent#count|count]]() const
  * ErrorCode [[xresultcomponent#read|read]](H5IO * io, H5Obj * grp, bool bDataOnly = true)
  * void [[xresultcomponent#write|write]](H5IO * io, H5Obj * grp, bool bDataOnly = true)
**//Private interface//**
  * [[xresultcomponent#xresultcomponent1|XResultComponent]](const [[xresultcomponent#xresultcomponent1|XResultComponent]] & rc)

----

{{anchor:m_icount}}
**int m_iCount**

数据长度

{{anchor:m_idatatype}}
**TypeID m_iDataType**

数值类型（float或者double）

{{anchor:m_icomptype}}
**TypeID m_iCompType**

分量类型

{{anchor:m_lloffset}}
**int64 m_llOffset**

在源文件中的起始位置

{{anchor:m_max}}
**ExtremeValue m_Max**

数据最大值以及对应的索引

{{anchor:m_min}}
**ExtremeValue m_Min**

数据最小值以及对应的索引

{{anchor:m_pdataarray}}
**void * m_pDataArray**

分量数据数组首地址

{{anchor:m_prlt}}
**const XResult * m_pRlt**

所属的结果数据对象

----

{{anchor:xresultcomponent2}}
**XResultComponent(ulong id, const char * name = "") **
  *function: 构造函数
  *parameters: 
    - [i]ulong id: 身份ID
    - [i] const char * name = "": 分量标签
  *return value: 无

{{anchor:getcomponenttype}}
**TypeID getComponentType() const**
  *function: 获取分量类型
  *parameters: NULL
  *return value: 分量类型标识

{{anchor:setcomponenttype}}
**void setComponentType(TypeID t)**
  *function: 设置分量类型
  *parameters: 
    - [i]TypeID t: 分量类型标识
  *return value: 无

{{anchor:setresult}}
**void setResult(const XResult * rlt)**
  *function: 绑定结果数据对象
  *parameters: 
    - [i]const XResult * rlt: 结果数据对象
  *return value: 无

{{anchor:getresult}}
**const XResult * getResult() const**
  *function: 获取所属的结果数据对象
  *parameters: NULL
  *return value: 所属的结果数据对象

{{anchor:~xresultcomponent}}
**~XResultComponent()**
  *function: 析构函数
  *parameters: NULL
  *return value: 无

{{anchor:copy}}
**void operator = (const XResultComponent & rc)**
  *function: 复制结构分量
  *parameters: 
    - [i]const XResultComponent & rc: 被复制的结果分量引用
  *return value: 无

{{anchor:init}}
**void init(const char * name, TypeID type = Result_Component_Unknown)**
  *function: 初始化分量数据
  *parameters: 
    - [i]const char * name: 分量标签
    - [i] TypeID type = Result_Component_Unknown: 分量类型
  *return value: 无

{{anchor:updateextreme}}
**void updateExtreme(float v, ulong id)**
  *function: 更新极值
  *parameters: 
    - [i]float v: 结果值
    - [i] ulong id: 值对应的节点或单元ID
  *return value: 无

{{anchor:getsourcelocation}}
**int64 getSourceLocation() const**
  *function: 获取分量结果在源文件中的起始位置
  *parameters: NULL
  *return value: 分量结果在源文件中的起始位置

{{anchor:setsourcelocation}}
**void setSourceLocation(int64 fpos = 0)**
  *function: 设置分量结果在源文件中的起始位置
  *parameters: 
    - [i]int64 fpos = 0: 分量结果在源文件中的起始位置
  *return value: 无

{{anchor:getmax}}
**ExtremeValue & getMax()**
  *function: 获取分量数据的最大值
  *parameters: NULL
  *return value: 分量数据的最大值引用

{{anchor:getmin}}
**ExtremeValue & getMin()**
  *function: 获取分量数据的最小值
  *parameters: NULL
  *return value: 分量数据的最小值引用

{{anchor:getmax}}
**const ExtremeValue & getMax() const**
  *function: 获取分量数据的最大值
  *parameters: NULL
  *return value: 分量数据的最大值引用

{{anchor:getmin}}
**const ExtremeValue & getMin() const**
  *function: 获取分量数据的最小值
  *parameters: NULL
  *return value: 分量数据的最小值引用

{{anchor:setcount}}
**void setCount(int cnt)**
  *function: 设置分量数据长度
  *parameters: 
    - [i]int cnt: 分量数据长度
  *return value: 无

{{anchor:alloc}}
**void alloc()**
  *function: 为分量数据分配内存空间
  *parameters: NULL
  *return value: 无

{{anchor:dump}}
**void dump()**
  *function: 将分量数据倒入到二进制缓存文件中
  *parameters: NULL
  *return value: 无

{{anchor:clear}}
**void clear()**
  *function: 清空结果数据
  *parameters: NULL
  *return value: 无

{{anchor:copydata}}
**void copyData(const void * data)**
  *function: 复制分量数据
  *parameters: 
    - [i]const void * data: 数据源地址
  *return value: 无

{{anchor:reset}}
**void reset()**
  *function: 清空结果数据并重置极值
  *parameters: NULL
  *return value: 无

{{anchor:getnoderesultvalue}}
**float getNodeResultValue(const XNode * n) const**
  *function: 查询分量数据在节点n上的值
  *parameters: 
    - [i]const XNode * n: 查询的节点n
  *return value: 分量数据在节点n上的值

{{anchor:getelementresultvalue}}
**float getElementResultValue(const XElement * n) const**
  *function: 查询分量数据在单元n上的值
  *parameters: 
    - [i]const XElement * n: 查询单元
  *return value: 分量数据在单元n上的值

{{anchor:getelementnoderesultvalue}}
**float getElementNodeResultValue(const XElement * n, int nodeIndex, const int * elemNodeIndexArray) const**
  *function: 查询分量数据在单元节点上的值
  *parameters: 
    - [i]const XElement * n: 查询单元
    - [i] int nodeIndex: 节点序号
    - [i] const int * elemNodeIndexArray: 单元节点索引数组
  *return value: 分量数据在单元节点上的值

{{anchor:getintegralpointresultvalue}}
**float getIntegralPointResultValue(const XElement * n, int ipIndex, const int * elemNodeIndexArray) const**
  *function: 查询分量数据在单元积分点上的值
  *parameters: 
    - [i]const XElement * n: 查询单元
    - [i] int ipIndex: 积分点序号
    - [i] const int * elemNodeIndexArray: 单元积分点索引数组
  *return value: 分量数据在单元积分点上的值

{{anchor:getaveragefromelemnodalvalue}}
**float getAverageFromElemNodalValue(const XElement * n, const int * elemNodeIndexArray) const**
  *function: 由单元节点上的值平均计算得到单元上的值
  *parameters: 
    - [i]const XElement * n: 查询单元
    - [i] const int * elemNodeIndexArray: 单元节点索引数组
  *return value: 分量数据在单元n上的值

{{anchor:setnoderesultvalue}}
**void setNodeResultValue(const XNode * n, float v)**
  *function: 设置节点n上的值
  *parameters: 
    - [i]const XNode * n: 节点指针
    - [i] float v: 节点上的值
  *return value: 无

{{anchor:setelementresultvalue}}
**void setElementResultValue(const XElement * n, float v)**
  *function: 设置单元上的值
  *parameters: 
    - [i]const XElement * n: 单元指针
    - [i] float v: 单元上的值
  *return value: 无

{{anchor:setelementnoderesultvalue}}
**void setElementNodeResultValue(const XElement * n, const int * elemNodeIndexArray, const double * v, bool bFromLocalCSYS = false)**
  *function: 设置单元节点上的值
  *parameters: 
    - [i]const XElement * n: 单元指针
    - [i] const int * elemNodeIndexArray: 单元节点索引数组
    - [i] const double * v: 指定单元各节点上的值
    - [i] bool bFromLocalCSYS = false: 是否从局部坐标系计算得到
  *return value: 无

{{anchor:setintegralpointresultvalue}}
**void setIntegralPointResultValue(const XElement * n, const int * elemNodeIndexArray, const double * v)**
  *function: 设置单元积分点上的值
  *parameters: 
    - [i]const XElement * n: 单元指针
    - [i] const int * elemNodeIndexArray: 单元节点索引数组
    - [i] const double * v: 指定单元各积分点上的值
  *return value: 无

{{anchor:setintegralpointresultvalue}}
**void setIntegralPointResultValue(const XElement * n, const int * elemNodeIndexArray, const float * v)**
  *function: 设置单元积分点上的值
  *parameters: 
    - [i]const XElement * n: 单元指针
    - [i] const int * elemNodeIndexArray: 单元节点索引数组
    - [i] const float * v: 指定单元各积分点上的值
  *return value: 无

{{anchor:at}}
**float & at(int i)**
  *function: 分量数据第i个值
  *parameters: 
    - [i]int i: 序号
  *return value: 分量数据第i个值

{{anchor:at}}
**const float & at(int i) const**
  *function: 分量数据第i个值
  *parameters: 
    - [i]int i: 序号
  *return value: 分量数据第i个值

{{anchor:data}}
**float * data()**
  *function: 获取结果数据数组地址
  *parameters: NULL
  *return value: 结果数据数组地址

{{anchor:data}}
**const float * data() const**
  *function: 获取结果数据数组地址
  *parameters: NULL
  *return value: 结果数据数组地址

{{anchor:count}}
**int count() const**
  *function: 获取数据长度
  *parameters: NULL
  *return value: 数据长度

{{anchor:read}}
**ErrorCode read(H5IO * io, H5Obj * grp, bool bDataOnly = true)**
  *function: 从HDF5文件中读取结果分量数据
  *parameters: 
    - [i]H5IO * io: HDF5文件句柄
    - [i] H5Obj * grp: 对应的HDF5节点
    - [i] bool bDataOnly = true: 是否只读取数据（不读取极值等属性）
  *return value: 成功读取返回Error_None，否则返回相应错误码

{{anchor:write}}
**void write(H5IO * io, H5Obj * grp, bool bDataOnly = true)**
  *function: 将分量数据写入到HDf5文件中
  *parameters: 
    - [i]H5IO * io: HDF5文件句柄
    - [i] H5Obj * grp: 对应的HDF5节点
    - [i] bool bDataOnly = true: 是否只写出数据（不写出极值等属性）
  *return value: 无

----

{{anchor:xresultcomponent1}}
**XResultComponent(const XResultComponent & rc)**
  *function: 复制构造函数
  *parameters: 
    - [i]const [[xresultcomponent#xresultcomponent1|XResultComponent]] & rc: 
  *return value: 无