Loading...
Searching...
No Matches
ReactionParser.h
Go to the documentation of this file.
//
// Copyright (c) 2007-2024, Novartis Institutes for BioMedical Research Inc.
// and other RDKit contributors
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Novartis Institutes for BioMedical Research Inc.
// nor the names of its contributors may be used to endorse or promote
// products derived from this software without specific prior written
// permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
#include <RDGeneral/export.h>
#ifndef RD_REACTIONPARSER_H_21Aug2006
#define RD_REACTIONPARSER_H_21Aug2006
#include <string>
#include <fstream>
#include <map>
#include <sstream>
#include <utility>
#include <boost/format.hpp>
#include <RDGeneral/BadFileException.h>
#include <RDGeneral/FileParseException.h>
#include <GraphMol/FileParsers/FileParsers.h>
#include <GraphMol/SmilesParse/SmilesWrite.h>
namespace RDKit {
class ROMol;
class ChemicalReaction;
//! used to indicate an error in parsing reaction data
class RDKIT_CHEMREACTIONS_EXPORT ChemicalReactionParserException
: public std::exception {
public:
//! construct with an error message
explicit ChemicalReactionParserException(const char *msg) : _msg(msg) {}
//! construct with an error message
explicit ChemicalReactionParserException(std::string msg)
: _msg(std::move(msg)) {}
//! get the error message
const char *what() const noexcept override { return _msg.c_str(); }
~ChemicalReactionParserException() noexcept override = default;
private:
std::string _msg;
};
namespace v2 {
namespace ReactionParser {
struct RDKIT_CHEMREACTIONS_EXPORT ReactionSmartsParserParams {
bool sanitize = false; /**< sanitize the molecules after building them */
std::map<std::string, std::string>
replacements; /**< allows SMILES "macros" */
bool allowCXSMILES = true; /**< recognize and parse CXSMILES*/
bool strictCXSMILES =
true; /**< throw an exception if the CXSMILES parsing fails */
};
RDKIT_CHEMREACTIONS_EXPORT std::unique_ptr<ChemicalReaction> ReactionFromSmarts(
const std::string &smarts,
const ReactionSmartsParserParams &params = ReactionSmartsParserParams());
RDKIT_CHEMREACTIONS_EXPORT std::unique_ptr<ChemicalReaction> ReactionFromSmiles(
const std::string &smarts,
const ReactionSmartsParserParams &params = ReactionSmartsParserParams());
} // namespace ReactionParser
} // namespace v2
inline namespace v1 {
//---------------------------------------------------------------------------
//! \name Reaction SMARTS/SMILES Support
//! @{
//! Parse a string containing "Reaction SMARTS" into a ChemicalReaction
/*!
Our definition of Reaction SMARTS is something that looks a lot like reaction
SMILES, except that SMARTS queries are allowed on the reactant side and that
atom-map numbers are required (at least for now)
\param text the SMARTS to convert
\param replacements a string->string map of replacement strings. \see
SmilesToMol for more information about replacements
\param useSmiles if set, the SMILES parser will be used instead of the
SMARTS parserfor the individual components
\param allowCXSMILES if set, any CXSMILES extensions present will be
parsed, otherwise it will be ignored
*/
inline ChemicalReaction *RxnSmartsToChemicalReaction(
const std::string &text,
std::map<std::string, std::string> *replacements = nullptr,
bool useSmiles = false, bool allowCXSMILES = true) {
v2::ReactionParser::ReactionSmartsParserParams params;
if (replacements) {
params.replacements = *replacements;
}
params.allowCXSMILES = allowCXSMILES;
if (useSmiles) {
return v2::ReactionParser::ReactionFromSmiles(text, params).release();
} else {
return v2::ReactionParser::ReactionFromSmarts(text, params).release();
}
}
} // namespace v1
//! returns the reaction SMARTS for a reaction
RDKIT_CHEMREACTIONS_EXPORT std::string ChemicalReactionToRxnSmarts(
const ChemicalReaction &rxn, const SmilesWriteParams &params);
//! \overload
inline std::string ChemicalReactionToRxnSmarts(const ChemicalReaction &rxn) {
SmilesWriteParams params;
params.canonical = false;
return ChemicalReactionToRxnSmarts(rxn, params);
}
//! returns the reaction SMILES for a reaction
RDKIT_CHEMREACTIONS_EXPORT std::string ChemicalReactionToRxnSmiles(
const ChemicalReaction &rxn,
const SmilesWriteParams &params = SmilesWriteParams());
//! \overload
inline std::string ChemicalReactionToRxnSmiles(const ChemicalReaction &rxn,
bool canonical) {
SmilesWriteParams params;
params.canonical = canonical;
return ChemicalReactionToRxnSmiles(rxn, params);
}
//! returns the reaction SMARTS for a reaction with CX extension
RDKIT_CHEMREACTIONS_EXPORT std::string ChemicalReactionToCXRxnSmarts(
const ChemicalReaction &rxn, const SmilesWriteParams &params,
std::uint32_t flags = SmilesWrite::CXSmilesFields::CX_ALL);
//! \overload
inline std::string ChemicalReactionToCXRxnSmarts(const ChemicalReaction &rxn) {
SmilesWriteParams params;
params.canonical = false;
return ChemicalReactionToCXRxnSmarts(rxn, params);
}
//! returns the reaction SMILES for a reaction with CX extension
RDKIT_CHEMREACTIONS_EXPORT std::string ChemicalReactionToCXRxnSmiles(
const ChemicalReaction &rxn, const SmilesWriteParams &params,
std::uint32_t flags = SmilesWrite::CXSmilesFields::CX_ALL);
//! \overload
inline std::string ChemicalReactionToCXRxnSmiles(const ChemicalReaction &rxn,
bool canonical = true) {
SmilesWriteParams params;
params.canonical = canonical;
return ChemicalReactionToCXRxnSmiles(rxn, params);
}
//! @}
//---------------------------------------------------------------------------
//! \name Reaction Mol Support
//! @{
//! Parse a ROMol into a ChemicalReaction, RXN role must be set before
/*!
Alternative to build a reaction from a molecule (fragments) which have RXN
roles set as atom properties: common_properties::molRxnRole (1=reactant,
2=product, 3=agent)
\param mol ROMol with RXN roles set
*/
RDKIT_CHEMREACTIONS_EXPORT ChemicalReaction *RxnMolToChemicalReaction(
const ROMol &mol);
//! returns a ROMol with RXN roles used to describe the reaction
RDKIT_CHEMREACTIONS_EXPORT ROMol *ChemicalReactionToRxnMol(
const ChemicalReaction &rxn);
//! @}
//---------------------------------------------------------------------------
//! \name MDL rxn Support
//! @{
namespace v2 {
namespace ReactionParser {
RDKIT_CHEMREACTIONS_EXPORT std::unique_ptr<ChemicalReaction>
ReactionFromRxnBlock(const std::string &rxnBlock,
const FileParsers::MolFileParserParams &params =
FileParsers::MolFileParserParams());
RDKIT_CHEMREACTIONS_EXPORT std::unique_ptr<ChemicalReaction>
ReactionFromRxnFile(const std::string &fileName,
const FileParsers::MolFileParserParams &params =
FileParsers::MolFileParserParams());
RDKIT_CHEMREACTIONS_EXPORT std::unique_ptr<ChemicalReaction>
ReactionFromRxnDataStream(std::istream &rxnStream, unsigned int &line,
const FileParsers::MolFileParserParams &params =
FileParsers::MolFileParserParams());
} // namespace ReactionParser
} // namespace v2
inline namespace v1 {
//! Parse a text block in MDL rxn format into a ChemicalReaction
inline ChemicalReaction *RxnBlockToChemicalReaction(const std::string &rxnBlock,
bool sanitize = false,
bool removeHs = false,
bool strictParsing = true) {
v2::FileParsers::MolFileParserParams params;
params.sanitize = sanitize;
params.removeHs = removeHs;
params.strictParsing = strictParsing;
return v2::ReactionParser::ReactionFromRxnBlock(rxnBlock, params).release();
}
//! Parse a file in MDL rxn format into a ChemicalReaction
inline ChemicalReaction *RxnFileToChemicalReaction(const std::string &fileName,
bool sanitize = false,
bool removeHs = false,
bool strictParsing = true) {
v2::FileParsers::MolFileParserParams params;
params.sanitize = sanitize;
params.removeHs = removeHs;
params.strictParsing = strictParsing;
return v2::ReactionParser::ReactionFromRxnFile(fileName, params).release();
}
//! Parse a text stream in MDL rxn format into a ChemicalReaction
inline ChemicalReaction *RxnDataStreamToChemicalReaction(
std::istream &rxnStream, unsigned int &line, bool sanitize = false,
bool removeHs = false, bool strictParsing = true) {
v2::FileParsers::MolFileParserParams params;
params.sanitize = sanitize;
params.removeHs = removeHs;
params.strictParsing = strictParsing;
return v2::ReactionParser::ReactionFromRxnDataStream(rxnStream, line, params)
.release();
}
} // namespace v1
//! returns an rxn block for a reaction
/*!
\param rxn chemical reaction
\param separateAgents flag to decide if agents are put in a separate block,
otherwise they are included in the reactants block
(default)
\param forceV3000 flag to cause the V3000 format to be used instead of
V2000
*/
RDKIT_CHEMREACTIONS_EXPORT std::string ChemicalReactionToRxnBlock(
const ChemicalReaction &rxn, bool separateAgents = false,
bool forceV3000 = false);
//! returns an V3000 rxn block for a reaction
/*!
\param rxn chemical reaction
\param separateAgents flag to decide if agents are put in a separate block,
otherwise they are included in the reactants block
(default)
*/
RDKIT_CHEMREACTIONS_EXPORT std::string ChemicalReactionToV3KRxnBlock(
const ChemicalReaction &rxn, bool separateAgents = false);
//! @}
//---------------------------------------------------------------------------
//! \name PNG Support
//! @{
//! Tags used for PNG metadata
namespace PNGData {
RDKIT_CHEMREACTIONS_EXPORT extern const std::string rxnSmilesTag;
RDKIT_CHEMREACTIONS_EXPORT extern const std::string rxnSmartsTag;
RDKIT_CHEMREACTIONS_EXPORT extern const std::string rxnRxnTag;
RDKIT_CHEMREACTIONS_EXPORT extern const std::string rxnPklTag;
} // namespace PNGData
namespace v2 {
namespace ReactionParser {
//! \brief constructs a ChemicalReaction from the metadata in a PNG stream
/*!
Looks through the metadata in the PNG to find the first tag that matches one
of the tags in \c RDKit::PNGData. A reaction is constructed from this chunk.
Throws a \c FileParseException if no suitable tag is found.
*/
RDKIT_CHEMREACTIONS_EXPORT std::unique_ptr<ChemicalReaction>
ReactionFromPNGStream(std::istream &pngStream);
//! \brief constructs a ChemicalReaction from the metadata in a PNG string
//! See \c PNGStreamToChemicalReaction() for more details
inline std::unique_ptr<ChemicalReaction> ReactionFromPNGString(
const std::string &data) {
std::stringstream inStream(data);
return ReactionFromPNGStream(inStream);
};
//! \brief constructs a ChemicalReaction from the metadata in a PNG file
//! See \c PNGStreamToChemicalReaction() for more details
inline std::unique_ptr<ChemicalReaction> ReactionFromPNGFile(
const std::string &fname) {
std::ifstream inStream(fname.c_str(), std::ios::binary);
if (!inStream || (inStream.bad())) {
throw BadFileException((boost::format("Bad input file %s") % fname).str());
}
return ReactionFromPNGStream(inStream);
};
} // namespace ReactionParser
} // namespace v2
inline namespace v1 {
//! \brief constructs a ChemicalReaction from the metadata in a PNG stream
/*!
Looks through the metadata in the PNG to find the first tag that matches one
of the tags in \c RDKit::PNGData. A reaction is constructed from this chunk.
Throws a \c FileParseException if no suitable tag is found.
The caller is responsible for the returned pointer.
*/
inline ChemicalReaction *PNGStreamToChemicalReaction(std::istream &pngStream) {
return v2::ReactionParser::ReactionFromPNGStream(pngStream).release();
}
//! \brief constructs a ChemicalReaction from the metadata in a PNG string
//! See \c PNGStreamToChemicalReaction() for more details
inline ChemicalReaction *PNGStringToChemicalReaction(const std::string &data) {
return v2::ReactionParser::ReactionFromPNGString(data).release();
}
//! \brief constructs a ChemicalReaction from the metadata in a PNG file
//! See \c PNGStreamToChemicalReaction() for more details
inline ChemicalReaction *PNGFileToChemicalReaction(const std::string &fname) {
return v2::ReactionParser::ReactionFromPNGFile(fname).release();
}
} // namespace v1
//! \brief adds metadata for a ChemicalReaction to the data from a PNG stream.
//! The modified PNG data is returned.
/*!
\param rxn the reaction to add
\param iStream the stream to read from
\param includePkl include a reaction pickle
\param includeSmiles include reaction SMILES for the reaction
\param includeSmarts include reaction SMARTS for the reaction
\param includeRxn include an RXN block for the reaction
*/
RDKIT_CHEMREACTIONS_EXPORT std::string addChemicalReactionToPNGStream(
const ChemicalReaction &rxn, std::istream &iStream, bool includePkl = true,
bool includeSmiles = true, bool includeSmarts = false,
bool includeRxn = false);
//! \brief adds metadata for a ChemicalReaction to the data from a PNG string.
//! See addChemicalReactionToPNGStream() for more details.
inline std::string addChemicalReactionToPNGString(const ChemicalReaction &rxn,
const std::string &pngString,
bool includePkl = true,
bool includeSmiles = true,
bool includeSmarts = false,
bool includeRxn = false) {
std::stringstream inStream(pngString);
return addChemicalReactionToPNGStream(
rxn, inStream, includePkl, includeSmiles, includeSmarts, includeRxn);
}
//! \brief adds metadata for a ChemicalReaction to the data from a PNG string.
//! See addChemicalReactionToPNGStream() for more details.
inline std::string addChemicalReactionToPNGFile(const ChemicalReaction &rxn,
const std::string &fname,
bool includePkl = true,
bool includeSmiles = true,
bool includeSmarts = false,
bool includeRxn = false) {
std::ifstream inStream(fname.c_str(), std::ios::binary);
return addChemicalReactionToPNGStream(
rxn, inStream, includePkl, includeSmiles, includeSmarts, includeRxn);
}
//! @}
inline std::unique_ptr<ChemicalReaction> operator""_rxnsmarts(const char *text,
size_t len) {
std::string sma(text, len);
std::unique_ptr<ChemicalReaction> ptr;
try {
ptr = v2::ReactionParser::ReactionFromSmarts(sma);
} catch (...) {
ptr = nullptr;
}
return ptr;
}
inline std::unique_ptr<ChemicalReaction> operator""_rxnsmiles(const char *text,
size_t len) {
std::string sma(text, len);
std::unique_ptr<ChemicalReaction> ptr;
try {
ptr = v2::ReactionParser::ReactionFromSmiles(sma);
} catch (...) {
ptr = nullptr;
}
return ptr;
}
//---------------------------------------------------------------------------
//! \name CDXML rxn Support
///@{
//! Parse text in CDXML rxn format into a vector of ChemicalReactions
RDKIT_CHEMREACTIONS_EXPORT std::vector<std::unique_ptr<ChemicalReaction>>
CDXMLToChemicalReactions(const std::string &rxnBlock, bool sanitize = false,
bool removeHs = false);
//! Parse a file in CDXML rxn format into a vector of ChemicalReactions
RDKIT_CHEMREACTIONS_EXPORT std::vector<std::unique_ptr<ChemicalReaction>>
CDXMLFileToChemicalReactions(const std::string &fileName, bool sanitize = false,
bool removeHs = false);
//! Parse a text stream in CDXML rxn format into a vector of ChemicalReactions
RDKIT_CHEMREACTIONS_EXPORT std::vector<std::unique_ptr<ChemicalReaction>>
CDXMLDataStreamToChemicalReactions(std::istream &rxnStream,
bool sanitize = false,
bool removeHs = false);
} // namespace RDKit
#endif
BadFileException.h
FileParseException.h
FileParsers.h
SmilesWrite.h
RDKit::BadFileException
used by various file parsing classes to indicate a bad file
Definition BadFileException.h:22
RDKit::ChemicalReactionParserException::what
const char * what() const noexcept override
get the error message
Definition ReactionParser.h:64
RDKit::ChemicalReactionParserException::ChemicalReactionParserException
ChemicalReactionParserException(std::string msg)
construct with an error message
Definition ReactionParser.h:61
RDKit::ChemicalReactionParserException::~ChemicalReactionParserException
~ChemicalReactionParserException() noexcept override=default
RDKit::ChemicalReactionParserException::ChemicalReactionParserException
ChemicalReactionParserException(const char *msg)
construct with an error message
Definition ReactionParser.h:59
RDKit::ChemicalReaction
This is a class for storing and applying general chemical reactions.
Definition Reaction.h:122
RDKit::ROMol
Definition ROMol.h:285
export.h
RDKIT_CHEMREACTIONS_EXPORT
#define RDKIT_CHEMREACTIONS_EXPORT
Definition export.h:57
RDKit::PNGData
Tags used for PNG metadata.
Definition ReactionParser.h:283
RDKit::PNGData::rxnRxnTag
RDKIT_CHEMREACTIONS_EXPORT const std::string rxnRxnTag
RDKit::PNGData::rxnSmilesTag
RDKIT_CHEMREACTIONS_EXPORT const std::string rxnSmilesTag
RDKit::PNGData::rxnSmartsTag
RDKIT_CHEMREACTIONS_EXPORT const std::string rxnSmartsTag
RDKit::PNGData::rxnPklTag
RDKIT_CHEMREACTIONS_EXPORT const std::string rxnPklTag
RDKit::v1
Definition ReactionParser.h:91
RDKit::v1::RxnSmartsToChemicalReaction
ChemicalReaction * RxnSmartsToChemicalReaction(const std::string &text, std::map< std::string, std::string > *replacements=nullptr, bool useSmiles=false, bool allowCXSMILES=true)
Parse a string containing "Reaction SMARTS" into a ChemicalReaction.
Definition ReactionParser.h:113
RDKit::v1::RxnBlockToChemicalReaction
ChemicalReaction * RxnBlockToChemicalReaction(const std::string &rxnBlock, bool sanitize=false, bool removeHs=false, bool strictParsing=true)
Parse a text block in MDL rxn format into a ChemicalReaction.
Definition ReactionParser.h:218
RDKit::v1::RxnDataStreamToChemicalReaction
ChemicalReaction * RxnDataStreamToChemicalReaction(std::istream &rxnStream, unsigned int &line, bool sanitize=false, bool removeHs=false, bool strictParsing=true)
Parse a text stream in MDL rxn format into a ChemicalReaction.
Definition ReactionParser.h:240
RDKit::v1::PNGStreamToChemicalReaction
ChemicalReaction * PNGStreamToChemicalReaction(std::istream &pngStream)
constructs a ChemicalReaction from the metadata in a PNG stream
Definition ReactionParser.h:336
RDKit::v1::RxnFileToChemicalReaction
ChemicalReaction * RxnFileToChemicalReaction(const std::string &fileName, bool sanitize=false, bool removeHs=false, bool strictParsing=true)
Parse a file in MDL rxn format into a ChemicalReaction.
Definition ReactionParser.h:229
RDKit::v1::PNGStringToChemicalReaction
ChemicalReaction * PNGStringToChemicalReaction(const std::string &data)
constructs a ChemicalReaction from the metadata in a PNG string See PNGStreamToChemicalReaction() for...
Definition ReactionParser.h:341
RDKit::v1::PNGFileToChemicalReaction
ChemicalReaction * PNGFileToChemicalReaction(const std::string &fname)
constructs a ChemicalReaction from the metadata in a PNG file See PNGStreamToChemicalReaction() for m...
Definition ReactionParser.h:346
RDKit::v2::ReactionParser
Definition ReactionParser.h:72
RDKit::v2::ReactionParser::ReactionFromPNGString
std::unique_ptr< ChemicalReaction > ReactionFromPNGString(const std::string &data)
constructs a ChemicalReaction from the metadata in a PNG string See PNGStreamToChemicalReaction() for...
Definition ReactionParser.h:306
RDKit::v2::ReactionParser::ReactionFromRxnBlock
RDKIT_CHEMREACTIONS_EXPORT std::unique_ptr< ChemicalReaction > ReactionFromRxnBlock(const std::string &rxnBlock, const FileParsers::MolFileParserParams &params=FileParsers::MolFileParserParams())
RDKit::v2::ReactionParser::ReactionFromRxnDataStream
RDKIT_CHEMREACTIONS_EXPORT std::unique_ptr< ChemicalReaction > ReactionFromRxnDataStream(std::istream &rxnStream, unsigned int &line, const FileParsers::MolFileParserParams &params=FileParsers::MolFileParserParams())
RDKit::v2::ReactionParser::ReactionFromPNGFile
std::unique_ptr< ChemicalReaction > ReactionFromPNGFile(const std::string &fname)
constructs a ChemicalReaction from the metadata in a PNG file See PNGStreamToChemicalReaction() for m...
Definition ReactionParser.h:313
RDKit::v2::ReactionParser::ReactionFromSmarts
RDKIT_CHEMREACTIONS_EXPORT std::unique_ptr< ChemicalReaction > ReactionFromSmarts(const std::string &smarts, const ReactionSmartsParserParams &params=ReactionSmartsParserParams())
RDKit::v2::ReactionParser::ReactionFromRxnFile
RDKIT_CHEMREACTIONS_EXPORT std::unique_ptr< ChemicalReaction > ReactionFromRxnFile(const std::string &fileName, const FileParsers::MolFileParserParams &params=FileParsers::MolFileParserParams())
RDKit::v2::ReactionParser::ReactionFromPNGStream
RDKIT_CHEMREACTIONS_EXPORT std::unique_ptr< ChemicalReaction > ReactionFromPNGStream(std::istream &pngStream)
constructs a ChemicalReaction from the metadata in a PNG stream
RDKit::v2::ReactionParser::ReactionFromSmiles
RDKIT_CHEMREACTIONS_EXPORT std::unique_ptr< ChemicalReaction > ReactionFromSmiles(const std::string &smarts, const ReactionSmartsParserParams &params=ReactionSmartsParserParams())
RDKit::v2
Definition ReactionParser.h:71
RDKit
Std stuff.
Definition Abbreviations.h:19
RDKit::ChemicalReactionToCXRxnSmarts
RDKIT_CHEMREACTIONS_EXPORT std::string ChemicalReactionToCXRxnSmarts(const ChemicalReaction &rxn, const SmilesWriteParams &params, std::uint32_t flags=SmilesWrite::CXSmilesFields::CX_ALL)
returns the reaction SMARTS for a reaction with CX extension
RDKit::ChemicalReactionToRxnSmarts
RDKIT_CHEMREACTIONS_EXPORT std::string ChemicalReactionToRxnSmarts(const ChemicalReaction &rxn, const SmilesWriteParams &params)
returns the reaction SMARTS for a reaction
RDKit::CDXMLFileToChemicalReactions
RDKIT_CHEMREACTIONS_EXPORT std::vector< std::unique_ptr< ChemicalReaction > > CDXMLFileToChemicalReactions(const std::string &fileName, bool sanitize=false, bool removeHs=false)
Parse a file in CDXML rxn format into a vector of ChemicalReactions.
RDKit::ChemicalReactionToCXRxnSmiles
RDKIT_CHEMREACTIONS_EXPORT std::string ChemicalReactionToCXRxnSmiles(const ChemicalReaction &rxn, const SmilesWriteParams &params, std::uint32_t flags=SmilesWrite::CXSmilesFields::CX_ALL)
returns the reaction SMILES for a reaction with CX extension
RDKit::ChemicalReactionToRxnBlock
RDKIT_CHEMREACTIONS_EXPORT std::string ChemicalReactionToRxnBlock(const ChemicalReaction &rxn, bool separateAgents=false, bool forceV3000=false)
returns an rxn block for a reaction
RDKit::CDXMLDataStreamToChemicalReactions
RDKIT_CHEMREACTIONS_EXPORT std::vector< std::unique_ptr< ChemicalReaction > > CDXMLDataStreamToChemicalReactions(std::istream &rxnStream, bool sanitize=false, bool removeHs=false)
Parse a text stream in CDXML rxn format into a vector of ChemicalReactions.
RDKit::CDXMLToChemicalReactions
RDKIT_CHEMREACTIONS_EXPORT std::vector< std::unique_ptr< ChemicalReaction > > CDXMLToChemicalReactions(const std::string &rxnBlock, bool sanitize=false, bool removeHs=false)
Parse text in CDXML rxn format into a vector of ChemicalReactions.
RDKit::addChemicalReactionToPNGStream
RDKIT_CHEMREACTIONS_EXPORT std::string addChemicalReactionToPNGStream(const ChemicalReaction &rxn, std::istream &iStream, bool includePkl=true, bool includeSmiles=true, bool includeSmarts=false, bool includeRxn=false)
adds metadata for a ChemicalReaction to the data from a PNG stream. The modified PNG data is returned...
RDKit::ChemicalReactionToRxnSmiles
RDKIT_CHEMREACTIONS_EXPORT std::string ChemicalReactionToRxnSmiles(const ChemicalReaction &rxn, const SmilesWriteParams &params=SmilesWriteParams())
returns the reaction SMILES for a reaction
RDKit::addChemicalReactionToPNGFile
std::string addChemicalReactionToPNGFile(const ChemicalReaction &rxn, const std::string &fname, bool includePkl=true, bool includeSmiles=true, bool includeSmarts=false, bool includeRxn=false)
adds metadata for a ChemicalReaction to the data from a PNG string. See addChemicalReactionToPNGStrea...
Definition ReactionParser.h:381
RDKit::ChemicalReactionToV3KRxnBlock
RDKIT_CHEMREACTIONS_EXPORT std::string ChemicalReactionToV3KRxnBlock(const ChemicalReaction &rxn, bool separateAgents=false)
returns an V3000 rxn block for a reaction
RDKit::RxnMolToChemicalReaction
RDKIT_CHEMREACTIONS_EXPORT ChemicalReaction * RxnMolToChemicalReaction(const ROMol &mol)
Parse a ROMol into a ChemicalReaction, RXN role must be set before.
RDKit::ChemicalReactionToRxnMol
RDKIT_CHEMREACTIONS_EXPORT ROMol * ChemicalReactionToRxnMol(const ChemicalReaction &rxn)
returns a ROMol with RXN roles used to describe the reaction
RDKit::addChemicalReactionToPNGString
std::string addChemicalReactionToPNGString(const ChemicalReaction &rxn, const std::string &pngString, bool includePkl=true, bool includeSmiles=true, bool includeSmarts=false, bool includeRxn=false)
adds metadata for a ChemicalReaction to the data from a PNG string. See addChemicalReactionToPNGStrea...
Definition ReactionParser.h:369
RDKit::SmilesWriteParams
Definition SmilesWrite.h:30
RDKit::SmilesWriteParams::canonical
bool canonical
Definition SmilesWrite.h:37
RDKit::v2::FileParsers::MolFileParserParams
Definition FileParsers.h:47
RDKit::v2::FileParsers::MolFileParserParams::strictParsing
bool strictParsing
Definition FileParsers.h:50
RDKit::v2::FileParsers::MolFileParserParams::sanitize
bool sanitize
Definition FileParsers.h:48
RDKit::v2::FileParsers::MolFileParserParams::removeHs
bool removeHs
Definition FileParsers.h:49
RDKit::v2::ReactionParser::ReactionSmartsParserParams
Definition ReactionParser.h:73
RDKit::v2::ReactionParser::ReactionSmartsParserParams::replacements
std::map< std::string, std::string > replacements
Definition ReactionParser.h:76
RDKit::v2::ReactionParser::ReactionSmartsParserParams::strictCXSMILES
bool strictCXSMILES
Definition ReactionParser.h:78
RDKit::v2::ReactionParser::ReactionSmartsParserParams::sanitize
bool sanitize
Definition ReactionParser.h:74
RDKit::v2::ReactionParser::ReactionSmartsParserParams::allowCXSMILES
bool allowCXSMILES
Definition ReactionParser.h:77