intset_to_ints.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/>.
 *
 */
 
#include <iostream>
#include <string>
#include <vector>
#include <stdexcept>
#include <cassert>
#include <rr.h>
#include <integral.h>
#include <iter.h>
#include <algebra.h>
 
#ifndef _libint2_src_bin_libint_intsettoints_h_
#define _libint2_src_bin_libint_intsettoints_h_
 
namespace libint2 {
 
  class IntegralSet_to_Integrals_base {
  protected:
    virtual ~IntegralSet_to_Integrals_base() {}
  };
 
  template <class I>
  class IntegralSet_to_Integrals : public RecurrenceRelation,
    public IntegralSet_to_Integrals_base {
  public:
    typedef I TargetType;
    typedef typename I::iter_type ChildType;
    typedef RecurrenceRelation::ExprType ExprType;
 
    IntegralSet_to_Integrals(const SafePtr<I>&);
    virtual ~IntegralSet_to_Integrals() {}
 
    static SafePtr<IntegralSet_to_Integrals<I>> Instance(const SafePtr<TargetType>& Tint, unsigned int dir) {
      assert(dir == 0);
      // attempt to construct
      SafePtr<IntegralSet_to_Integrals<I>> this_ptr(new IntegralSet_to_Integrals<I>(Tint));
      // if succeeded (nchildren > 0) do post-construction
      assert(this_ptr->num_children() != 0);
      return this_ptr;
    }
    static bool directional() { return false; }
 
 
    unsigned int num_children() const override { return children_.size(); }
    SafePtr<TargetType> target() const { return target_; };
    SafePtr<ChildType> child(unsigned int i) const;
    SafePtr<DGVertex> rr_target() const override { return static_pointer_cast<DGVertex,TargetType>(target()); }
    SafePtr<DGVertex> rr_child(unsigned int i) const override { return static_pointer_cast<DGVertex,ChildType>(child(i)); }
    bool is_simple() const override {
      return true;
    }
    bool invariant_type() const override {
      // Converts from one BFSet to another!
      return false;
    }
 
  private:
    SafePtr<TargetType> target_;
    std::vector< SafePtr<ChildType> > children_;
 
    std::string generate_label() const override {
      return "IntegralSet_to_Integrals";
      //throw std::runtime_error("IntegralSet_to_Integrals::label() -- code for this RR is never generated, so this function should never be used");
    }
    std::string spfunction_call(const SafePtr<CodeContext>& context,
                                const SafePtr<ImplicitDimensions>& dims) const override
    {
      throw std::logic_error("IntegralSet_to_Integrals::spfunction_call -- should not call this function");
    }
 
  };
 
 
  template <class I>
    IntegralSet_to_Integrals<I>::IntegralSet_to_Integrals(const SafePtr<I>& Tint) :
    target_(Tint)
    {
      target_ = Tint;
 
      // Construct a subiterator for I
      SubIteratorBase<I> siter(Tint);
 
      // Set children pointers
      for(siter.init(); siter; ++siter)
        children_.push_back(siter.elem());
    };
 
  template <class I>
    SafePtr<typename I::iter_type>
    IntegralSet_to_Integrals<I>::child(unsigned int i) const
    {
      return children_.at(i);
    };
 
 
};
 
#endif