Miller Indices Calculator - Converteer Kristalvlak Intercepties naar (hkl)

Q: Wat zijn de meest voorkomende Miller-indices?

In kubische kristallen kom je vaak tegen: (100), (010), (001) - De zes kubusoppervlakken (110), (101), (011) - Diagonale vlakken die twee assen doorsnijden (111) - Het octaëdrische vlak, dat alle drie assen gelijkmatig doorsnijdt (112) - Veel voorkomend glijvlak in BCC-metalen zoals ijzer Deze laag-index vlakken hebben de grootste d-spacing en laagste oppervlakte-energie, waardoor ze de meest waargenomen kristalvlakken en voorkeurglijvlakken zijn.

Bereken Miller indices (hkl) van kristalvlak intercepties. Snelle, nauwkeurige converter voor kristallografie, XRD-analyse en materiaalkunde. Werkt voor alle kristalsystemen.

Miller Indices Calculator

Kristalvlak Intercepties

Voer de intercepties van het kristalvlak met de x-, y- en z-assen in. Gebruik '∞' of 'oneindig' voor vlakken parallel aan een as.

X-as Interceptie

Voer een getal of ∞ in voor oneindigheid (parallel aan as)

Y-as Interceptie

Voer een getal of ∞ in voor oneindigheid (parallel aan as)

Z-as Interceptie

Voer een getal of ∞ in voor oneindigheid (parallel aan as)

De Miller indices voor dit vlak zijn:

(1,1,1)

Visualisatie

Wat zijn Miller Indices?

Miller indices zijn een notatiesysteem dat wordt gebruikt in de kristallografie om vlakken en richtingen in kristalroosters aan te geven.

Om Miller indices (h,k,l) uit intercepties (a,b,c) te berekenen:

1. Neem de reciproken van de intercepties: (1/a, 1/b, 1/c) 2. Converteer naar de kleinste set integers met dezelfde verhouding 3. Als een vlak parallel is aan een as (interceptie = oneindig), is de bijbehorende Miller index 0

Negatieve indices worden aangegeven met een streep boven het getal, bijv. (h̄,k,l)
De notatie (hkl) vertegenwoordigt een specifiek vlak, terwijl {hkl} een familie van equivalente vlakken vertegenwoordigt
Richtingsindices worden geschreven tussen vierkante haken [hkl], en families van richtingen worden aangeduid met <hkl>

Laadcalculator...

📚

Documentatie

Miller Indices begrijpen: Een praktische gids voor kristalvlak notatie

Als je ooit met kristallografie of materiaalkunde hebt gewerkt, weet je dat het nauwkeurig beschrijven van kristalvlakken cruciaal is. Miller indices bieden precies dat—een systematische manier om elk vlak in een kristalrooster te identificeren met slechts drie integers (h,k,l).

Deze rekenmachine zet vlakintercepts langs kristallografische assen om in standaard Miller indices notatie. Bij het analyseren van kristalstructuren of het interpreteren van röntgendiffractiegegevens zul je vaak specifieke vlakken moeten refereren. In plaats van elk vlak te beschrijven met zijn geometrische intercepts (wat omslachtig kan zijn), geven Miller indices je een beknopte, universeel begrepen notatie.

Wat deze notatie bijzonder nuttig maakt, is hoe het communicatie tussen onderzoekers vereenvoudigt. In plaats van te zeggen "het vlak dat de x-as doorsnijdt bij 2, de y-as bij 3 en de z-as bij 6", verwijs je eenvoudigweg naar het (321) vlak. Deze standaardisatie is essentieel geweest voor kristallografie sinds William Hallowes Miller het in 1839 introduceerde.

Wat zijn Miller-indices?

Miller-indices zijn drie integers (h,k,l) die een familie van parallelle vlakken in een kristalrooster uniek identificeren. Hier is het kernidee: ze worden afgeleid van de reciproken van de punten waar een vlak de kristallografische assen doorsnijdt.

Denk er zo over—als een vlak door een kristal snijdt op specifieke punten langs de x-, y- en z-assen, dan neem je de reciproken van die interceptwaarden en reduceer je ze tot de kleinste gehele getallen. Deze wiskundige benadering lijkt aanvankelijk abstract, maar heeft een praktisch voordeel: vlakken die structureel vergelijkbaar zijn, krijgen vergelijkbare indices, en parallelle vlakken delen dezelfde indices ongeacht hun positie.

Visuele weergave van Miller-indices

[Volledige SVG-afbeelding blijft ongewijzigd]

Hoe Miller-indices te berekenen: De kernformule

Het berekenen van Miller-indices volgt een eenvoudig vier-stappen proces:

