eigen_newton_solver_block.hpp

Go to the documentation of this file.

/*
 * Copyright 2023 Blue Brain Project, EPFL.
 * See the top-level LICENSE file for details.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
///
/// THIS FILE IS GENERATED AT BUILD TIME AND SHALL NOT BE EDITED.
///
 
#pragma once
 
/**
 * \dir
 * \brief Auto generated AST Implementations
 *
 * \file
 * \brief Auto generated AST classes declaration
 */
 
#include "ast/ast_decl.hpp"
#include "ast/block.hpp"
 
namespace nmodl::ast {
 
/**
 * \addtogroup ast_class
 * \ingroup ast
 * \{
 */
 
/**
 * \brief Represent newton solver solution block based on Eigen
 *
 * 
*/
class EigenNewtonSolverBlock : public Block {
  private:
    /// number of state vars used in solve
    std::shared_ptr<Integer> n_state_vars;
    /// Statements to be declared in the functor
    std::shared_ptr<StatementBlock> variable_block;
    /// Statement block to be executed before calling newton solver
    std::shared_ptr<StatementBlock> initialize_block;
    /// update X from states
    std::shared_ptr<StatementBlock> setup_x_block;
    /// odes as functor for eigen
    std::shared_ptr<StatementBlock> functor_block;
    /// update back states from X
    std::shared_ptr<StatementBlock> update_states_block;
    /// Statement block to be executed after calling newton solver
    std::shared_ptr<StatementBlock> finalize_block;
    /// token with location information
    std::shared_ptr<ModToken> token;
    /// symbol table for a block
    symtab::SymbolTable* symtab = nullptr;
 
  public:
  /// \name Ctor & dtor
  /// \{
    explicit EigenNewtonSolverBlock(Integer* n_state_vars, StatementBlock* variable_block, StatementBlock* initialize_block, StatementBlock* setup_x_block, StatementBlock* functor_block, StatementBlock* update_states_block, StatementBlock* finalize_block);
    explicit EigenNewtonSolverBlock(std::shared_ptr<Integer> n_state_vars, std::shared_ptr<StatementBlock> variable_block, std::shared_ptr<StatementBlock> initialize_block, std::shared_ptr<StatementBlock> setup_x_block, std::shared_ptr<StatementBlock> functor_block, std::shared_ptr<StatementBlock> update_states_block, std::shared_ptr<StatementBlock> finalize_block);
    EigenNewtonSolverBlock(const EigenNewtonSolverBlock& obj);
    virtual ~EigenNewtonSolverBlock() = default;
  /// \}
  
  /**
   * \brief Check if the ast node is an instance of ast::EigenNewtonSolverBlock
   * \return true as object is of type ast::EigenNewtonSolverBlock
   */
  bool is_eigen_newton_solver_block () const noexcept override {
    return true;
  }
 
  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * \return pointer to the clone/copy of the current node
   */
  // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks)
   EigenNewtonSolverBlock* clone() const override {
    return new EigenNewtonSolverBlock(*this);
  }
  // NOLINTEND(clang-analyzer-cplusplus.NewDeleteLeaks)
 
