RDKit
Open-source cheminformatics and machine learning.
Loading...
Searching...
No Matches
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 public:
81 FingerprintArguments(bool countSimulation,
82 const std::vector<std::uint32_t> countBounds,
83 std::uint32_t fpSize,
84 std::uint32_t numBitsPerFeature = 1,
85 bool includeChirality = false);
86 bool df_countSimulation = false;
87 bool df_includeChirality = false;
88 std::vector<std::uint32_t> d_countBounds;
89 std::uint32_t d_fpSize = 2048;
90 std::uint32_t d_numBitsPerFeature = 1;
91
92 /**
93 \brief method that returns information string about the fingerprint specific
94 argument set and the arguments themselves
95
96 \return std::string information string
97 */
98 virtual std::string infoString() const = 0;
99
100 /**
101 \brief method that returns information string about common fingerprinting
102 arguments' values
103
104 \return std::string information string
105 */
106 std::string commonArgumentsString() const;
107
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,
284 const std::vector<std::uint32_t> *customAtomInvariants_arg,
285 const std::vector<std::uint32_t> *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
340 std::vector<std::unique_ptr<ExplicitBitVect>> getFingerprints(
341 const std::vector<const ROMol *> &mols, int numThreads = 1) const;
342
343 std::vector<std::unique_ptr<SparseBitVect>> getSparseFingerprints(
344 const std::vector<const ROMol *> &mols, int numThreads = 1) const;
345
346 std::vector<std::unique_ptr<SparseIntVect<std::uint32_t>>>
347 getCountFingerprints(const std::vector<const ROMol *> &mols,
348 int numThreads = 1) const;
349
350 std::vector<std::unique_ptr<SparseIntVect<OutputType>>>
351 getSparseCountFingerprints(const std::vector<const ROMol *> &mols,
352 int numThreads = 1) const;
353
355 const ROMol &mol, const std::vector<std::uint32_t> *fromAtoms = nullptr,
356 const std::vector<std::uint32_t> *ignoreAtoms = nullptr, int confId = -1,
357 AdditionalOutput *additionalOutput = nullptr,
358 const std::vector<std::uint32_t> *customAtomInvariants = nullptr,
359 const std::vector<std::uint32_t> *customBondInvariants = nullptr) const {
360 FingerprintFuncArguments ffa(fromAtoms, ignoreAtoms, confId,
361 additionalOutput, customAtomInvariants,
362 customBondInvariants);
363 return getSparseCountFingerprint(mol, ffa).release();
364 };
365
367 const ROMol &mol, const std::vector<std::uint32_t> *fromAtoms = nullptr,
368 const std::vector<std::uint32_t> *ignoreAtoms = nullptr, int confId = -1,
369 AdditionalOutput *additionalOutput = nullptr,
370 const std::vector<std::uint32_t> *customAtomInvariants = nullptr,
371 const std::vector<std::uint32_t> *customBondInvariants = nullptr) const {
372 FingerprintFuncArguments ffa(fromAtoms, ignoreAtoms, confId,
373 additionalOutput, customAtomInvariants,
374 customBondInvariants);
375 return getSparseFingerprint(mol, ffa).release();
376 };
377
379 const ROMol &mol, const std::vector<std::uint32_t> *fromAtoms = nullptr,
380 const std::vector<std::uint32_t> *ignoreAtoms = nullptr, int confId = -1,
381 AdditionalOutput *additionalOutput = nullptr,
382 const std::vector<std::uint32_t> *customAtomInvariants = nullptr,
383 const std::vector<std::uint32_t> *customBondInvariants = nullptr) const {
384 FingerprintFuncArguments ffa(fromAtoms, ignoreAtoms, confId,
385 additionalOutput, customAtomInvariants,
386 customBondInvariants);
387 return getCountFingerprint(mol, ffa).release();
388 };
389
391 const ROMol &mol, const std::vector<std::uint32_t> *fromAtoms = nullptr,
392 const std::vector<std::uint32_t> *ignoreAtoms = nullptr, int confId = -1,
393 AdditionalOutput *additionalOutput = nullptr,
394 const std::vector<std::uint32_t> *customAtomInvariants = nullptr,
395 const std::vector<std::uint32_t> *customBondInvariants = nullptr) const {
396 FingerprintFuncArguments ffa(fromAtoms, ignoreAtoms, confId,
397 additionalOutput, customAtomInvariants,
398 customBondInvariants);
399 return getFingerprint(mol, ffa).release();
400 };
401
402 std::string infoString() const;
403};
404
407 const ROMol &, const std::vector<std::uint32_t> *,
408 const std::vector<std::uint32_t> *, int, AdditionalOutput *,
409 const std::vector<std::uint32_t> *,
410 const std::vector<std::uint32_t> *) const;
413 const ROMol &, const std::vector<std::uint32_t> *,
414 const std::vector<std::uint32_t> *, int, AdditionalOutput *,
415 const std::vector<std::uint32_t> *,
416 const std::vector<std::uint32_t> *) const;
419 const ROMol &, const std::vector<std::uint32_t> *,
420 const std::vector<std::uint32_t> *, int, AdditionalOutput *,
421 const std::vector<std::uint32_t> *,
422 const std::vector<std::uint32_t> *) const;
425 const ROMol &, const std::vector<std::uint32_t> *,
426 const std::vector<std::uint32_t> *, int, AdditionalOutput *,
427 const std::vector<std::uint32_t> *,
428 const std::vector<std::uint32_t> *) const;
431 const ROMol &, const std::vector<std::uint32_t> *,
432 const std::vector<std::uint32_t> *, int, AdditionalOutput *,
433 const std::vector<std::uint32_t> *,
434 const std::vector<std::uint32_t> *) const;
437 const ROMol &, const std::vector<std::uint32_t> *,
438 const std::vector<std::uint32_t> *, int, AdditionalOutput *,
439 const std::vector<std::uint32_t> *,
440 const std::vector<std::uint32_t> *) const;
443 const ROMol &, const std::vector<std::uint32_t> *,
444 const std::vector<std::uint32_t> *, int, AdditionalOutput *,
445 const std::vector<std::uint32_t> *,
446 const std::vector<std::uint32_t> *) const;
449 const ROMol &, const std::vector<std::uint32_t> *,
450 const std::vector<std::uint32_t> *, int, AdditionalOutput *,
451 const std::vector<std::uint32_t> *,
452 const std::vector<std::uint32_t> *) const;
453
455
456//! used to indicate errors for unimplemented fp types in convenience
457//! functions
459 : public std::exception {
460 public:
461 //! construct with an error message
462 UnimplementedFPException(const char *msg) : _msg(msg) {}
463 //! construct with an error message
464 UnimplementedFPException(std::string msg) : _msg(std::move(msg)) {}
465 //! get the error message
466 const char *what() const noexcept override { return _msg.c_str(); }
468
469 private:
470 std::string _msg;
471};
472
473// convenience functions, fingerprint generation with default values
474
476 const ROMol &mol, FPType fPType);
477
479 FPType fPType);
480
482 const ROMol &mol, FPType fPType);
483
485 FPType fPType);
486
489
491 const std::vector<const ROMol *> molVector, FPType fPType);
492
495
497 const std::vector<const ROMol *> molVector, FPType fPType);
498
499} // namespace RDKit
500
501#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::vector< std::unique_ptr< ExplicitBitVect > > getFingerprints(const std::vector< const ROMol * > &mols, int numThreads=1) const
std::vector< std::unique_ptr< SparseIntVect< OutputType > > > getSparseCountFingerprints(const std::vector< const ROMol * > &mols, int numThreads=1) const
std::vector< std::unique_ptr< SparseIntVect< std::uint32_t > > > getCountFingerprints(const std::vector< const ROMol * > &mols, int numThreads=1) const
std::vector< std::unique_ptr< SparseBitVect > > getSparseFingerprints(const std::vector< const ROMol * > &mols, int numThreads=1) 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
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.
#define RDKIT_FINGERPRINTS_EXPORT
Definition export.h:177
Std stuff.
RDKIT_FINGERPRINTS_EXPORT SparseBitVect * getSparseFP(const ROMol &mol, FPType fPType)
bool rdvalue_is(const RDValue_cast_t)
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)