/*!

* \file COutput.cpp

* \brief Main subroutines for output solver information

* \author F. Palacios, T. Economon

* \version 8.4.0 "Harrier"

*

* SU2 Project Website: https://su2code.github.io

*

* The SU2 Project is maintained by the SU2 Foundation

* (http://su2foundation.org)

*

* Copyright 2012-2026, SU2 Contributors (cf. AUTHORS.md)

*

* SU2 is free software; you can redistribute it and/or

* modify it under the terms of the GNU Lesser General Public

* License as published by the Free Software Foundation; either

* version 2.1 of the License, or (at your option) any later version.

*

* SU2 is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

* Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public

* License along with SU2. If not, see <http://www.gnu.org/licenses/>.

*/

#include <iostream>

#include <csignal>

#include "../../../Common/include/geometry/CGeometry.hpp"

#include "../../include/solvers/CSolver.hpp"

#include "../../include/output/COutput.hpp"

#include "../../include/output/CTurboOutput.hpp"

#include "../../include/output/filewriter/CFVMDataSorter.hpp"

#include "../../include/output/filewriter/CFEMDataSorter.hpp"

#include "../../include/output/filewriter/CCGNSFileWriter.hpp"

#include "../../include/output/filewriter/CSurfaceFVMDataSorter.hpp"

#include "../../include/output/filewriter/CSurfaceFEMDataSorter.hpp"

#include "../../include/output/filewriter/CParaviewFileWriter.hpp"

#include "../../include/output/filewriter/CSTLFileWriter.hpp"

#include "../../include/output/filewriter/CParaviewBinaryFileWriter.hpp"

#include "../../include/output/filewriter/CParaviewXMLFileWriter.hpp"

#include "../../include/output/filewriter/CParaviewVTMFileWriter.hpp"

#include "../../include/output/filewriter/CTecplotFileWriter.hpp"

#include "../../include/output/filewriter/CTecplotBinaryFileWriter.hpp"

#include "../../include/output/filewriter/CCSVFileWriter.hpp"

#include "../../include/output/filewriter/CSU2FileWriter.hpp"

#include "../../include/output/filewriter/CSU2BinaryFileWriter.hpp"

#include "../../include/output/filewriter/CSU2MeshFileWriter.hpp"

namespace {

volatile sig_atomic_t STOP;

void signalHandler(int signum) {

std::cout << "Interrupt signal (" << signum << ") received, saving files and exiting.\n";

STOP = 1;

}

}

COutput::COutput(const CConfig *config, unsigned short ndim, bool fem_output):

rank(SU2_MPI::GetRank()),

size(SU2_MPI::GetSize()),

nDim(ndim),

multiZone(config->GetMultizone_Problem()),

gridMovement(config->GetDynamic_Grid()),

femOutput(fem_output),

si_units(config->GetSystemMeasurements() == SI),