Identificeer de intercepties - Bepaal waar het vlak de x-, y- en z-kristallografische assen kruist (noem deze a, b en c)
Neem reciproken - Bereken 1/a, 1/b en 1/c
Verwijder breuken - Vermenigvuldig alle drie de waarden met hetzelfde getal om breuken te elimineren
Reduceer tot laagste termen - Deel door de grootste gemeenschappelijke deler om de kleinste integers te krijgen

De wiskundige relatie wordt uitgedrukt als:

$h : k : l = \frac{1}{a} : \frac{1}{b} : \frac{1}{c}$

Waarbij (h,k,l) de Miller-indices zijn en a, b, c de intercepties langs elke as zijn.

Een veel voorkomend punt van verwarring: waarom reciproken gebruiken? Het blijkt dat deze keuze praktische voordelen heeft. Vlakken die nooit een as doorsnijden (parallel eraan) zouden een oneindige interceptie hebben—maar 1/∞ is nul, wat ons een nette numerieke representatie geeft. Deze elegantie is waarom Miller's notatie bijna twee eeuwen stand heeft gehouden.

Speciale gevallen die je zult tegenkomen

Bij het werken met Miller-indices zul je verschillende randgevallen tegenkomen die aanvankelijk lastig lijken:

Parallelle vlakken - Wanneer een vlak parallel loopt aan een as (deze nooit doorsnijdt), is die interceptie oneindig. Aangezien 1/∞ = 0, wordt de overeenkomstige index nul. Dus een vlak parallel aan de y-as zou (201) kunnen zijn, waarbij die middelste nul aangeeft dat het de y-as nooit kruist.

Negatieve intercepties - Vlakken kunnen assen doorsnijden aan de negatieve kant van de oorsprong. In formele kristallografische notatie worden negatieve indices weergegeven met een streep boven het getal: (h̄kl). In digitale contexten wordt dit vaak geschreven als (-h,k,l) voor praktische doeleinden.

Fractionale intercepties - Soms komen je initiële intercepties uit als breuken. Geen probleem—vermenigvuldig gewoon alle reciproken met de kleinste gemeenschappelijke veelvoud om de noemers te verwijderen. De verhouding is belangrijk, niet de absolute waarden.

Altijd vereenvoudigen - Een veelgemaakte fout is indices in een onverkleinde vorm te laten staan. (622) en (311) vertegenwoordigen dezelfde vlakfamilie, maar kristallografen gebruiken altijd (311)—de laagste integer set. Denk eraan zoals breuken reduceren: deel altijd door de grootste gemeenschappelijke deler.

Hoe deze Calculator te Gebruiken

Het gebruik van de calculator is eenvoudig:

Voer uw intercepts in - Geef aan waar het vlak de x-, y- en z-assen kruist
- Positieve getallen voor intercepts aan de positieve kant
- Negatieve getallen voor intercepts aan de negatieve kant
- Nul of oneindig voor vlakken parallel aan een as
Ontvang directe resultaten - De calculator berekent de Miller-indices automatisch
Bekijk de visualisatie - Een 3D-weergave toont de oriëntatie van uw vlak in het kristalrooster
Kopieer voor uw werk - Verplaats de resultaten direct naar uw analysesoftware of notities

Uitgewerkt Voorbeeld

Laten we een concreet geval doorlopen. Stel dat u een vlak hebt dat intercepteert:

x-as bij 2
y-as bij 3
z-as bij 6

Hier is de berekening:

Begin met intercepts: (2, 3, 6)
Neem reciproken: (1/2, 1/3, 1/6)
Verwijder breuken door te vermenigvuldigen met LCM(2,3,6) = 6: (3, 2, 1)
Controleer of reduceerbaar: GCD(3,2,1) = 1, dus we zijn klaar

Resultaat: (321) vlak

Dit is een veelvoorkomend voorbeeld omdat het het volledige proces demonstreert. In de praktijk zult u vaak eenvoudigere gevallen tegenkomen zoals (100) of (110) vlakken, die belangrijke kristalvlakken vertegenwoordigen.

Praktische Toepassingen van Miller-indices

Miller-indices komen voor in meerdere vakgebieden waar kristalstructuur belangrijk is. Hier zijn de meest voorkomende toepassingen:

Röntgendiffractie-analyse

Wanneer je röntgendiffractie (XRD) patronen analyseert, zijn Miller-indices onmisbaar. Elke diffractietop correspondeert met een specifieke set kristalvlakken. De relatie tussen vlakafstand en diffractiehoeken volgt Bragg's wet:

$n\lambda = 2d_{hkl}\sin\theta$

