Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://www.mooseframework.org
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #include "KokkosMaterialBase.h"
      11             : 
      12             : #include "FEProblemBase.h"
      13             : 
      14             : namespace Moose
      15             : {
      16             : namespace Kokkos
      17             : {
      18             : 
      19             : InputParameters
      20      128754 : MaterialBase::validParams()
      21             : {
      22      128754 :   InputParameters params = ::MaterialBase::validParams();
      23             : 
      24      257508 :   params.suppressParameter<bool>("use_displaced_mesh");
      25      257508 :   params.suppressParameter<bool>("compute");
      26      257508 :   params.suppressParameter<std::vector<OutputName>>("outputs");
      27      128754 :   params.suppressParameter<std::vector<std::string>>("output_properties");
      28             : 
      29      128754 :   params.addPrivateParam<bool>(MooseBase::kokkos_object_param, true);
      30      386262 :   params.addPrivateParam<bool>("_kokkos_material", true);
      31             : 
      32      128754 :   params.registerBase("KokkosMaterial");
      33             : 
      34      128754 :   return params;
      35           0 : }
      36             : 
      37         952 : MaterialBase::MaterialBase(const InputParameters & parameters)
      38             :   : ::MaterialBase(parameters),
      39         766 :     MeshHolder(*_fe_problem.mesh().getKokkosMesh()),
      40         766 :     AssemblyHolder(_fe_problem.kokkosAssembly()),
      41         766 :     SystemHolder(_fe_problem.getKokkosSystems()),
      42         766 :     _t(TransientInterface::_t),
      43         766 :     _t_old(TransientInterface::_t_old),
      44         766 :     _t_step(TransientInterface::_t_step),
      45         766 :     _dt(TransientInterface::_dt),
      46        2298 :     _dt_old(TransientInterface::_dt_old)
      47             : {
      48         952 : }
      49             : 
      50       36803 : MaterialBase::MaterialBase(const MaterialBase & object)
      51             :   : ::MaterialBase(object, {}),
      52             :     MeshHolder(object),
      53             :     AssemblyHolder(object),
      54             :     SystemHolder(object),
      55       29790 :     _t(object._t),
      56       29790 :     _t_old(object._t_old),
      57       29790 :     _t_step(object._t_step),
      58       29790 :     _dt(object._dt),
      59       59580 :     _dt_old(object._dt_old)
      60             : {
      61       36803 :   _element_ids = object._element_ids;
      62       36803 :   _element_side_ids = object._element_side_ids;
      63       36803 : }
      64             : 
      65             : void
      66         838 : MaterialBase::initialSetup()
      67             : {
      68         838 :   if (materialDataType() == Moose::BLOCK_MATERIAL_DATA)
      69             :   {
      70         275 :     std::set<ContiguousElementID> element_ids;
      71             : 
      72         550 :     for (auto block : blockIDs())
      73         275 :       element_ids.insert(_mesh.getKokkosMesh()->getSubdomainContiguousElementIDs(block).begin(),
      74         214 :                          _mesh.getKokkosMesh()->getSubdomainContiguousElementIDs(block).end());
      75             : 
      76         275 :     _element_ids = element_ids;
      77         275 :   }
      78             :   else
      79             :   {
      80         563 :     auto & restricted_blocks = boundaryRestricted() ? meshBlockIDs() : blockIDs();
      81         563 :     auto & restricted_boundaries = boundaryRestricted() ? boundaryIDs() : meshBoundaryIDs();
      82         563 :     auto & material_boundaries = kokkosAssembly().getMaterialBoundaries();
      83             : 
      84         563 :     std::vector<BoundaryID> boundaries;
      85             : 
      86         563 :     std::set_intersection(restricted_boundaries.begin(),
      87             :                           restricted_boundaries.end(),
      88             :                           material_boundaries.begin(),
      89             :                           material_boundaries.end(),
      90             :                           std::back_inserter(boundaries));
      91             : 
      92         563 :     std::set<Pair<ContiguousElementID, unsigned int>> element_side_ids;
      93             : 
      94         688 :     for (auto boundary : boundaries)
      95        1365 :       for (auto elem_id : _mesh.getBoundaryActiveSemiLocalElemIds(boundary))
      96             :       {
      97        1240 :         const auto elem = _mesh.elemPtr(elem_id);
      98             : 
      99        2080 :         if (elem->processor_id() == processor_id() &&
     100        1790 :             restricted_blocks.find(elem->subdomain_id()) != restricted_blocks.end())
     101        1970 :           element_side_ids.insert({_mesh.getKokkosMesh()->getContiguousElementID(elem),
     102         840 :                                    _mesh.sideWithBoundaryID(elem, boundary)});
     103         125 :       }
     104             : 
     105         563 :     _element_side_ids = element_side_ids;
     106         563 :   }
     107         838 : }
     108             : 
     109             : } // namespace Kokkos
     110             : } // namespace Moose