solver.cpp

Go to the documentation of this file.

// Copyright (C) 2024 The m-AIA AUTHORS
//
// This file is part of m-AIA (https://git.rwth-aachen.de/aia/m-AIA/m-AIA)
//
// SPDX-License-Identifier: LGPL-3.0-only
 
#include "solver.h"
#include "IO/context.h"
 
using namespace std;
 
std::map<MInt, MString> Solver::m_aliases;
 
//---------------------------------------------------------------------------
//
Solver::Solver(const MInt solverId, const MPI_Comm comm, const MBool isActive)
  : m_mpiComm(comm), m_noDim(read_nDim()), m_solverId(solverId) {
  TRACE();
 
  if(isActive) {
    // Determine domainId and number of domains if this solver is active
    MPI_Comm_rank(mpiComm(), &m_domainId);
    MPI_Comm_size(mpiComm(), &m_noDomains);
  } else {
    m_domainId = -1;
    m_noDomains = -1;
  }
 
  // Find aliases, default is solverId
  if(Context::solverPropertyExists("solverAlias", solverId)) {
    MString solverAlias = std::to_string(m_solverId);
    solverAlias = Context::getSolverProperty<MString>("solverAlias", m_solverId, AT_, &solverAlias);
    m_aliases[m_solverId] = solverAlias;
  }
 
  // Get output and restart directories
  MString testcaseDir = "./";
  m_testcaseDir = Context::getSolverProperty<MString>("testcaseDir", m_solverId, AT_, &testcaseDir);
  m_outputDir = Context::getSolverProperty<MString>("outputDir", m_solverId, AT_, &testcaseDir);
  m_restartDir = Context::getSolverProperty<MString>("restartDir", m_solverId, AT_, &m_outputDir);
  m_solutionOutput =
      Context::getSolverProperty<MString>("solutionOutput", m_solverId, AT_, &m_outputDir); // Naming a la FV
  // Context::getSolverProperty<MString>("solutionDir", m_solverId, AT_, &m_outputDir); // TODO: unify?
  m_outputDir = testcaseDir + m_outputDir;
  m_restartDir = testcaseDir + m_restartDir;
  m_solutionOutput = testcaseDir + m_solutionOutput;
 
  m_restartFile = false;
  m_restartFile = Context::getSolverProperty<MBool>("restartFile", m_solverId, AT_, &m_restartFile);
 
  m_restart = false;
  m_restart = Context::getSolverProperty<MBool>("restartFile", m_solverId, AT_, &m_restart);
 
  m_residualInterval = Context::getSolverProperty<MInt>("residualInterval", m_solverId, AT_);
 
  m_restartInterval = -1;
  m_restartInterval = Context::getSolverProperty<MInt>("restartInterval", m_solverId, AT_, &m_restartInterval);
 
  m_restartOffset = 0;
  m_restartOffset = Context::getSolverProperty<MInt>("restartOffset", m_solverId, AT_, &m_restartOffset);
 
  m_useNonSpecifiedRestartFile = false;
  m_useNonSpecifiedRestartFile =
      Context::getSolverProperty<MBool>("useNonSpecifiedRestartFile", m_solverId, AT_, &m_useNonSpecifiedRestartFile);
 
  m_initFromRestartFile = false;
  m_initFromRestartFile =
      Context::getSolverProperty<MBool>("initFromRestartFile", m_solverId, AT_, &m_initFromRestartFile);
 
  if(!m_restart && !m_initFromRestartFile) {
    m_restartTimeStep = 0;
  } else {
    if(!m_useNonSpecifiedRestartFile) {
      m_restartTimeStep = Context::getSolverProperty<MInt>("restartTimeStep", m_solverId, AT_);
    } else {
      m_restartTimeStep = 0;
    }
  }
 
  m_solutionInterval = Context::getSolverProperty<MInt>("solutionInterval", m_solverId, AT_);
 
  m_solverType = Context::getSolverProperty<MString>("solvertype", m_solverId, AT_);
 
  MString solverMethod = "defaultMethod";
  m_solverMethod = Context::getSolverProperty<MString>("solverMethod", m_solverId, AT_, &solverMethod);
}
 
MInt Solver::readSolverSamplingVarNames(std::vector<MString>& varNames, const MString featureName) const {
  MInt noVars = 0;
  MString propName = "samplingVariables"; // default property
  if(featureName != ""
     && Context::propertyExists("samplingVariables" + featureName, m_solverId)) { // feature specific property
    propName += featureName;
  }
 
  if(Context::propertyExists(propName, m_solverId)) {
    // Number of sampling variables
    noVars = Context::propertyLength(propName, solverId());
 
    varNames.clear();
    for(MInt i = 0; i < noVars; i++) {
      const MString samplingVarName = Context::getSolverProperty<MString>(propName, solverId(), AT_, i);
      varNames.push_back(samplingVarName);
    }
  }
  return noVars;
}
 
MString Solver::getIdentifier(const MBool useSolverId, const MString preString, const MString postString) {
  if(Context::solverPropertyExists("solverAlias", m_solverId)) {
    return preString + m_aliases.at(m_solverId) + postString;
  } else if(useSolverId) {
    return preString + std::to_string(m_solverId) + postString;
  } else {
    return "";
  }
}