SCMQuadPowerIC.C

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#include "SCMQuadPowerIC.h"
#include "Function.h"
#include "Receiver.h"
#include "QuadSubChannelMesh.h"
 
using namespace std;
using namespace Eigen;
 
registerMooseObject("SubChannelApp", SCMQuadPowerIC);
 
InputParameters
SCMQuadPowerIC::validParams()
{
  InputParameters params = QuadSubChannelBaseIC::validParams();
  params.addClassDescription("Computes axial heat rate (W/m) assigned to the fuel pins in a square "
                             "lattice arrangement");
  // params.addRequiredParam<Real>("power", "The total power of the subassembly [W]");
  params.addRequiredParam<PostprocessorName>(
      "power", "The postprocessor or Real to use for the total power of the subassembly [W]");
  params.addRequiredParam<std::string>(
      "filename", "name of radial power profile .txt file (should be a single column) [UnitLess].");
  params.addParam<FunctionName>(
      "axial_heat_rate",
      "1.0",
      "Axial shape of the heat rate as a function of the distance from the start of the "
      "heated section [Unitless]. Its magnitude does not matter because each pin is "
      "rescaled to its assigned power");
  return params;
}
 
SCMQuadPowerIC::SCMQuadPowerIC(const InputParameters & params)
  : QuadSubChannelBaseIC(params),
    _power(getPostprocessorValue("power")),
    _numberoflines(0),
    _filename(getParam<std::string>("filename")),
    _axial_heat_rate(getFunction("axial_heat_rate"))
{
  if (processor_id() > 0)
    return;
 
  if (!_mesh.pinMeshExist())
    mooseError(name(), ": This object requires a pin mesh.");
 
  auto n_pins = _mesh.getNumOfPins();
 
  _power_dis.resize(n_pins, 1);
  _power_dis.setZero();
  _pin_power_correction.resize(n_pins, 1);
  _pin_power_correction.setOnes();
 
  Real vin;
  ifstream inFile;
 
  inFile.open(_filename);
  if (!inFile)
    mooseError(name(), "unable to open file : ", _filename);
 
  while (inFile >> vin)
    _numberoflines += 1;
 
  if (inFile.fail() && !inFile.eof())
    mooseError(name(), " non numerical input at line : ", _numberoflines);
 
  if (_numberoflines != n_pins)
    mooseError(name(), " Radial profile file doesn't have correct size : ", n_pins);
  inFile.close();
 
  inFile.open(_filename);
  int i(0);
  while (inFile >> vin)
  {
    _power_dis(i, 0) = vin;
    i++;
  }
  inFile.close();
  _console << " Power distribution matrix :\n" << _power_dis << " \n";
}
 
void
SCMQuadPowerIC::initialSetup()
{
  // A power postprocessor executes before initial conditions only if it executes on INITIAL;
  // otherwise it still holds its default of zero here. A Receiver is set by a transfer instead,
  // so its execute_on does not control its value.
  if (!isDefaultPostprocessorValue("power") &&
      !dynamic_cast<const Receiver *>(&getUserObjectBase("power")) &&
      !getUserObjectBase("power").getExecuteOnEnum().isValueSet(EXEC_INITIAL))
    paramError("power",
               "The 'execute_on' parameter of the power postprocessor must include 'initial'");
 
  if (processor_id() > 0)
    return;
  auto n_pins = _mesh.getNumOfPins();
  auto nz = _mesh.getNumOfAxialCells();
  auto z_grid = _mesh.getZGrid();
  auto heated_length = _mesh.getHeatedLength();
  auto unheated_length_entry = _mesh.getHeatedLengthEntry();
 
  // The power postprocessor executes on INITIAL before initial conditions are set up, so its
  // value is only available here, not in the constructor
  auto sum = _power_dis.sum();
  // full (100%) power of one pin [W]
  auto fpin_power = _power / sum;
  // actual pin power [W]
  _ref_power = _power_dis * fpin_power;
  // Convert the actual pin power to a linear heat rate [W/m]
  _ref_qprime = _ref_power / heated_length;
 
  _estimate_power.resize(n_pins, 1);
  _estimate_power.setZero();
  for (unsigned int iz = 1; iz < nz + 1; iz++)
  {
    // Compute axial location of nodes.
    auto z2 = z_grid[iz];
    auto z1 = z_grid[iz - 1];
    if (MooseUtils::absoluteFuzzyGreaterThan(z2, unheated_length_entry) &&
        MooseUtils::absoluteFuzzyLessThan(z1, unheated_length_entry + heated_length))
    {
      // cycle through pins
      for (unsigned int i_pin = 0; i_pin < n_pins; i_pin++)
      {
        // Evaluate the axial shape at this pin's nodes, where value() assigns q_prime and the
        // solver integrates it, so the correction also holds for shapes that vary between pins
        const Point shift(0, 0, unheated_length_entry);
        auto heat1 = _axial_heat_rate.value(_t, Point(*_mesh.getPinNode(i_pin, iz - 1) - shift));
        auto heat2 = _axial_heat_rate.value(_t, Point(*_mesh.getPinNode(i_pin, iz) - shift));
 
        // Compute the height of this element.
        auto dz = z2 - z1;
 
        // calculation of power for the first heated segment if nodes don't align
        if (MooseUtils::absoluteFuzzyGreaterThan(z2, unheated_length_entry) &&
            MooseUtils::absoluteFuzzyLessThan(z1, unheated_length_entry))
        {
          heat1 = 0.0;
        }
 
        // calculation of power for the last heated segment if nodes don't align
        if (MooseUtils::absoluteFuzzyGreaterThan(z2, unheated_length_entry + heated_length) &&
            MooseUtils::absoluteFuzzyLessThan(z1, unheated_length_entry + heated_length))
        {
          heat2 = 0.0;
        }
 
        _estimate_power(i_pin) += _ref_qprime(i_pin) * (heat1 + heat2) * dz / 2.0;
      }
    }
  }
  // if a Pin has zero power (_ref_qprime(i_pin) = 0) then I need to avoid dividing by zero. I
  // divide by a wrong non-zero number which is not correct but this error doesn't mess things cause
  // _ref_qprime(i_pin) = 0.0
  auto total_power = 0.0;
  for (unsigned int i_pin = 0; i_pin < n_pins; i_pin++)
  {
    total_power += _estimate_power(i_pin);
    if (_estimate_power(i_pin) == 0.0)
      _estimate_power(i_pin) = 1.0;
  }
  // We need to correct the linear power assigned to the nodes of each pin
  // so that the total power calculated  by the trapezoidal rule agrees with the power assigned by
  // the user.
  _pin_power_correction = _ref_power.cwiseQuotient(_estimate_power);
  _console << "###########################################" << std::endl;
  _console << "Total power estimation by IC kernel before correction: " << total_power << " [W] "
           << std::endl;
  _console << "IC Power correction vector :\n" << _pin_power_correction << " \n";
}
 
Real
SCMQuadPowerIC::value(const Point & p)
{
  auto heated_length = _mesh.getHeatedLength();
  auto unheated_length_entry = _mesh.getHeatedLengthEntry();
  Point p1(0, 0, unheated_length_entry);
  Point P = p - p1;
 
  if (MooseUtils::absoluteFuzzyGreaterEqual(p(2), unheated_length_entry) &&
      MooseUtils::absoluteFuzzyLessEqual(p(2), unheated_length_entry + heated_length))
  {
    auto i_pin = _mesh.getPinIndexFromPoint(p);
    return _ref_qprime(i_pin) * _pin_power_correction(i_pin) * _axial_heat_rate.value(_t, P);
  }
  else
    return 0.0;
}