  /// \name Getters
  /// \{
 
  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::EIGEN_NEWTON_SOLVER_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::EIGEN_NEWTON_SOLVER_BLOCK;
  }
 
  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "EigenNewtonSolverBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "EigenNewtonSolverBlock";
  }
 
    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "EIGEN_NEWTON_SOLVE"
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "EIGEN_NEWTON_SOLVE";
    }
 
  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<EigenNewtonSolverBlock>(shared_from_this());
  }
 
  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const EigenNewtonSolverBlock>(shared_from_this());
  }
 
  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
   * can insert new nodes in the ast as a solution of ODEs. In this case, we return
   * nullptr to store in the nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken* get_token() const noexcept override {
    return token.get();
  }
  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable* get_symbol_table() const override {
    return symtab;
  }
  
  
  
  /**
   * \brief Getter for member variable \ref EigenNewtonSolverBlock.n_state_vars
   */
  std::shared_ptr<Integer> get_n_state_vars() const noexcept  {
    return n_state_vars;
  }
  
  
  
  /**
   * \brief Getter for member variable \ref EigenNewtonSolverBlock.variable_block
   */
  std::shared_ptr<StatementBlock> get_variable_block() const noexcept  {
    return variable_block;
  }
  
  
  
  /**
   * \brief Getter for member variable \ref EigenNewtonSolverBlock.initialize_block
   */
  std::shared_ptr<StatementBlock> get_initialize_block() const noexcept  {
    return initialize_block;
  }
  
  
  
  /**
   * \brief Getter for member variable \ref EigenNewtonSolverBlock.setup_x_block
   */
  std::shared_ptr<StatementBlock> get_setup_x_block() const noexcept  {
    return setup_x_block;
  }
  
  
  
  /**
   * \brief Getter for member variable \ref EigenNewtonSolverBlock.functor_block
   */
  std::shared_ptr<StatementBlock> get_functor_block() const noexcept  {
    return functor_block;
  }
  
  
  
  /**
   * \brief Getter for member variable \ref EigenNewtonSolverBlock.update_states_block
   */
  std::shared_ptr<StatementBlock> get_update_states_block() const noexcept  {
    return update_states_block;
  }
  
  
  
  /**
   * \brief Getter for member variable \ref EigenNewtonSolverBlock.finalize_block
   */
  std::shared_ptr<StatementBlock> get_finalize_block() const noexcept  {
    return finalize_block;
  }
  /// \}
 
  /// \name Setters
  /// \{
  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }
  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable* newsymtab) override {
    symtab = newsymtab;
  }
  
  /**
   * \brief Setter for member variable \ref EigenNewtonSolverBlock.n_state_vars (rvalue reference)
   */
  void set_n_state_vars(std::shared_ptr<Integer>&& n_state_vars);
 
  /**
   * \brief Setter for member variable \ref EigenNewtonSolverBlock.n_state_vars
   */
  void set_n_state_vars(const std::shared_ptr<Integer>& n_state_vars);
 
  
  /**
   * \brief Setter for member variable \ref EigenNewtonSolverBlock.variable_block (rvalue reference)
   */
  void set_variable_block(std::shared_ptr<StatementBlock>&& variable_block);
 
  /**
   * \brief Setter for member variable \ref EigenNewtonSolverBlock.variable_block
   */
  void set_variable_block(const std::shared_ptr<StatementBlock>& variable_block);
 
  
  /**
   * \brief Setter for member variable \ref EigenNewtonSolverBlock.initialize_block (rvalue reference)
   */
  void set_initialize_block(std::shared_ptr<StatementBlock>&& initialize_block);
 
  /**
   * \brief Setter for member variable \ref EigenNewtonSolverBlock.initialize_block
   */
  void set_initialize_block(const std::shared_ptr<StatementBlock>& initialize_block);
 
  
  /**
   * \brief Setter for member variable \ref EigenNewtonSolverBlock.setup_x_block (rvalue reference)
   */
  void set_setup_x_block(std::shared_ptr<StatementBlock>&& setup_x_block);
 
  /**
   * \brief Setter for member variable \ref EigenNewtonSolverBlock.setup_x_block
   */
  void set_setup_x_block(const std::shared_ptr<StatementBlock>& setup_x_block);
 
  
  /**
   * \brief Setter for member variable \ref EigenNewtonSolverBlock.functor_block (rvalue reference)
   */
  void set_functor_block(std::shared_ptr<StatementBlock>&& functor_block);
 
  /**
   * \brief Setter for member variable \ref EigenNewtonSolverBlock.functor_block
   */
  void set_functor_block(const std::shared_ptr<StatementBlock>& functor_block);
 
  
  /**
   * \brief Setter for member variable \ref EigenNewtonSolverBlock.update_states_block (rvalue reference)
   */
  void set_update_states_block(std::shared_ptr<StatementBlock>&& update_states_block);
 
  /**
   * \brief Setter for member variable \ref EigenNewtonSolverBlock.update_states_block
   */
  void set_update_states_block(const std::shared_ptr<StatementBlock>& update_states_block);
 
  
  /**
   * \brief Setter for member variable \ref EigenNewtonSolverBlock.finalize_block (rvalue reference)
   */
  void set_finalize_block(std::shared_ptr<StatementBlock>&& finalize_block);
 
  /**
   * \brief Setter for member variable \ref EigenNewtonSolverBlock.finalize_block
   */
  void set_finalize_block(const std::shared_ptr<StatementBlock>& finalize_block);
 
  /// \}
 
  /// \name Visitor
  /// \{
  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;
 
  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;
 
  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;
 
  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;
  /// \}
 
  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};
 
/** \} */  // end of ast_class
 
  
  
  
  
  
  
  
 
}  // namespace nmodl::ast