RDKit
Open-source cheminformatics and machine learning.
FingerprintGenerator.h
Go to the documentation of this file.
1//
2// Copyright (C) 2018-2022 Boran Adas and other RDKit contributors
3//
4// @@ All Rights Reserved @@
5// This file is part of the RDKit.
6// The contents are covered by the terms of the BSD license
7// which is included in the file license.txt, found at the root
8// of the RDKit source tree.
9//
10
11#include <RDGeneral/export.h>
12#ifndef RD_FINGERPRINTGEN_H_2018_05
13#define RD_FINGERPRINTGEN_H_2018_05
14
18#include <utility>
19#include <vector>
20#include <memory>
21#include <cstdint>
22
23namespace RDKit {
24class ROMol;
25
27 using atomToBitsType = std::vector<std::vector<std::uint64_t>>;
29 std::map<std::uint64_t,
30 std::vector<std::pair<std::uint32_t, std::uint32_t>>>;
31 using bitPathsType = std::map<std::uint64_t, std::vector<std::vector<int>>>;
32 using atomCountsType = std::vector<unsigned int>;
33
34 // numAtoms long
35 atomToBitsType *atomToBits = nullptr;
36
37 // bitId -> vector of (atomId, radius) for morgan
38 // bitId -> (atom1, atom2) for atom pairs
39 bitInfoMapType *bitInfoMap = nullptr;
40
41 // rdkit fp
42 // maps bitId -> vector of bond paths
43 bitPathsType *bitPaths = nullptr;
44
45 // number of paths that set bits for each atom, must have the same size as
46 // atom count for molecule.
47 atomCountsType *atomCounts = nullptr;
48
50 atomToBitsHolder.reset(new atomToBitsType);
51 atomToBits = atomToBitsHolder.get();
52 }
54 bitInfoMapHolder.reset(new bitInfoMapType);
55 bitInfoMap = bitInfoMapHolder.get();
56 }
58 bitPathsHolder.reset(new bitPathsType);
59 bitPaths = bitPathsHolder.get();
60 }
62 atomCountsHolder.reset(new atomCountsType);
63 atomCounts = atomCountsHolder.get();
64 }
65
66 private:
67 std::unique_ptr<atomToBitsType> atomToBitsHolder;
68 std::unique_ptr<bitInfoMapType> bitInfoMapHolder;
69 std::unique_ptr<bitPathsType> bitPathsHolder;
70 std::unique_ptr<atomCountsType> atomCountsHolder;
71};
72
73/*!
74 \brief Abstract base class that holds molecule independent arguments that are
75 common amongst all fingerprint types and classes inherited from this would
76 hold fingerprint type specific arguments
77
78 */
80 : private boost::noncopyable {
81 public:
82 FingerprintArguments(bool countSimulation,
83 const std::vector<std::uint32_t> countBounds,
84 std::uint32_t fpSize,
85 std::uint32_t numBitsPerFeature = 1,
86 bool includeChirality = false);
89 std::vector<std::uint32_t> d_countBounds;
90 std::uint32_t d_fpSize;
91 std::uint32_t d_numBitsPerFeature;
92
93 /**
94 \brief method that returns information string about the fingerprint specific
95 argument set and the arguments themselves
96
97 \return std::string information string
98 */
99 virtual std::string infoString() const = 0;
100
101 /**
102 \brief method that returns information string about common fingerprinting
103 arguments' values
104
105 \return std::string information string
106 */
107 std::string commonArgumentsString() const;
108
110};
111
112/*!
113 \brief abstract base class that holds atom-environments that will be hashed to
114 generate the fingerprint
115
116 */
117template <typename OutputType>
118class RDKIT_FINGERPRINTS_EXPORT AtomEnvironment : private boost::noncopyable {
119 public:
120 /*!
121 \brief calculates and returns the bit id to be set for this atom-environment
122
123 \param arguments Fingerprinting type specific molecule independent
124 arguments
125 \param atomInvariants Atom-invariants to be used during hashing
126 \param bondInvariants Bond-invariants to be used during hashing
127 \param hashResults if set results will be ready to be modded
128
129 \return OutputType calculated bit id for this environment
130 */
131 virtual OutputType getBitId(FingerprintArguments *arguments,
132 const std::vector<std::uint32_t> *atomInvariants,
133 const std::vector<std::uint32_t> *bondInvariants,
135 const bool hashResults = false,
136 const std::uint64_t fpSize = 0) const = 0;
138 size_t bitId) const = 0;
139
140 virtual ~AtomEnvironment() {}
141};
142
143/*!
144 \brief abstract base class that generates atom-environments from a molecule
145
146 */
147template <typename OutputType>
149 : private boost::noncopyable {
150 public:
151 /*!
152 \brief generate and return all atom-envorinments from a molecule
153
154 \param mol molecule to generate the atom-environments from
155 \param arguments fingerprint type specific molecule independent
156 arguments
157 \param fromAtoms atoms to be used during environment generation,
158 usage of this parameter depends on the implementation of different
159 fingerprint types
160 \param ignoreAtoms atoms to be ignored during environment generation,
161 usage of this parameter depends on the implementation of different
162 fingerprint types
163 \param confId which conformation to use during environment
164 generation, needed for some fingerprint types
165 \param additionalOutput contains pointers for additional outputs of
166 fingerprinting operation, usage depends on implementation of the fingerprint
167 type
168 \param atomInvariants atom invariants to be used during environment
169 generation, in some cases some of the hashing can be done during environment
170 generation so it is also passed here
171 \param bondInvariants bond invariants to be used during environment
172 generation, same as atomInvariants it might be needed
173 \param hashResults if set results will be ready to be modded
174
175 \return std::vector<AtomEnvironment *> atom-environments generated from
176 this molecule
177 */
178 virtual std::vector<AtomEnvironment<OutputType> *> getEnvironments(
179 const ROMol &mol, FingerprintArguments *arguments,
180 const std::vector<std::uint32_t> *fromAtoms = nullptr,
181 const std::vector<std::uint32_t> *ignoreAtoms = nullptr,
182 const int confId = -1, const AdditionalOutput *additionalOutput = nullptr,
183 const std::vector<std::uint32_t> *atomInvariants = nullptr,
184 const std::vector<std::uint32_t> *bondInvariants = nullptr,
185 const bool hashResults = false) const = 0;
186
187 /**
188 \brief method that returns information about this /c AtomEnvironmentGenerator
189 and its arguments if any
190
191 \return std::string information string
192 */
193 virtual std::string infoString() const = 0;
194 /*!
195 \brief Returns the size of the fingerprint based on arguments
196
197 \return OutputType size of the fingerprint
198 */
199 virtual OutputType getResultSize() const = 0;
200
202
204};
205
206/*!
207 \brief abstract base class for atom invariants generators
208
209 */
211 : private boost::noncopyable {
212 public:
213 /*!
214 \brief get atom invariants from a molecule
215
216 \param mol molecule to generate the atom invariants for
217
218 \return std::vector<std::uint32_t> atom invariants generated for the given
219 molecule
220 */
221 virtual std::vector<std::uint32_t> *getAtomInvariants(
222 const ROMol &mol) const = 0;
223
224 /**
225 \brief method that returns information about this /c AtomInvariantsGenerator
226 and its arguments
227
228 \return std::string information string
229 */
230 virtual std::string infoString() const = 0;
231
233 virtual AtomInvariantsGenerator *clone() const = 0;
234};
235
236/*!
237 \brief abstract base class for bond invariants generators
238
239 */
241 : private boost::noncopyable {
242 public:
243 /*!
244 \brief get bond invariants from a molecule
245
246 \param mol molecule to generate the bond invariants for
247
248 \return std::vector<std::uint32_t> bond invariants generated for the given
249 molecule
250 */
251 virtual std::vector<std::uint32_t> *getBondInvariants(
252 const ROMol &mol) const = 0;
253
254 /**
255 \brief method that returns information about this /c BondInvariantsGenerator
256 and its arguments
257
258 \return std::string information string
259 */
260 virtual std::string infoString() const = 0;
261
263 virtual BondInvariantsGenerator *clone() const = 0;
264}; // namespace RDKit
265
266/*!
267 \brief struct that makes calling the fingerprint generation functions easier
268
269 FingerprintFuncArguments doesn't own any of the pointers it stores.
270
271 */
273 const std::vector<std::uint32_t> *fromAtoms = nullptr;
274 const std::vector<std::uint32_t> *ignoreAtoms = nullptr;
275 int confId = -1;
277 const std::vector<std::uint32_t> *customAtomInvariants = nullptr;
278 const std::vector<std::uint32_t> *customBondInvariants = nullptr;
281 const std::vector<std::uint32_t> *fromAtoms_arg,
282 const std::vector<std::uint32_t> *ignoreAtoms_arg, int confId_arg,
283 AdditionalOutput *additionalOutput_arg,
284 const std::vector<std::uint32_t> *customAtomInvariants_arg,
285 const std::vector<std::uint32_t> *customBondInvariants_arg)
286 : fromAtoms(fromAtoms_arg),
287 ignoreAtoms(ignoreAtoms_arg),
288 confId(confId_arg),
289 additionalOutput(additionalOutput_arg),
290 customAtomInvariants(customAtomInvariants_arg),
291 customBondInvariants(customBondInvariants_arg){};
292};
293
294/*!
295 \brief class that generates same fingerprint style for different output
296 formats
297
298 */
299template <typename OutputType>
301 : private boost::noncopyable {
302 FingerprintArguments *dp_fingerprintArguments;
303 AtomEnvironmentGenerator<OutputType> *dp_atomEnvironmentGenerator;
304 AtomInvariantsGenerator *dp_atomInvariantsGenerator;
305 BondInvariantsGenerator *dp_bondInvariantsGenerator;
306 const bool df_ownsAtomInvGenerator;
307 const bool df_ownsBondInvGenerator;
308
309 std::unique_ptr<SparseIntVect<OutputType>> getFingerprintHelper(
310 const ROMol &mol, FingerprintFuncArguments &args,
311 const std::uint64_t fpSize = 0) const;
312
313 public:
315 AtomEnvironmentGenerator<OutputType> *atomEnvironmentGenerator,
316 FingerprintArguments *fingerprintArguments,
317 AtomInvariantsGenerator *atomInvariantsGenerator = nullptr,
318 BondInvariantsGenerator *bondInvariantsGenerator = nullptr,
319 bool ownsAtomInvGenerator = false, bool ownsBondInvGenerator = false);
320
322
323 FingerprintArguments *getOptions() { return dp_fingerprintArguments; };
325 return dp_fingerprintArguments;
326 };
327
328 std::unique_ptr<SparseIntVect<OutputType>> getSparseCountFingerprint(
329 const ROMol &mol, FingerprintFuncArguments &args) const;
330
331 std::unique_ptr<SparseBitVect> getSparseFingerprint(
332 const ROMol &mol, FingerprintFuncArguments &args) const;
333
334 std::unique_ptr<SparseIntVect<std::uint32_t>> getCountFingerprint(
335 const ROMol &mol, FingerprintFuncArguments &args) const;
336
337 std::unique_ptr<ExplicitBitVect> getFingerprint(
338 const ROMol &mol, FingerprintFuncArguments &args) const;
339
341 const ROMol &mol, const std::vector<std::uint32_t> *fromAtoms = nullptr,
342 const std::vector<std::uint32_t> *ignoreAtoms = nullptr, int confId = -1,
343 AdditionalOutput *additionalOutput = nullptr,
344 const std::vector<std::uint32_t> *customAtomInvariants = nullptr,
345 const std::vector<std::uint32_t> *customBondInvariants = nullptr) const {
346 FingerprintFuncArguments ffa(fromAtoms, ignoreAtoms, confId,
347 additionalOutput, customAtomInvariants,
348 customBondInvariants);
349 return getSparseCountFingerprint(mol, ffa).release();
350 };
351
353 const ROMol &mol, const std::vector<std::uint32_t> *fromAtoms = nullptr,
354 const std::vector<std::uint32_t> *ignoreAtoms = nullptr, int confId = -1,
355 AdditionalOutput *additionalOutput = nullptr,
356 const std::vector<std::uint32_t> *customAtomInvariants = nullptr,
357 const std::vector<std::uint32_t> *customBondInvariants = nullptr) const {
358 FingerprintFuncArguments ffa(fromAtoms, ignoreAtoms, confId,
359 additionalOutput, customAtomInvariants,
360 customBondInvariants);
361 return getSparseFingerprint(mol, ffa).release();
362 };
363
365 const ROMol &mol, const std::vector<std::uint32_t> *fromAtoms = nullptr,
366 const std::vector<std::uint32_t> *ignoreAtoms = nullptr, int confId = -1,
367 AdditionalOutput *additionalOutput = nullptr,
368 const std::vector<std::uint32_t> *customAtomInvariants = nullptr,
369 const std::vector<std::uint32_t> *customBondInvariants = nullptr) const {
370 FingerprintFuncArguments ffa(fromAtoms, ignoreAtoms, confId,
371 additionalOutput, customAtomInvariants,
372 customBondInvariants);
373 return getCountFingerprint(mol, ffa).release();
374 };
375
377 const ROMol &mol, const std::vector<std::uint32_t> *fromAtoms = nullptr,
378 const std::vector<std::uint32_t> *ignoreAtoms = nullptr, int confId = -1,
379 AdditionalOutput *additionalOutput = nullptr,
380 const std::vector<std::uint32_t> *customAtomInvariants = nullptr,
381 const std::vector<std::uint32_t> *customBondInvariants = nullptr) const {
382 FingerprintFuncArguments ffa(fromAtoms, ignoreAtoms, confId,
383 additionalOutput, customAtomInvariants,
384 customBondInvariants);
385 return getFingerprint(mol, ffa).release();
386 };
387
388 std::string infoString() const;
389};
390
393 const ROMol &, const std::vector<std::uint32_t> *,
394 const std::vector<std::uint32_t> *, int, AdditionalOutput *,
395 const std::vector<std::uint32_t> *,
396 const std::vector<std::uint32_t> *) const;
399 const ROMol &, const std::vector<std::uint32_t> *,
400 const std::vector<std::uint32_t> *, int, AdditionalOutput *,
401 const std::vector<std::uint32_t> *,
402 const std::vector<std::uint32_t> *) const;
405 const ROMol &, const std::vector<std::uint32_t> *,
406 const std::vector<std::uint32_t> *, int, AdditionalOutput *,
407 const std::vector<std::uint32_t> *,
408 const std::vector<std::uint32_t> *) const;
411 const ROMol &, const std::vector<std::uint32_t> *,
412 const std::vector<std::uint32_t> *, int, AdditionalOutput *,
413 const std::vector<std::uint32_t> *,
414 const std::vector<std::uint32_t> *) const;
417 const ROMol &, const std::vector<std::uint32_t> *,
418 const std::vector<std::uint32_t> *, int, AdditionalOutput *,
419 const std::vector<std::uint32_t> *,
420 const std::vector<std::uint32_t> *) const;
423 const ROMol &, const std::vector<std::uint32_t> *,
424 const std::vector<std::uint32_t> *, int, AdditionalOutput *,
425 const std::vector<std::uint32_t> *,
426 const std::vector<std::uint32_t> *) const;
429 const ROMol &, const std::vector<std::uint32_t> *,
430 const std::vector<std::uint32_t> *, int, AdditionalOutput *,
431 const std::vector<std::uint32_t> *,
432 const std::vector<std::uint32_t> *) const;
435 const ROMol &, const std::vector<std::uint32_t> *,
436 const std::vector<std::uint32_t> *, int, AdditionalOutput *,
437 const std::vector<std::uint32_t> *,
438 const std::vector<std::uint32_t> *) const;
439
441
442//! used to indicate errors for unimplemented fp types in convenience
443//! functions
445 : public std::exception {
446 public:
447 //! construct with an error message
448 UnimplementedFPException(const char *msg) : _msg(msg) {}
449 //! construct with an error message
450 UnimplementedFPException(std::string msg) : _msg(std::move(msg)) {}
451 //! get the error message
452 const char *what() const noexcept override { return _msg.c_str(); }
453 ~UnimplementedFPException() noexcept override = default;
454
455 private:
456 std::string _msg;
457};
458
459// convenience functions, fingerprint generation with default values
460
462 const ROMol &mol, FPType fPType);
463
465 FPType fPType);
466
468 const ROMol &mol, FPType fPType);
469
471 FPType fPType);
472
473RDKIT_FINGERPRINTS_EXPORT std::vector<SparseIntVect<std::uint64_t> *> *
474getSparseCountFPBulk(const std::vector<const ROMol *> molVector, FPType fPType);
475
477 const std::vector<const ROMol *> molVector, FPType fPType);
478
479RDKIT_FINGERPRINTS_EXPORT std::vector<SparseIntVect<std::uint32_t> *>
480 *getCountFPBulk(const std::vector<const ROMol *> molVector, FPType fPType);
481
483 const std::vector<const ROMol *> molVector, FPType fPType);
484
485} // namespace RDKit
486
487#endif
a class for bit vectors that are densely occupied
abstract base class that generates atom-environments from a molecule
virtual std::vector< AtomEnvironment< OutputType > * > getEnvironments(const ROMol &mol, FingerprintArguments *arguments, const std::vector< std::uint32_t > *fromAtoms=nullptr, const std::vector< std::uint32_t > *ignoreAtoms=nullptr, const int confId=-1, const AdditionalOutput *additionalOutput=nullptr, const std::vector< std::uint32_t > *atomInvariants=nullptr, const std::vector< std::uint32_t > *bondInvariants=nullptr, const bool hashResults=false) const =0
generate and return all atom-envorinments from a molecule
const FingerprintArguments * dp_fingerprintArguments
virtual std::string infoString() const =0
method that returns information about this /c AtomEnvironmentGenerator and its arguments if any
virtual OutputType getResultSize() const =0
Returns the size of the fingerprint based on arguments.
abstract base class that holds atom-environments that will be hashed to generate the fingerprint
virtual void updateAdditionalOutput(AdditionalOutput *AdditionalOutput, size_t bitId) const =0
virtual OutputType getBitId(FingerprintArguments *arguments, const std::vector< std::uint32_t > *atomInvariants, const std::vector< std::uint32_t > *bondInvariants, AdditionalOutput *AdditionalOutput, const bool hashResults=false, const std::uint64_t fpSize=0) const =0
calculates and returns the bit id to be set for this atom-environment
abstract base class for atom invariants generators
virtual std::string infoString() const =0
method that returns information about this /c AtomInvariantsGenerator and its arguments
virtual AtomInvariantsGenerator * clone() const =0
virtual std::vector< std::uint32_t > * getAtomInvariants(const ROMol &mol) const =0
get atom invariants from a molecule
abstract base class for bond invariants generators
virtual std::string infoString() const =0
method that returns information about this /c BondInvariantsGenerator and its arguments
virtual BondInvariantsGenerator * clone() const =0
virtual std::vector< std::uint32_t > * getBondInvariants(const ROMol &mol) const =0
get bond invariants from a molecule
Abstract base class that holds molecule independent arguments that are common amongst all fingerprint...
virtual std::string infoString() const =0
method that returns information string about the fingerprint specific argument set and the arguments ...
FingerprintArguments(bool countSimulation, const std::vector< std::uint32_t > countBounds, std::uint32_t fpSize, std::uint32_t numBitsPerFeature=1, bool includeChirality=false)
std::string commonArgumentsString() const
method that returns information string about common fingerprinting arguments' values
std::vector< std::uint32_t > d_countBounds
class that generates same fingerprint style for different output formats
std::unique_ptr< SparseBitVect > getSparseFingerprint(const ROMol &mol, FingerprintFuncArguments &args) const
FingerprintGenerator(AtomEnvironmentGenerator< OutputType > *atomEnvironmentGenerator, FingerprintArguments *fingerprintArguments, AtomInvariantsGenerator *atomInvariantsGenerator=nullptr, BondInvariantsGenerator *bondInvariantsGenerator=nullptr, bool ownsAtomInvGenerator=false, bool ownsBondInvGenerator=false)
std::unique_ptr< ExplicitBitVect > getFingerprint(const ROMol &mol, FingerprintFuncArguments &args) const
std::string infoString() const
std::unique_ptr< SparseIntVect< std::uint32_t > > getCountFingerprint(const ROMol &mol, FingerprintFuncArguments &args) const
std::unique_ptr< SparseIntVect< OutputType > > getSparseCountFingerprint(const ROMol &mol, FingerprintFuncArguments &args) const
SparseIntVect< std::uint32_t > * getCountFingerprint(const ROMol &mol, const std::vector< std::uint32_t > *fromAtoms=nullptr, const std::vector< std::uint32_t > *ignoreAtoms=nullptr, int confId=-1, AdditionalOutput *additionalOutput=nullptr, const std::vector< std::uint32_t > *customAtomInvariants=nullptr, const std::vector< std::uint32_t > *customBondInvariants=nullptr) const
SparseBitVect * getSparseFingerprint(const ROMol &mol, const std::vector< std::uint32_t > *fromAtoms=nullptr, const std::vector< std::uint32_t > *ignoreAtoms=nullptr, int confId=-1, AdditionalOutput *additionalOutput=nullptr, const std::vector< std::uint32_t > *customAtomInvariants=nullptr, const std::vector< std::uint32_t > *customBondInvariants=nullptr) const
ExplicitBitVect * getFingerprint(const ROMol &mol, const std::vector< std::uint32_t > *fromAtoms=nullptr, const std::vector< std::uint32_t > *ignoreAtoms=nullptr, int confId=-1, AdditionalOutput *additionalOutput=nullptr, const std::vector< std::uint32_t > *customAtomInvariants=nullptr, const std::vector< std::uint32_t > *customBondInvariants=nullptr) const
FingerprintArguments * getOptions()
SparseIntVect< OutputType > * getSparseCountFingerprint(const ROMol &mol, const std::vector< std::uint32_t > *fromAtoms=nullptr, const std::vector< std::uint32_t > *ignoreAtoms=nullptr, int confId=-1, AdditionalOutput *additionalOutput=nullptr, const std::vector< std::uint32_t > *customAtomInvariants=nullptr, const std::vector< std::uint32_t > *customBondInvariants=nullptr) const
const FingerprintArguments * getOptions() const
a class for efficiently storing sparse vectors of ints
Definition: SparseIntVect.h:28
UnimplementedFPException(const char *msg)
construct with an error message
~UnimplementedFPException() noexcept override=default
UnimplementedFPException(std::string msg)
construct with an error message
const char * what() const noexcept override
get the error message
a class for bit vectors that are sparsely occupied.
Definition: SparseBitVect.h:34
#define RDKIT_FINGERPRINTS_EXPORT
Definition: export.h:177
RDKIT_FINGERPRINTS_EXPORT SparseIntVect< std::uint32_t > * getFingerprint(const ROMol &mol, unsigned int radius, std::vector< boost::uint32_t > *invariants=nullptr, const std::vector< boost::uint32_t > *fromAtoms=nullptr, bool useChirality=false, bool useBondTypes=true, bool useCounts=true, bool onlyNonzeroInvariants=false, BitInfoMap *atomsSettingBits=nullptr, bool includeRedundantEnvironments=false)
returns the Morgan fingerprint for a molecule
Std stuff.
Definition: Abbreviations.h:19
RDKIT_FINGERPRINTS_EXPORT SparseBitVect * getSparseFP(const ROMol &mol, FPType fPType)
RDKIT_FINGERPRINTS_EXPORT std::vector< SparseBitVect * > * getSparseFPBulk(const std::vector< const ROMol * > molVector, FPType fPType)
RDKIT_FINGERPRINTS_EXPORT std::vector< ExplicitBitVect * > * getFPBulk(const std::vector< const ROMol * > molVector, FPType fPType)
RDKIT_FINGERPRINTS_EXPORT SparseIntVect< std::uint64_t > * getSparseCountFP(const ROMol &mol, FPType fPType)
RDKIT_FINGERPRINTS_EXPORT std::vector< SparseIntVect< std::uint32_t > * > * getCountFPBulk(const std::vector< const ROMol * > molVector, FPType fPType)
RDKIT_FINGERPRINTS_EXPORT std::vector< SparseIntVect< std::uint64_t > * > * getSparseCountFPBulk(const std::vector< const ROMol * > molVector, FPType fPType)
RDKIT_FINGERPRINTS_EXPORT SparseIntVect< std::uint32_t > * getCountFP(const ROMol &mol, FPType fPType)
RDKIT_FINGERPRINTS_EXPORT ExplicitBitVect * getFP(const ROMol &mol, FPType fPType)
std::vector< std::vector< std::uint64_t > > atomToBitsType
std::vector< unsigned int > atomCountsType
std::map< std::uint64_t, std::vector< std::vector< int > > > bitPathsType
std::map< std::uint64_t, std::vector< std::pair< std::uint32_t, std::uint32_t > > > bitInfoMapType
struct that makes calling the fingerprint generation functions easier
const std::vector< std::uint32_t > * customAtomInvariants
const std::vector< std::uint32_t > * customBondInvariants
const std::vector< std::uint32_t > * fromAtoms
const std::vector< std::uint32_t > * ignoreAtoms
FingerprintFuncArguments(const std::vector< std::uint32_t > *fromAtoms_arg, const std::vector< std::uint32_t > *ignoreAtoms_arg, int confId_arg, AdditionalOutput *additionalOutput_arg, const std::vector< std::uint32_t > *customAtomInvariants_arg, const std::vector< std::uint32_t > *customBondInvariants_arg)