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
|
//
// Copyright (C) 2018-2021 Susan H. Leung and other RDKit contributors
//
// @@ All Rights Reserved @@
// This file is part of the RDKit.
// The contents are covered by the terms of the BSD license
// which is included in the file license.txt, found at the root
// of the RDKit source tree.
//
/*! \file Charge.h
\brief Defines the Reionizer class and Uncharger class.
*/
#include <RDGeneral/export.h>
#ifndef RD_CHARGE_H
#define RD_CHARGE_H
#include <utility>
#include "MolStandardize.h"
#include <Catalogs/Catalog.h>
#include <GraphMol/MolStandardize/AcidBaseCatalog/AcidBaseCatalogEntry.h>
#include <GraphMol/MolStandardize/AcidBaseCatalog/AcidBaseCatalogParams.h>
namespace RDKit {
class RWMol;
class ROMol;
namespace MolStandardize {
RDKIT_MOLSTANDARDIZE_EXPORT extern const CleanupParameters
defaultCleanupParameters;
typedef RDCatalog::HierarchCatalog<AcidBaseCatalogEntry, AcidBaseCatalogParams,
int>
AcidBaseCatalog;
struct RDKIT_MOLSTANDARDIZE_EXPORT ChargeCorrection {
std::string Name;
std::string Smarts;
int Charge;
ChargeCorrection(std::string name, std::string smarts, int charge)
: Name(std::move(name)), Smarts(std::move(smarts)), Charge(charge) {}
};
// The default list of ChargeCorrections.
RDKIT_MOLSTANDARDIZE_EXPORT extern std::vector<ChargeCorrection>
CHARGE_CORRECTIONS;
//! The reionizer class to fix charges and reionize a molecule such that the
/// strongest acids ionize first.
/*!
<b>Notes:</b>
-
*/
class RDKIT_MOLSTANDARDIZE_EXPORT Reionizer {
public:
Reionizer();
//! construct a Reionizer with a particular acidbaseFile
Reionizer(const std::string acidbaseFile);
//! construct a Reionizer with parameter data
Reionizer(const std::vector<std::tuple<std::string, std::string, std::string>>
&data);
//! construct a Reionizer with a particular acidbaseFile and charge
/// corrections
Reionizer(const std::string acidbaseFile,
const std::vector<ChargeCorrection> ccs);
//! construct a Reionizer with a particular acidbaseFile and charge
/// corrections
Reionizer(std::istream &acidbaseStream,
const std::vector<ChargeCorrection> ccs);
//! construct a Reionizer with parameter data and charge corrections
Reionizer(const std::vector<std::tuple<std::string, std::string, std::string>>
&data,
const std::vector<ChargeCorrection> ccs);
//! making Reionizer objects non-copyable
Reionizer(const Reionizer &other) = delete;
Reionizer &operator=(Reionizer const &) = delete;
~Reionizer();
//! Enforce charges on certain atoms, then perform competitive reionization.
ROMol *reionize(const ROMol &mol);
//! Enforce charges on certain atoms, then perform competitive reionization,
//! modifies molecule in place
void reionizeInPlace(RWMol &mol);
private:
AcidBaseCatalog *d_abcat;
std::vector<ChargeCorrection> d_ccs;
std::pair<unsigned int, std::vector<unsigned int>> *strongestProtonated(
const ROMol &mol,
const std::vector<std::pair<ROMOL_SPTR, ROMOL_SPTR>> &abpairs);
std::pair<unsigned int, std::vector<unsigned int>> *weakestIonized(
const ROMol &mol,
const std::vector<std::pair<ROMOL_SPTR, ROMOL_SPTR>> &abpairs);
}; // Reionizer class
// caller owns the returned pointer
inline Reionizer *reionizerFromParams(const CleanupParameters ¶ms) {
if (params.acidbaseData.empty()) {
return new Reionizer(params.acidbaseFile);
} else {
return new Reionizer(params.acidbaseData);
}
}
//! The Uncharger class for neutralizing ionized acids and bases.
/*!
<b>Notes:</b>
- This class uncharges molecules by adding and/or removing hydrogens.
- For zwitterions, hydrogens are moved to eliminate charges where
possible.
- By default, in cases where there is a positive or negative charge
that is not possible to remove, an attempt is made to also preserve the
corresponding amount of opposite charge and result in an overall neutral
output structure.
- When the `force` option is set, all neutralizable sites are
uncharged, also when not-removable charges are present and the resulting
overall charge is therefore not null.
- By default, the removal of the existing charges is performed with
the addition or subtraction of both protons and hydride ions as appropriate.
If the `protonationOnly` option is enabled, the transformations applying to
the input structure are limited to changes in its protonation state and
charges that would otherwise require the exchange of a hydride ion (e.g.,
carbocations) are handled as not-removable.
*/
class RDKIT_MOLSTANDARDIZE_EXPORT Uncharger {
public:
Uncharger();
Uncharger(bool canonicalOrdering) : Uncharger() {
df_canonicalOrdering = canonicalOrdering;
}
Uncharger(bool canonicalOrdering, bool force) : Uncharger() {
df_canonicalOrdering = canonicalOrdering;
df_force = force;
}
Uncharger(bool canonicalOrdering, bool force, bool protonationOnly)
: Uncharger() {
df_canonicalOrdering = canonicalOrdering;
df_force = force;
df_protonationOnly = protonationOnly;
}
Uncharger(const Uncharger &) = default;
~Uncharger() = default;
ROMol *uncharge(const ROMol &mol);
void unchargeInPlace(RWMol &mol);
private:
bool df_canonicalOrdering = true;
bool df_force = false;
bool df_protonationOnly = false;
std::shared_ptr<ROMol> pos_h;
std::shared_ptr<ROMol> pos_noh;
std::shared_ptr<ROMol> neg;
std::shared_ptr<ROMol> neg_acid;
}; // Uncharger class
} // namespace MolStandardize
} // namespace RDKit
#endif
|
