1use crate::types::OrganicInorganic;
12use serde::{Deserialize, Serialize};
13
14#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
24#[serde(rename_all = "snake_case")]
25pub enum FunctionalGroup {
26 Anhydride,
28 Isocyanate,
30 Nitrile,
32 Nitro,
34 Epoxide,
36 SulphonicAcid,
38 Phosphate,
40 Amide,
42 Ester,
44 CarboxylicAcid,
46 Aldehyde,
48 Ketone,
50 Phenol,
52 Thiol,
54 Sulphide,
56 Alcohol,
58 Ether,
60 Amine,
62 Halide,
64 AromaticRing,
66}
67
68impl FunctionalGroup {
69 pub fn label(self) -> &'static str {
71 match self {
72 Self::Anhydride => "Anhydride",
73 Self::Isocyanate => "Isocyanate",
74 Self::Nitrile => "Nitrile",
75 Self::Nitro => "Nitro",
76 Self::Epoxide => "Epoxide",
77 Self::SulphonicAcid => "SulphonicAcid",
78 Self::Phosphate => "Phosphate",
79 Self::Amide => "Amide",
80 Self::Ester => "Ester",
81 Self::CarboxylicAcid => "CarboxylicAcid",
82 Self::Aldehyde => "Aldehyde",
83 Self::Ketone => "Ketone",
84 Self::Phenol => "Phenol",
85 Self::Thiol => "Thiol",
86 Self::Sulphide => "Sulphide",
87 Self::Alcohol => "Alcohol",
88 Self::Ether => "Ether",
89 Self::Amine => "Amine",
90 Self::Halide => "Halide",
91 Self::AromaticRing => "AromaticRing",
92 }
93 }
94}
95
96pub fn classify_organic(smiles: &str) -> OrganicInorganic {
107 if !smiles.chars().any(|c| c == 'C' || c == 'c') {
109 return OrganicInorganic::Inorganic;
110 }
111
112 let normalised = smiles.replace(' ', "");
114 let inorganic_exact: &[&str] = &[
115 "O=C=O", "[O-]C(=O)[O-]", "[O-]C([O-])=O",
118 "[C-]#[O+]", "[C+]#[O-]",
120 "S=C=S", "[C-]#N", "[N+]#[C-]",
123 "C(=O)([O-])[O-]", ];
125 if inorganic_exact.iter().any(|p| normalised == *p) {
126 return OrganicInorganic::Inorganic;
127 }
128
129 let metal_symbols: &[&str] = &[
132 "[Fe]", "[Co]", "[Ni]", "[Cr]", "[Mn]", "[Mo]", "[W]",
133 "[Ti]", "[V]", "[Ru]", "[Rh]", "[Pd]", "[Os]", "[Ir]",
134 "[Pt]", "[Zn]", "[Al]", "[Pb]", "[Sn]", "[Hg]", "[Tl]",
135 ];
136 for metal in metal_symbols {
139 if smiles.contains(metal) {
140 let idx = smiles.find(metal).unwrap_or(usize::MAX);
143 let after = smiles.get(idx + metal.len()..).unwrap_or("");
144 let before = smiles.get(..idx).unwrap_or("");
145 let bonded = after.starts_with('C')
146 || after.starts_with('c')
147 || before.ends_with('C')
148 || before.ends_with('c');
149 if bonded {
150 return OrganicInorganic::Organometallic;
151 }
152 }
153 }
154
155 OrganicInorganic::Organic
156}
157
158pub fn detect_functional_groups(smiles: &str) -> Vec<FunctionalGroup> {
173 let mut groups: Vec<FunctionalGroup> = Vec::new();
174
175 let any = |patterns: &[&str]| -> bool { patterns.iter().any(|p| smiles.contains(p)) };
177
178 let cyclic_anhydride = (1u8..=9).any(|n| {
182 smiles.contains(&format!("O=C{}OC(=O)", n))
183 });
184 if smiles.contains("C(=O)OC(=O)") || cyclic_anhydride {
185 groups.push(FunctionalGroup::Anhydride);
186 }
187
188 if any(&["N=C=O", "O=C=N"]) {
190 groups.push(FunctionalGroup::Isocyanate);
191 }
192
193 if any(&["C#N", "N#C"]) {
195 groups.push(FunctionalGroup::Nitrile);
196 }
197
198 if any(&[
201 "O=[N+]([O-])", "[N+](=O)[O-]", "N(=O)=O",
204 "[N+]([O-])=O",
205 "[N+](=O)([O-])",
206 ]) {
207 groups.push(FunctionalGroup::Nitro);
208 }
209
210 if any(&[
214 "C1CO1", "C1OC1", "[C@@H]1O[C@H]1", "[C@H]1O[C@@H]1",
218 ]) {
219 groups.push(FunctionalGroup::Epoxide);
220 }
221
222 if any(&["S(=O)(=O)O", "S(=O)(=O)[OH]", "S(O)(=O)=O", "[S](=O)(=O)O"]) {
224 groups.push(FunctionalGroup::SulphonicAcid);
225 }
226
227 if smiles.contains('P')
229 && any(&["P(=O)(O)", "P(=O)([O", "P(O)(O)", "P([OH])", "OP(=O)", "P(=O)O"])
230 {
231 groups.push(FunctionalGroup::Phosphate);
232 }
233
234 if any(&[
237 "NC(=O)", "NC(C", "C(N)=O", "C(=O)N", "C(=O)[NH", "[NH]C(=O)", "[NH2]C(=O)",
239 "N)=O", ]) {
241 let has_iso = groups.contains(&FunctionalGroup::Isocyanate);
243 let has_nitrile = groups.contains(&FunctionalGroup::Nitrile);
244 if !has_iso && !has_nitrile {
245 groups.push(FunctionalGroup::Amide);
246 }
247 }
248
249 let has_anhydride = groups.contains(&FunctionalGroup::Anhydride);
252 if !has_anhydride
253 && any(&[
254 "OC(C)=O", "OC(=O)C", "C(=O)OC", "C(=O)Oc", "OC(CC", "OC(c", ])
257 {
258 groups.push(FunctionalGroup::Ester);
259 }
260
261 let has_ester = groups.contains(&FunctionalGroup::Ester);
264 if !has_ester && !has_anhydride {
265 let has_acid_pattern = any(&[
268 "C(=O)O", "C(O)=O", "C(=O)[OH]", ]);
272 if has_acid_pattern {
274 groups.push(FunctionalGroup::CarboxylicAcid);
275 }
276 }
277
278 let has_higher_carbonyl = groups.iter().any(|g| {
282 matches!(
283 g,
284 FunctionalGroup::Amide
285 | FunctionalGroup::Ester
286 | FunctionalGroup::CarboxylicAcid
287 | FunctionalGroup::Anhydride
288 )
289 });
290 if !has_higher_carbonyl {
291 let aldehyde = smiles.ends_with("C=O")
292 || smiles.ends_with("[CH]=O")
293 || smiles.starts_with("O=C") || any(&["[CH]=O", "[CHO]"]);
295 if aldehyde {
296 groups.push(FunctionalGroup::Aldehyde);
297 }
298 }
299
300 if !has_higher_carbonyl {
303 let has_aldehyde = groups.contains(&FunctionalGroup::Aldehyde);
304 if !has_aldehyde
305 && any(&[
306 "C(C)=O", "C(CC)=O", "C(CCC)=O",
308 "C(c)=O", "c(=O)C", "C(=O)C", ])
312 {
313 groups.push(FunctionalGroup::Ketone);
314 }
315 }
316
317 if any(&[
319 "c1ccccc1O", "Oc1ccccc1",
320 "c(O)", "c([OH])", "Oc1cc", "Oc1ccc", "c1cc(O)", "c1ccc(O)",
323 ]) {
324 groups.push(FunctionalGroup::Phenol);
325 }
326
327 if any(&["[SH]", "C[SH]", "c[SH]"])
330 || smiles.ends_with("CS")
331 || smiles.ends_with("cS")
332 {
333 groups.push(FunctionalGroup::Thiol);
334 }
335
336 let has_sulphonic = groups.contains(&FunctionalGroup::SulphonicAcid);
338 let has_thiol = groups.contains(&FunctionalGroup::Thiol);
339 if !has_sulphonic
340 && !has_thiol
341 && smiles.contains('S')
342 && any(&["CSC", "cSC", "CSc", "cSc", "C(S)C"])
343 {
344 groups.push(FunctionalGroup::Sulphide);
345 }
346
347 let has_phenol = groups.contains(&FunctionalGroup::Phenol);
350 let has_acid = groups.contains(&FunctionalGroup::CarboxylicAcid);
351 let has_ester2 = groups.contains(&FunctionalGroup::Ester);
352 let has_anhydride2 = groups.contains(&FunctionalGroup::Anhydride);
353 let has_aldehyde_grp = groups.contains(&FunctionalGroup::Aldehyde);
355 if !has_phenol && !has_acid && !has_ester2 && !has_anhydride2 && !has_aldehyde_grp {
356 let alcohol = any(&["[OH]", "C[OH]"])
357 || smiles.ends_with("CO")
358 || smiles.ends_with("CCO")
359 || smiles.ends_with("O") || any(&["C(O)", "C([OH])"]);
361 if alcohol {
362 groups.push(FunctionalGroup::Alcohol);
363 }
364 }
365
366 let has_epoxide = groups.contains(&FunctionalGroup::Epoxide);
369 let has_ester3 = groups.contains(&FunctionalGroup::Ester);
370 let has_acid2 = groups.contains(&FunctionalGroup::CarboxylicAcid);
371 if !has_epoxide && !has_ester3 && !has_acid2 && !has_anhydride
372 && any(&["COC", "cOC", "COc", "cOc"]) {
373 groups.push(FunctionalGroup::Ether);
374 }
375
376 let has_amide = groups.contains(&FunctionalGroup::Amide);
379 let has_nitrile = groups.contains(&FunctionalGroup::Nitrile);
380 let has_nitro = groups.contains(&FunctionalGroup::Nitro);
381 if smiles.contains('N')
382 && !has_nitrile
383 && !has_nitro
384 {
385 let amine = any(&[
387 "CN", "NC", "[NH2]", "[NH3+]", "[NH]", "cN", "Nc",
388 ]);
389 if amine && (!has_amide || any(&["[NH2]", "[NH3+]", "CN(", "N(C)C"])) {
391 groups.push(FunctionalGroup::Amine);
392 }
393 }
394
395 if any(&[
397 "CF", "CCl", "CBr", "CI",
398 "Fc", "Clc", "Brc", "Ic",
399 "[F]", "[Cl]", "[Br]", "[I]",
400 "c[F]", "c[Cl]", "c[Br]", "c[I]",
401 "CF3", "CCl3", "CHF", "CHCl", "CHBr",
402 ]) {
403 groups.push(FunctionalGroup::Halide);
404 }
405
406 if smiles.chars().any(|c| matches!(c, 'c' | 'n' | 'o' | 's' | 'p')) {
408 groups.push(FunctionalGroup::AromaticRing);
409 }
410
411 groups
412}
413
414#[cfg(test)]
419mod tests {
420 use super::*;
421
422 fn fg(smiles: &str) -> Vec<FunctionalGroup> {
423 detect_functional_groups(smiles)
424 }
425
426 fn has(smiles: &str, g: FunctionalGroup) -> bool {
427 fg(smiles).contains(&g)
428 }
429
430 #[test]
433 fn co2_is_inorganic() {
434 assert_eq!(classify_organic("O=C=O"), OrganicInorganic::Inorganic);
435 }
436
437 #[test]
438 fn water_is_inorganic() {
439 assert_eq!(classify_organic("O"), OrganicInorganic::Inorganic);
440 }
441
442 #[test]
443 fn ethanol_is_organic() {
444 assert_eq!(classify_organic("CCO"), OrganicInorganic::Organic);
445 }
446
447 #[test]
448 fn benzene_is_organic() {
449 assert_eq!(classify_organic("c1ccccc1"), OrganicInorganic::Organic);
450 }
451
452 #[test]
455 fn acetic_acid_detected() {
456 assert!(has("CC(=O)O", FunctionalGroup::CarboxylicAcid));
458 assert!(!has("CC(=O)O", FunctionalGroup::Ester));
459 }
460
461 #[test]
462 fn ethyl_acetate_detected_as_ester() {
463 assert!(has("CCOC(C)=O", FunctionalGroup::Ester));
465 assert!(!has("CCOC(C)=O", FunctionalGroup::CarboxylicAcid));
466 }
467
468 #[test]
469 fn phthalic_anhydride_detected() {
470 let groups = fg("O=C1OC(=O)c2ccccc21");
472 assert!(groups.contains(&FunctionalGroup::Anhydride));
473 assert!(!groups.contains(&FunctionalGroup::Ester));
474 }
475
476 #[test]
477 fn acetaldehyde_detected() {
478 assert!(has("CC=O", FunctionalGroup::Aldehyde));
480 assert!(!has("CC=O", FunctionalGroup::Ketone));
481 }
482
483 #[test]
487 fn acetaldehyde_not_classified_as_alcohol() {
488 assert!(!has("CC=O", FunctionalGroup::Alcohol),
489 "aldehyde SMILES 'CC=O' must not produce Alcohol group");
490 }
491
492 #[test]
493 fn acetone_detected_as_ketone() {
494 assert!(has("CC(C)=O", FunctionalGroup::Ketone));
496 assert!(!has("CC(C)=O", FunctionalGroup::Aldehyde));
497 }
498
499 #[test]
500 fn ethanol_detected_as_alcohol() {
501 assert!(has("CCO", FunctionalGroup::Alcohol));
503 assert!(!has("CCO", FunctionalGroup::Ether));
504 }
505
506 #[test]
507 fn dimethyl_ether_detected() {
508 assert!(has("COC", FunctionalGroup::Ether));
510 assert!(!has("COC", FunctionalGroup::Alcohol));
511 }
512
513 #[test]
514 fn methylamine_detected() {
515 assert!(has("CN", FunctionalGroup::Amine));
517 }
518
519 #[test]
520 fn acetamide_detected() {
521 assert!(has("CC(N)=O", FunctionalGroup::Amide));
523 assert!(!has("CC(N)=O", FunctionalGroup::Ketone));
524 }
525
526 #[test]
527 fn acetonitrile_detected() {
528 assert!(has("CC#N", FunctionalGroup::Nitrile));
530 }
531
532 #[test]
533 fn chloromethane_detected() {
534 assert!(has("CCl", FunctionalGroup::Halide));
536 }
537
538 #[test]
539 fn ethylene_oxide_detected() {
540 assert!(has("C1CO1", FunctionalGroup::Epoxide));
542 }
543
544 #[test]
545 fn benzene_detected_as_aromatic() {
546 assert!(has("c1ccccc1", FunctionalGroup::AromaticRing));
547 }
548
549 #[test]
550 fn phenol_detected() {
551 assert!(has("Oc1ccccc1", FunctionalGroup::Phenol));
553 }
554
555 #[test]
556 fn nitrobenzene_detected() {
557 assert!(has("O=[N+]([O-])c1ccccc1", FunctionalGroup::Nitro));
559 }
560
561 #[test]
562 fn ethanesulfonic_acid_detected() {
563 assert!(has("CCS(=O)(=O)O", FunctionalGroup::SulphonicAcid));
565 }
566
567 #[test]
568 fn dimethyl_sulfide_detected() {
569 assert!(has("CSC", FunctionalGroup::Sulphide));
571 }
572
573 #[test]
574 fn methanethiol_detected() {
575 assert!(has("C[SH]", FunctionalGroup::Thiol));
577 }
578
579 #[test]
580 fn isocyanate_detected() {
581 assert!(has("CN=C=O", FunctionalGroup::Isocyanate));
583 }
584
585 #[test]
586 fn trimethyl_phosphate_detected() {
587 assert!(has("COP(=O)(OC)OC", FunctionalGroup::Phosphate));
589 }
590}