Research code for satellite steady-state temperature-field prediction.
_{Small satellite. Many temperatures. Two toolboxes.}

Paper · Quick start · Training · NXOpen companion · Citation

The handoff is the exported case data: engineering-input logs, incident-flux samples, nodal temperatures, and consistent coordinates/node ordering. The NX export format explains the loader conventions. NXOpen is the simulation companion, not a Python runtime dependency of SSTONet.

Satellite Temperature Field Prediction under Varying Thermal Contact Conditions Using Topology-Aware Operator Learning

Chang Xu · Haibo Yang · Qianliang Wu · Zhanxiao Liu · Changsheng Zhou
Aerospace Science and Technology, 2026, article 114015
Publisher page · DOI: 10.1016/j.ast.2026.114015

Repeated thermal assessment is expensive when satellite loads, surface properties, and thermal contacts change. SSTONet learns the mapping from these conditions to a complete steady-state temperature field, with particular attention to component and interface errors.

A multilayer perceptron (MLP) Branch encodes each operating case. A graph neural network (GNN) Trunk learns a spatial basis from fixed coordinates and connectivity. Their inner product reconstructs nodal temperatures. After training, the graph basis can be prepared once and reused across operating cases.

These values describe the selected seed-42 models on 500 held-out cases with the benchmark flux inputs. The paper evaluates interpolation within the sampled parameter domain of the fixed assembly. The synthetic example below checks software operation; it does not reproduce these benchmark results.

flowchart LR
    U["Operating inputs<br/>and incident flux"] --> B["MLP Branch<br/>case coefficients"]
    G["Fixed coordinates<br/>and connectivity"] --> T["Graph Trunk<br/>spatial encoding"]
    T --> S["Prepared<br/>spatial basis"]
    B --> R["Inner-product<br/>reconstruction"]
    S --> R
    R --> Y["Nodal<br/>temperatures"]
    classDef input fill:#F5F4EE,stroke:#879B8B,color:#173A36;
    classDef model fill:#E6EEE5,stroke:#26796D,color:#173A36;
    classDef output fill:#F5ECD8,stroke:#A5803E,color:#493E25;
    class U,G input;
    class B,T,S,R model;
    class Y output;

SSTONet-FEM uses supplied finite-element adjacency. SSTONet-KNN uses neighbors within components and radius-based links between components. Geometric edge weights guide spatial encoding; contact and coupling values are supplied through the operating input.

The sstonet.inference module provides the reusable Trunk cache. Its validity checks bind the spatial basis to the model, graph, device, and precision. See the quick-start example for normalization and cached prediction.

Training creates your own local checkpoints and fitted normalizers under the output directory. Data and generated artifacts are excluded from Git. Reference-data generation uses the separate NXOpen_satellite toolkit; the neural models here run in a Python environment.

The source-release checks use Python 3.14.4 and PyTorch 2.11.0. environment.yml records the tested Python and direct library versions, with conda managing Python and the scientific packages.

git clone https://github.com/Ne1ther/SSTONet.git
cd SSTONet
conda env create --file environment.yml
conda activate sstonet

The environment definition installs the local package in editable mode. To use an existing Python 3.14.4 environment instead:

python -m pip install -r requirements-tested.txt
python -m pip install -e .

TensorBoard logging is optional:

python -m pip install -e ".[tensorboard]"

🛰️ Take a tiny test flight. The example creates a small synthetic problem in memory, trains a compact graph model, and checks that cached prediction agrees with ordinary prediction:

python examples/quickstart.py --variant fem
python examples/quickstart.py --variant knn

It saves no files. The generated temperatures exercise the software interface and are not NX solutions or paper benchmark results.

.
├── sstonet/
│   ├── models/             # SSTONet and baseline model implementations
│   ├── training/           # Trainers, normalization, checkpoint save/load
│   ├── inference/          # Reusable graph-Trunk basis
│   ├── data/               # NX CSV loader and dataset splitting
│   ├── utils/              # Temperature-field error metrics
│   ├── config.py           # YAML configuration support
│   └── callbacks.py        # Training callbacks
├── configs/                # Eleven principal model configurations
├── assets/                 # README illustrations
├── scripts/
│   └── train.py            # Shared training entry point
├── examples/
│   └── quickstart.py       # Synthetic training and cached prediction
├── tests/                  # Self-contained model and trainer tests
├── environment.yml         # Verified conda environment
├── requirements-tested.txt # Verified direct Python dependencies
├── CITATION.cff
├── LICENSE
├── pyproject.toml
└── README.md

