RGroupGa.h

Go to the documentation of this file.

//
//  Copyright (C) 2020 Gareth Jones, Glysade LLC
//
//   @@ All Rights Reserved @@
//  This file is part of the RDKit.
//  The contents are covered by the terms of the BSD license
//  which is included in the file license.txt, found at the root
//  of the RDKit source tree.
//
 
#ifndef RGROUPDECOMPGA_H_
#define RGROUPDECOMPGA_H_
 
#include <vector>
#include <memory>
#include <map>
#include <chrono>
 
#include "../../../External/GA/ga/StringChromosome.h"
#include "../../../External/GA/ga/GaBase.h"
#include "../../../External/GA/ga/GaOperation.h"
#include "../../../External/GA/ga/LinkedPopLinearSel.h"
#include "../../../External/GA/ga/IntegerStringChromosomePolicy.h"
#include "RGroupFingerprintScore.h"
#include "RGroupScore.h"
 
namespace RDKit {
 
using namespace GapeGa;
using namespace std;
 
class RGroupDecompositionChromosome;
class RGroupGa;
struct RGroupDecompData;
 
typedef LinkedPopLinearSel<RGroupDecompositionChromosome, RGroupGa>
    RGroupGaPopulation;
 
typedef enum {
  RgroupMutate = 0x01,
  Crossover = 0x02,
  Create = 0x04,
} OperationName;
 
class RGroupDecompositionChromosome : public IntegerStringChromosome {
 public:
  RGroupDecompositionChromosome(RGroupGa &rGroupGa);
 
  double getFitness() const { return fitness; }
 
  OperationName getOperationName() const { return operationName; }
 
  void setOperationName(OperationName operationName) {
    this->operationName = operationName;
  }
 
  std::string info() const;
 
  double score();
 
  double recalculateScore();
 
  bool isOk() { return true; }
 
  void decode();
 
  void copyGene(const StringChromosomeBase &other) override;
 
  FingerprintVarianceScoreData &getFingerprintVarianceScoreData() {
    return fingerprintVarianceScoreData;
  }
 
  const vector<size_t> &getPermutation() const { return permutation; }
 
  const RGroupGa &getRGroupGA() const { return rGroupGa; }
 
 private:
  RGroupDecompositionChromosome(const RGroupDecompositionChromosome &other) =
      delete;
  RGroupDecompositionChromosome &operator=(
      const RGroupDecompositionChromosome &other) = delete;
  double fitness{0.0};
  FingerprintVarianceScoreData fingerprintVarianceScoreData;
  OperationName operationName = Create;
  vector<size_t> permutation;
 
  RGroupGa &rGroupGa;
};
 
struct GaResult {
  RGroupScorer rGroupScorer;
 
  GaResult(const double score, const vector<vector<size_t>> &permutations)
      : rGroupScorer(RGroupScorer(permutations, score)) {}
  GaResult(const GaResult &other) : rGroupScorer(other.rGroupScorer) {}
 
  GaResult() {}
 
  // Copy constructor required by MSVC for future<GaResult>
  GaResult &operator=(const GaResult &other);
};
 
class RDKIT_RGROUPDECOMPOSITION_EXPORT RGroupGa : public GaBase {
 public:
  RGroupGa(const RGroupDecompData &rGroupData,
           const chrono::steady_clock::time_point *const t0 = nullptr);
 
  IntegerStringChromosomePolicy &getChromosomePolicy() {
    return chromosomePolicy;
  }
 
  int chromosomeLength() const { return chromLength; }
 
  int numberDecompositions() const { return numberDecomps; }
 
  GaResult run(int runNumber = 1);
 
  vector<GaResult> runBatch();
 
  shared_ptr<RGroupDecompositionChromosome> createChromosome();
 
  const RGroupDecompData &getRGroupData() const { return rGroupData; }
 
  const vector<shared_ptr<GaOperation<RGroupDecompositionChromosome>>>
  getOperations() const;
 
  unsigned int numberPermutations() const { return numPermutations; }
 
 private:
  RGroupGa(const RGroupGa &other) = delete;
  RGroupGa &operator=(const RGroupGa &other) = delete;
  const RGroupDecompData &rGroupData;
 
  IntegerStringChromosomePolicy chromosomePolicy;
  int numberOperations;
  int numberOperationsWithoutImprovement;
  int chromLength;
  unsigned int numPermutations;
  int numberDecomps;
  const chrono::steady_clock::time_point *const t0;
 
  void createOperations();
 
  static void rGroupMutateOperation(
      const std::vector<std::shared_ptr<RGroupDecompositionChromosome>>
          &parents,
      std::vector<std::shared_ptr<RGroupDecompositionChromosome>> &children);
  static void rGroupCrossoverOperation(
      const std::vector<std::shared_ptr<RGroupDecompositionChromosome>>
          &parents,
      std::vector<std::shared_ptr<RGroupDecompositionChromosome>> &children);
};
 
void copyVarianceData(const FingerprintVarianceScoreData &fromData,
                      FingerprintVarianceScoreData &toData);
 
void clearVarianceData(
    FingerprintVarianceScoreData &fingerprintVarianceScoreData);
 
}  // namespace RDKit
 
#endif  // RGROUPDECOMPGA_H_