CrystalGeometry.h

// Copyright 2023, UChicago Argonne, LLC
// All Rights Reserved
// Software Name: NEML2 -- the New Engineering material Model Library, version 2
// By: Argonne National Laboratory
// OPEN SOURCE LICENSE (MIT)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
 
#pragma once
 
#include "neml2/base/Registry.h"
#include "neml2/models/Data.h"
#include "neml2/tensors/BatchTensorBase.h"
 
namespace neml2
{
class Vec;
class R2;
class SR2;
class WR2;
class MillerIndex;
 
namespace crystallography
{
 
class CrystalGeometry : public Data
{
public:
  static OptionSet expected_options();
 
  CrystalGeometry(const OptionSet & options);
 
  CrystalGeometry(const OptionSet & options, const R2 & cclass, const Vec & lattice_vectors);
 
  Vec a1() const;
  Vec a2() const;
  Vec a3() const;
 
  Vec b1() const;
  Vec b2() const;
  Vec b3() const;
 
  TorchSize nslip() const;
  TorchSize nslip_groups() const;
  TorchSize nslip_in_group(TorchSize i) const;
 
  const Vec & cartesian_slip_directions() const { return _cartesian_slip_directions; };
  const Vec & cartesian_slip_planes() const { return _cartesian_slip_planes; };
  const Scalar & burgers() const { return _burgers; };
 
  const R2 & A() const { return _A; };
  const SR2 & M() const { return _M; };
  const WR2 & W() const { return _W; };
 
  const R2 & symmetry_operators() const { return _sym_ops; };
 
  // The slice happens along the last batch axis
  template <
      class Derived,
      typename = typename std::enable_if_t<std::is_base_of_v<BatchTensorBase<Derived>, Derived>>>
  Derived slip_slice(const Derived & tensor, TorchSize grp) const;
 
private:
  CrystalGeometry(const OptionSet & options,
                  const R2 & cclass,
                  const Vec & lattice_vectors,
                  std::tuple<Vec, Vec, Scalar, std::vector<TorchSize>> slip_data);
 
  static Vec make_reciprocal_lattice(const Vec & lattice_vectors);
 
  static std::tuple<Vec, Vec, Scalar, std::vector<TorchSize>>
  setup_schmid_tensors(const Vec & A,
                       const R2 & cls,
                       const MillerIndex & slip_directions,
                       const MillerIndex & slip_planes);
 
  static Vec miller_to_cartesian(const Vec & A, const MillerIndex & d);
 
private:
  const R2 & _sym_ops;
  const Vec & _lattice_vectors;
  const Vec & _reciprocal_lattice_vectors;
  const MillerIndex & _slip_directions;
  const MillerIndex & _slip_planes;
 
  const Vec & _cartesian_slip_directions;
  const Vec & _cartesian_slip_planes;
  const Scalar & _burgers;
  const std::vector<TorchSize> _slip_offsets;
 
  const R2 & _A;
  const SR2 & _M;
  const WR2 & _W;
};
 
template <class Derived, typename>
Derived
CrystalGeometry::slip_slice(const Derived & tensor, TorchSize grp) const
{
  neml_assert_dbg(grp < nslip_groups());
  return tensor.batch_index({torch::indexing::Ellipsis,
                             torch::indexing::Slice(_slip_offsets[grp], _slip_offsets[grp + 1])});
}
 
} // namespace crystallography
} // namespace neml2