Waarbij $d_{hkl}$ de afstand tussen vlakken met indices (h,k,l) is, $\lambda$ de röntgengolflengte, en $\theta$ de diffractiehoek.

In praktische XRD-werkzaamheden zul je vaak diffractietoppen moeten indexeren—waargenomen toppen koppelen aan specifieke (hkl) vlakken. Dit proces is fundamenteel voor het identificeren van onbekende kristallijne materialen of het bevestigen van kristalstructuur na synthese.

Materiaaltechniek

Oppervlakte-eigenschappen - Verschillende kristalvlakken tonen verschillende atomaire arrangementen, wat betekent dat ze verschillende oppervlakte-energieën hebben. Het (111) vlak van een FCC-metaal heeft bijvoorbeeld een lagere oppervlakte-energie dan (100) of (110) vlakken. Dit is enorm belangrijk in katalyse, waar reactiesnelheden afhangen van welke kristalvlakken blootgesteld zijn.

Mechanisch gedrag - Metalen vervormen langs specifieke kristallografische glijsystemen. In FCC-metalen zoals aluminium vindt glijding plaats op {111} vlakken in <110> richtingen. Inzicht in welke vlakken actief zijn tijdens vervorming helpt bij het voorspellen van materiaalgedrag onder stress.

Halfgeleider fabricage - Siliciumwafers worden langs specifieke kristallografische vlakken gesneden, meestal (100) of (111). De keuze beïnvloedt epitaxiale groeisnelheden, dopinggedrag en apparaatprestaties. Volgens IEEE-standaarden voor halfgeleiderkristallen domineert de (100) oriëntatie moderne CMOS-fabricage.

Textuuranalyse - Wanneer metalen worden gewalst, gesmeed of getrokken, ontwikkelen korrels voorkeursoriëntaties (textuur). Het beschrijven van deze textuur vereist Miller-indices om aan te geven welke vlakken zich richten naar verwerkingsrichtingen. Deze textuur beïnvloedt direct eigenschappen zoals magnetisch gedrag in elektrische staalsoorten en rekbaarheid in aluminiumplaten.

Mineralogie

Geologen beschrijven mineraal kristalvlakken met Miller-indices. Wanneer je een kwartskristal bekijkt, corresponderen die platte vlakken met specifieke (hkl) vlakken. Splijting—hoe mineralen langs bepaalde vlakken breken—wordt ook beschreven met deze notatie. De perfecte {100} splijting van haliet (keukenzout) of de {111} splijting van fluoriet zijn klassieke voorbeelden.

Alternatieve Notatiesystemen

Hoewel Miller-indices de kristallografie domineren, zul je af en toe alternatieve notaties tegenkomen:

Miller-Bravais indices - Voor hexagonale kristallen is dit een vier-index systeem (hkil) waarbij i=-(h+k), wat de hexagonale symmetrie beter vangt. Je zult dit tegenkomen in werk over zink, magnesium en veel halfgeleiders zoals GaN. De redundante vierde index maakt het gemakkelijker om equivalente vlakken te herkennen—iets wat niet voor de hand liggend is in de drie-index notatie voor hexagonale systemen.

Weber-symbolen en Naumann-notatie - Deze verschijnen voornamelijk in oudere mineralogische literatuur. De meeste moderne werken zijn overgestapt op Miller-indices, maar je kunt deze tegenkomen bij het lezen van historische papers.

Directe roostervectoren - Sommig theoretisch werk beschrijft vlakken met behulp van directe roostervectoren in plaats van Miller-indices. Deze benadering is gebruikelijk in computationele materiaalkunde waar je rechtstreeks werkt met atomaire coördinaten.

Ondanks deze alternatieven blijven Miller-indices de lingua franca van de kristallografie omdat ze werken voor alle zeven kristalsystemen en een intuïtief raamwerk bieden voor de meeste toepassingen.

Historische Ontwikkeling

William Hallowes Miller, een Britse mineraloog, introduceerde deze notatiesystematiek in 1839 in zijn "Verhandeling over Kristallografie". Het interessante is dat Miller het idee van het indexeren van kristalvlakken niet uitvond—eerdere systemen zoals Weiss-parameters bestonden al. Millers doorbraak was het gebruik van reciproque intercepten, wat elegant omging met parallelle vlakken (waar intercepten oneindig zijn) en vele berekeningen vereenvoudigde.

De werkelijke waarde van het systeem werd duidelijk met Max von Laues ontdekking van röntgendiffractie in 1912. William Henry Bragg en William Lawrence Bragg (vader en zoon) herkenden onmiddellijk hoe Miller-indices perfect de vlakken beschreven die verantwoordelijk waren voor diffractiepieken. Hun werk uit 1913 over kristalstructuurbepaling bevestigde Miller-indices als essentiële instrumenten.

