Claude generated: Update of the light-up specific comments

Had Claude help generate all of the new comments for the light-up related scripts such that we no longer have the cubic related stuff in it.

Author: rcarson3

src/options.toml

@@ -629,38 +629,75 @@ grain_file = "grains.txt"
         avg_elastic_strain_fname = "avg_elastic_strain.txt"
 
     # ===== Crystal Orientation Analysis (Light-Up) =====
-    # Tracks which crystals are favorably oriented for slip
-    # Useful for: texture evolution, identifying active grains
+    # Tracks which crystals are favorably oriented for slip across all crystal systems
+    # Supports cubic, hexagonal, trigonal, rhombohedral, tetragonal, orthorhombic, monoclinic, triclinic
+    # Useful for: texture evolution, identifying active grains, powder diffraction simulation
     [[PostProcessing.light_up]]
         # Enable this analysis
         enabled = true
 
         # Which material to analyze (must match Materials.material_name)
         material_name = "aluminum_alloy"
+
+        # Crystal system type - determines symmetry operations and lattice parameter requirements
+        # Supported values: 'CUBIC', 'HEXAGONAL', 'TRIGONAL', 'RHOMBOHEDRAL', 
+        #                   'TETRAGONAL', 'ORTHORHOMBIC', 'MONOCLINIC', 'TRICLINIC'
+        laue_type = 'CUBIC'
 
         # Crystal directions to monitor [h,k,l]
         # These are Miller indices in crystal coordinates
-        # Example: [1,1,1] = octahedral slip, [1,1,0] = prismatic
+        # Examples: [1,1,1] = octahedral planes, [1,0,0] = cube faces, [1,1,0] = cube edges
+        # For hexagonal: [1,0,0] = basal, [0,0,1] = c-axis, [1,1,0] = prismatic
         hkl_directions = [[1, 1, 1], [1, 0, 0], [1, 1, 0]]
 
         # Angular tolerance in radians
-        # Grains within this angle of target are "lit up"
-        # 0.0873 radians ≈ 5 degrees
+        # Grains within this angle of target direction are considered "in-fiber"
+        # 0.0873 radians ≈ 5 degrees, 0.1745 radians ≈ 10 degrees
         distance_tolerance = 0.0873
 
         # Sample direction in lab coordinates [x,y,z]
-        # Used as reference for orientation analysis
-        # [0,0,1] = Z direction (loading direction)
+        # Used as reference for orientation analysis and lattice strain calculations
+        # [0,0,1] = Z direction (typical loading direction)
+        # [1,0,0] = X direction, [0,1,0] = Y direction
         sample_direction = [0.0, 0.0, 1.0]
 
-        # Crystal lattice parameters [a, b, c] in Angstroms
-        # For cubic: a=b=c, for hexagonal: a=b≠c
-        # Used for crystallographic calculations
-        lattice_parameters = [3.6, 3.6, 3.6]
+        # Crystal lattice parameters - requirements vary by crystal system:
+        # CUBIC:          [a] (lattice parameter in Angstroms)
+        # HEXAGONAL:      [a, c] (basal and c-axis parameters in Angstroms)
+        # TRIGONAL:       [a, c] (basal and c-axis parameters in Angstroms)
+        # RHOMBOHEDRAL:   [a, alpha] (lattice parameter in Angstroms, angle in radians)
+        # TETRAGONAL:     [a, c] (basal and c-axis parameters in Angstroms)
+        # ORTHORHOMBIC:   [a, b, c] (three lattice parameters in Angstroms)
+        # MONOCLINIC:     [a, b, c, beta] (three lattice parameters in Angstroms, monoclinic angle in radians)
+        # TRICLINIC:      [a, b, c, alpha, beta, gamma] (three lattice parameters in Angstroms, three angles in radians)
+        lattice_parameters = [3.6]  # Cubic aluminum: a = 3.6 Angstroms
 
         # Base name for output files
-        # Creates files like: lattice_avg_111.txt, lattice_avg_100.txt
+        # Creates files like: lattice_avg_directional_stiffness.txt, lattice_avg_dpeff.txt, lattice_avg_strains.txt...
+        # File naming automatically includes region number as well as quantity related to it
         lattice_basename = "lattice_avg_"
+
+    # Example: Hexagonal crystal system (e.g., titanium, zinc)
+    # [[PostProcessing.light_up]]
+    #     enabled = true
+    #     material_name = "titanium_alloy"
+    #     laue_type = 'HEXAGONAL'
+    #     hkl_directions = [[1, 0, 0], [0, 0, 1], [1, 1, 0]]  # basal, c-axis, prismatic
+    #     distance_tolerance = 0.0873
+    #     sample_direction = [0.0, 0.0, 1.0]
+    #     lattice_parameters = [2.95, 4.68]  # a = 2.95 Å, c = 4.68 Å for Ti
+    #     lattice_basename = "ti_lattice_"
+
+    # Example: Rhombohedral crystal system (e.g., some ceramics, bismuth)
+    # [[PostProcessing.light_up]]
+    #     enabled = true
+    #     material_name = "rhombohedral_ceramic"
+    #     laue_type = 'RHOMBOHEDRAL'
+    #     hkl_directions = [[1, 1, 1], [1, 0, 0], [1, 1, 0]]
+    #     distance_tolerance = 0.0873
+    #     sample_direction = [0.0, 0.0, 1.0]
+    #     lattice_parameters = [4.75, 1.0472]  # a = 4.75 Å, alpha = 60° = 1.0472 radians
+    #     lattice_basename = "rhombo_lattice_"
 
     # ===== Field Projections =====
     # Projects integration point data to nodes for visualization