us_units(config->GetSystemMeasurements() == US) {

cauchyTimeConverged = false;

maxTimeDelayActive = false;

PrevStopTime = 0.0;

convergenceTable = new PrintingToolbox::CTablePrinter(&std::cout);

multiZoneHeaderTable = new PrintingToolbox::CTablePrinter(&std::cout);

fileWritingTable = new PrintingToolbox::CTablePrinter(&std::cout);

historyFileTable = new PrintingToolbox::CTablePrinter(&histFile, "");

/*--- Set default filenames ---*/

surfaceFilename = "surface";

volumeFilename = "volume";

restartFilename = "restart";

/*--- Retrieve the history filename, including extension ---*/

historyFilename = config->GetHistory_FileName();

historySep = ",";

/*--- Initialize residual ---*/

rhoResNew = EPS;

rhoResOld = EPS;

nRequestedHistoryFields = config->GetnHistoryOutput();

for (unsigned short iField = 0; iField < nRequestedHistoryFields; iField++){

requestedHistoryFields.push_back(config->GetHistoryOutput_Field(iField));

}

nRequestedScreenFields = config->GetnScreenOutput();

for (unsigned short iField = 0; iField < nRequestedScreenFields; iField++){

requestedScreenFields.push_back(config->GetScreenOutput_Field(iField));

}

nRequestedVolumeFields = config->GetnVolumeOutput();

for (unsigned short iField = 0; iField < nRequestedVolumeFields; iField++){

requestedVolumeFields.push_back(config->GetVolumeOutput_Field(iField));

}

/*--- Default is to write history to file and screen --- */

noWriting = false;

/*--- Initialize convergence monitoring structure ---*/

nCauchy_Elems = config->GetCauchy_Elems();

cauchyEps = config->GetCauchy_Eps();

minLogResidual = config->GetMinLogResidual();

for (unsigned short iField = 0; iField < config->GetnConv_Field(); iField++){

convFields.emplace_back(config->GetConv_Field(iField));

}

newFunc = vector<su2double>(convFields.size());

oldFunc = vector<su2double>(convFields.size());

cauchySerie = vector<vector<su2double>>(convFields.size(), vector<su2double>(nCauchy_Elems, 0.0));

cauchyValue = 0.0;

convergence = false;

/*--- Initialize time convergence monitoring structure ---*/

nWndCauchy_Elems = config->GetWnd_Cauchy_Elems();

wndCauchyEps = config->GetWnd_Cauchy_Eps();

wndConvFields.reserve(config->GetnWndConv_Field());

for (unsigned short iField = 0; iField < config->GetnWndConv_Field(); iField++){

wndConvFields.emplace_back(config->GetWndConv_Field(iField));

}

WndOld_Func = vector<su2double>(wndConvFields.size());

WndNew_Func = vector<su2double>(wndConvFields.size());

WndCauchy_Serie = vector<vector<su2double>>(wndConvFields.size(), vector<su2double>(nWndCauchy_Elems, 0.0));

WndCauchy_Value = 0.0;

TimeConvergence = false;

/*--- Check that the number of cauchy elems is not too large ---*/

if (nCauchy_Elems > 1000){

SU2_MPI::Error("Number of Cauchy Elems must be smaller than 1000", CURRENT_FUNCTION);

}

if (nWndCauchy_Elems > 1000){

SU2_MPI::Error("Number of Time Cauchy Elems must be smaller than 1000", CURRENT_FUNCTION);

}

/*--- Initialize all convergence flags to false. ---*/

convergence = false;

buildFieldIndexCache = false;

curInnerIter = 0;

curOuterIter = 0;

curTimeIter = 0;

volumeDataSorter = nullptr;

volumeDataSorterCompact = nullptr;

surfaceDataSorter = nullptr;

headerNeeded = false;

/*--- Setup a signal handler for SIGTERM. ---*/

signal(SIGTERM, signalHandler);

}

COutput::~COutput() {

delete convergenceTable;

delete multiZoneHeaderTable;

delete fileWritingTable;

delete historyFileTable;

delete volumeDataSorter;

delete volumeDataSorterCompact;

delete surfaceDataSorter;

}

void COutput::SetHistoryOutput(CGeometry *geometry,

CSolver **solver_container,

CConfig *config,

unsigned long TimeIter,

unsigned long OuterIter,

unsigned long InnerIter) {

curTimeIter = TimeIter;

curAbsTimeIter = max(TimeIter, config->GetStartWindowIteration()) - config->GetStartWindowIteration();

curOuterIter = OuterIter;

curInnerIter = InnerIter;

/*--- Retrieve residual and extra data -----------------------------------------------------------------*/

LoadCommonHistoryData(config);

LoadHistoryData(config, geometry, solver_container);

ConvergenceMonitoring(config, curInnerIter);

PostprocessHistoryData(config);

MonitorTimeConvergence(config, curTimeIter);

OutputScreenAndHistory(config);

}

void COutput::SetHistoryOutput(CGeometry *geometry,

CSolver **solver_container,

CConfig *config) {

/*--- Retrieve residual and extra data -----------------------------------------------------------------*/

LoadCommonHistoryData(config);

LoadHistoryData(config, geometry, solver_container);

ConvergenceMonitoring(config, curInnerIter);

PostprocessHistoryData(config);

}

void COutput::SetHistoryOutput(CGeometry ****geometry, CSolver *****solver, CConfig **config, std::shared_ptr<CTurbomachineryStagePerformance>(TurboStagePerf), std::shared_ptr<CTurboOutput> TurboPerf, unsigned short val_iZone, unsigned long TimeIter, unsigned long OuterIter, unsigned long InnerIter, unsigned short val_iInst){

unsigned long Iter= InnerIter;

if (config[ZONE_0]->GetMultizone_Problem())

Iter = OuterIter;

/*--- Turbomachinery Performance Screen summary output---*/

if (Iter%100 == 0 && rank == MASTER_NODE) {

SetTurboPerformance_Output(TurboPerf, config[val_iZone], TimeIter, OuterIter, InnerIter);

SetTurboMultiZonePerformance_Output(TurboStagePerf, TurboPerf, config[val_iZone]);

}

for (int iZone = 0; iZone < config[ZONE_0]->GetnZone(); iZone ++){

if (rank == MASTER_NODE) {

WriteTurboSpanwisePerformance(TurboPerf, geometry[iZone][val_iInst][MESH_0], config, iZone);

}

}

/*--- Update turboperformance history file*/

if (rank == MASTER_NODE){

LoadTurboHistoryData(TurboStagePerf, TurboPerf, config[val_iZone]);

}

}

