dol 0.8.1

DOL (Design Ontology Language) - A declarative specification language for ontology-first development
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177

// =============================================================================
// Chemistry Spirit - Library Entry Point
// DOL v0.9.0
// =============================================================================

module chemistry @ 0.9.0

docs {
    Chemistry Spirit library entry point.

    This module re-exports all public chemistry modules for convenient access.
    Users can either import the entire chemistry namespace or specific modules.

    Example usage:
        // Import entire chemistry library
        use local::chemistry

        // Or import specific modules
        use local::chemistry::elements
        use local::chemistry::molecules
        use local::chemistry::reactions
}

// ---------------------------------------------------------------------------
// Re-exports from submodules
// ---------------------------------------------------------------------------

use local::elements
use local::molecules
use local::reactions

// ---------------------------------------------------------------------------
// Physical Constants for Chemistry
// ---------------------------------------------------------------------------

docs {
    Avogadro's number (particles/mol).
}

pub const AVOGADRO: f64 = 6.02214076e23

docs {
    Universal gas constant (J/(mol*K)).
}

pub const GAS_CONSTANT: f64 = 8.314462618

docs {
    Boltzmann constant (J/K).
}

pub const BOLTZMANN: f64 = 1.380649e-23

docs {
    Planck's constant (J*s).
}

pub const PLANCK: f64 = 6.62607015e-34

docs {
    Elementary charge (C).
}

pub const ELEMENTARY_CHARGE: f64 = 1.602176634e-19

docs {
    Electron mass (kg).
}

pub const ELECTRON_MASS: f64 = 9.1093837015e-31

docs {
    Atomic mass unit (kg).
}

pub const ATOMIC_MASS_UNIT: f64 = 1.66053906660e-27

docs {
    Bohr radius (m).
}

pub const BOHR_RADIUS: f64 = 5.29177210903e-11

docs {
    Rydberg constant (m^-1).
}

pub const RYDBERG: f64 = 10973731.568160

docs {
    Standard temperature (K).
}

pub const STANDARD_TEMP: f64 = 298.15

docs {
    Standard pressure (Pa).
}

pub const STANDARD_PRESSURE: f64 = 100000.0

docs {
    Faraday constant (C/mol).
}

pub const FARADAY: f64 = 96485.33212

// ---------------------------------------------------------------------------
// Common Energy Conversions
// ---------------------------------------------------------------------------

docs {
    Joules per kilocalorie.
}

pub const J_PER_KCAL: f64 = 4184.0

docs {
    Joules per electron volt.
}

pub const J_PER_EV: f64 = 1.602176634e-19

docs {
    kJ/mol per eV.
}

pub const KJ_PER_MOL_PER_EV: f64 = 96.485

// ---------------------------------------------------------------------------
// Utility Types
// ---------------------------------------------------------------------------

docs {
    Result type for chemistry calculations that may fail.
}

pub gen ChemistryResult<T> {
    has value: Option<T>
    has error: Option<string>
    has warning: Option<string>
}

docs {
    Create a successful chemistry result.
}

pub fun ok<T>(value: T) -> ChemistryResult<T> {
    return ChemistryResult {
        value: Some(value),
        error: None,
        warning: None
    }
}

docs {
    Create an error chemistry result.
}

pub fun err<T>(message: string) -> ChemistryResult<T> {
    return ChemistryResult {
        value: None,
        error: Some(message),
        warning: None
    }
}

docs {
    Check if a chemistry result is successful.
}

pub fun is_ok<T>(result: ChemistryResult<T>) -> bool {
    match result.value {
        Some(_) => true,
        None => false
    }
}