src/postprocessing/mechanics_lightup.cpp

@@ -83,6 +83,34 @@ std::string get_lattice_basename(const std::string& lattice_basename, const int
 "_";
 }
 
+/**
+ * @brief Get crystallographic point group symmetry operations
+ * 
+ * @param lattice_type Crystal system type specifying the point group
+ * @return Vector of quaternions representing symmetry operations
+ * 
+ * Returns the complete set of point group symmetry operations for the
+ * specified crystal system as quaternions in the form [angle, x, y, z].
+ * Each quaternion represents a rotation operation that maps crystallographic
+ * directions to their symmetrically equivalent counterparts.
+ * 
+ * The number and type of symmetry operations depend on the crystal system:
+ * - Cubic: 24 operations (identity, 3-fold, 4-fold, 2-fold rotations)
+ * - Hexagonal: 12 operations (identity, 6-fold, 3-fold, 2-fold rotations)  
+ * - Trigonal: 6 operations (identity, 3-fold, 2-fold rotations)
+ * - Rhombohedral: 6 operations (identity, 3-fold about [111], 2-fold perpendicular to [111])
+ * - Tetragonal: 8 operations (identity, 4-fold, 2-fold rotations)
+ * - Orthorhombic: 4 operations (identity, three 2-fold rotations)
+ * - Monoclinic: 2 operations (identity, one 2-fold rotation)
+ * - Triclinic: 1 operation (identity only)
+ * 
+ * These symmetry operations are used by LatticeTypeGeneral to generate
+ * symmetrically equivalent HKL directions for lattice strain calculations
+ * in powder diffraction simulations.
+ * 
+ * @note Quaternions use the convention [angle, axis_x, axis_y, axis_z]
+ *       where angle is in radians and the axis is normalized.
+ */
 std::vector<std::array<double, 4>> GetSymmetryGroups(const LatticeType& lattice_type) 
 {
     // If not mentioned specifically these are taken from:
@@ -209,44 +237,44 @@ std::vector<std::array<double, 4>> GetSymmetryGroups(const LatticeType& lattice_
     return lattice_symm;
 }
 
-size_t GetNumberSymmetryOperations(const LatticeType& lattice_type) {
-    return GetSymmetryGroups(lattice_type).size();
-}
-
 /**
- * @brief Constructor for any lattice structure
+ * @brief Get number of symmetry operations for a crystal system
+ * 
+ * @param lattice_type Crystal system type specifying the point group
+ * @return Number of symmetry operations in the point group
  * 
- * @param lattice_param_a Array of lattice parameters
- *  'cubic'          a
- *  'hexagonal'      a, c
- *  'trigonal'       a, c
- *  'rhombohedral'   a, alpha (in radians)
- *  'tetragonal'     a, c
- *  'orthorhombic'   a, b, c
- *  'monoclinic'     a, b, c, beta (in radians)
- *  'triclinic'      a, b, c, alpha, beta, gamma (in radians)
- * @param lattice_param_type Crystallographic lattice type
+ * Returns the total number of symmetry operations for the specified
+ * crystal system's point group. This count includes the identity operation
+ * and all rotational symmetries of the crystal structure.
  * 
- * Initializes any lattice structure by computing reciprocal lattice
- * vectors and generating the various symmetry quaternions.
+ * The count varies by crystal system:
+ * - Cubic: 24 symmetry operations
+ * - Hexagonal: 12 symmetry operations
+ * - Trigonal: 6 symmetry operations
+ * - Rhombohedral: 6 symmetry operations
+ * - Tetragonal: 8 symmetry operations
+ * - Orthorhombic: 4 symmetry operations
+ * - Monoclinic: 2 symmetry operations
+ * - Triclinic: 1 symmetry operation
+ * 
+ * This function is used to initialize the NSYM member variable in
+ * LatticeTypeGeneral and to allocate appropriate storage for
+ * symmetry-related calculations.
+ * 
+ * @see GetSymmetryGroups() for the actual symmetry operation quaternions
  */
+size_t GetNumberSymmetryOperations(const LatticeType& lattice_type) {
+    return GetSymmetryGroups(lattice_type).size();
+}
+
+
 LatticeTypeGeneral::LatticeTypeGeneral(const std::vector<double>& lattice_param_a, const LatticeType& lattice_type) : 
 NSYM(GetNumberSymmetryOperations(lattice_type))
 {
     symmetric_quaternions(lattice_type);
     compute_lattice_b_param(lattice_param_a, lattice_type);
 }
 
-/**
- * @brief Compute reciprocal lattice parameter matrix
- * 
- * @param lparam_a Direct lattice parameters [a, b, c, alpha, beta, gamma]
- * 
- * Computes the reciprocal lattice vectors (lattice_b matrix) from
- * direct lattice parameters. For cubic crystals, assumes 90-degree
- * angles between axes. The reciprocal lattice is used to transform
- * HKL indices to direction vectors in reciprocal space.
- */
 void
 LatticeTypeGeneral::compute_lattice_b_param(const std::vector<double>& lparam_a, const LatticeType& lattice_type)
 {