void COutput::SetMultizoneHistoryOutput(COutput **output, CConfig **config, CConfig *driver_config, unsigned long TimeIter, unsigned long OuterIter){

curTimeIter = TimeIter;

curAbsTimeIter = max(TimeIter, driver_config->GetStartWindowIteration()) - driver_config->GetStartWindowIteration();

curOuterIter = OuterIter;

/*--- Retrieve residual and extra data -----------------------------------------------------------------*/

LoadCommonHistoryData(driver_config);

LoadMultizoneHistoryData(output, config);

ConvergenceMonitoring(driver_config, curOuterIter);

PostprocessHistoryData(driver_config);

MonitorTimeConvergence(driver_config, curTimeIter);

OutputScreenAndHistory(driver_config);

}

void COutput::OutputScreenAndHistory(CConfig *config) {

if (rank == MASTER_NODE && !noWriting) {

if (WriteHistoryFileOutput(config)) SetHistoryFileOutput(config);

if (WriteScreenHeader(config)) SetScreenHeader(config);

if (WriteScreenOutput(config)) SetScreenOutput(config);

}

}

void COutput::SetupCustomHistoryOutput(const std::string& expression, CustomHistoryOutput& output) const {

std::vector<std::string> symbols;

output.expression = mel::Parse<passivedouble>(expression, symbols);

output.symbolValues.reserve(symbols.size());

for (const auto& symbol : symbols) {

const auto* ptr = GetPtrToHistoryOutput(symbol);

if (ptr == nullptr) {

SU2_MPI::Error(std::string("Invalid history output (") + symbol + std::string(") used in expression:\n") +

expression, CURRENT_FUNCTION);

}

output.symbolValues.push_back(ptr);

}

output.ready = true;

}

void COutput::SetCustomAndComboObjectives(int idxSol, const CConfig *config, CSolver **solver) {

if (config->GetKind_ObjFunc() == CUSTOM_OBJFUNC && !config->GetCustomObjFunc().empty()) {

if (!customObjFunc.ready) {

SetupCustomHistoryOutput(config->GetCustomObjFunc(), customObjFunc);

}

solver[idxSol]->SetTotal_Custom_ObjFunc(customObjFunc.Eval());

}

solver[idxSol]->Evaluate_ObjFunc(config, solver);

SetHistoryOutputValue("COMBO", solver[idxSol]->GetTotal_ComboObj());

}

void COutput::AllocateDataSorters(CConfig *config, CGeometry *geometry){

/*---- Construct a data sorter object to partition and distribute

* the local data into linear chunks across the processors ---*/

if (femOutput){

if (volumeDataSorter == nullptr)

volumeDataSorter = new CFEMDataSorter(config, geometry, volumeFieldNames);

if (config->GetWrt_Restart_Compact() && volumeDataSorterCompact == nullptr)

volumeDataSorterCompact = new CFEMDataSorter(config, geometry, requiredVolumeFieldNames);

if (surfaceDataSorter == nullptr)

surfaceDataSorter = new CSurfaceFEMDataSorter(config, geometry,

dynamic_cast<CFEMDataSorter*>(volumeDataSorter));

} else {

if (volumeDataSorter == nullptr)

volumeDataSorter = new CFVMDataSorter(config, geometry, volumeFieldNames);

if (config->GetWrt_Restart_Compact() && volumeDataSorterCompact == nullptr)

volumeDataSorterCompact = new CFVMDataSorter(config, geometry, requiredVolumeFieldNames);

if (surfaceDataSorter == nullptr)

surfaceDataSorter = new CSurfaceFVMDataSorter(config, geometry,

dynamic_cast<CFVMDataSorter*>(volumeDataSorter));

}

}

void COutput::LoadData(CGeometry *geometry, CConfig *config, CSolver** solver_container){

/*--- Check if the data sorters are allocated, if not, allocate them. --- */

AllocateDataSorters(config, geometry);

/*--- Loop over all points and store the requested volume output data into the data sorter objects ---*/

LoadDataIntoSorter(config, geometry, solver_container);

/*--- Partition and sort the volume output data -- */

volumeDataSorter->SortOutputData();

if (volumeDataSorterCompact != nullptr) volumeDataSorterCompact->SortOutputData();

}

