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      122036 : MaterialBase::validParams()
      21             : {
      22      122036 :   InputParameters params = ::MaterialBase::validParams();
      23             : 
      24      244072 :   params.suppressParameter<bool>("use_displaced_mesh");
      25      244072 :   params.suppressParameter<bool>("compute");
      26      244072 :   params.suppressParameter<std::vector<OutputName>>("outputs");
      27      122036 :   params.suppressParameter<std::vector<std::string>>("output_properties");
      28             : 
      29      122036 :   params.addPrivateParam<bool>(MooseBase::kokkos_object_param, true);
      30      244072 :   params.addPrivateParam<bool>("_kokkos_material", true);
      31             : 
      32      122036 :   return params;
      33           0 : }
      34             : 
      35         952 : MaterialBase::MaterialBase(const InputParameters & parameters)
      36             :   : ::MaterialBase(parameters),
      37         766 :     MeshHolder(*_fe_problem.mesh().getKokkosMesh()),
      38         766 :     AssemblyHolder(_fe_problem.kokkosAssembly()),
      39         766 :     SystemHolder(_fe_problem.getKokkosSystems()),
      40         766 :     _t(TransientInterface::_t),
      41         766 :     _t_old(TransientInterface::_t_old),
      42         766 :     _t_step(TransientInterface::_t_step),
      43         766 :     _dt(TransientInterface::_dt),
      44        2298 :     _dt_old(TransientInterface::_dt_old)
      45             : {
      46         952 : }
      47             : 
      48       50065 : MaterialBase::MaterialBase(const MaterialBase & object)
      49             :   : ::MaterialBase(object, {}),
      50             :     MeshHolder(object),
      51             :     AssemblyHolder(object),
      52             :     SystemHolder(object),
      53       41155 :     _t(object._t),
      54       41155 :     _t_old(object._t_old),
      55       41155 :     _t_step(object._t_step),
      56       41155 :     _dt(object._dt),
      57       82310 :     _dt_old(object._dt_old)
      58             : {
      59       50065 :   _element_ids = object._element_ids;
      60       50065 :   _element_side_ids = object._element_side_ids;
      61       50065 : }
      62             : 
      63             : void
      64         838 : MaterialBase::initialSetup()
      65             : {
      66         838 :   if (materialDataType() == Moose::BLOCK_MATERIAL_DATA)
      67             :   {
      68         275 :     std::set<ContiguousElementID> element_ids;
      69             : 
      70         550 :     for (auto block : blockIDs())
      71         275 :       element_ids.insert(_mesh.getKokkosMesh()->getSubdomainContiguousElementIDs(block).begin(),
      72         214 :                          _mesh.getKokkosMesh()->getSubdomainContiguousElementIDs(block).end());
      73             : 
      74         275 :     _element_ids = element_ids;
      75         275 :   }
      76             :   else
      77             :   {
      78         563 :     auto & restricted_blocks = boundaryRestricted() ? meshBlockIDs() : blockIDs();
      79         563 :     auto & restricted_boundaries = boundaryRestricted() ? boundaryIDs() : meshBoundaryIDs();
      80         563 :     auto & material_boundaries = kokkosAssembly().getMaterialBoundaries();
      81             : 
      82         563 :     std::vector<BoundaryID> boundaries;
      83             : 
      84         563 :     std::set_intersection(restricted_boundaries.begin(),
      85             :                           restricted_boundaries.end(),
      86             :                           material_boundaries.begin(),
      87             :                           material_boundaries.end(),
      88             :                           std::back_inserter(boundaries));
      89             : 
      90         563 :     std::set<Pair<ContiguousElementID, unsigned int>> element_side_ids;
      91             : 
      92         688 :     for (auto boundary : boundaries)
      93        1365 :       for (auto elem_id : _mesh.getBoundaryActiveSemiLocalElemIds(boundary))
      94             :       {
      95        1240 :         const auto elem = _mesh.elemPtr(elem_id);
      96             : 
      97        2080 :         if (elem->processor_id() == processor_id() &&
      98        1790 :             restricted_blocks.find(elem->subdomain_id()) != restricted_blocks.end())
      99        1970 :           element_side_ids.insert({_mesh.getKokkosMesh()->getContiguousElementID(elem),
     100         840 :                                    _mesh.sideWithBoundaryID(elem, boundary)});
     101         125 :       }
     102             : 
     103         563 :     _element_side_ids = element_side_ids;
     104         563 :   }
     105         838 : }
     106             : 
     107             : } // namespace Kokkos
     108             : } // namespace Moose