Gedurende de 20e eeuw, terwijl röntgenkristallografie zich uitbreidde van mineralogie naar metallurgie, vaste-stoffysica en uiteindelijk proteïnekristallografie, gingen Miller-indices mee. Tegenwoordig zijn ze onmisbaar in vakgebieden die Miller nooit had kunnen vermoeden—van het analyseren van halfgeleider-heterostructuren tot het ontwerpen van nanodeeltjescatalysatoren.

Implementatievoorbeelden

Als u Miller-indices programmatisch moet berekenen—bijvoorbeeld bij het verwerken van grote datasets of het bouwen van analysepijplijnen—hier zijn implementaties in verschillende talen. Elke implementatie behandelt de belangrijkste uitdagingen: het nemen van reciproken, het wissen van breuken en het reduceren tot de laagste termen.

Python-implementatie

1import math
2import numpy as np
3
4def calculate_miller_indices(intercepts):
5    """
6    Bereken Miller-indices uit intercepties
7    
8    Args:
9        intercepts: Lijst van drie intercepties [a, b, c]
10        
11    Returns:
12        Lijst van drie Miller-indices [h, k, l]
13    """
14    # Behandel oneindige intercepties (parallel aan as)
15    reciprocals = []
16    for intercept in intercepts:
17        if intercept == 0 or math.isinf(intercept):
18            reciprocals.append(0)
19        else:
20            reciprocals.append(1 / intercept)
21    
22    # Vind niet-nul waarden voor GCD-berekening
23    non_zero = [r for r in reciprocals if r != 0]
24    
25    if not non_zero:
26        return [0, 0, 0]
27    
28    # Schaal naar redelijke integers (vermijd drijvendekomma-problemen)
29    scale = 1000
30    scaled = [round(r * scale) for r in non_zero]
31    
32    # Vind GCD
33    gcd_value = np.gcd.reduce(scaled)
34    
35    # Converteer terug naar kleinste integers
36    miller_indices = []
37    for r in reciprocals:
38        if r == 0:
39            miller_indices.append(0)
40        else:
41            miller_indices.append(round((r * scale) / gcd_value))
42    
43    return miller_indices
44
45# Voorbeeldgebruik
46intercepts = [2, 3, 6]
47indices = calculate_miller_indices(intercepts)
48print(f"Miller-indices voor intercepties {intercepts}: {indices}")  # Uitvoer: [3, 2, 1]
49

JavaScript-implementatie

1function gcd(a, b) {
2  a = Math.abs(a);
3  b = Math.abs(b);
4  
5  while (b !== 0) {
6    const temp = b;
7    b = a % b;
8    a = temp;
9  }
10  
11  return a;
12}
13
14function gcdMultiple(numbers) {
15  return numbers.reduce((result, num) => gcd(result, num), numbers[0]);
16}
17
18function calculateMillerIndices(intercepts) {
19  // Behandel oneindige intercepties
20  const reciprocals = intercepts.map(intercept => {
21    if (intercept === 0 || !isFinite(intercept)) {
22      return 0;
23    }
24    return 1 / intercept;
25  });
26  
27  // Vind niet-nul waarden voor GCD-berekening
28  const nonZeroReciprocals = reciprocals.filter(val => val !== 0);
29  
30  if (nonZeroReciprocals.length === 0) {
31    return [0, 0, 0];
32  }
33  
34  // Schaal naar integers om drijvendekomma-problemen te vermijden
35  const scale = 1000;
36  const scaled = nonZeroReciprocals.map(val => Math.round(val * scale));
37  
38  // Vind GCD
39  const divisor = gcdMultiple(scaled);
40  
41  // Converteer naar kleinste integers
42  const millerIndices = reciprocals.map(val => 
43    val === 0 ? 0 : Math.round((val * scale) / divisor)
44  );
45  
46  return millerIndices;
47}
48
49// Voorbeeld
50const intercepts = [2, 3, 6];
51const indices = calculateMillerIndices(intercepts);
52console.log(`Miller-indices voor intercepties ${intercepts}: (${indices.join(',')})`);
53// Uitvoer: Miller-indices voor intercepties 2,3,6: (3,2,1)
54

Java-implementatie

