tofgraph.h

Go to the documentation of this file.

/*
 *            Copyright 2009-2026 The VOTCA Development Team
 *                       (http://www.votca.org)
 *
 *      Licensed under the Apache License, Version 2.0 (the "License")
 *
 * You may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *              http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
 
#pragma once
#ifndef VOTCA_XTP_TOFGRAPH_H
#define VOTCA_XTP_TOFGRAPH_H
 
// Standard includes
#include <string>
#include <vector>
 
// Local VOTCA includes
#include "eigen.h"
#include "qmstate.h"
#include "topology.h"
 
namespace votca {
namespace tools {
class Property;
}
}  // namespace votca
 
namespace votca {
namespace xtp {

class ToFGraph {
 public:
  struct Options {
    Index axis = 0;
    double source_thickness = 0.0;
    double sink_thickness = 0.0;
    std::string source_pattern = "";
    std::string sink_pattern = "";
    bool bulk = false;
    std::vector<std::string> ignore_types;
  };

  static Options BulkOptions(const std::string& injection_pattern,
                             const std::string& ignore_types);

  static Options OptionsFromProperty(const tools::Property& tof);
 
  enum class Role { Bulk, Source, Sink };
 
  struct Site {
    Index segment = -1;
    Eigen::Vector3d pos = Eigen::Vector3d::Zero();
    double x = 0.0;
    Role role = Role::Bulk;
    bool reaches_sink = false;
    double energy = 0.0;
    double potential = 0.0;
    bool ignored = false;
  };
 
  struct Edge {
    Index to = -1;
    double rate = 0.0;
    Eigen::Vector3d dR = Eigen::Vector3d::Zero();  // pos(to) - pos(from)
    Index pair = -1;                               // id in the neighbour list
  };

  class EdgeRange {
   public:
    EdgeRange(const Edge* b, const Edge* e) : begin_(b), end_(e) {}
    const Edge* begin() const { return begin_; }
    const Edge* end() const { return end_; }
    Index size() const { return Index(end_ - begin_); }
 
   private:
    const Edge* begin_;
    const Edge* end_;
  };

  ToFGraph(const Topology& top, const Options& opt, QMStateType carrier,
           double temperature, const Eigen::Vector3d& field);
 
  Index NumberOfSites() const { return Index(sites_.size()); }
  const std::vector<Site>& Sites() const { return sites_; }
  const Site& getSite(Index i) const { return sites_[i]; }
 
  EdgeRange OutEdges(Index i) const {
    return EdgeRange(edges_.data() + offsets_[i],
                     edges_.data() + offsets_[i + 1]);
  }
  Index NumberOfEdges() const { return Index(edges_.size()); }
  Index EdgeOffset(Index i) const { return offsets_[i]; }
  const Edge& getEdge(Index e) const { return edges_[e]; }
  double EscapeRate(Index i) const { return escape_rates_[i]; }

  const std::vector<Index>& SourceSites() const { return sources_; }
  const std::vector<Index>& DisconnectedSources() const {
    return disconnected_sources_;
  }
  const std::vector<Index>& SinkSites() const { return sinks_; }
 
  Index NumberOfCutPairs() const { return cut_pairs_; }
  Index NumberOfIgnoredSites() const { return ignored_sites_; }
  bool isBulk() const { return opt_.bulk; }

  const Eigen::Vector3d& Normal() const { return normal_; }
  double Thickness() const { return thickness_; }
  double Length() const { return length_; }

  bool isReversible() const { return reversible_; }
  double DetailedBalanceDeviation() const { return db_deviation_; }
 
  QMStateType CarrierType() const { return carrier_; }
  double Temperature() const { return temperature_; }
  const Eigen::Vector3d& Field() const { return field_; }

  std::string Summary() const;
 
 private:
  Options opt_;
  QMStateType carrier_;
  double temperature_;
  Eigen::Vector3d field_;
 
  std::vector<Site> sites_;
  std::vector<Edge> edges_;
  std::vector<Index> offsets_;
  std::vector<double> escape_rates_;
  std::vector<Index> sources_;
  std::vector<Index> disconnected_sources_;
  std::vector<Index> sinks_;
  Index cut_pairs_ = 0;
  Index ignored_sites_ = 0;
  Index sites_without_sink_ = 0;
  Eigen::Vector3d normal_ = Eigen::Vector3d::Zero();
  double thickness_ = 0.0;
  double length_ = 0.0;
  bool reversible_ = false;
  double db_deviation_ = 0.0;
 
  void SetupSites(const Topology& top);
  void SetupEdges(const Topology& top);
  void FindReachability();
  void SetupBulkSources();
};
 
}  // namespace xtp
}  // namespace votca
 
#endif  // VOTCA_XTP_TOFGRAPH_H