void COutput::WriteToFile(CConfig *config, CGeometry *geometry, OUTPUT_TYPE format, string fileName) {

/*--- File writer that will later be used to write the file to disk. Created below in the "switch" ---*/

CFileWriter *fileWriter = nullptr;

/*--- Set current time iter even if history file is not written ---*/

curTimeIter = config->GetTimeIter();

/*--- If the filename with appended iteration is set (depending on the WRT_*_OVERWRITE options)

* two files are writen, the normal one and a copy to avoid overwriting previous outputs. ---*/

string filename_iter, extension;

/*--- Write output information to screen ---*/

auto LogOutputFiles = [&](const std::string& message) {

if (rank == MASTER_NODE) {

(*fileWritingTable) << message << fileName + extension;

if (!filename_iter.empty()) (*fileWritingTable) << message + " + iter" << filename_iter + extension;

}

};

/*--- Write files depending on the format --- */

switch (format) {

case OUTPUT_TYPE::SURFACE_CSV:

extension = CSU2FileWriter::fileExt;

if (fileName.empty())

fileName = config->GetFilename(surfaceFilename, "", curTimeIter);

if (!config->GetWrt_Surface_Overwrite())

filename_iter = config->GetFilename_Iter(fileName, curInnerIter, curOuterIter);

/*--- If we have compact restarts, we use only the required fields. ---*/

if (config->GetWrt_Restart_Compact())

surfaceDataSorter->SetRequiredFieldNames(requiredVolumeFieldNames);

surfaceDataSorter->SortConnectivity(config, geometry);

surfaceDataSorter->SortOutputData();

LogOutputFiles("CSV file");

fileWriter = new CSU2FileWriter(surfaceDataSorter);

break;

case OUTPUT_TYPE::RESTART_ASCII: case OUTPUT_TYPE::CSV:

extension = CSU2FileWriter::fileExt;

if (fileName.empty())

fileName = config->GetFilename(restartFilename, "", curTimeIter);

if (!config->GetWrt_Restart_Overwrite())

filename_iter = config->GetFilename_Iter(fileName, curInnerIter, curOuterIter);

/*--- If we have compact restarts, we use only the required fields. ---*/

if (config->GetWrt_Restart_Compact())

volumeDataSorter->SetRequiredFieldNames(requiredVolumeFieldNames);

LogOutputFiles("SU2 ASCII restart");

fileWriter = new CSU2FileWriter(volumeDataSorter);

break;

case OUTPUT_TYPE::RESTART_BINARY:

extension = CSU2BinaryFileWriter::fileExt;

if (fileName.empty())

fileName = config->GetFilename(restartFilename, "", curTimeIter);

if (!config->GetWrt_Restart_Overwrite())

filename_iter = config->GetFilename_Iter(fileName, curInnerIter, curOuterIter);

LogOutputFiles("SU2 binary restart");

if (config->GetWrt_Restart_Compact()) {

/*--- If we have compact restarts, we use only the required fields. ---*/

volumeDataSorterCompact->SetRequiredFieldNames(requiredVolumeFieldNames);

fileWriter = new CSU2BinaryFileWriter(volumeDataSorterCompact);

} else {

fileWriter = new CSU2BinaryFileWriter(volumeDataSorter);

}

break;

case OUTPUT_TYPE::MESH:

extension = CSU2MeshFileWriter::fileExt;

if (fileName.empty())

fileName = config->GetFilename(volumeFilename, "", curTimeIter);

if (!config->GetWrt_Volume_Overwrite())

filename_iter = config->GetFilename_Iter(fileName, curInnerIter, curOuterIter);

/*--- Load and sort the output data and connectivity. ---*/

volumeDataSorter->SortConnectivity(config, geometry, true);

LogOutputFiles("SU2 mesh");

fileWriter = new CSU2MeshFileWriter(volumeDataSorter, config->GetiZone(), config->GetnZone());

break;

case OUTPUT_TYPE::TECPLOT_BINARY:

extension = CTecplotBinaryFileWriter::fileExt;

if (fileName.empty())

fileName = config->GetFilename(volumeFilename, "", curTimeIter);

if (!config->GetWrt_Volume_Overwrite())

filename_iter = config->GetFilename_Iter(fileName, curInnerIter, curOuterIter);

/*--- Load and sort the output data and connectivity. ---*/

volumeDataSorter->SortConnectivity(config, geometry, false);

LogOutputFiles("Tecplot binary");

fileWriter = new CTecplotBinaryFileWriter(volumeDataSorter, curTimeIter, GetHistoryFieldValue("TIME_STEP"));

break;

case OUTPUT_TYPE::TECPLOT_ASCII:

extension = CTecplotFileWriter::fileExt;

if (fileName.empty())

fileName = config->GetFilename(volumeFilename, "", curTimeIter);

if (!config->GetWrt_Volume_Overwrite())

filename_iter = config->GetFilename_Iter(fileName, curInnerIter, curOuterIter);

/*--- Load and sort the output data and connectivity. ---*/

volumeDataSorter->SortConnectivity(config, geometry, true);

LogOutputFiles("Tecplot ASCII");

fileWriter = new CTecplotFileWriter(volumeDataSorter, curTimeIter, GetHistoryFieldValue("TIME_STEP"));

break;

case OUTPUT_TYPE::PARAVIEW_XML:

extension = CParaviewXMLFileWriter::fileExt;

if (fileName.empty())

fileName = config->GetFilename(volumeFilename, "", curTimeIter);

if (!config->GetWrt_Volume_Overwrite())

filename_iter = config->GetFilename_Iter(fileName, curInnerIter, curOuterIter);

/*--- Load and sort the output data and connectivity. ---*/

volumeDataSorter->SortConnectivity(config, geometry, true);

LogOutputFiles("Paraview");

fileWriter = new CParaviewXMLFileWriter(volumeDataSorter);

break;

case OUTPUT_TYPE::PARAVIEW_LEGACY_BINARY:

extension = CParaviewBinaryFileWriter::fileExt;

if (fileName.empty())

fileName = config->GetFilename(volumeFilename, "", curTimeIter);

if (!config->GetWrt_Volume_Overwrite())

filename_iter = config->GetFilename_Iter(fileName, curInnerIter, curOuterIter);

/*--- Load and sort the output data and connectivity. ---*/

volumeDataSorter->SortConnectivity(config, geometry, true);

LogOutputFiles("Paraview binary (legacy)");

fileWriter = new CParaviewBinaryFileWriter(volumeDataSorter);

break;

case OUTPUT_TYPE::PARAVIEW_MULTIBLOCK:

{

extension = CParaviewVTMFileWriter::fileExt;

if (fileName.empty())

fileName = config->GetUnsteady_FileName(volumeFilename, curTimeIter, "");

if (!config->GetWrt_Volume_Overwrite())

filename_iter = config->GetFilename_Iter(fileName, curInnerIter, curOuterIter);

/*--- Sort volume connectivity ---*/

volumeDataSorter->SortConnectivity(config, geometry, true);

LogOutputFiles("Paraview Multiblock");

fileWriter = new CParaviewVTMFileWriter(GetHistoryFieldValue("CUR_TIME"), config->GetiZone(), config->GetnZone());

/*--- We cast the pointer to its true type, to avoid virtual functions ---*/

auto* vtmWriter = dynamic_cast<CParaviewVTMFileWriter*>(fileWriter);

/*--- then we write the data into the folder---*/

vtmWriter->WriteFolderData(fileName, config, multiZoneHeaderString, volumeDataSorter, surfaceDataSorter, geometry);

/*--- and we write the data into the folder with the iteration number ---*/

if (!config->GetWrt_Volume_Overwrite())

vtmWriter->WriteFolderData(filename_iter, config, multiZoneHeaderString, volumeDataSorter, surfaceDataSorter, geometry);

}

break;

case OUTPUT_TYPE::PARAVIEW_ASCII:

extension = CParaviewFileWriter::fileExt;

if (fileName.empty())

fileName = config->GetFilename(volumeFilename, "", curTimeIter);

if (!config->GetWrt_Volume_Overwrite())

filename_iter = config->GetFilename_Iter(fileName, curInnerIter, curOuterIter);

/*--- Load and sort the output data and connectivity. ---*/

volumeDataSorter->SortConnectivity(config, geometry, true);

LogOutputFiles("Paraview ASCII");

fileWriter = new CParaviewFileWriter(volumeDataSorter);

break;

case OUTPUT_TYPE::SURFACE_PARAVIEW_ASCII:

extension = CParaviewFileWriter::fileExt;

if (fileName.empty())

fileName = config->GetFilename(surfaceFilename, "", curTimeIter);

if (!config->GetWrt_Surface_Overwrite())

filename_iter = config->GetFilename_Iter(fileName, curInnerIter, curOuterIter);

/*--- Load and sort the output data and connectivity. ---*/

surfaceDataSorter->SortConnectivity(config, geometry);

surfaceDataSorter->SortOutputData();

LogOutputFiles("Paraview ASCII surface");

fileWriter = new CParaviewFileWriter(surfaceDataSorter);

break;

case OUTPUT_TYPE::SURFACE_PARAVIEW_LEGACY_BINARY:

extension = CParaviewBinaryFileWriter::fileExt;

if (fileName.empty())

fileName = config->GetFilename(surfaceFilename, "", curTimeIter);

if (!config->GetWrt_Surface_Overwrite())

filename_iter = config->GetFilename_Iter(fileName, curInnerIter, curOuterIter);

/*--- Load and sort the output data and connectivity. ---*/

surfaceDataSorter->SortConnectivity(config, geometry);

surfaceDataSorter->SortOutputData();

LogOutputFiles("Paraview binary surface (legacy)");

fileWriter = new CParaviewBinaryFileWriter(surfaceDataSorter);

break;

case OUTPUT_TYPE::SURFACE_PARAVIEW_XML:

extension = CParaviewXMLFileWriter::fileExt;

if (fileName.empty())

fileName = config->GetFilename(surfaceFilename, "", curTimeIter);

if (!config->GetWrt_Surface_Overwrite())

filename_iter = config->GetFilename_Iter(fileName, curInnerIter, curOuterIter);

/*--- Load and sort the output data and connectivity. ---*/

surfaceDataSorter->SortConnectivity(config, geometry);

surfaceDataSorter->SortOutputData();

LogOutputFiles("Paraview surface");

fileWriter = new CParaviewXMLFileWriter(surfaceDataSorter);

break;

case OUTPUT_TYPE::SURFACE_TECPLOT_ASCII:

extension = CTecplotFileWriter::fileExt;

if (fileName.empty())

fileName = config->GetFilename(surfaceFilename, "", curTimeIter);

if (!config->GetWrt_Surface_Overwrite())

filename_iter = config->GetFilename_Iter(fileName, curInnerIter, curOuterIter);

/*--- Load and sort the output data and connectivity. ---*/

surfaceDataSorter->SortConnectivity(config, geometry);

surfaceDataSorter->SortOutputData();

LogOutputFiles("Tecplot ASCII surface");

fileWriter = new CTecplotFileWriter(surfaceDataSorter, curTimeIter, GetHistoryFieldValue("TIME_STEP"));

break;

case OUTPUT_TYPE::SURFACE_TECPLOT_BINARY:

extension = CTecplotBinaryFileWriter::fileExt;

if (fileName.empty())

fileName = config->GetFilename(surfaceFilename, "", curTimeIter);

if (!config->GetWrt_Surface_Overwrite())

filename_iter = config->GetFilename_Iter(fileName, curInnerIter, curOuterIter);

/*--- Load and sort the output data and connectivity. ---*/

surfaceDataSorter->SortConnectivity(config, geometry);

surfaceDataSorter->SortOutputData();

LogOutputFiles("Tecplot binary surface");

fileWriter = new CTecplotBinaryFileWriter(surfaceDataSorter, curTimeIter, GetHistoryFieldValue("TIME_STEP"));

break;

case OUTPUT_TYPE::STL_ASCII:

extension = CSTLFileWriter::fileExt;

if (fileName.empty())

fileName = config->GetFilename(surfaceFilename, "", curTimeIter);

if (!config->GetWrt_Surface_Overwrite())

filename_iter = config->GetFilename_Iter(fileName, curInnerIter, curOuterIter);

/*--- Load and sort the output data and connectivity. ---*/

surfaceDataSorter->SortConnectivity(config, geometry);

surfaceDataSorter->SortOutputData();

LogOutputFiles("STL ASCII");

fileWriter = new CSTLFileWriter(surfaceDataSorter);

break;

case OUTPUT_TYPE::CGNS:

extension = CCGNSFileWriter::fileExt;

if (fileName.empty())

fileName = config->GetFilename(volumeFilename, "", curTimeIter);

if (!config->GetWrt_Volume_Overwrite())

filename_iter = config->GetFilename_Iter(fileName, curInnerIter, curOuterIter);

/*--- Load and sort the output data and connectivity. ---*/

volumeDataSorter->SortConnectivity(config, geometry, true);

LogOutputFiles("CGNS");

fileWriter = new CCGNSFileWriter(volumeDataSorter);

break;

case OUTPUT_TYPE::SURFACE_CGNS:

extension = CCGNSFileWriter::fileExt;

if (fileName.empty())

fileName = config->GetFilename(surfaceFilename, "", curTimeIter);

if (!config->GetWrt_Surface_Overwrite())

filename_iter = config->GetFilename_Iter(fileName, curInnerIter, curOuterIter);

/*--- Load and sort the output data and connectivity. ---*/

surfaceDataSorter->SortConnectivity(config, geometry);

surfaceDataSorter->SortOutputData();

LogOutputFiles("CGNS surface");

fileWriter = new CCGNSFileWriter(surfaceDataSorter, true);

break;

default:

break;

}

if (fileWriter != nullptr) {

/*--- Write data to file ---*/

fileWriter->WriteData(fileName);

su2double BandWidth = fileWriter->GetBandwidth();

/*--- Write data with iteration number to file if required ---*/

if (!filename_iter.empty()) {

fileWriter->WriteData(filename_iter);

/*--- Average bandwidth ---*/

BandWidth = (BandWidth + fileWriter->GetBandwidth()) / 2;

}

/*--- Compute and store the bandwidth ---*/

if (format == OUTPUT_TYPE::RESTART_BINARY) {

config->SetRestart_Bandwidth_Agg(config->GetRestart_Bandwidth_Agg() + BandWidth);

}

if (config->GetWrt_Performance() && (rank == MASTER_NODE)){

fileWritingTable->SetAlign(PrintingToolbox::CTablePrinter::RIGHT);

(*fileWritingTable) << " " << "(" + PrintingToolbox::to_string(BandWidth) + " MB/s)";

fileWritingTable->SetAlign(PrintingToolbox::CTablePrinter::LEFT);

}

delete fileWriter;

}

}

