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 "EBSDMesh.h"
      11             : #include "MooseApp.h"
      12             : 
      13             : #include <fstream>
      14             : 
      15             : registerMooseObject("PhaseFieldApp", EBSDMesh);
      16             : 
      17             : InputParameters
      18           0 : EBSDMesh::validParams()
      19             : {
      20           0 :   InputParameters params = GeneratedMesh::validParams();
      21           0 :   params.addClassDescription("Mesh generated from a specified DREAM.3D EBSD data file.");
      22           0 :   params.addRequiredParam<FileName>("filename", "The name of the file containing the EBSD data");
      23           0 :   params.addParam<unsigned int>(
      24           0 :       "uniform_refine", 0, "Number of coarsening levels available in adaptive mesh refinement.");
      25             : 
      26             :   // suppress parameters
      27           0 :   params.suppressParameter<MooseEnum>("dim");
      28           0 :   params.set<MooseEnum>("dim") = MooseEnum("1=1 2 3", "1");
      29           0 :   params.suppressParameter<unsigned int>("nx");
      30           0 :   params.suppressParameter<unsigned int>("ny");
      31           0 :   params.suppressParameter<unsigned int>("nz");
      32           0 :   params.suppressParameter<Real>("xmin");
      33           0 :   params.suppressParameter<Real>("ymin");
      34           0 :   params.suppressParameter<Real>("zmin");
      35           0 :   params.suppressParameter<Real>("xmax");
      36           0 :   params.suppressParameter<Real>("ymax");
      37           0 :   params.suppressParameter<Real>("zmax");
      38             : 
      39           0 :   return params;
      40           0 : }
      41             : 
      42           0 : EBSDMesh::EBSDMesh(const InputParameters & parameters)
      43           0 :   : GeneratedMesh(parameters), _filename(getParam<FileName>("filename"))
      44             : {
      45           0 :   mooseDeprecated(
      46             :       "EBSDMesh is deprecated, please use the EBSDMeshGenerator instead. For example:\n\n[Mesh]\n  "
      47             :       "type = EBDSMesh\n  filename = my_ebsd_data.dat\n[]\n\nbecomes\n\n[Mesh]\n  [ebsd_mesh]\n    "
      48             :       "type = EBDSMeshGenerator\n    filename = my_ebsd_data.dat\n  []\n[]");
      49             : 
      50           0 :   if (_nx != 1 || _ny != 1 || _nz != 1)
      51           0 :     mooseWarning("Do not specify mesh geometry information, it is read from the EBSD file.");
      52           0 : }
      53             : 
      54           0 : EBSDMesh::~EBSDMesh() {}
      55             : 
      56             : void
      57           0 : EBSDMesh::readEBSDHeader()
      58             : {
      59           0 :   std::ifstream stream_in(_filename.c_str());
      60             : 
      61           0 :   if (!stream_in)
      62           0 :     paramError("filename", "Can't open EBSD file: ", _filename);
      63             : 
      64             :   // Labels to look for in the header
      65             :   std::vector<std::string> labels = {
      66           0 :       "x_step", "x_dim", "y_step", "y_dim", "z_step", "z_dim", "x_min", "y_min", "z_min"};
      67             : 
      68             :   // Dimension variables to store once they are found in the header
      69             :   // X_step, X_Dim, Y_step, Y_Dim, Z_step, Z_Dim
      70             :   // We use Reals even though the Dim values should all be integers...
      71           0 :   std::vector<Real> label_vals(labels.size(), 0.0);
      72             : 
      73             :   std::string line;
      74           0 :   while (std::getline(stream_in, line))
      75             :   {
      76             :     // We need to process the comment lines that have:
      77             :     // X_step, X_Dim
      78             :     // Y_step, Y_Dim
      79             :     // Z_step, Z_Dim
      80             :     // in them. The labels are case insensitive.
      81           0 :     if (line.find("#") == 0)
      82             :     {
      83             :       // Process lines that start with a comment character (comments and meta data)
      84             :       std::transform(line.begin(), line.end(), line.begin(), ::tolower);
      85             : 
      86           0 :       for (unsigned i = 0; i < labels.size(); ++i)
      87           0 :         if (line.find(labels[i]) != std::string::npos)
      88             :         {
      89             :           std::string dummy;
      90           0 :           std::istringstream iss(line);
      91           0 :           iss >> dummy >> dummy >> label_vals[i];
      92             : 
      93             :           // One label per line, break out of for loop over labels
      94             :           break;
      95           0 :         }
      96             :     }
      97             :     else
      98             :       // first non comment line marks the end of the header
      99             :       break;
     100             :   }
     101             : 
     102             :   // Copy stuff out of the label_vars array into class variables
     103           0 :   _geometry.d[0] = label_vals[0];
     104           0 :   _geometry.n[0] = label_vals[1];
     105           0 :   _geometry.min[0] = label_vals[6];
     106             : 
     107           0 :   _geometry.d[1] = label_vals[2];
     108           0 :   _geometry.n[1] = label_vals[3];
     109           0 :   _geometry.min[1] = label_vals[7];
     110             : 
     111           0 :   _geometry.d[2] = label_vals[4];
     112           0 :   _geometry.n[2] = label_vals[5];
     113           0 :   _geometry.min[2] = label_vals[8];
     114             : 
     115             :   unsigned int dim;
     116             : 
     117             :   // determine mesh dimension
     118           0 :   for (dim = 3; dim > 0 && _geometry.n[dim - 1] == 0; --dim)
     119             :     ;
     120             : 
     121             :   // check if the data has nonzero stepsizes
     122           0 :   for (unsigned i = 0; i < dim; ++i)
     123             :   {
     124           0 :     if (_geometry.n[i] == 0)
     125           0 :       mooseError("Error reading header, EBSD grid size is zero.");
     126           0 :     if (_geometry.d[i] == 0.0)
     127           0 :       mooseError("Error reading header, EBSD data step size is zero.");
     128             :   }
     129             : 
     130           0 :   if (dim == 0)
     131           0 :     mooseError("Error reading header, EBSD data is zero dimensional.");
     132             : 
     133           0 :   _geometry.dim = dim;
     134           0 : }
     135             : 
     136             : void
     137           0 : EBSDMesh::buildMesh()
     138             : {
     139           0 :   readEBSDHeader();
     140             : 
     141           0 :   unsigned int uniform_refine = getParam<unsigned int>("uniform_refine");
     142           0 :   _dim = (_geometry.dim == 1 ? "1" : (_geometry.dim == 2 ? "2" : "3"));
     143             : 
     144             :   std::array<unsigned int, 3> nr;
     145           0 :   nr[0] = _geometry.n[0];
     146           0 :   nr[1] = _geometry.n[1];
     147           0 :   nr[2] = _geometry.n[2];
     148             : 
     149             :   // set min/max box length
     150           0 :   _xmin = _geometry.min[0];
     151           0 :   _xmax = nr[0] * _geometry.d[0] + _geometry.min[0];
     152           0 :   _ymin = _geometry.min[1];
     153           0 :   _ymax = nr[1] * _geometry.d[1] + _geometry.min[1];
     154           0 :   _zmin = _geometry.min[2];
     155           0 :   _zmax = nr[2] * _geometry.d[2] + _geometry.min[2];
     156             : 
     157             :   // check if the requested uniform refine level is possible and determine initial grid size
     158           0 :   for (unsigned int i = 0; i < uniform_refine; ++i)
     159           0 :     for (unsigned int j = 0; j < _geometry.dim; ++j)
     160             :     {
     161           0 :       if (nr[j] % 2 != 0)
     162           0 :         mooseError("EBSDMesh error. Requested uniform_refine levels not possible.");
     163           0 :       nr[j] /= 2;
     164             :     }
     165             : 
     166           0 :   _nx = nr[0];
     167           0 :   _ny = nr[1];
     168           0 :   _nz = nr[2];
     169             : 
     170           0 :   GeneratedMesh::buildMesh();
     171           0 : }