The training entry point accepts the NX CSV format described below. Supply the export folder and, for FEM-based models, the matching graph folder:

python scripts/train.py \
  --model gnn_deeponet \
  --config configs/gnn_deeponet.yaml \
  --data-dir /path/to/nx_exports \
  --graph-dir /path/to/graph \
  --output-dir results/my_run \
  --device auto

For component-aware neighborhoods:

python scripts/train.py \
  --model component_gnn_deeponet \
  --config configs/component_gnn_deeponet.yaml \
  --data-dir /path/to/nx_exports \
  --device auto

--device auto selects an available backend. Use --device cpu, --device cuda, or --device mps to choose explicitly. --epochs and --n-samples override the YAML settings.

Each run records its effective configuration, exact train/validation/test indices, split hash, training history, error metrics, and locally generated checkpoints. The graph trainers save fitted normalizers with their checkpoints so later predictions can be returned in physical temperature units. Load only checkpoints you generated or trust, because the trainer checkpoint format includes serialized preprocessing objects.

nx_exports/
├── Mixed_Coefficient_DOE_for_nx_automation_N_Solar_vector_log.csv
├── Mixed_Coefficient_DOE_for_nx_automation_N_Load_log.csv
├── Mixed_Coefficient_DOE_for_nx_automation_N_Optical_log.csv
├── Mixed_Coefficient_DOE_for_nx_automation_N_Thermal_coupl_log.csv
└── Mixed_Coefficient_DOE_for_nx_automation_N/
    └── NodeResults/
        ├── NodeResult_<component>_Temperature.csv
        └── Result_<component>_Radiation.csv

For datasets in another format, pass arrays directly to a trainer:

from sstonet.models import GNNDeepONet
from sstonet.training import GNNDeepONetTrainer

model = GNNDeepONet(branch_input_dim=X_train.shape[1])
trainer = GNNDeepONetTrainer(model, device="cpu", use_edge_attr=True)
trainer.fit(
    X_train, coords, edge_index, T_train,
    X_val=X_val, T_val=T_val,
    epochs=300, batch_size=32,
)
T_pred = trainer.predict(X_test, coords, edge_index)

Here X_train has shape (cases, inputs), coords has shape (nodes, 3), edge_index has shape (2, edges), and T_train has shape (cases, nodes). Raw model outputs use the trainer's normalized temperature scale; trainer.predict reverses that normalization.

For cached inference, precompute_trunk(model, coords_t, edge_index_t, edge_weight_t) returns an object with a predict method. Use the same normalized coordinates, input normalizer, and geometric edge weights as training. Call model.eval() before preparing the cache. The quick-start example shows the complete normalization and reconstruction steps.

python -m pytest -q

The suite uses synthetic data to check model outputs, graph operations, training, checkpoint round trips, best-validation-state restoration, and cache correctness/invalidation. It requires no NX installation, private dataset, or pretrained model.

For new reference simulations, use NXOpen_satellite. Its automation handles parameter updates, design-of-experiments batches, solve orchestration, and result export inside NX / Simcenter 3D. Return here to train the neural operators and evaluate their temperature fields. The two repositories keep their own installation requirements and work together through the exported case data.

If this code supports your research, please cite the paper:

@article{xu2026sstonet,
  title   = {Satellite Temperature Field Prediction under Varying Thermal
             Contact Conditions Using Topology-Aware Operator Learning},
  author  = {Xu, Chang and Yang, Haibo and Wu, Qianliang and Liu, Zhanxiao
             and Zhou, Changsheng},
  journal = {Aerospace Science and Technology},
  year    = {2026},
  pages   = {114015},
  doi     = {10.1016/j.ast.2026.114015}
}

Machine-readable metadata is available in CITATION.cff. The source code is provided under the MIT License.