1import java.util.Arrays;
2
3public class MillerIndicesCalculator {
4    
5    public static int gcd(int a, int b) {
6        a = Math.abs(a);
7        b = Math.abs(b);
8        
9        while (b != 0) {
10            int temp = b;
11            b = a % b;
12            a = temp;
13        }
14        
15        return a;
16    }
17    
18    public static int gcdMultiple(int[] numbers) {
19        int result = numbers[0];
20        for (int i = 1; i < numbers.length; i++) {
21            result = gcd(result, numbers[i]);
22        }
23        return result;
24    }
25    
26    public static int[] calculateMillerIndices(double[] intercepts) {
27        double[] reciprocals = new double[intercepts.length];
28        
29        // Bereken reciproken
30        for (int i = 0; i < intercepts.length; i++) {
31            if (intercepts[i] == 0 || Double.isInfinite(intercepts[i])) {
32                reciprocals[i] = 0;
33            } else {
34                reciprocals[i] = 1 / intercepts[i];
35            }
36        }
37        
38        // Tel niet-nul waarden
39        int nonZeroCount = 0;
40        for (double r : reciprocals) {
41            if (r != 0) nonZeroCount++;
42        }
43        
44        if (nonZeroCount == 0) {
45            return new int[]{0, 0, 0};
46        }
47        
48        // Schaal naar integers
49        int scale = 1000;
50        int[] scaled = new int[nonZeroCount];
51        int index = 0;
52        
53        for (double r : reciprocals) {
54            if (r != 0) {
55                scaled[index++] = (int) Math.round(r * scale);
56            }
57        }
58        
59        // Vind GCD
60        int divisor = gcdMultiple(scaled);
61        
62        // Converteer naar kleinste integers
63        int[] millerIndices = new int[reciprocals.length];
64        for (int i = 0; i < reciprocals.length; i++) {
65            if (reciprocals[i] == 0) {
66                millerIndices[i] = 0;
67            } else {
68                millerIndices[i] = (int) Math.round((reciprocals[i] * scale) / divisor);
69            }
70        }
71        
72        return millerIndices;
73    }
74    
75    public static void main(String[] args) {
76        double[] intercepts = {2, 3, 6};
77        int[] indices = calculateMillerIndices(intercepts);
78        
79        System.out.println("Miller-indices voor intercepties " + 
80                           Arrays.toString(intercepts) + ": " + 
81                           Arrays.toString(indices));
82        // Uitvoer: Miller-indices voor intercepties [2.0, 3.0, 6.0]: [3, 2, 1]
83    }
84}
85

Excel VBA-implementatie

1' Excel VBA-functie voor Miller-indices berekening
2Function CalculateMillerIndices(x As Double, y As Double, z As Double) As String
3    Dim recipX As Double, recipY As Double, recipZ As Double
4    Dim nonZeroCount As Integer, i As Integer
5    Dim scale As Long, gcdVal As Long
6    Dim scaledVals() As Long
7    Dim millerH As Long, millerK As Long, millerL As Long
8    
9    ' Bereken reciproken
10    If x = 0 Then
11        recipX = 0
12    Else
13        recipX = 1 / x
14    End If
15    
16    If y = 0 Then
17        recipY = 0
18    Else
19        recipY = 1 / y
20    End If
21    
22    If z = 0 Then
23        recipZ = 0
24    Else
25        recipZ = 1 / z
26    End If
27    
28    ' Tel niet-nul waarden
29    nonZeroCount = 0
30    If recipX <> 0 Then nonZeroCount = nonZeroCount + 1
31    If recipY <> 0 Then nonZeroCount = nonZeroCount + 1
32    If recipZ <> 0 Then nonZeroCount = nonZeroCount + 1
33    
34    If nonZeroCount = 0 Then
35        CalculateMillerIndices = "(0,0,0)"
36        Exit Function
37    End If
38    
39    ' Schaal naar integers
40    scale = 1000
41    ReDim scaledVals(1 To nonZeroCount)
42    i = 1
43    
44    If recipX <> 0 Then
45        scaledVals(i) = Round(recipX * scale)
46        i = i + 1
47    End If
48    
49    If recipY <> 0 Then
50        scaledVals(i) = Round(recipY * scale)
51        i = i + 1
52    End If
53    
54    If recipZ <> 0 Then
55        scaledVals(i) = Round(recipZ * scale)
56    End If
57    
58    ' Vind GCD
59    gcdVal = scaledVals(1)
60    For i = 2 To nonZeroCount
61        gcdVal = GCD(gcdVal, scaledVals(i))
62    Next i
63    
64    ' Bereken Miller-indices
65    If recipX = 0 Then
66        millerH = 0
67    Else
68        millerH = Round((recipX * scale) / gcdVal)
69    End If
70    
71    If recipY = 0 Then
72        millerK = 0
73    Else
74        millerK = Round((recipY * scale) / gcdVal)
75    End If
76    
77    If recipZ = 0 Then
78        millerL = 0
79    Else
80        millerL = Round((recipZ * scale) / gcdVal)
81    End If
82    
83    CalculateMillerIndices = "(" & millerH & "," & millerK & "," & millerL & ")"
84End Function
85
86Function GCD(a As Long, b As Long) As Long
87    Dim temp As Long
88    
89    a = Abs(a)
90    b = Abs(b)
91    
92    Do While b <> 0
93        temp = b
94        b = a Mod b
95        a = temp
96    Loop
97    
98    GCD = a
99End Function
100
101' Gebruik in Excel:
102' =CalculateMillerIndices(2, 3, 6)
103' Resultaat: (3,2,1)
104