bool COutput::GetCauchyCorrectedTimeConvergence(const CConfig *config){

// Handle Cauchy convergence delay for 2nd order time stepping

if(!cauchyTimeConverged && TimeConvergence && config->GetTime_Marching() == TIME_MARCHING::DT_STEPPING_2ND){

// Change flags for 2nd order Time stepping: In case of convergence, this iter and next iter gets written out. then solver stops

cauchyTimeConverged = TimeConvergence;

TimeConvergence = false;

}

else if(cauchyTimeConverged){

TimeConvergence = cauchyTimeConverged;

}

// Handle max time delay for 2nd order time stepping

// Delay stopping at max_time to ensure both timestep N and N-1 are written for proper restart

if(config->GetTime_Marching() == TIME_MARCHING::DT_STEPPING_2ND){

const su2double cur_time = GetHistoryFieldValue("CUR_TIME");

const su2double max_time = config->GetMax_Time();

const bool final_time_reached = (cur_time >= max_time);

// If max_time is reached on first detection, delay the stop

if(final_time_reached && !maxTimeDelayActive){

maxTimeDelayActive = true;

TimeConvergence = false; // Delay stop to run one more iteration

}

else if(maxTimeDelayActive){

TimeConvergence = true; // Now allow stop

maxTimeDelayActive = false; // Reset for next run

}

}

return TimeConvergence;

}

