Line data    Source code

       1             : /**********************************************************************/
       2             : /*                     DO NOT MODIFY THIS HEADER                      */
       3             : /* MAGPIE - Mesoscale Atomistic Glue Program for Integrated Execution */
       4             : /*                                                                    */
       5             : /*            Copyright 2017 Battelle Energy Alliance, LLC            */
       6             : /*                        ALL RIGHTS RESERVED                         */
       7             : /**********************************************************************/
       8             : 
       9             : #include "FFTProblem.h"
      10             : #include "FFTBufferBase.h"
      11             : #include "MooseFFTVariable.h"
      12             : 
      13             : #include "libmesh/system.h"
      14             : 
      15             : registerMooseObject("MagpieApp", FFTProblem);
      16             : 
      17             : InputParameters
      18          18 : FFTProblem::validParams()
      19             : {
      20          18 :   InputParameters params = FEProblem::validParams();
      21          18 :   params.addClassDescription("Enhanced FEProblem that supports FFT buffers as variables.");
      22          18 :   params.set<bool>("skip_nl_system_check") = true;
      23          18 :   return params;
      24           0 : }
      25             : 
      26           9 : FFTProblem::FFTProblem(const InputParameters & parameters)
      27           9 :   : FEProblem(parameters), _fft_dummy_system(*this, "FFTSystem")
      28             : {
      29           9 :   const auto soln_tag = getVectorTagID(Moose::SOLUTION_TAG);
      30           9 :   _fft_dummy_system.associateVectorToTag(*_fft_dummy_system.system().current_local_solution,
      31             :                                          soln_tag);
      32           9 : }
      33             : 
      34             : bool
      35         771 : FFTProblem::hasVariable(const std::string & var_name) const
      36             : {
      37             :   // first check for FFT buffers
      38             :   std::vector<UserObject *> objs;
      39        1542 :   theWarehouse().query().condition<AttribThread>(0).condition<AttribName>(var_name).queryInto(objs);
      40         771 :   if (!objs.empty() && dynamic_cast<FFTBufferBase<Real> *>(objs[0]))
      41             :   {
      42          18 :     mooseInfo("hasVariable returned true for '", var_name, "' for FFTBuffer");
      43             :     return true;
      44             :   }
      45             : 
      46             :   // fall back to regular variable
      47         753 :   if (FEProblem::hasVariable(var_name))
      48             :     return true;
      49             : 
      50             :   return false;
      51             : }
      52             : 
      53             : MooseVariableFEBase &
      54        1185 : FFTProblem::getVariable(THREAD_ID tid,
      55             :                         const std::string & var_name,
      56             :                         Moose::VarKindType expected_var_type,
      57             :                         Moose::VarFieldType expected_var_field_type)
      58             : {
      59             :   // first check for FFT buffers
      60             :   std::vector<UserObject *> objs;
      61        2370 :   theWarehouse().query().condition<AttribThread>(0).condition<AttribName>(var_name).queryInto(objs);
      62        1185 :   if (!objs.empty() && dynamic_cast<FFTBufferBase<Real> *>(objs[0]))
      63             :   {
      64          18 :     mooseInfo("getVariable is returning a dummy object for '", var_name, "' for FFTBuffer");
      65             : 
      66          18 :     auto & varlist = _fft_vars[var_name];
      67             : 
      68             :     // add dummy name into the dummy system
      69             :     unsigned int fft_var_number;
      70          18 :     if (varlist.empty())
      71           3 :       fft_var_number = _fft_dummy_system.system().add_variable(var_name, CONSTANT, MONOMIAL);
      72             :     else
      73          15 :       fft_var_number = _fft_dummy_system.system().variable_number(var_name);
      74             : 
      75          18 :     if (varlist.size() <= tid)
      76           3 :       varlist.resize(tid + 1);
      77             : 
      78          18 :     if (!varlist[tid])
      79             :     {
      80           3 :       auto params = MooseVariableBase::validParams();
      81           6 :       params.set<MooseEnum>("order") = "CONSTANT";
      82           6 :       params.set<MooseEnum>("family") = "MONOMIAL";
      83           3 :       params.set<unsigned int>("_var_num") = fft_var_number;
      84           3 :       params.set<THREAD_ID>("tid") = tid;
      85           3 :       params.set<THREAD_ID>("_tid") = tid;
      86           3 :       params.set<Moose::VarKindType>("_var_kind") = Moose::VarKindType::VAR_AUXILIARY;
      87           3 :       params.set<SystemBase *>("_system_base") = &_fft_dummy_system;
      88           3 :       params.set<MooseApp *>("_moose_app") = &_app;
      89           3 :       params.set<std::string>("_type") = "MooseFFTVariable";
      90           3 :       params.set<std::string>("_object_name") = var_name;
      91           3 :       params.set<FEProblemBase *>("_fe_problem_base") = this;
      92           3 :       params.finalize(""); // empty syntax here; this is produced internally
      93             : 
      94           3 :       varlist[tid] = std::make_unique<MooseFFTVariable>(params);
      95           3 :     }
      96             : 
      97          18 :     return *varlist[tid];
      98             :   }
      99             : 
     100        1167 :   return FEProblem::getVariable(tid, var_name, expected_var_type, expected_var_field_type);
     101             : }