C++-implementatie

1#include <iostream>
2#include <vector>
3#include <cmath>
4#include <numeric>
5#include <algorithm>
6
7// Bereken GCD van twee getallen
8int gcd(int a, int b) {
9    a = std::abs(a);
10    b = std::abs(b);
11    
12    while (b != 0) {
13        int temp = b;
14        b = a % b;
15        a = temp;
16    }
17    
18    return a;
19}
20
21// Bereken GCD van meerdere getallen
22int gcdMultiple(const std::vector<int>& numbers) {
23    int result = numbers[0];
24    for (size_t i = 1; i < numbers.size(); ++i) {
25        result = gcd(result, numbers[i]);
26    }
27    return result;
28}
29
30// Bereken Miller-indices uit intercepties
31std::vector<int> calculateMillerIndices(const std::vector<double>& intercepts) {
32    std::vector<double> reciprocals;
33    
34    // Bereken reciproken
35    for (double intercept : intercepts) {
36        if (intercept == 0 || std::isinf(intercept)) {
37            reciprocals.push_back(0);
38        } else {
39            reciprocals.push_back(1.0 / intercept);
40        }
41    }
42    
43    // Vind niet-nul waarden
44    std::vector<double> nonZeroReciprocals;
45    for (double r : reciprocals) {
46        if (r != 0) {
47            nonZeroReciprocals.push_back(r);
48        }
49    }
50    
51    if (nonZeroReciprocals.empty()) {
52        return {0, 0, 0};
53    }
54    
55    // Schaal naar integers
56    const int scale = 1000;
57    std::vector<int> scaled;
58    for (double r : nonZeroReciprocals) {
59        scaled.push_back(std::round(r * scale));
60    }
61    
62    // Vind GCD
63    int divisor = gcdMultiple(scaled);
64    
65    // Converteer naar kleinste integers
66    std::vector<int> millerIndices;
67    for (double r : reciprocals) {
68        if (r == 0) {
69            millerIndices.push_back(0);
70        } else {
71            millerIndices.push_back(std::round((r * scale) / divisor));
72        }
73    }
74    
75    return millerIndices;
76}
77
78int main() {
79    std::vector<double> intercepts = {2, 3, 6};
80    std::vector<int> indices = calculateMillerIndices(intercepts);
81    
82    std::cout << "Miller-indices voor intercepties [";
83    for (size_t i = 0; i < intercepts.size(); ++i) {
84        std::cout << intercepts[i];
85        if (i < intercepts.size() - 1) std::cout << ", ";
86    }
87    std::cout << "]: (";
88    
89    for (size_t i = 0; i < indices.size(); ++i) {
90        std::cout << indices[i];
91        if (i < indices.size() - 1) std::cout << ",";
92    }
93    std::cout << ")" << std::endl;
94    
95    // Uitvoer: Miller-indices voor intercepties [2, 3, 6]: (3,2,1)
96    
97    return 0;
98}
99

Oefenproblemen en Oplossingen

Het doorwerken van voorbeelden helpt het berekeningsproces te verduidelijken:

Geval 1: Standaardberekening

Intercepties: (2, 3, 6) → Reciproken: (1/2, 1/3, 1/6) → Breuken wissen (×6): (3, 2, 1)
Resultaat: (321)

Geval 2: Vlak parallel aan een as

Intercepties: (1, ∞, 2) → Reciproken: (1, 0, 1/2) → Breuken wissen (×2): (2, 0, 1)
Resultaat: (201) - Die nul geeft aan dat het vlak nooit de y-as kruist

Geval 3: Negatieve interceptie

Intercepties: (-1, 2, 3) → Reciproken: (-1, 1/2, 1/3) → Breuken wissen (×6): (-6, 3, 2)
Resultaat: (-6,3,2) of kristallografisch geschreven als (6̄32)

Geval 4: Gedeeltelijke intercepties

Intercepties: (1/2, 1/3, 1/4) → Reciproken: (2, 3, 4) → Al gehele getallen
Resultaat: (234) - Wanneer intercepties breuken zijn, komen reciproken vaak schoon uit

Geval 5: Primair kubisch vlak

