dgvertex.h

/*
 *  Copyright (C) 2004-2021 Edward F. Valeev
 *
 *  This file is part of Libint.
 *
 *  Libint is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  Libint is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Libint.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef _libint2_src_bin_libint_dgvertex_h_
#define _libint2_src_bin_libint_dgvertex_h_
 
#include <list>
#include <vector>
//#include <dg.h>
#include <global_macros.h>
#include <drtree.h>
#include <dgarc.h>
#include <iostream>
#include <string>
#include <smart_ptr.h>
#include <memory.h>
#include <exception.h>
#include <hashable.h>
#include <key.h>
 
namespace libint2 {
 
  class DirectedGraph;
 
  class DGVertex : public Hashable<KeyTypes::InstanceID,ComputeKey> {
  public:
    typedef MemoryManager::Address Address;
    typedef MemoryManager::Size Size;
    typedef NotSet<Address> AddressNotSet;
    typedef NotSet<std::string> GraphLabelNotSet;
    typedef NotSet<std::string> SymbolNotSet;
    typedef KeyTypes::ClassID ClassID;
    typedef KeyTypes::InstanceID InstanceID;
    typedef KeyTypes::InstanceID KeyType;
    typedef Hashable<KeyType,ComputeKey>::KeyReturnType KeyReturnType;
    typedef std::list< SafePtr<DGArc> > ArcSetType;
 
    ClassID typeid_;
    InstanceID instid_;
    DGVertex(ClassID tid);
    DGVertex(ClassID tid, const std::vector<SafePtr<DGArc> >& parents, const std::vector<SafePtr<DGArc> >& children);
    DGVertex(const DGVertex& v);
    virtual ~DGVertex();
 
    void make_a_target();
    bool is_a_target() const { return target_;};
    virtual void add_exit_arc(const SafePtr<DGArc>&);
    virtual void del_exit_arcs();
    void replace_exit_arc(const SafePtr<DGArc>& A, const SafePtr<DGArc>& B);
    void detach();
 
    const ArcSetType& exit_arcs() const { return children_; }
    const ArcSetType& entry_arcs() const { return parents_; }
    unsigned int num_entry_arcs() const;
    ArcSetType::const_iterator first_entry_arc() const { return parents_.begin(); }
    ArcSetType::const_iterator plast_entry_arc() const { return parents_.end(); }
    unsigned int num_exit_arcs() const;
    ArcSetType::const_iterator first_exit_arc() const { return children_.begin(); }
    ArcSetType::const_iterator plast_exit_arc() const { return children_.end(); }
    const SafePtr<DGArc>& exit_arc(const SafePtr<DGVertex>& v) const;
 
    virtual KeyReturnType key() const =0;
    virtual bool equiv(const SafePtr<DGVertex>&) const =0;
 
    bool precomputed() const;
 
    virtual unsigned int size() const =0;
 
    virtual const std::string& label() const =0;
    virtual const std::string& id() const =0;
    virtual std::string description() const =0;
    virtual void print(std::ostream& os) const;
 
    const DirectedGraph* dg() const { return dg_; }
    void dg(const DirectedGraph* d) { dg_ = d; }
    const std::string& graph_label() const;
    void set_graph_label(const std::string& graph_label);
 
    const SafePtr<DRTree>& subtree() const { return subtree_; }
 
    //
    // NOTE : the following functions probably belong to a separate class, such as Entity!
    //
 
    void refer_this_to(const SafePtr<DGVertex>&  V);
    bool refers_to_another() const { return referred_vertex_ != 0; }
    const std::string& symbol() const;
    void set_symbol(const std::string& symbol);
    bool symbol_set() const;
    void reset_symbol();
    Address address() const;
    void set_address(const Address& address);
    bool address_set() const;
    void need_to_compute(bool ntc);
    void not_need_to_compute() { need_to_compute(false); }
    bool need_to_compute() const;
#if CHECK_SAFETY
    bool declared() const { return  precomputed() ? true : declared_; }
    void declared(bool d) { declared_ = d; }
#endif
 
    void prepare_to_traverse();
    unsigned int tag();
    void schedule() { scheduled_ = true; }
    bool scheduled() const { return scheduled_; }
    SafePtr<DGVertex> postcalc() const { return postcalc_; };
    void set_postcalc(const SafePtr<DGVertex>& postcalc) { postcalc_ = postcalc; };
 
    void reset();
    virtual void unregister() const;
 
  public:
 
    virtual bool this_precomputed() const =0;
 
  private:
    const DirectedGraph* dg_;
    std::string graph_label_;
 
    const DGVertex* referred_vertex_;
    std::vector<const DGVertex*> refs_;
    void register_reference(const DGVertex*);
 
    std::string symbol_;
    Address address_;
    // Whether this vertex needs to be computed
    bool need_to_compute_;
#if CHECK_SAFETY
    // has the symbol been declared in the code?
    bool declared_;
#endif
 
    ArcSetType parents_;
    ArcSetType children_;
 
    // Whether this is a "target" vertex, i.e. the target of a calculation
    bool target_;
    // If set to true -- traversal has started and add_entry... cannot be called
    bool can_add_arcs_;
 
    void del_exit_arc(const SafePtr<DGArc>& c);
    void add_entry_arc(const SafePtr<DGArc>&);
    void del_entry_arc(const SafePtr<DGArc>&);
 
    // These members used in traversal and scheduling algorithms
 
    unsigned int num_tagged_arcs_;
    SafePtr<DGVertex> postcalc_;
    bool scheduled_;
 
 
    // Refback to subtree which contains this vertex
 
    // note that this is a refback (back reference to the "owning" object) so changing it
    // does not change class invariant -- hence mutable
 
    mutable SafePtr<DRTree> subtree_;
    friend void DRTree::add_vertex(const SafePtr<DGVertex>& vertex);
    friend void DRTree::detach_from(const SafePtr<DGVertex>& v);
 
  };
 
  //
  // Nonmember predicates
  //
  struct UnrolledIntegralSet : public std::unary_function<const SafePtr<DGVertex>&,bool> {
    bool operator()(const SafePtr<DGVertex>& V);
  };
  struct NotUnrolledIntegralSet : public std::unary_function<const SafePtr<DGVertex>&,bool> {
    bool operator()(const SafePtr<DGVertex>& V);
  };
  struct IntegralInTargetIntegralSet : public std::unary_function<const SafePtr<DGVertex>&,bool> {
    bool operator()(const SafePtr<DGVertex>& V);
  };
 
  inline DGVertexKey key(const DGVertex& v) {
    return DGVertexKey(v.typeid_,v.instid_);
  }
 
};
 
#endif