bool COutput::SetResultFiles(CGeometry *geometry, CConfig *config, CSolver** solver_container,

unsigned long iter, bool force_writing) {

bool isFileWrite = false, dataIsLoaded = false;

const auto nVolumeFiles = config->GetnVolumeOutputFiles();

const auto* VolumeFiles = config->GetVolumeOutputFiles();

/*--- Check if the data sorters are allocated, if not, allocate them. --- */

AllocateDataSorters(config, geometry);

for (unsigned short iFile = 0; iFile < nVolumeFiles; iFile++) {

/*--- Collect the volume data from the solvers.

* If time-domain is enabled, we also load the data although we don't output it,

* since we might want to do time-averaging. ---*/

const bool write_file = WriteVolumeOutput(config, iter, force_writing || cauchyTimeConverged, iFile);

if ((write_file || config->GetTime_Domain()) && !dataIsLoaded) {

LoadDataIntoSorter(config, geometry, solver_container);

dataIsLoaded = true;

}

if (!write_file) continue;

/*--- Partition and sort the data --- */

volumeDataSorter->SortOutputData();

if (volumeDataSorterCompact != nullptr) volumeDataSorterCompact->SortOutputData();

if (rank == MASTER_NODE && !isFileWrite) {

fileWritingTable->SetAlign(PrintingToolbox::CTablePrinter::CENTER);

fileWritingTable->PrintHeader();

fileWritingTable->SetAlign(PrintingToolbox::CTablePrinter::LEFT);

}

/*--- Loop through all requested output files and write

* the partitioned and sorted data stored in the data sorters. ---*/

WriteToFile(config, geometry, VolumeFiles[iFile]);

/*--- Write any additonal files defined in the child class ----*/

WriteAdditionalFiles(config, geometry, solver_container);

isFileWrite = true;

}

if (rank == MASTER_NODE && isFileWrite) {

fileWritingTable->PrintFooter();

headerNeeded = true;

}

return isFileWrite;

}