Intercepties: (1, ∞, ∞) → Reciproken: (1, 0, 0)
Resultaat: (100) - Een van de zes primaire vlakken van een kubisch kristal

Veelgestelde vragen

Waarvoor worden Miller-indices gebruikt?

Miller-indices identificeren specifieke vlakken in kristalroosters. Je zult ze voortdurend gebruiken bij röntgendiffractie-analyse (indexeren van pieken), materiaaltechniek (beschrijven van glijvlakken en splijting), halfgeleiderproductie (specificeren van waferorientaties) en mineralogie (karakteriseren van kristalvlakken). Ze zijn de standaardtaal voor het bespreken van kristallografische vlakken in al deze vakgebieden.

Hoe ga ik om met vlakken parallel aan een as?

Wanneer een vlak parallel loopt aan een as en deze nooit doorsnijdt, is die interceptie bij oneindig. Omdat 1/∞ = 0, is de bijbehorende Miller-index nul. Een vlak parallel aan de y-as krijgt een nul in de middelste positie: (h,0,l). Dit is een van de elegante eigenschappen van Miller's notatie—het behandelt dit grensgeval op een natuurlijke manier.

Wat betekenen negatieve indices?

Negatieve indices betekenen dat het vlak die as doorsnijdt aan de negatieve kant van de oorsprong. Kristallografen schrijven dit met een streep boven het getal: (h̄kl). In termen van fysische eigenschappen zijn (321) en (3̄2̄1̄) vlakken equivalent—het zijn parallelle vlakken aan tegenovergestelde kanten van de oorsprong. Het onderscheid is voornamelijk van belang wanneer je een specifiek kristalvlak beschrijft of oriëntatierelaties analyseert.

Hoe verhouden Miller-indices zich tot kristalstructuur?

Miller-indices beschrijven sets van parallelle vlakken die door het kristalrooster snijden. De afstand tussen deze vlakken (d-spacing) hangt af van zowel de indices als de kristalroosterparameters. Hogere indices betekenen meer dicht bij elkaar gelegen vlakken. Bij röntgendiffractie fungeren vlakken met specifieke (hkl) waarden als spiegels voor röntgenstralen, en de d-spacing bepaalt de diffractiehoek volgens de wet van Bragg. Deze connectie is de reden waarom het indexeren van diffractiepatronen—het toewijzen van (hkl) waarden aan waargenomen pieken—fundamenteel is voor structuurbepaling.

Wat is het verschil tussen Miller- en Miller-Bravais-indices?

Miller-indices (hkl) werken voor alle kristalsystemen, maar hexagonale kristallen vormen een speciale uitdaging. In hexagonale systemen hebben kristallografisch equivalente vlakken geen duidelijk vergelijkbare Miller-indices. Miller-Bravais-indices (hkil) voegen een redundante vierde index toe waarbij i = -(h+k). Dit maakt de hexagonale symmetrie expliciet—equivalente vlakken hebben vergelijkbare indices. Je zult dit voornamelijk tegenkomen bij hexagonale metalen (Mg, Zn, Ti) of wurtzite halfgeleiders (GaN, ZnO).

Hoe bereken ik hoeken tussen kristalvlakken?

Voor kubische kristallen is de hoek θ tussen vlakken (h₁k₁l₁) en (h₂k₂l₂):

$\cos\theta = \frac{h_1h_2 + k_1k_2 + l_1l_2}{\sqrt{(h_1^2 + k_1^2 + l_1^2)(h_2^2 + k_2^2 + l_2^2)}}$

Dit is in wezen een inproduct van de normaalvectoren. Voor niet-kubische systemen (orthorombisch, tetragonaal, etc.) heb je de metrische tensor nodig, die rekening houdt met niet-loodrechte assen of ongelijke roosterparameters. De meeste kristallografiesoftware voert deze berekeningen automatisch uit.

Hoe hangt d-spacing samen met Miller-indices?

De d-spacing—de loodrechte afstand tussen aangrenzende parallelle vlakken—neemt af naarmate de indices toenemen. Voor kubische kristallen met roosterparameter a:

$d_{hkl} = \frac{a}{\sqrt{h^2 + k^2 + l^2}}$

Deze eenvoudige formule is de reden waarom kubische systemen handig zijn voor onderwijs. Voor andere kristalsystemen incorporeert de formule aanvullende roosterparameters (b, c en hoeken α, β, γ). De Internationale Tabellen voor Kristallografie bieden formules voor alle zeven kristalsystemen.

Kunnen Miller-indices breuken zijn?

