View Javadoc
1   // ******************************************************************************
2   //
3   // Title:       Force Field X.
4   // Description: Force Field X - Software for Molecular Biophysics.
5   // Copyright:   Copyright (c) Michael J. Schnieders 2001-2025.
6   //
7   // This file is part of Force Field X.
8   //
9   // Force Field X is free software; you can redistribute it and/or modify it
10  // under the terms of the GNU General Public License version 3 as published by
11  // the Free Software Foundation.
12  //
13  // Force Field X is distributed in the hope that it will be useful, but WITHOUT
14  // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
15  // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
16  // details.
17  //
18  // You should have received a copy of the GNU General Public License along with
19  // Force Field X; if not, write to the Free Software Foundation, Inc., 59 Temple
20  // Place, Suite 330, Boston, MA 02111-1307 USA
21  //
22  // Linking this library statically or dynamically with other modules is making a
23  // combined work based on this library. Thus, the terms and conditions of the
24  // GNU General Public License cover the whole combination.
25  //
26  // As a special exception, the copyright holders of this library give you
27  // permission to link this library with independent modules to produce an
28  // executable, regardless of the license terms of these independent modules, and
29  // to copy and distribute the resulting executable under terms of your choice,
30  // provided that you also meet, for each linked independent module, the terms
31  // and conditions of the license of that module. An independent module is a
32  // module which is not derived from or based on this library. If you modify this
33  // library, you may extend this exception to your version of the library, but
34  // you are not obligated to do so. If you do not wish to do so, delete this
35  // exception statement from your version.
36  //
37  // ******************************************************************************
38  package ffx.crystal;
39  
40  /**
41   * Enumeration of the different Laue systems. Some are only used for nonstandard cells.
42   *
43   * @author Michael J. Schnieders
44   * @since 1.0
45   */
46  public enum LaueSystem {
47    /**
48     * Laue System 111.
49     */
50    L111,
51    /**
52     * Laue System 112.
53     */
54    L112,
55    /**
56     * Laue System 121.
57     */
58    L121,
59    /**
60     * Laue System 211.
61     */
62    L211,
63    /**
64     * Laue System 21U.
65     */
66    L21U,
67    /**
68     * Laue System 21V.
69     */
70    L21V,
71    /**
72     * Laue System 21W.
73     */
74    L21W,
75    /**
76     * Laue System 21X.
77     */
78    L21X,
79    /**
80     * Laue System 21Y.
81     */
82    L21Y,
83    /**
84     * Laue System 21Z.
85     */
86    L21Z,
87    /**
88     * Laue System 222.
89     */
90    L222,
91    /**
92     * Laue System 22U.
93     */
94    L22U,
95    /**
96     * Laue System 22V.
97     */
98    L22V,
99    /**
100    * Laue System 22W.
101    */
102   L22W,
103   /**
104    * Laue System 114.
105    */
106   L114,
107   /**
108    * Laue System 141.
109    */
110   L141,
111   /**
112    * Laue System 411.
113    */
114   L411,
115   /**
116    * Laue System 224.
117    */
118   L224,
119   /**
120    * Laue System 242.
121    */
122   L242,
123   /**
124    * Laue System 422.
125    */
126   L422,
127   /**
128    * Laue System 113.
129    */
130   L113,
131   /**
132    * Laue System 131.
133    */
134   L131,
135   /**
136    * Laue System 311.
137    */
138   L311,
139   /**
140    * Laue System 11T.
141    */
142   L11T,
143   /**
144    * Laue System 1T1.
145    */
146   L1T1,
147   /**
148    * Laue System T11.
149    */
150   LT11,
151   /**
152    * Laue System 31A.
153    */
154   L31A,
155   /**
156    * Laue System 31B.
157    */
158   L31B,
159   /**
160    * Laue System 31C.
161    */
162   L31C,
163   /**
164    * Laue System 31D.
165    */
166   L31D,
167   /**
168    * Laue System 223.
169    */
170   L223,
171   /**
172    * Laue System 232.
173    */
174   L232,
175   /**
176    * Laue System 322.
177    */
178   L322,
179   /**
180    * Laue System 32A.
181    */
182   L32A,
183   /**
184    * Laue System 32B.
185    */
186   L32B,
187   /**
188    * Laue System 32C.
189    */
190   L32C,
191   /**
192    * Laue System 32D.
193    */
194   L32D,
195   /**
196    * Laue System 32U.
197    */
198   L32U,
199   /**
200    * Laue System 32V.
201    */
202   L32V,
203   /**
204    * Laue System 32W.
205    */
206   L32W,
207   /**
208    * Laue System 32X.
209    */
210   L32X,
211   /**
212    * Laue System 32Y.
213    */
214   L32Y,
215   /**
216    * Laue System 32Z.
217    */
218   L32Z,
219   /**
220    * Laue System M3B.
221    */
222   LM3B,
223   /**
224    * Laue System M3M.
225    */
226   LM3M;
227 
228   /**
229    * Check the given HKL is valid given the Laue system.
230    *
231    * @param h an int.
232    * @param k an int.
233    * @param l an int.
234    * @return True if the reflection is valid, false otherwise.
235    */
236   public boolean checkRestrictions(int h, int k, int l) {
237     switch (this) {
238       case L111 -> {
239         return (l > 0 || (l == 0 && (h > 0 || (h == 0 && k >= 0))));
240       }
241       case L112 -> {
242         return (l >= 0 && (h > 0 || (h == 0 && k >= 0)));
243       }
244       case L121 -> {
245         return (k >= 0 && (l > 0 || (l == 0 && h >= 0)));
246       }
247       case L211 -> {
248         return (h >= 0 && (k > 0 || (k == 0 && l >= 0)));
249       }
250       case L21U -> {
251         return (h + k >= 0 && (l > 0 || (l == 0 && h - k >= 0)));
252       }
253       case L21V -> {
254         return (l + h >= 0 && (k > 0 || (k == 0 && l - h >= 0)));
255       }
256       case L21W -> {
257         return (k + l >= 0 && (h > 0 || (h == 0 && k - l >= 0)));
258       }
259       case L21X -> {
260         return (h - k >= 0 && (l > 0 || (l == 0 && h + k >= 0)));
261       }
262       case L21Y -> {
263         return (l - h >= 0 && (k > 0 || (k == 0 && l + h >= 0)));
264       }
265       case L21Z -> {
266         return (k - l >= 0 && (h > 0 || (h == 0 && k + l >= 0)));
267       }
268       case L222 -> {
269         return (h >= 0 && k >= 0 && l >= 0);
270       }
271       case L22U -> {
272         return (h <= k && h >= -k && l >= 0);
273       }
274       case L22V -> {
275         return (l <= h && l >= -h && k >= 0);
276       }
277       case L22W -> {
278         return (k <= l && k >= -l && h >= 0);
279       }
280       case L114 -> {
281         return (l >= 0 && ((h >= 0 && k > 0) || (h == 0 && k == 0)));
282       }
283       case L141 -> {
284         return (k >= 0 && ((l >= 0 && h > 0) || (l == 0 && h == 0)));
285       }
286       case L411 -> {
287         return (h >= 0 && ((k >= 0 && l > 0) || (k == 0 && l == 0)));
288       }
289       case L224 -> {
290         return (h >= k && k >= 0 && l >= 0);
291       }
292       case L242 -> {
293         return (l >= h && h >= 0 && k >= 0);
294       }
295       case L422 -> {
296         return (k >= l && l >= 0 && h >= 0);
297       }
298       case L113 -> {
299         return (h >= 0 && k > 0) || (h == 0 && k == 0 && l >= 0);
300       }
301       case L131 -> {
302         return (l >= 0 && h > 0) || (l == 0 && h == 0 && k >= 0);
303       }
304       case L311 -> {
305         return (k >= 0 && l > 0) || (k == 0 && l == 0 && h >= 0);
306       }
307       case L11T -> {
308         return (h <= 0 && k > 0) || (h == 0 && k == 0 && l >= 0);
309       }
310       case L1T1 -> {
311         return (l <= 0 && h > 0) || (l == 0 && h == 0 && k >= 0);
312       }
313       case LT11 -> {
314         return (k <= 0 && l > 0) || (k == 0 && l == 0 && h >= 0);
315       }
316       case L31A -> {
317         return (k - l >= 0 && l - h > 0) || (h == l && k == l && h + k + l >= 0);
318       }
319       case L31B -> {
320         return (k - l >= 0 && l + h > 0) || (-h == l && k == l && -h + k + l >= 0);
321       }
322       case L31C -> {
323         return (-k - l >= 0 && l - h > 0) || (h == l && -k == l && h - k + l >= 0);
324       }
325       case L31D -> {
326         return (k + l >= 0 && -l - h > 0) || (h == -l && k == -l && h + k - l >= 0);
327       }
328       case L223 -> {
329         return (h >= k && k >= 0 && (k > 0 || l >= 0));
330       }
331       case L232 -> {
332         return (l >= h && h >= 0 && (h > 0 || k >= 0));
333       }
334       case L322 -> {
335         return (k >= l && l >= 0 && (l > 0 || h >= 0));
336       }
337       case L32A -> {
338         return (h >= k && k + l >= h + h && (k + l > h + h || h + k + l >= 0));
339       }
340       case L32B -> {
341         return (-h >= k && k + l >= -h - h && (k + l > -h - h || -h + k + l >= 0));
342       }
343       case L32C -> {
344         return (h >= -k && -k + l >= h + h && (-k + l > h + h || h - k + l >= 0));
345       }
346       case L32D -> {
347         return (h >= k && k - l >= h + h && (k - l > h + h || h + k - l >= 0));
348       }
349       case L32U -> {
350         return (h >= k && k >= 0 && (h > k || l >= 0));
351       }
352       case L32V -> {
353         return (k >= l && l >= 0 && (k > l || h >= 0));
354       }
355       case L32W -> {
356         return (l >= h && h >= 0 && (l > h || k >= 0));
357       }
358       case L32X -> {
359         return (-h >= k && k >= 0 && (-h > k || l >= 0));
360       }
361       case L32Y -> {
362         return (-k >= l && l >= 0 && (-k > l || h >= 0));
363       }
364       case L32Z -> {
365         return (-l >= h && h >= 0 && (-l > h || k >= 0));
366       }
367       case LM3B -> {
368         return (h >= 0 && ((l >= h && k > h) || (l == h && k == h)));
369       }
370       case LM3M -> {
371         return (k >= l && l >= h && h >= 0);
372       }
373       default -> {
374         return false;
375       }
376     }
377   }
378 }