assigner.hpp

Go to the documentation of this file.

#ifndef INDIGOX_ALGORITHM_ELECTRON_OPTIMISER_HPP
#define INDIGOX_ALGORITHM_ELECTRON_OPTIMISER_HPP

#include "../../classes/periodictable.hpp"
#include "../../graph/assignment.hpp"
#include "../../utils/common.hpp"
#include "../../utils/fwd_declares.hpp"
#include <boost/dynamic_bitset/dynamic_bitset.hpp>

#include <EASTL/vector_set.h>
#include <bitset>
#include <cstdint>
#include <map>
#include <set>
#include <string>
#include <vector>

namespace indigox::algorithm {

  using score_t = uint64_t;
  using AssignMask = boost::dynamic_bitset<>;
  using key_t = uint32_t;
  using ScoreTable = std::map<key_t, score_t>;

  class IXElectronAssigner {
    friend ElectronAssigner CreateElectronAssigner(const Molecule &m);

  public:
    class AssignAlgorithm {
    protected:
      enum _bool_opts {
        __pairs,      
        __charged_c,  
        __preplace,   
        __initalised, 
        __num_opts    
      };

    public:
      AssignAlgorithm() = delete; // no default constructor

      AssignAlgorithm(const ScoreTable &t);

      virtual ~AssignAlgorithm() {}

      virtual void Initalise(const Molecule &m);

      virtual void Run() = 0;

      graph::AssignmentGraph GetAssignmentGraph();

      inline score_t GetOptimisedScore() const { return _min_score; }

      inline size_t GetOptimalCount() const { return _results.size(); }

      bool ApplyAssignment(size_t idx);

      bool IsInitalised() const { return _opts[__initalised]; }

    protected:
      AssignMask CalculateUpperLimit();

      score_t CalculateVertexScore(const graph::AGVertex &v) const;

      score_t CalculateAssignmentScore(const AssignMask &a);

      void SetAssignment(const AssignMask &a);

    protected:
      _Molecule _mol;
      graph::AssignmentGraph _g;
      std::vector<graph::AGVertex> _locs;
      size_t _num_e;
      std::bitset<__num_opts> _opts;
      const score_t _inf;
      score_t _min_score;
      score_t _limit;
      std::vector<AssignMask> _results;
      const ScoreTable &_table;
      int16_t _max_charge;
      uint16_t _max_results;
      AssignMask _previous_mask;
    };

    enum class AssignerAlgorithm {
      LocalOptimisation, 
      AStar,             
      FPT                
    };

    struct Settings {
      static AssignerAlgorithm Algorithm;

      static utils::Option ElectronPairs;

      static utils::Option ChargedCarbon;

      static utils::Option Preassign;

      static std::string ScoreFile;

      static score_t Infinity;

      static uint8_t MaxBondOrder;

      static int16_t MaxChargeMagnitude;

      static uint16_t MaxNumResults;

      static eastl::vector_set<Element> AllowedElements;
    };

  public:
    IXElectronAssigner() = delete; // no default constructor

  private:
    IXElectronAssigner(const Molecule &mol) : _mol(mol) {}

  public:
    size_t Run();

    inline graph::AssignmentGraph GetAssignmentGraph() {
      return _algo->GetAssignmentGraph();
    }

    void LoadScoreTable();

    inline bool ApplyAssignment(size_t idx) {
      return _algo->ApplyAssignment(idx);
    }

    inline size_t GetOptimalCount() const { return _algo->GetOptimalCount(); }
    inline score_t GetOptimisedScore() const {
      return _algo->GetOptimisedScore();
    }

  private:
    _Molecule _mol;
    std::unique_ptr<AssignAlgorithm> _algo;
    ScoreTable _table;
    std::string _current_file;
  };

  using AssignerAlgorithm = IXElectronAssigner::AssignerAlgorithm;

  inline ElectronAssigner CreateElectronAssigner(const Molecule &m) {
    return ElectronAssigner(new IXElectronAssigner(m));
  }
} // namespace indigox::algorithm

#endif /* INDIGOX_ALGORITHM_ELECTRON_OPTIMISER_HPP */