RasterProcessTool/Toolbox/SimulationSARTool/PowerSimulationIncoherent/OribtModelOperator.cpp

696 lines
23 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

#include "OribtModelOperator.h"
#include <Eigen/Core>
#include <Eigen/Dense>
#include <QMatrix>
#include <QtMath>
#include <QDate>
#include <QTime>
#include <QDateTime>
#include <BaseTool.h>
OrbitElements::OrbitElements() : semiMajorAxis(0), eccentricity(0), inclination(0),
longitudeOfAscendingNode(0), argumentOfPeriapsis(0), trueAnomaly(0) {}
/** 六根数轨道拟合模型************************************************************************************/
OrbitEstimator::OrbitEstimator() {}
void OrbitEstimator::estimateOrbit(const SatellitePos& node) {
// 根据轨道节点估算轨道六根数的具体算法
elements = estimateKeplerianElements(node);
}
void OrbitEstimator::saveToXml(const QString& filename) const {
QDomDocument doc("OrbitElements");
QDomElement root = doc.createElement("OrbitElements");
doc.appendChild(root);
QDomElement elem;
elem = doc.createElement("SemiMajorAxis");
elem.appendChild(doc.createTextNode(QString::number(elements.semiMajorAxis)));
root.appendChild(elem);
elem = doc.createElement("Eccentricity");
elem.appendChild(doc.createTextNode(QString::number(elements.eccentricity)));
root.appendChild(elem);
elem = doc.createElement("Inclination");
elem.appendChild(doc.createTextNode(QString::number(elements.inclination)));
root.appendChild(elem);
elem = doc.createElement("LongitudeOfAscendingNode");
elem.appendChild(doc.createTextNode(QString::number(elements.longitudeOfAscendingNode)));
root.appendChild(elem);
elem = doc.createElement("ArgumentOfPeriapsis");
elem.appendChild(doc.createTextNode(QString::number(elements.argumentOfPeriapsis)));
root.appendChild(elem);
elem = doc.createElement("TrueAnomaly");
elem.appendChild(doc.createTextNode(QString::number(elements.trueAnomaly)));
root.appendChild(elem);
QFile file(filename);
if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
qDebug() << "Cannot open file for writing:" << filename;
return;
}
QTextStream out(&file);
doc.save(out, 4); // Indent by 4 spaces
file.close();
}
bool OrbitEstimator::loadFromXml(const QString& filename) {
QFile file(filename);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
qDebug() << "Cannot open file for reading:" << filename;
return false;
}
QDomDocument doc;
if (!doc.setContent(&file)) {
file.close();
return false;
}
file.close();
QDomElement root = doc.documentElement();
QDomNodeList nodeList = root.elementsByTagName("*");
for (int i = 0; i < nodeList.count(); ++i) {
QDomElement element = nodeList.at(i).toElement();
if (element.tagName() == "SemiMajorAxis") {
elements.semiMajorAxis = element.text().toDouble();
}
else if (element.tagName() == "Eccentricity") {
elements.eccentricity = element.text().toDouble();
}
else if (element.tagName() == "Inclination") {
elements.inclination = element.text().toDouble();
}
else if (element.tagName() == "LongitudeOfAscendingNode") {
elements.longitudeOfAscendingNode = element.text().toDouble();
}
else if (element.tagName() == "ArgumentOfPeriapsis") {
elements.argumentOfPeriapsis = element.text().toDouble();
}
else if (element.tagName() == "TrueAnomaly") {
elements.trueAnomaly = element.text().toDouble();
}
}
return true;
}
SatellitePos OrbitEstimator::calculateNode(double time) const {
// 根据轨道六根数计算轨道节点的具体算法
return calculateKeplerianNode(elements, time);
}
SatellitePos OrbitEstimator::predictNode(double time)
{
return calculateNode(time);
}
OrbitElements OrbitEstimator::estimateKeplerianElements(const SatellitePos& node) {
// 示例简单地将所有值设为0
OrbitElements elements;
elements.semiMajorAxis = 0;
elements.eccentricity = 0;
elements.inclination = 0;
elements.longitudeOfAscendingNode = 0;
elements.argumentOfPeriapsis = 0;
elements.trueAnomaly = 0;
return elements;
}
SatellitePos OrbitEstimator::calculateKeplerianNode(const OrbitElements& elements, double time) const {
const double G = 6.67430e-11; // 引力常数 m^3 kg^-1 s^-2
const double M_Earth = 5.972e24; // 地球质量 kg
const double mu = G * M_Earth; // 地球引力参数 m^3 s^-2
double a = elements.semiMajorAxis;
double e = elements.eccentricity;
double i = elements.inclination;
double Omega = elements.longitudeOfAscendingNode;
double omega = elements.argumentOfPeriapsis;
// 计算平均运动
double n = std::sqrt(mu / (a * a * a));
// 计算从参考时刻到给定时间的平均异常
double t_ref = 0.0; // 参考时刻假设为0
double M = n * (time - t_ref);
// 求解开普勒方程 E - e*sin(E) = M 使用牛顿迭代法
double E = M; // 初始猜测
double tolerance = 1e-8;
int maxIterations = 100;
for (int iter = 0; iter < maxIterations; ++iter) {
double f = E - e * std::sin(E) - M;
double df = 1 - e * std::cos(E);
double delta = f / df;
E -= delta;
if (std::abs(delta) < tolerance) {
break;
}
}
// 计算偏近点角 ν
double sin_nu = std::sqrt(1 - e * e) * std::sin(E) / (1 - e * std::cos(E));
double cos_nu = (std::cos(E) - e) / (1 - e * std::cos(E));
double nu = std::atan2(sin_nu, cos_nu);
// 计算半径 r
double r = a * (1 - e * std::cos(E));
// 计算位置向量在轨道平面上的分量
double Px_prime = r * std::cos(nu);
double Py_prime = r * std::sin(nu);
// 计算速度向量在轨道平面上的分量
double h = std::sqrt(mu * a * (1 - e * e)); // 角动量
double Vx_prime = -(h / r) * std::sin(nu);
double Vy_prime = (h / r) * (std::cos(nu) + e);
// 将轨道平面坐标系转换到惯性坐标系
double cos_Omega = std::cos(Omega);
double sin_Omega = std::sin(Omega);
double cos_omega = std::cos(omega);
double sin_omega = std::sin(omega);
double cos_i = std::cos(i);
double sin_i = std::sin(i);
double Px = Px_prime * (cos_Omega * cos_omega - sin_Omega * sin_omega * cos_i) +
Py_prime * (-cos_Omega * sin_omega - sin_Omega * cos_omega * cos_i);
double Py = Px_prime * (sin_Omega * cos_omega + cos_Omega * sin_omega * cos_i) +
Py_prime * (-sin_Omega * sin_omega + cos_Omega * cos_omega * cos_i);
double Pz = Px_prime * sin_omega * sin_i + Py_prime * cos_omega * sin_i;
double Vx = Vx_prime * (cos_Omega * cos_omega - sin_Omega * sin_omega * cos_i) +
Vy_prime * (-cos_Omega * sin_omega - sin_Omega * cos_omega * cos_i);
double Vy = Vx_prime * (sin_Omega * cos_omega + cos_Omega * sin_omega * cos_i) +
Vy_prime * (-sin_Omega * sin_omega + cos_Omega * cos_omega * cos_i);
double Vz = Vx_prime * sin_omega * sin_i + Vy_prime * cos_omega * sin_i;
SatellitePos node;
node.time = time;
node.Px = Px;
node.Py = Py;
node.Pz = Pz;
node.Vx = Vx;
node.Vy = Vy;
node.Vz = Vz;
return node;
}
double OrbitEstimator::solveKeplerEquation(double M, double e) const {
double E = M; // 初始猜测
double tolerance = 1e-8;
int maxIterations = 100;
for (int iter = 0; iter < maxIterations; ++iter) {
double f = E - e * std::sin(E) - M;
double df = 1 - e * std::cos(E);
double delta = f / df;
E -= delta;
if (std::abs(delta) < tolerance) {
break;
}
}
return E;
}
/** 多项式轨道拟合模型************************************************************************************/
void PolynomialOrbitModel::fitPolynomial(const QList<SatellitePos>& nodes, int degree) {
QList<double> times;
QList<double> positionsX;
QList<double> positionsY;
QList<double> positionsZ;
QList<double> velocitiesX;
QList<double> velocitiesY;
QList<double> velocitiesZ;
for (const auto& node : nodes) {
times.append(node.time);
positionsX.append(node.Px);
positionsY.append(node.Py);
positionsZ.append(node.Pz);
velocitiesX.append(node.Vx);
velocitiesY.append(node.Vy);
velocitiesZ.append(node.Vz);
}
qDebug() << "fit degree " << degree;
coefficientsX = leastSquaresFit(times, positionsX, degree);
coefficientsY = leastSquaresFit(times, positionsY, degree);
coefficientsZ = leastSquaresFit(times, positionsZ, degree);
coefficientsVx = leastSquaresFit(times, velocitiesX, degree);
coefficientsVy = leastSquaresFit(times, velocitiesY, degree);
coefficientsVz = leastSquaresFit(times, velocitiesZ, degree);
}
SatellitePos PolynomialOrbitModel::predictPosition(double time) {
double Px = 0.0;
double Py = 0.0;
double Pz = 0.0;
double Vx = 0.0;
double Vy = 0.0;
double Vz = 0.0;
for (int i = 0; i < coefficientsX.size(); ++i) {
Px += coefficientsX(i) * std::pow(time, i);
Py += coefficientsY(i) * std::pow(time, i);
Pz += coefficientsZ(i) * std::pow(time, i);
Vx += coefficientsVx(i) * std::pow(time, i);
Vy += coefficientsVy(i) * std::pow(time, i);
Vz += coefficientsVz(i) * std::pow(time, i);
}
SatellitePos predictedNode;
predictedNode.time = time;
predictedNode.Px = Px;
predictedNode.Py = Py;
predictedNode.Pz = Pz;
predictedNode.Vx = Vx;
predictedNode.Vy = Vy;
predictedNode.Vz = Vz;
return predictedNode;
}
Eigen::VectorXd PolynomialOrbitModel::leastSquaresFit(const QList<double>& x, const QList<double>& y, int degree) {
int n = x.size();
Eigen::MatrixXd A=Eigen::MatrixXd::Zero(n, degree + 1);
for (int i = 0; i < n; ++i) {
for (int j = 0; j <= degree; ++j) {
A(i, j) = std::pow(x[i], j);
}
}
Eigen::VectorXd b(y.count());
for (long i = 0; i < y.count(); i++) {
b(i) = y[i];
}
Eigen::VectorXd coefficients = A.colPivHouseholderQr().solve(b);
//Eigen::Vector2d coefficientsVector = Eigen::Vector2d::Zero(degree);
//coefficientsVector = coefficients.array();
return coefficients;
}
void PolynomialOrbitModel::saveCoefficientsToXml(QDomElement& parent, const Eigen::VectorXd& coefficients, const QString& tagName) const {
QDomDocument doc = parent.ownerDocument();
QDomElement coeffElement = doc.createElement(tagName);
for (int i = 0; i < coefficients.size(); ++i) {
QDomElement valueElement = doc.createElement("Value");
valueElement.appendChild(doc.createTextNode(QString::number(coefficients(i))));
coeffElement.appendChild(valueElement);
}
parent.appendChild(coeffElement);
}
bool PolynomialOrbitModel::loadCoefficientsFromXml(const QDomElement& parent, Eigen::VectorXd& coefficients, const QString& tagName) {
QDomNodeList coeffNodes = parent.elementsByTagName(tagName);
if (coeffNodes.isEmpty()) {
qWarning() << "Tag" << tagName << "not found in XML.";
return false;
}
QDomElement coeffElement = coeffNodes.at(0).toElement();
QDomNodeList valueNodes = coeffElement.elementsByTagName("Value");
int size = valueNodes.count();
coefficients.resize(size);
for (int i = 0; i < size; ++i) {
QDomElement valueElement = valueNodes.at(i).toElement();
coefficients(i) = valueElement.text().toDouble();
}
return true;
}
void PolynomialOrbitModel::saveToXml(const QString& filename) const {
QDomDocument doc("PolynomialOrbitModel");
QDomElement root = doc.createElement("PolynomialOrbitModel");
doc.appendChild(root);
saveCoefficientsToXml(root, coefficientsX, "CoefficientsX");
saveCoefficientsToXml(root, coefficientsY, "CoefficientsY");
saveCoefficientsToXml(root, coefficientsZ, "CoefficientsZ");
saveCoefficientsToXml(root, coefficientsVx, "CoefficientsVx");
saveCoefficientsToXml(root, coefficientsVy, "CoefficientsVy");
saveCoefficientsToXml(root, coefficientsVz, "CoefficientsVz");
QFile file(filename);
if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
qDebug() << "Cannot open file for writing:" << filename;
return;
}
QTextStream out(&file);
doc.save(out, 4); // Indent by 4 spaces
file.close();
}
bool PolynomialOrbitModel::loadFromXml(const QString& filename) {
QFile file(filename);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
qDebug() << "Cannot open file for reading:" << filename;
return false;
}
QDomDocument doc;
if (!doc.setContent(&file)) {
file.close();
return false;
}
file.close();
QDomElement root = doc.documentElement();
if (!loadCoefficientsFromXml(root, coefficientsX, "CoefficientsX")) return false;
if (!loadCoefficientsFromXml(root, coefficientsY, "CoefficientsY")) return false;
if (!loadCoefficientsFromXml(root, coefficientsZ, "CoefficientsZ")) return false;
if (!loadCoefficientsFromXml(root, coefficientsVx, "CoefficientsVx")) return false;
if (!loadCoefficientsFromXml(root, coefficientsVy, "CoefficientsVy")) return false;
if (!loadCoefficientsFromXml(root, coefficientsVz, "CoefficientsVz")) return false;
return true;
}
SatellitePos PolynomialOrbitModel::predictNode(double time)
{
return predictPosition(time);
}
/** 两行根数************************************************************************************/
TwoLineElements::TwoLineElements() {}
bool TwoLineElements::loadFromTleFile(const QString& filename) {
QFile file(filename);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
qDebug() << "Cannot open file for reading:" << filename;
return false;
}
QTextStream in(&file);
line1 = in.readLine().toStdString();
line2 = in.readLine().toStdString();
if (line1.empty() || line2.empty()) {
qDebug() << "Invalid TLE data in file:" << filename;
return false;
}
file.close();
parseTleLines();
return true;
}
void TwoLineElements::parseTleLines() {
// 解析第一行
// 示例1 25544U 98067A 23044.15434167 .00001971 00000-0 39389-4 0 9994
// 第二行
// 示例2 25544 51.6416 243.5887 0001672 130.5360 325.0288 15.49472743275958
// 这里仅做基本解析,实际应用中需要更严格的验证和错误处理
}
double TwoLineElements::meanMotion() const {
// 第二行第53-63位是平均运动每分钟转数
return std::stod(line2.substr(52, 11));
}
double TwoLineElements::semiMajorAxis() const {
const double G = 6.67430e-11; // 引力常数 m^3 kg^-1 s^-2
const double M_Earth = 5.972e24; // 地球质量 kg
const double mu = G * M_Earth; // 地球引力参数 m^3 s^-2
double n = meanMotion() * 2 * M_PI / 60; // 转换为弧度/秒
return std::cbrt(mu / (n * n));
}
double TwoLineElements::eccentricity() const {
// 第二行第9-16位是离心率小数点省略
return std::stod("0." + line2.substr(8, 7));
}
double TwoLineElements::inclination() const {
// 第二行第20-25位是倾斜角
return std::stod(line2.substr(19, 5));
}
double TwoLineElements::longitudeOfAscendingNode() const {
// 第二行第34-42位是升交点赤经
return std::stod(line2.substr(33, 9));
}
double TwoLineElements::argumentOfPeriapsis() const {
// 第二行第45-52位是近地点幅角
return std::stod(line2.substr(44, 8));
}
double TwoLineElements::meanAnomaly() const {
// 第二行第64-72位是平均近点角
return std::stod(line2.substr(63, 9));
}
double TwoLineElements::revolutionNumberAtEpoch() const {
// 第二行第64-72位是绕地次数
return std::stod(line2.substr(63, 5));
}
double TwoLineElements::epochTime() const {
// 第一行第20-32位是历元时间
int year = std::stoi(line1.substr(18, 2)) + 2000;
double dayOfYear = std::stod(line1.substr(20, 12));
int month = 1, day = 1;
while (dayOfYear > 0) {
int daysInMonth[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
daysInMonth[1] = 29;
}
if (dayOfYear <= daysInMonth[month - 1]) {
day = static_cast<int>(dayOfYear);
break;
}
dayOfYear -= daysInMonth[month - 1];
month++;
}
QDate date(year, month, day);
QTime time(0, 0, 0);
QDateTime dateTime(date, time);
return dateTime.toSecsSinceEpoch() + (dayOfYear - day) * 86400;
}
SatellitePos TwoLineElements::calculateNode(double time) const {
return calculateKeplerianNode(time);
}
SatellitePos TwoLineElements::predictNode(double time)
{
return calculateNode(time);
}
SatellitePos TwoLineElements::calculateKeplerianNode(double time) const {
const double G = 6.67430e-11; // 引力常数 m^3 kg^-1 s^-2
const double M_Earth = 5.972e24; // 地球质量 kg
const double mu = G * M_Earth; // 地球引力参数 m^3 s^-2
double a = semiMajorAxis();
double e = eccentricity();
double i = inclination() * M_PI / 180.0;
double Omega = longitudeOfAscendingNode() * M_PI / 180.0;
double omega = argumentOfPeriapsis() * M_PI / 180.0;
double M0 = meanAnomaly() * M_PI / 180.0;
// 计算平均运动
double n = std::sqrt(mu / (a * a * a));
// 计算从参考时刻到给定时间的平均异常
double t_ref = epochTime(); // 参考时刻
double M = M0 + n * (time - t_ref);
// 求解开普勒方程 E - e*sin(E) = M 使用牛顿迭代法
double E = solveKeplerEquation(M, e);
// 计算偏近点角 ν
double sin_nu = std::sqrt(1 - e * e) * std::sin(E) / (1 - e * std::cos(E));
double cos_nu = (std::cos(E) - e) / (1 - e * std::cos(E));
double nu = std::atan2(sin_nu, cos_nu);
// 计算半径 r
double r = a * (1 - e * std::cos(E));
// 计算位置向量在轨道平面上的分量
double Px_prime = r * std::cos(nu);
double Py_prime = r * std::sin(nu);
// 计算速度向量在轨道平面上的分量
double h = std::sqrt(mu * a * (1 - e * e)); // 角动量
double Vx_prime = -(h / r) * std::sin(nu);
double Vy_prime = (h / r) * (std::cos(nu) + e);
// 将轨道平面坐标系转换到惯性坐标系
double cos_Omega = std::cos(Omega);
double sin_Omega = std::sin(Omega);
double cos_omega = std::cos(omega);
double sin_omega = std::sin(omega);
double cos_i = std::cos(i);
double sin_i = std::sin(i);
double Px = Px_prime * (cos_Omega * cos_omega - sin_Omega * sin_omega * cos_i) +
Py_prime * (-cos_Omega * sin_omega - sin_Omega * cos_omega * cos_i);
double Py = Px_prime * (sin_Omega * cos_omega + cos_Omega * sin_omega * cos_i) +
Py_prime * (-sin_Omega * sin_omega + cos_Omega * cos_omega * cos_i);
double Pz = Px_prime * sin_omega * sin_i + Py_prime * cos_omega * sin_i;
double Vx = Vx_prime * (cos_Omega * cos_omega - sin_Omega * sin_omega * cos_i) +
Vy_prime * (-cos_Omega * sin_omega - sin_Omega * cos_omega * cos_i);
double Vy = Vx_prime * (sin_Omega * cos_omega + cos_Omega * sin_omega * cos_i) +
Vy_prime * (-sin_Omega * sin_omega + cos_Omega * cos_omega * cos_i);
double Vz = Vx_prime * sin_omega * sin_i + Vy_prime * cos_omega * sin_i;
SatellitePos node;
node.time = time;
node.Px = Px;
node.Py = Py;
node.Pz = Pz;
node.Vx = Vx;
node.Vy = Vy;
node.Vz = Vz;
return node;
}
double TwoLineElements::solveKeplerEquation(double M, double e) const {
double E = M; // 初始猜测
double tolerance = 1e-8;
int maxIterations = 100;
for (int iter = 0; iter < maxIterations; ++iter) {
double f = E - e * std::sin(E) - M;
double df = 1 - e * std::cos(E);
double delta = f / df;
E -= delta;
if (std::abs(delta) < tolerance) {
break;
}
}
return E;
}
/** 轨道节点文件读写************************************************************************************/
QList<SatellitePos> loadNodesFromXml(const QString& filename) {
QFile file(filename);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
qDebug() << "Cannot open file for reading:" << filename;
return {};
}
QDomDocument doc;
if (!doc.setContent(&file)) {
file.close();
return {};
}
file.close();
QDomElement root = doc.documentElement();
QDomNodeList gpsParamNodes = root.elementsByTagName("GPSParam");
QList<SatellitePos> loadedNodes;
for (int i = 0; i < gpsParamNodes.count(); ++i) {
QDomElement paramElement = gpsParamNodes.at(i).toElement();
SatellitePos node;
node.time = convertToMilliseconds(paramElement.firstChildElement("TimeStamp").text().toStdString());
node.Px = paramElement.firstChildElement("xPosition").text().toDouble();
node.Py = paramElement.firstChildElement("yPosition").text().toDouble();
node.Pz = paramElement.firstChildElement("zPosition").text().toDouble();
node.Vx = paramElement.firstChildElement("xVelocity").text().toDouble();
node.Vy = paramElement.firstChildElement("yVelocity").text().toDouble();
node.Vz = paramElement.firstChildElement("zVelocity").text().toDouble();
loadedNodes.append(node);
}
return loadedNodes;
}
void saveNodesToXml(const QString& filename, const QList<SatellitePos>& inposes) {
QDomDocument doc("GPSData");
QDomElement root = doc.createElement("GPS");
doc.appendChild(root);
for (const auto& node : inposes) {
QDomElement paramElement = doc.createElement("GPSParam");
QDomElement timeStampElement = doc.createElement("TimeStamp");
timeStampElement.appendChild(doc.createTextNode(QString::number(node.time)));
paramElement.appendChild(timeStampElement);
QDomElement xPositionElement = doc.createElement("xPosition");
xPositionElement.appendChild(doc.createTextNode(QString::number(node.Px)));
paramElement.appendChild(xPositionElement);
QDomElement yPositionElement = doc.createElement("yPosition");
yPositionElement.appendChild(doc.createTextNode(QString::number(node.Py)));
paramElement.appendChild(yPositionElement);
QDomElement zPositionElement = doc.createElement("zPosition");
zPositionElement.appendChild(doc.createTextNode(QString::number(node.Pz)));
paramElement.appendChild(zPositionElement);
QDomElement xVelocityElement = doc.createElement("xVelocity");
xVelocityElement.appendChild(doc.createTextNode(QString::number(node.Vx)));
paramElement.appendChild(xVelocityElement);
QDomElement yVelocityElement = doc.createElement("yVelocity");
yVelocityElement.appendChild(doc.createTextNode(QString::number(node.Vy)));
paramElement.appendChild(yVelocityElement);
QDomElement zVelocityElement = doc.createElement("zVelocity");
zVelocityElement.appendChild(doc.createTextNode(QString::number(node.Vz)));
paramElement.appendChild(zVelocityElement);
root.appendChild(paramElement);
}
QFile file(filename);
if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
qDebug() << "Cannot open file for writing:" << filename;
return;
}
QTextStream out(&file);
doc.save(out, 4); // Indent by 4 spaces
file.close();
}
OrbitModelAbstract::OrbitModelAbstract()
{
}
OrbitModelAbstract::~OrbitModelAbstract()
{
}
SatellitePos OrbitModelAbstract::predictNode(double time)
{
return SatellitePos();
}