Nee, altijd gehele getallen volgens conventie. Als uw berekening breuken oplevert zoals (3/2, 1, 1/2), vermenigvuldig dan alles met de LCM van de noemer om (3, 2, 1) te krijgen. De eis van gehele getallen houdt de notatie gestandaardiseerd—iedereen beschrijft hetzelfde vlak op dezelfde manier.

Hoe bepaal ik Miller-indices experimenteel?

Voor grote enkele kristallen meet optische goniometrie de hoeken tussen kristalvlakken, die kunnen worden omgezet naar Miller-indices. Gebruikelijker is röntgen- of elektronendiffractie. Het diffractiepatroon toont stippen of pieken onder specifieke hoeken, elk overeenkomend met een set roostervlakken. Door deze hoeken te meten en de wet van Bragg toe te passen, kunt u (hkl) waarden toewijzen aan elke reflectie—een proces dat indexeren wordt genoemd. Moderne diffractometers met software automatiseren het meeste hiervan, maar het begrijpen van de onderliggende geometrie blijft belangrijk.

Wat zijn de meest voorkomende Miller-indices?

In kubische kristallen kom je vaak tegen:

(100), (010), (001) - De zes kubusoppervlakken
(110), (101), (011) - Diagonale vlakken die twee assen doorsnijden
(111) - Het octaëdrische vlak, dat alle drie assen gelijkmatig doorsnijdt
(112) - Veel voorkomend glijvlak in BCC-metalen zoals ijzer

Deze laag-index vlakken hebben de grootste d-spacing en laagste oppervlakte-energie, waardoor ze de meest waargenomen kristalvlakken en voorkeurglijvlakken zijn.

Werkt dit voor alle zeven kristalsystemen?

Ja. Miller-indices notatie is universeel toepasbaar op kubische, tetragonale, orthorombische, hexagonale, trigonale, monokliene en trikliene systemen. Het berekeningsproces (intercepties → reciproken → gehele getallen) blijft hetzelfde ongeacht het kristalsysteem. Hexagonale systemen gebruiken echter vaak de vier-index Miller-Bravais notatie voor duidelijkheid.

Wat is de nauwkeurigheid van de berekening?

De calculator gebruikt exacte gehele-getallen-rekenkunde na conversie van zwevendekommagetallen, waardoor de resultaten wiskundig precies zijn. De belangrijkste bron van onzekerheid is meestal het bepalen van de intercepties zelf—vooral bij het meten van experimentele gegevens of kristalstructuurmodellen. Het algoritme behandelt alle grensgevallen: parallelle vlakken, negatieve intercepties en gedeeltelijke intercepties.

Referenties

Miller, W. H. (1839). Een verhandeling over kristallografie. Cambridge: Voor J. & J.J. Deighton.
Ashcroft, N. W., & Mermin, N. D. (1976). Vaste stof natuurkunde. Holt, Rinehart and Winston.
Hammond, C. (2015). De basis van kristallografie en diffractie (4e ed.). Oxford University Press.
Cullity, B. D., & Stock, S. R. (2014). Elementen van röntgendiffractie (3e ed.). Pearson Education.
Kittel, C. (2004). Inleiding tot vaste stof natuurkunde (8e ed.). Wiley.
Kelly, A., & Knowles, K. M. (2012). Kristallografie en kristaldefecten (2e ed.). Wiley.
Internationale Unie van Kristallografie. (2016). Internationale tabellen voor kristallografie, Volume A: Ruimtegroep symmetrie. Wiley.
Giacovazzo, C., Monaco, H. L., Artioli, G., Viterbo, D., Ferraris, G., Gilli, G., Zanotti, G., & Catti, M. (2011). Fundamenten van kristallografie (3e ed.). Oxford University Press.
Buerger, M. J. (1978). Elementaire kristallografie: Een inleiding tot de fundamentele geometrische eigenschappen van kristallen. MIT Press.
Tilley, R. J. (2006). Kristallen en kristalstructuren. Wiley.

Snelle Referentie Samenvatting

Miller-indices (hkl) bieden een gestandaardiseerde manier om kristalvlakken te identificeren met behulp van drie getallen die zijn afgeleid van de reciproken van de interceptpunten van het vlak. De notatie werkt voor alle kristalsystemen en is sinds 1839 de standaard in de kristallografie.

Of je nu diffractiepatronen indexeert, glijsystemen in metalen beschrijft, halfgeleiderwaferorientaties specificeert of mineraalsplijtingsvlakken identificeert, Miller-indices zijn het gereedschap dat je zult gebruiken. Deze rekenmachine verzorgt de rekenkunde - het nemen van reciproken, het wissen van breuken en het reduceren tot laagste termen - zodat je je kunt concentreren op het interpreteren van de kristallografische betekenis.