Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       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 "RectangleCutUserObject.h"
      11             : 
      12             : // MOOSE includes
      13             : #include "MooseError.h"
      14             : 
      15             : // XFEM includes
      16             : #include "XFEMFuncs.h"
      17             : 
      18             : registerMooseObject("XFEMApp", RectangleCutUserObject);
      19             : 
      20             : InputParameters
      21          88 : RectangleCutUserObject::validParams()
      22             : {
      23             :   // Get input parameters from parent class
      24          88 :   InputParameters params = GeometricCut3DUserObject::validParams();
      25             : 
      26             :   // Add required parameters
      27         176 :   params.addRequiredParam<std::vector<Real>>("cut_data",
      28             :                                              "Vector of Real values providing cut information");
      29             :   // Class description
      30          88 :   params.addClassDescription("Creates a UserObject for planar cuts on 3D meshes for XFEM");
      31             :   // Return the parameters
      32          88 :   return params;
      33           0 : }
      34             : 
      35          44 : RectangleCutUserObject::RectangleCutUserObject(const InputParameters & parameters)
      36         132 :   : GeometricCut3DUserObject(parameters), _cut_data(getParam<std::vector<Real>>("cut_data"))
      37             : {
      38             :   // Set up constant parameters
      39             :   const int cut_data_len = 12;
      40             :   const int num_vertices = 4;
      41             : 
      42             :   // Throw error if length of cut_data is incorrect
      43          44 :   if (_cut_data.size() != cut_data_len)
      44           0 :     mooseError("Length of RectangleCutUserObject cut_data must be 12");
      45             : 
      46             :   // Assign cut_data to vars used to construct cuts
      47          44 :   _vertices.push_back(Point(_cut_data[0], _cut_data[1], _cut_data[2]));
      48          44 :   _vertices.push_back(Point(_cut_data[3], _cut_data[4], _cut_data[5]));
      49          44 :   _vertices.push_back(Point(_cut_data[6], _cut_data[7], _cut_data[8]));
      50          44 :   _vertices.push_back(Point(_cut_data[9], _cut_data[10], _cut_data[11]));
      51             : 
      52         220 :   for (unsigned int i = 0; i < num_vertices; ++i)
      53         176 :     _center += _vertices[i];
      54             :   _center *= 0.25;
      55             : 
      56         220 :   for (unsigned int i = 0; i < num_vertices; ++i)
      57             :   {
      58         176 :     unsigned int iplus1(i < 3 ? i + 1 : 0);
      59             :     std::pair<Point, Point> rays =
      60         176 :         std::make_pair(_vertices[i] - _center, _vertices[iplus1] - _center);
      61         176 :     _normal += rays.first.cross(rays.second);
      62             :   }
      63             :   _normal *= 0.25;
      64          44 :   Xfem::normalizePoint(_normal);
      65          44 : }
      66             : 
      67             : bool
      68      126928 : RectangleCutUserObject::isInsideCutPlane(Point p) const
      69             : {
      70             :   const int num_vertices = 4;
      71             : 
      72             :   bool inside = false;
      73             :   unsigned int counter = 0;
      74      634640 :   for (unsigned int i = 0; i < num_vertices; ++i)
      75             :   {
      76      507712 :     unsigned int iplus1 = (i < 3 ? i + 1 : 0);
      77      507712 :     Point middle2p = p - 0.5 * (_vertices[i] + _vertices[iplus1]);
      78             :     const Point side_tang = _vertices[iplus1] - _vertices[i];
      79      507712 :     Point side_norm = side_tang.cross(_normal);
      80      507712 :     Xfem::normalizePoint(middle2p);
      81      507712 :     Xfem::normalizePoint(side_norm);
      82      507712 :     if (middle2p * side_norm <= 0.0)
      83      439272 :       counter += 1;
      84             :   }
      85      126928 :   if (counter == num_vertices)
      86             :     inside = true;
      87      126928 :   return inside;
      88             : }
      89             : 
      90             : const std::vector<Point>
      91           0 : RectangleCutUserObject::getCrackFrontPoints(unsigned int /*num_crack_front_points*/) const
      92             : {
      93           0 :   mooseError("getCrackFrontPoints() is not implemented for this object.");
      94             : }
      95             : 
      96             : const std::vector<RealVectorValue>
      97           0 : RectangleCutUserObject::getCrackPlaneNormals(unsigned int /*num_crack_front_points*/) const
      98             : {
      99           0 :   mooseError("getCrackPlaneNormals() is not implemented for this object.");
     100             : }