void COutput::PrintConvergenceSummary(){

PrintingToolbox::CTablePrinter ConvSummary(&cout);

ConvSummary.AddColumn("Convergence Field", 28);

ConvSummary.AddColumn("Value", 14);

ConvSummary.AddColumn("Criterion", 14);

ConvSummary.AddColumn("Converged",12);

ConvSummary.SetAlign(PrintingToolbox::CTablePrinter::CENTER);

ConvSummary.PrintHeader();

for (unsigned short iField_Conv = 0; iField_Conv < convFields.size(); iField_Conv++){

const string &convField = convFields[iField_Conv];

if (historyOutput_Map.at(convField).fieldType == HistoryFieldType::COEFFICIENT) {

string convMark = "No";

if ( historyOutput_Map.at("CAUCHY_" + convField).value < cauchyEps) convMark = "Yes";

ConvSummary << historyOutput_Map.at("CAUCHY_" + convField).fieldName

<< historyOutput_Map.at("CAUCHY_" + convField).value

<< " < " + PrintingToolbox::to_string(cauchyEps) << convMark;

}

else if (historyOutput_Map.at(convField).fieldType == HistoryFieldType::RESIDUAL ||

historyOutput_Map.at(convField).fieldType == HistoryFieldType::AUTO_RESIDUAL) {

string convMark = "No";

if (historyOutput_Map.at(convField).value < minLogResidual) convMark = "Yes";

ConvSummary << historyOutput_Map.at(convField).fieldName

<< historyOutput_Map.at(convField).value

<< " < " + PrintingToolbox::to_string(minLogResidual) << convMark;

}

}

ConvSummary.PrintFooter();

}

