Loading...
Searching...
No Matches
assignBondOrderProcessor.h
Go to the documentation of this file.
// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
#ifndef BALL_STRUCTURE_ASSIGNBONDORDERPROCESSOR_H
#define BALL_STRUCTURE_ASSIGNBONDORDERPROCESSOR_H
#ifndef BALL_CONCEPT_PROCESSOR_H
#include <BALL/CONCEPT/processor.h>
#endif
#ifndef BALL_KERNEL_ATOMCONTAINER_H
#include <BALL/KERNEL/atomContainer.h>
#endif
#ifndef BALL_DATATYPE_HASHMAP_H
#include <BALL/DATATYPE/hashMap.h>
#endif
#ifndef BALL_DATATYPE_HASHSET_H
#include <BALL/DATATYPE/hashSet.h>
#endif
#ifndef BALL_KERNEL_BOND_H
#include <BALL/KERNEL/bond.h>
#endif
#ifndef BALL_DATATYPE_OPTIONS_H
# include <BALL/DATATYPE/options.h>
#endif
#ifndef BALL_COMMON_EXCEPTION_H
# include <BALL/COMMON/exception.h>
#endif
#ifndef BALL_SYSTEM_TIMER_H
# include <BALL/SYSTEM/timer.h>
#endif
#ifndef BALL_STRUCTURE_BONDORDERS_BONDORDERASSIGNMENTSTRATEGY_H
# include <BALL/STRUCTURE/BONDORDERS/bondOrderAssignmentStrategy.h>
#endif
#ifndef BALL_STRUCTURE_BONDORDERS_BONDORDERASSIGNMENT_H
# include <BALL/STRUCTURE/BONDORDERS/bondOrderAssignment.h>
#endif
#ifndef BALL_STRUCTURE_BONDORDERS_PARTIALBONDORDERASSIGNMENT_H
# include <BALL/STRUCTURE/BONDORDERS/partialBondOrderAssignment.h>
#endif
#include <map>
#include <vector>
namespace BALL
{
class BALL_EXPORT AssignBondOrderProcessor
: public UnaryProcessor<AtomContainer>
{
protected:
friend class PartialBondOrderAssignment;
friend class BondOrderAssignment;
class PQ_Entry_;
friend class PQ_Entry_;
friend class BondOrderAssignmentStrategy;
friend class AStarBondOrderStrategy;
friend class BranchAndBoundBondOrderStrategy;
friend class FPTBondOrderStrategy;
friend class ILPBondOrderStrategy;
friend class KGreedyBondOrderStrategy;
public:
struct BALL_EXPORT Option
{
static const char* OVERWRITE_SINGLE_BOND_ORDERS;
static const char* OVERWRITE_DOUBLE_BOND_ORDERS;
static const char* OVERWRITE_TRIPLE_BOND_ORDERS;
static const char* OVERWRITE_SELECTED_BONDS;
static const char* ADD_HYDROGENS; //TODO
static const char* COMPUTE_ALSO_CONNECTIVITY; //TODO
static const char* CONNECTIVITY_CUTOFF; //TODO
static const char* USE_FINE_PENALTY;
static const char* KEKULIZE_RINGS;
static const char* ALGORITHM;
static const char* INIFile;
static const char* MAX_BOND_ORDER;
static const char* MAX_NUMBER_OF_SOLUTIONS;
static const char* MAX_PENALTY;
static const char* COMPUTE_ALSO_NON_OPTIMAL_SOLUTIONS;
static const char* BOND_LENGTH_WEIGHTING;
static const char* APPLY_FIRST_SOLUTION;
};
struct BALL_EXPORT Default
{
static const bool OVERWRITE_SINGLE_BOND_ORDERS;
static const bool OVERWRITE_DOUBLE_BOND_ORDERS;
static const bool OVERWRITE_TRIPLE_BOND_ORDERS;
static const bool OVERWRITE_SELECTED_BONDS;
static const bool ADD_HYDROGENS;
static const bool COMPUTE_ALSO_CONNECTIVITY;
static const float CONNECTIVITY_CUTOFF;
static const bool USE_FINE_PENALTY;
static const bool KEKULIZE_RINGS;
static const String ALGORITHM;
static const String INIFile;
static const int MAX_BOND_ORDER;
static const int MAX_NUMBER_OF_SOLUTIONS;
static const int MAX_PENALTY;
static const bool COMPUTE_ALSO_NON_OPTIMAL_SOLUTIONS;
static const float BOND_LENGTH_WEIGHTING;
static const bool APPLY_FIRST_SOLUTION;
};
struct BALL_EXPORT Algorithm
{
static const String A_STAR;
static const String ILP;
static const String FPT;
static const String K_GREEDY;
static const String BRANCH_AND_BOUND;
};
AssignBondOrderProcessor();
// constructor with parameter filename //TODO
//AssignBondOrderProcessor(const String& file_name);
virtual ~AssignBondOrderProcessor();
virtual bool start();
void clear();
virtual Processor::Result operator ()(AtomContainer& ac);
virtual bool finish();
Size getNumberOfAddedHydrogens(Position i)
{
if (i >= solutions_.size())
{
Log.error() << "AssignBondOrderProcessor: No solution with index " << i << std::endl;
return 0;
}
int num_hydrogens = 0;
HashMap<Atom*, int>::Iterator it = solutions_[i].number_of_virtual_hydrogens.begin();
for (; it != solutions_[i].number_of_virtual_hydrogens.end(); it++)
num_hydrogens += it->second;
return num_hydrogens;
}
Size getNumberOfComputedSolutions() {return solutions_.size();}
AtomContainer* getAtomContainer() {return ac_;}
AtomContainer const* getAtomContainer() const {return ac_;}
const System& getSolution(Position i);
float getTotalCharge(Position i)
{
if (i >= solutions_.size())
{
Log.error() << "AssignBondOrderProcessor: No solution with index " << i << std::endl;
return std::numeric_limits<float>::max();
}
else
{
return getTotalCharge_(solutions_[i]);
}
}
float getTotalPenalty(Position i=0)
{
if (i >= solutions_.size())
{
Log.error() << "AssignBondOrderProcessor: No solution with index " << i << std::endl;
return std::numeric_limits<float>::max();
}
else
return getTotalPenalty_(solutions_[i]);
}
/* Returns the number of node expansions before solution i was found.
*
* param i index of the solution, whose number of node expansions should be returned.
* return int - number of node expansions before solution i was found.
*/
int getNumberOfNodeExpansions(Position i)
{
if (i >= solutions_.size())
{
Log.error() << "AssignBondOrderProcessor: No solution with index " << i << std::endl;
return -1;
}
else
return getNumberOfNodeExpansions_(solutions_[i]);
}
/* Returns the number of node expansions before solution i was found.
*
* param i index of the solution, whose queue size should be returned.
* return int - queue size when solution i was found.
*/
int getQueueSize(Position i)
{
if (i >= solutions_.size())
{
Log.error() << "AssignBondOrderProcessor: No solution with index " << i << std::endl;
return -1;
}
else
return getQueueSize_(solutions_[i]);
}
bool apply(Position i);
void resetBondOrders();
bool computeNextSolution(bool apply_solution = true);
void setDefaultOptions();
bool hasValidOptions(){return readOptions_();}
float evaluatePenalty(AtomContainer* ac);
Options options;
protected:
bool readOptions_();
bool readAtomPenalties_();
bool preassignPenaltyClasses_();
int getPenaltyClass_(Atom* atom);
bool precomputeBondLengthPenalties_();
float computeVirtualHydrogens_(Atom* atom);
//TODO: move to solution!
bool apply_(BondOrderAssignment& solution);
void storeOriginalConfiguration_();
/* Returns the queue's size at the moment the given solution was found.
*
* param sol solution, whose queue size should be returned.
* return int - queue size when the given solution was found.
*/
int getQueueSize_(const BondOrderAssignment& sol){return sol.getQueueSize();}
float getTotalCharge_(const BondOrderAssignment& sol)
{
if (sol.valid)
{
return sol.total_charge;
}
else
{
return 0;
}
}
float getTotalPenalty_(const BondOrderAssignment& sol)
{
return sol.coarsePenalty();
}
/* Returns the number of node expansions before the given solution was found.
*
* param sol solution, whose number of node expansions should be returned.
* return int - number of node expansions before solution i was found.
*/
int getNumberOfNodeExpansions_(const BondOrderAssignment& sol){return sol.getNumberOfNodeExpansions();}
bool valid_;
bool evaluation_mode_;
// Map for storing the bonds fixed orders
// if a bond is free, the map returns 0
std::map<Bond*, short> bond_fixed_;
// all free bonds in the atom container
std::vector<Bond*> free_bonds_;
// Map for storing the bonds associated index (all bonds)
HashMap<Bond*, Index> bond_to_index_;
// Vector for mapping from variable indices onto bonds (all bonds)
std::vector<Bond*> index_to_bond_;
// ***************** datastructures for virtual hydrogen bonds ******************
//
// NOTE: a single virtual bond represents ALL possible hydrogen
// bonds for a given atom
//
// the atoms with upto n possible additional hydrogens
HashMap<Atom*, int> number_of_virtual_hydrogens_;
//
// the max number of virtual hydrogens per virtual bond index
std::vector<int> virtual_bond_index_to_number_of_virtual_hydrogens_;
//
// the number of virtual bonds
Size num_of_virtual_bonds_;
//
// the virtual bond index assigned to this atom!
vector<Atom*> virtual_bond_index_to_atom_;
HashMap<Atom*, int> atom_to_virtual_bond_index_;
//
//
// a virtual dummy bond
Bond* virtual_bond_;
// ******************* general datastructures *********************
// the number of bonds given (free + fixed!)
Position total_num_of_bonds_;
// num of free bonds without virtual bonds!
int num_of_free_bonds_;
// store for all atom-indices the atoms fixed valences
std::vector<Position> fixed_val_;
// storing the solutions
vector<BondOrderAssignment> solutions_;
// the original conformation before we computed anything
// this is a vector because we can have multiple molecules...
vector<BondOrderAssignment> starting_configuration_;
// the inverse of the atom type penalty normalization factor
float atom_type_normalization_factor_;
// the inverse of the bond length penalty normalization factor
float bond_length_normalization_factor_;
// denotes the index of the last applied solution
// -1 if there was no valid solution applied
int last_applied_solution_;
// the AtomContainer, the processor is operating on
AtomContainer* ac_;
// max bond order to consider
int max_bond_order_;
// balance parameter between atom type and bond length penalty
float alpha_;
// the max number of solutions to compute
int max_number_of_solutions_;
// the max penalty score
int max_penalty_;
// flag to indicate, whether also non-optimal solutions should be computed
bool compute_also_non_optimal_solutions_;
// flag for adding missing hydrogens
bool add_missing_hydrogens_;
// flag for computing also the bond connectivity
bool compute_also_connectivity_;
// flag for using fine penalties derived from 3d information
bool use_fine_penalty_;
// //////// general stuff /////////
// The penalty administration datastructures.
// filled by readAtomPenalties_
// organized in imaginarey blocks of length
// block_to_length_[i], starting from
// block_to_start_idx_[i] associating
// block_to_start_valence_[i] to the start_idx
vector<int> penalties_;
vector<Position> block_to_start_idx_;
vector<Size> block_to_length_;
vector<int> block_to_start_valence_;
// stores the defining element and the SMART-string of each block
vector<std::pair<String, String> > block_definition_;
// Stores which atom belongs to which penalty block.
// The first vector element of each atom block denotes the penalty block
// assigned to the atom without any additional VIRTUAL Hydrogens,
// the second element with one additional Hydrogen and so on.
vector< vector<int> > atom_to_block_;
// Stores the possible bond lengths penalties per order.
HashMap<Bond*, vector<float> > bond_lengths_penalties_;
Timer timer_;
AssignBondOrderProcessor(const AssignBondOrderProcessor& abop);
AssignBondOrderProcessor& operator = (const AssignBondOrderProcessor& abop);
// The strategies this class can use
StringHashMap<boost::shared_ptr<BondOrderAssignmentStrategy> > strategies_;
};
} // namespace BALL
#endif // BALL_STRUCTURE_ASSIGNBONDORDERPROCESSOR_H
exception.h
BALL_EXPORT
#define BALL_EXPORT
Definition COMMON/global.h:50
atomContainer.h
bondOrderAssignmentStrategy.h
bondOrderAssignment.h
bond.h
BALL::AssignBondOrderProcessor::PartialBondOrderAssignment
friend class PartialBondOrderAssignment
Definition assignBondOrderProcessor.h:92
BALL::AssignBondOrderProcessor::ILPBondOrderStrategy
friend class ILPBondOrderStrategy
Definition assignBondOrderProcessor.h:103
BALL::AssignBondOrderProcessor::compute_also_non_optimal_solutions_
bool compute_also_non_optimal_solutions_
Definition assignBondOrderProcessor.h:740
BALL::AssignBondOrderProcessor::computeNextSolution
bool computeNextSolution(bool apply_solution=true)
BALL::AssignBondOrderProcessor::~AssignBondOrderProcessor
virtual ~AssignBondOrderProcessor()
Destructor.
BALL::AssignBondOrderProcessor::options
Options options
the processor's options
Definition assignBondOrderProcessor.h:531
BALL::AssignBondOrderProcessor::virtual_bond_index_to_number_of_virtual_hydrogens_
std::vector< int > virtual_bond_index_to_number_of_virtual_hydrogens_
Definition assignBondOrderProcessor.h:683
BALL::AssignBondOrderProcessor::preassignPenaltyClasses_
bool preassignPenaltyClasses_()
BALL::AssignBondOrderProcessor::valid_
bool valid_
Processor is in a useable valid state.
Definition assignBondOrderProcessor.h:654
BALL::AssignBondOrderProcessor::bond_length_normalization_factor_
float bond_length_normalization_factor_
Definition assignBondOrderProcessor.h:718
BALL::AssignBondOrderProcessor::atom_to_block_
vector< vector< int > > atom_to_block_
Definition assignBondOrderProcessor.h:772
BALL::AssignBondOrderProcessor::getNumberOfComputedSolutions
Size getNumberOfComputedSolutions()
Definition assignBondOrderProcessor.h:386
BALL::AssignBondOrderProcessor::alpha_
float alpha_
Definition assignBondOrderProcessor.h:731
BALL::AssignBondOrderProcessor::free_bonds_
std::vector< Bond * > free_bonds_
Definition assignBondOrderProcessor.h:664
BALL::AssignBondOrderProcessor::storeOriginalConfiguration_
void storeOriginalConfiguration_()
BALL::AssignBondOrderProcessor::compute_also_connectivity_
bool compute_also_connectivity_
Definition assignBondOrderProcessor.h:746
BALL::AssignBondOrderProcessor::total_num_of_bonds_
Position total_num_of_bonds_
Definition assignBondOrderProcessor.h:699
BALL::AssignBondOrderProcessor::KGreedyBondOrderStrategy
friend class KGreedyBondOrderStrategy
Definition assignBondOrderProcessor.h:104
BALL::AssignBondOrderProcessor::getSolution
const System & getSolution(Position i)
BALL::AssignBondOrderProcessor::clear
void clear()
BALL::AssignBondOrderProcessor::BranchAndBoundBondOrderStrategy
friend class BranchAndBoundBondOrderStrategy
Definition assignBondOrderProcessor.h:101
BALL::AssignBondOrderProcessor::computeVirtualHydrogens_
float computeVirtualHydrogens_(Atom *atom)
BALL::AssignBondOrderProcessor::use_fine_penalty_
bool use_fine_penalty_
Definition assignBondOrderProcessor.h:749
BALL::AssignBondOrderProcessor::atom_to_virtual_bond_index_
HashMap< Atom *, int > atom_to_virtual_bond_index_
Definition assignBondOrderProcessor.h:690
BALL::AssignBondOrderProcessor::getNumberOfAddedHydrogens
Size getNumberOfAddedHydrogens(Position i)
Definition assignBondOrderProcessor.h:362
BALL::AssignBondOrderProcessor::timer_
Timer timer_
Definition assignBondOrderProcessor.h:777
BALL::AssignBondOrderProcessor::AssignBondOrderProcessor
AssignBondOrderProcessor(const AssignBondOrderProcessor &abop)
BALL::AssignBondOrderProcessor::block_to_start_idx_
vector< Position > block_to_start_idx_
Definition assignBondOrderProcessor.h:761
BALL::AssignBondOrderProcessor::number_of_virtual_hydrogens_
HashMap< Atom *, int > number_of_virtual_hydrogens_
Definition assignBondOrderProcessor.h:680
BALL::AssignBondOrderProcessor::bond_fixed_
std::map< Bond *, short > bond_fixed_
Definition assignBondOrderProcessor.h:661
BALL::AssignBondOrderProcessor::add_missing_hydrogens_
bool add_missing_hydrogens_
Definition assignBondOrderProcessor.h:743
BALL::AssignBondOrderProcessor::fixed_val_
std::vector< Position > fixed_val_
Definition assignBondOrderProcessor.h:705
BALL::AssignBondOrderProcessor::max_penalty_
int max_penalty_
Definition assignBondOrderProcessor.h:737
BALL::AssignBondOrderProcessor::max_number_of_solutions_
int max_number_of_solutions_
Definition assignBondOrderProcessor.h:734
BALL::AssignBondOrderProcessor::BondOrderAssignmentStrategy
friend class BondOrderAssignmentStrategy
Definition assignBondOrderProcessor.h:98
BALL::AssignBondOrderProcessor::getQueueSize_
int getQueueSize_(const BondOrderAssignment &sol)
Definition assignBondOrderProcessor.h:615
BALL::AssignBondOrderProcessor::ac_
AtomContainer * ac_
Definition assignBondOrderProcessor.h:725
BALL::AssignBondOrderProcessor::PQ_Entry_
friend class PQ_Entry_
Definition assignBondOrderProcessor.h:96
BALL::AssignBondOrderProcessor::getTotalCharge_
float getTotalCharge_(const BondOrderAssignment &sol)
Definition assignBondOrderProcessor.h:623
BALL::AssignBondOrderProcessor::BondOrderAssignment
friend class BondOrderAssignment
Definition assignBondOrderProcessor.h:93
BALL::AssignBondOrderProcessor::apply
bool apply(Position i)
BALL::AssignBondOrderProcessor::setDefaultOptions
void setDefaultOptions()
BALL::AssignBondOrderProcessor::apply_
bool apply_(BondOrderAssignment &solution)
BALL::AssignBondOrderProcessor::hasValidOptions
bool hasValidOptions()
Definition assignBondOrderProcessor.h:516
BALL::AssignBondOrderProcessor::getPenaltyClass_
int getPenaltyClass_(Atom *atom)
BALL::AssignBondOrderProcessor::AStarBondOrderStrategy
friend class AStarBondOrderStrategy
Definition assignBondOrderProcessor.h:100
BALL::AssignBondOrderProcessor::num_of_virtual_bonds_
Size num_of_virtual_bonds_
Definition assignBondOrderProcessor.h:686
BALL::AssignBondOrderProcessor::getQueueSize
int getQueueSize(Position i)
Definition assignBondOrderProcessor.h:468
BALL::AssignBondOrderProcessor::atom_type_normalization_factor_
float atom_type_normalization_factor_
Definition assignBondOrderProcessor.h:715
BALL::AssignBondOrderProcessor::strategies_
StringHashMap< boost::shared_ptr< BondOrderAssignmentStrategy > > strategies_
Definition assignBondOrderProcessor.h:783
BALL::AssignBondOrderProcessor::getTotalPenalty_
float getTotalPenalty_(const BondOrderAssignment &sol)
Definition assignBondOrderProcessor.h:641
BALL::AssignBondOrderProcessor::block_to_start_valence_
vector< int > block_to_start_valence_
Definition assignBondOrderProcessor.h:763
BALL::AssignBondOrderProcessor::bond_lengths_penalties_
HashMap< Bond *, vector< float > > bond_lengths_penalties_
Definition assignBondOrderProcessor.h:775
BALL::AssignBondOrderProcessor::bond_to_index_
HashMap< Bond *, Index > bond_to_index_
Definition assignBondOrderProcessor.h:667
BALL::AssignBondOrderProcessor::resetBondOrders
void resetBondOrders()
BALL::AssignBondOrderProcessor::getNumberOfNodeExpansions
int getNumberOfNodeExpansions(Position i)
Definition assignBondOrderProcessor.h:451
BALL::AssignBondOrderProcessor::last_applied_solution_
int last_applied_solution_
Definition assignBondOrderProcessor.h:722
BALL::AssignBondOrderProcessor::AssignBondOrderProcessor
AssignBondOrderProcessor()
Default Constructor.
BALL::AssignBondOrderProcessor::virtual_bond_
Bond * virtual_bond_
Definition assignBondOrderProcessor.h:694
BALL::AssignBondOrderProcessor::FPTBondOrderStrategy
friend class FPTBondOrderStrategy
Definition assignBondOrderProcessor.h:102
BALL::AssignBondOrderProcessor::num_of_free_bonds_
int num_of_free_bonds_
Definition assignBondOrderProcessor.h:702
BALL::AssignBondOrderProcessor::precomputeBondLengthPenalties_
bool precomputeBondLengthPenalties_()
BALL::AssignBondOrderProcessor::finish
virtual bool finish()
Processor method which is called after the operator()-call.
BALL::AssignBondOrderProcessor::getTotalPenalty
float getTotalPenalty(Position i=0)
Definition assignBondOrderProcessor.h:434
BALL::AssignBondOrderProcessor::block_definition_
vector< std::pair< String, String > > block_definition_
Definition assignBondOrderProcessor.h:765
BALL::AssignBondOrderProcessor::penalties_
vector< int > penalties_
Definition assignBondOrderProcessor.h:760
BALL::AssignBondOrderProcessor::block_to_length_
vector< Size > block_to_length_
Definition assignBondOrderProcessor.h:762
BALL::AssignBondOrderProcessor::starting_configuration_
vector< BondOrderAssignment > starting_configuration_
Definition assignBondOrderProcessor.h:712
BALL::AssignBondOrderProcessor::index_to_bond_
std::vector< Bond * > index_to_bond_
Definition assignBondOrderProcessor.h:670
BALL::AssignBondOrderProcessor::evaluatePenalty
float evaluatePenalty(AtomContainer *ac)
BALL::AssignBondOrderProcessor::getNumberOfNodeExpansions_
int getNumberOfNodeExpansions_(const BondOrderAssignment &sol)
Definition assignBondOrderProcessor.h:651
BALL::AssignBondOrderProcessor::start
virtual bool start()
Processor method which is called before the operator()-call.
BALL::AssignBondOrderProcessor::solutions_
vector< BondOrderAssignment > solutions_
Definition assignBondOrderProcessor.h:708
BALL::AssignBondOrderProcessor::readAtomPenalties_
bool readAtomPenalties_()
BALL::AssignBondOrderProcessor::readOptions_
bool readOptions_()
BALL::AssignBondOrderProcessor::evaluation_mode_
bool evaluation_mode_
Processor is in an evaluation mode. Default is false.
Definition assignBondOrderProcessor.h:657
BALL::AssignBondOrderProcessor::max_bond_order_
int max_bond_order_
Definition assignBondOrderProcessor.h:728
BALL::AssignBondOrderProcessor::getTotalCharge
float getTotalCharge(Position i)
Definition assignBondOrderProcessor.h:415
BALL::AssignBondOrderProcessor::virtual_bond_index_to_atom_
vector< Atom * > virtual_bond_index_to_atom_
Definition assignBondOrderProcessor.h:689
BALL::AssignBondOrderProcessor::getAtomContainer
AtomContainer const * getAtomContainer() const
Definition assignBondOrderProcessor.h:395
BALL::AssignBondOrderProcessor::getAtomContainer
AtomContainer * getAtomContainer()
Definition assignBondOrderProcessor.h:391
BALL::AtomContainer
Definition atomContainer.h:32
BALL::Atom
Definition atom.h:90
BALL::BondOrderAssignment::getQueueSize
int getQueueSize() const
Definition bondOrderAssignment.h:52
BALL::BondOrderAssignment::total_charge
float total_charge
Definition bondOrderAssignment.h:68
BALL::BondOrderAssignment::getNumberOfNodeExpansions
int getNumberOfNodeExpansions() const
Definition bondOrderAssignment.h:49
BALL::BondOrderAssignment::valid
bool valid
Definition bondOrderAssignment.h:55
BALL::Bond
Definition bond.h:57
BALL::HashMap
HashMap class based on the STL map (containing serveral convenience functions).
Definition hashMap.h:74
BALL::HashMap::Iterator
Base::iterator Iterator
Definition hashMap.h:97
BALL::Options
Definition options.h:48
BALL::PartialBondOrderAssignment::coarsePenalty
float coarsePenalty(float atom_type_penalty, float bond_length_penalty) const
BALL::Processor::Result
int Result
Definition processor.h:36
BALL::StringHashMap
Definition stringHashMap.h:42
BALL::String
Definition string.h:57
BALL::System
Definition KERNEL/system.h:40
BALL::Timer
Definition timer.h:31
BALL::UnaryProcessor< AtomContainer >::UnaryProcessor
UnaryProcessor()
Definition processor.h:69
hashMap.h
hashSet.h
BALL
Definition constants.h:13
BALL::Size
BALL_SIZE_TYPE Size
Definition COMMON/global.h:114
BALL::Log
BALL_EXPORT LogStream Log
BALL::Position
BALL_SIZE_TYPE Position
Definition COMMON/global.h:140
options.h
partialBondOrderAssignment.h
processor.h
BALL::AssignBondOrderProcessor::Algorithm
Definition assignBondOrderProcessor.h:251
BALL::AssignBondOrderProcessor::Algorithm::ILP
static const String ILP
Definition assignBondOrderProcessor.h:267
BALL::AssignBondOrderProcessor::Algorithm::K_GREEDY
static const String K_GREEDY
Definition assignBondOrderProcessor.h:296
BALL::AssignBondOrderProcessor::Algorithm::BRANCH_AND_BOUND
static const String BRANCH_AND_BOUND
Definition assignBondOrderProcessor.h:297
BALL::AssignBondOrderProcessor::Algorithm::A_STAR
static const String A_STAR
Definition assignBondOrderProcessor.h:255
BALL::AssignBondOrderProcessor::Algorithm::FPT
static const String FPT
Definition assignBondOrderProcessor.h:294
BALL::AssignBondOrderProcessor::Default
Default values for options.
Definition assignBondOrderProcessor.h:230
BALL::AssignBondOrderProcessor::Default::OVERWRITE_TRIPLE_BOND_ORDERS
static const bool OVERWRITE_TRIPLE_BOND_ORDERS
Definition assignBondOrderProcessor.h:233
BALL::AssignBondOrderProcessor::Default::ALGORITHM
static const String ALGORITHM
Definition assignBondOrderProcessor.h:240
BALL::AssignBondOrderProcessor::Default::OVERWRITE_SELECTED_BONDS
static const bool OVERWRITE_SELECTED_BONDS
Definition assignBondOrderProcessor.h:234
BALL::AssignBondOrderProcessor::Default::MAX_NUMBER_OF_SOLUTIONS
static const int MAX_NUMBER_OF_SOLUTIONS
Definition assignBondOrderProcessor.h:243
BALL::AssignBondOrderProcessor::Default::BOND_LENGTH_WEIGHTING
static const float BOND_LENGTH_WEIGHTING
Definition assignBondOrderProcessor.h:246
BALL::AssignBondOrderProcessor::Default::OVERWRITE_DOUBLE_BOND_ORDERS
static const bool OVERWRITE_DOUBLE_BOND_ORDERS
Definition assignBondOrderProcessor.h:232
BALL::AssignBondOrderProcessor::Default::INIFile
static const String INIFile
Definition assignBondOrderProcessor.h:241
BALL::AssignBondOrderProcessor::Default::USE_FINE_PENALTY
static const bool USE_FINE_PENALTY
Definition assignBondOrderProcessor.h:238
BALL::AssignBondOrderProcessor::Default::ADD_HYDROGENS
static const bool ADD_HYDROGENS
Definition assignBondOrderProcessor.h:235
BALL::AssignBondOrderProcessor::Default::CONNECTIVITY_CUTOFF
static const float CONNECTIVITY_CUTOFF
Definition assignBondOrderProcessor.h:237
BALL::AssignBondOrderProcessor::Default::COMPUTE_ALSO_CONNECTIVITY
static const bool COMPUTE_ALSO_CONNECTIVITY
Definition assignBondOrderProcessor.h:236
BALL::AssignBondOrderProcessor::Default::COMPUTE_ALSO_NON_OPTIMAL_SOLUTIONS
static const bool COMPUTE_ALSO_NON_OPTIMAL_SOLUTIONS
Definition assignBondOrderProcessor.h:245
BALL::AssignBondOrderProcessor::Default::MAX_PENALTY
static const int MAX_PENALTY
Definition assignBondOrderProcessor.h:244
BALL::AssignBondOrderProcessor::Default::KEKULIZE_RINGS
static const bool KEKULIZE_RINGS
Definition assignBondOrderProcessor.h:239
BALL::AssignBondOrderProcessor::Default::OVERWRITE_SINGLE_BOND_ORDERS
static const bool OVERWRITE_SINGLE_BOND_ORDERS
Definition assignBondOrderProcessor.h:231
BALL::AssignBondOrderProcessor::Default::APPLY_FIRST_SOLUTION
static const bool APPLY_FIRST_SOLUTION
Definition assignBondOrderProcessor.h:247
BALL::AssignBondOrderProcessor::Default::MAX_BOND_ORDER
static const int MAX_BOND_ORDER
Definition assignBondOrderProcessor.h:242
BALL::AssignBondOrderProcessor::Option
Option names.
Definition assignBondOrderProcessor.h:113
BALL::AssignBondOrderProcessor::Option::APPLY_FIRST_SOLUTION
static const char * APPLY_FIRST_SOLUTION
Definition assignBondOrderProcessor.h:224
BALL::AssignBondOrderProcessor::Option::OVERWRITE_SELECTED_BONDS
static const char * OVERWRITE_SELECTED_BONDS
Definition assignBondOrderProcessor.h:140
BALL::AssignBondOrderProcessor::Option::CONNECTIVITY_CUTOFF
static const char * CONNECTIVITY_CUTOFF
Definition assignBondOrderProcessor.h:158
BALL::AssignBondOrderProcessor::Option::OVERWRITE_DOUBLE_BOND_ORDERS
static const char * OVERWRITE_DOUBLE_BOND_ORDERS
Definition assignBondOrderProcessor.h:123
BALL::AssignBondOrderProcessor::Option::KEKULIZE_RINGS
static const char * KEKULIZE_RINGS
Definition assignBondOrderProcessor.h:166
BALL::AssignBondOrderProcessor::Option::MAX_NUMBER_OF_SOLUTIONS
static const char * MAX_NUMBER_OF_SOLUTIONS
Definition assignBondOrderProcessor.h:188
BALL::AssignBondOrderProcessor::Option::ADD_HYDROGENS
static const char * ADD_HYDROGENS
Definition assignBondOrderProcessor.h:146
BALL::AssignBondOrderProcessor::Option::ALGORITHM
static const char * ALGORITHM
Definition assignBondOrderProcessor.h:170
BALL::AssignBondOrderProcessor::Option::INIFile
static const char * INIFile
Definition assignBondOrderProcessor.h:174
BALL::AssignBondOrderProcessor::Option::BOND_LENGTH_WEIGHTING
static const char * BOND_LENGTH_WEIGHTING
Definition assignBondOrderProcessor.h:218
BALL::AssignBondOrderProcessor::Option::OVERWRITE_TRIPLE_BOND_ORDERS
static const char * OVERWRITE_TRIPLE_BOND_ORDERS
Definition assignBondOrderProcessor.h:129
BALL::AssignBondOrderProcessor::Option::COMPUTE_ALSO_CONNECTIVITY
static const char * COMPUTE_ALSO_CONNECTIVITY
Definition assignBondOrderProcessor.h:152
BALL::AssignBondOrderProcessor::Option::MAX_PENALTY
static const char * MAX_PENALTY
Definition assignBondOrderProcessor.h:200
BALL::AssignBondOrderProcessor::Option::COMPUTE_ALSO_NON_OPTIMAL_SOLUTIONS
static const char * COMPUTE_ALSO_NON_OPTIMAL_SOLUTIONS
Definition assignBondOrderProcessor.h:211
BALL::AssignBondOrderProcessor::Option::USE_FINE_PENALTY
static const char * USE_FINE_PENALTY
Definition assignBondOrderProcessor.h:162
BALL::AssignBondOrderProcessor::Option::MAX_BOND_ORDER
static const char * MAX_BOND_ORDER
Definition assignBondOrderProcessor.h:178
BALL::AssignBondOrderProcessor::Option::OVERWRITE_SINGLE_BOND_ORDERS
static const char * OVERWRITE_SINGLE_BOND_ORDERS
Definition assignBondOrderProcessor.h:117
timer.h