bool COutput::ConvergenceMonitoring(CConfig *config, unsigned long Iteration) {

convergence = true;

for (auto iField_Conv = 0ul; iField_Conv < convFields.size(); iField_Conv++) {

const auto& convField = convFields[iField_Conv];

const auto it = historyOutput_Map.find(convField);

if (it == historyOutput_Map.end()) continue;

const auto& field = it->second;

const su2double monitor = field.value;

/*--- Stop the simulation in case a nan appears, do not save the solution. ---*/

if (std::isnan(SU2_TYPE::GetValue(monitor))) {

SU2_MPI::Error("SU2 has diverged (NaN detected).", CURRENT_FUNCTION);

}

bool fieldConverged = false;

switch (field.fieldType) {

/*--- Cauchy based convergence criteria ---*/

case HistoryFieldType::COEFFICIENT: {

if (Iteration == 0) {

for (auto iCounter = 0ul; iCounter < nCauchy_Elems; iCounter++) {

cauchySerie[iField_Conv][iCounter] = 0.0;

}

newFunc[iField_Conv] = monitor;

}

oldFunc[iField_Conv] = newFunc[iField_Conv];

newFunc[iField_Conv] = monitor;

/*--- Automatically modify the scaling factor of relative Cauchy convergence for

* coefficients that are close to zero. Example: For the clean aircraft, the rolling

* moment coefficient MOMENT_X is close to zero and thus will never reach a relative

* cauchy convergence ->> dividing tiny numbers is not a good idea. Using absolute

* cauchy convergence is more robust in this case. ---*/

cauchyFunc = fabs(newFunc[iField_Conv] - oldFunc[iField_Conv]) / fmax(fabs(monitor), 0.1);

cauchySerie[iField_Conv][Iteration % nCauchy_Elems] = cauchyFunc;

cauchyValue = 0.0;

for (auto iCounter = 0ul; iCounter < nCauchy_Elems; iCounter++)

cauchyValue += cauchySerie[iField_Conv][iCounter];

cauchyValue /= nCauchy_Elems;

/*--- Start monitoring only if the current iteration

* is larger than the number of cauchy elements. --- */

fieldConverged = (cauchyValue < cauchyEps) && (Iteration >= nCauchy_Elems);

if (Iteration == 0) cauchyValue = 1.0;

SetHistoryOutputValue("CAUCHY_" + convField, cauchyValue);

} break;

/*--- Residual based convergence criteria ---*/

case HistoryFieldType::RESIDUAL:

case HistoryFieldType::AUTO_RESIDUAL:

fieldConverged = (Iteration != 0) && (monitor <= minLogResidual);

break;

default:

break;

}

convergence = fieldConverged && convergence;

}

/*--- Do not apply any convergence criteria if the number

* of iterations is less than a particular value. ---*/

if (convFields.empty() || Iteration < config->GetStartConv_Iter()) convergence = false;

/*--- If a SIGTERM signal is sent to one of the processes, we set convergence to true. ---*/

if (STOP) convergence = true;

/*--- Apply the same convergence criteria to all processors. ---*/

unsigned short local = convergence, global = 0;

SU2_MPI::Allreduce(&local, &global, 1, MPI_UNSIGNED_SHORT, MPI_MAX, SU2_MPI::GetComm());

convergence = global > 0;