How to use the wntr.aml.aml.expression.Node function in wntr

return _expression.Expression_get_type(self)

    __swig_setmethods__["nodes"] = _expression.Expression_nodes_set
    __swig_getmethods__["nodes"] = _expression.Expression_nodes_get
    if _newclass:
        nodes = _swig_property(_expression.Expression_nodes_get, _expression.Expression_nodes_set)
    __swig_setmethods__["vars"] = _expression.Expression_vars_set
    __swig_getmethods__["vars"] = _expression.Expression_vars_get
    if _newclass:
        vars = _swig_property(_expression.Expression_vars_get, _expression.Expression_vars_set)
    __swig_destroy__ = _expression.delete_Expression
    __del__ = lambda self: None
Expression_swigregister = _expression.Expression_swigregister
Expression_swigregister(Expression)

class VarVarMultiplyOperator(Node):
    """Proxy of C++ VarVarMultiplyOperator class."""

    __swig_setmethods__ = {}
    for _s in [Node]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VarVarMultiplyOperator, name, value)
    __swig_getmethods__ = {}
    for _s in [Node]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, VarVarMultiplyOperator, name)
    __repr__ = _swig_repr

    def __init__(self, n1, n2):
        """
        __init__(VarVarMultiplyOperator self, std::shared_ptr< Node > n1, std::shared_ptr< Node > n2) -> VarVarMultiplyOperator

has_ad2(VarOperatorDivideOperator self, Var arg2, Var arg3) -> bool

        Parameters
        ----------
        arg2: Var &
        arg3: Var &

        """
        return _expression.VarOperatorDivideOperator_has_ad2(self, arg2, arg3)

    __swig_destroy__ = _expression.delete_VarOperatorDivideOperator
    __del__ = lambda self: None
VarOperatorDivideOperator_swigregister = _expression.VarOperatorDivideOperator_swigregister
VarOperatorDivideOperator_swigregister(VarOperatorDivideOperator)

class ParamVarDivideOperator(Node):
    """Proxy of C++ ParamVarDivideOperator class."""

    __swig_setmethods__ = {}
    for _s in [Node]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ParamVarDivideOperator, name, value)
    __swig_getmethods__ = {}
    for _s in [Node]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ParamVarDivideOperator, name)
    __repr__ = _swig_repr

    def __init__(self, n1, n2):
        """
        __init__(ParamVarDivideOperator self, std::shared_ptr< Node > n1, std::shared_ptr< Node > n2) -> ParamVarDivideOperator

return _expression.Node_multiply_const(self, arg2)


    def _print(self):
        """
        _print(Node self) -> std::string

        Parameters
        ----------
        self: Node *

        """
        return _expression.Node__print(self)

Node_swigregister = _expression.Node_swigregister
Node_swigregister(Node)

class Summation(Node):
    """Proxy of C++ Summation class."""

    __swig_setmethods__ = {}
    for _s in [Node]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Summation, name, value)
    __swig_getmethods__ = {}
    for _s in [Node]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Summation, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(Summation self) -> Summation"""

has_ad2(VarParamMultiplyOperator self, Var arg2, Var arg3) -> bool

        Parameters
        ----------
        arg2: Var &
        arg3: Var &

        """
        return _expression.VarParamMultiplyOperator_has_ad2(self, arg2, arg3)

    __swig_destroy__ = _expression.delete_VarParamMultiplyOperator
    __del__ = lambda self: None
VarParamMultiplyOperator_swigregister = _expression.VarParamMultiplyOperator_swigregister
VarParamMultiplyOperator_swigregister(VarParamMultiplyOperator)

class VarOperatorMultiplyOperator(Node):
    """Proxy of C++ VarOperatorMultiplyOperator class."""

    __swig_setmethods__ = {}
    for _s in [Node]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VarOperatorMultiplyOperator, name, value)
    __swig_getmethods__ = {}
    for _s in [Node]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, VarOperatorMultiplyOperator, name)
    __repr__ = _swig_repr

    def __init__(self, n1, n2):
        """
        __init__(VarOperatorMultiplyOperator self, std::shared_ptr< Node > n1, std::shared_ptr< Node > n2) -> VarOperatorMultiplyOperator

has_ad2(OperatorOperatorMultiplyOperator self, Var arg2, Var arg3) -> bool

        Parameters
        ----------
        arg2: Var &
        arg3: Var &

        """
        return _expression.OperatorOperatorMultiplyOperator_has_ad2(self, arg2, arg3)

    __swig_destroy__ = _expression.delete_OperatorOperatorMultiplyOperator
    __del__ = lambda self: None
OperatorOperatorMultiplyOperator_swigregister = _expression.OperatorOperatorMultiplyOperator_swigregister
OperatorOperatorMultiplyOperator_swigregister(OperatorOperatorMultiplyOperator)

class VarVarDivideOperator(Node):
    """Proxy of C++ VarVarDivideOperator class."""

    __swig_setmethods__ = {}
    for _s in [Node]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VarVarDivideOperator, name, value)
    __swig_getmethods__ = {}
    for _s in [Node]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, VarVarDivideOperator, name)
    __repr__ = _swig_repr

    def __init__(self, n1, n2):
        """
        __init__(VarVarDivideOperator self, std::shared_ptr< Node > n1, std::shared_ptr< Node > n2) -> VarVarDivideOperator

has_ad2(ParamVarPowerOperator self, Var arg2, Var arg3) -> bool

        Parameters
        ----------
        arg2: Var &
        arg3: Var &

        """
        return _expression.ParamVarPowerOperator_has_ad2(self, arg2, arg3)

    __swig_destroy__ = _expression.delete_ParamVarPowerOperator
    __del__ = lambda self: None
ParamVarPowerOperator_swigregister = _expression.ParamVarPowerOperator_swigregister
ParamVarPowerOperator_swigregister(ParamVarPowerOperator)

class ParamParamPowerOperator(Node):
    """Proxy of C++ ParamParamPowerOperator class."""

    __swig_setmethods__ = {}
    for _s in [Node]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ParamParamPowerOperator, name, value)
    __swig_getmethods__ = {}
    for _s in [Node]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ParamParamPowerOperator, name)
    __repr__ = _swig_repr

    def __init__(self, n1, n2):
        """
        __init__(ParamParamPowerOperator self, std::shared_ptr< Node > n1, std::shared_ptr< Node > n2) -> ParamParamPowerOperator

has_ad2(VarParamDivideOperator self, Var arg2, Var arg3) -> bool

        Parameters
        ----------
        arg2: Var &
        arg3: Var &

        """
        return _expression.VarParamDivideOperator_has_ad2(self, arg2, arg3)

    __swig_destroy__ = _expression.delete_VarParamDivideOperator
    __del__ = lambda self: None
VarParamDivideOperator_swigregister = _expression.VarParamDivideOperator_swigregister
VarParamDivideOperator_swigregister(VarParamDivideOperator)

class VarOperatorDivideOperator(Node):
    """Proxy of C++ VarOperatorDivideOperator class."""

    __swig_setmethods__ = {}
    for _s in [Node]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VarOperatorDivideOperator, name, value)
    __swig_getmethods__ = {}
    for _s in [Node]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, VarOperatorDivideOperator, name)
    __repr__ = _swig_repr

    def __init__(self, n1, n2):
        """
        __init__(VarOperatorDivideOperator self, std::shared_ptr< Node > n1, std::shared_ptr< Node > n2) -> VarOperatorDivideOperator

has_ad2(OperatorOperatorDivideOperator self, Var arg2, Var arg3) -> bool

        Parameters
        ----------
        arg2: Var &
        arg3: Var &

        """
        return _expression.OperatorOperatorDivideOperator_has_ad2(self, arg2, arg3)

    __swig_destroy__ = _expression.delete_OperatorOperatorDivideOperator
    __del__ = lambda self: None
OperatorOperatorDivideOperator_swigregister = _expression.OperatorOperatorDivideOperator_swigregister
OperatorOperatorDivideOperator_swigregister(OperatorOperatorDivideOperator)

class VarVarPowerOperator(Node):
    """Proxy of C++ VarVarPowerOperator class."""

    __swig_setmethods__ = {}
    for _s in [Node]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VarVarPowerOperator, name, value)
    __swig_getmethods__ = {}
    for _s in [Node]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, VarVarPowerOperator, name)
    __repr__ = _swig_repr

    def __init__(self, n1, n2):
        """
        __init__(VarVarPowerOperator self, std::shared_ptr< Node > n1, std::shared_ptr< Node > n2) -> VarVarPowerOperator

has_ad2(ParamParamDivideOperator self, Var arg2, Var arg3) -> bool

        Parameters
        ----------
        arg2: Var &
        arg3: Var &

        """
        return _expression.ParamParamDivideOperator_has_ad2(self, arg2, arg3)

    __swig_destroy__ = _expression.delete_ParamParamDivideOperator
    __del__ = lambda self: None
ParamParamDivideOperator_swigregister = _expression.ParamParamDivideOperator_swigregister
ParamParamDivideOperator_swigregister(ParamParamDivideOperator)

class ParamOperatorDivideOperator(Node):
    """Proxy of C++ ParamOperatorDivideOperator class."""

    __swig_setmethods__ = {}
    for _s in [Node]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ParamOperatorDivideOperator, name, value)
    __swig_getmethods__ = {}
    for _s in [Node]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ParamOperatorDivideOperator, name)
    __repr__ = _swig_repr

    def __init__(self, n1, n2):
        """
        __init__(ParamOperatorDivideOperator self, std::shared_ptr< Node > n1, std::shared_ptr< Node > n2) -> ParamOperatorDivideOperator

----------
        self: Var *

        """
        return _expression.Var_get_type(self)

    __swig_setmethods__["name"] = _expression.Var_name_set
    __swig_getmethods__["name"] = _expression.Var_name_get
    if _newclass:
        name = _swig_property(_expression.Var_name_get, _expression.Var_name_set)
    __swig_destroy__ = _expression.delete_Var
    __del__ = lambda self: None
Var_swigregister = _expression.Var_swigregister
Var_swigregister(Var)

class Param(Node):
    """Proxy of C++ Param class."""

    __swig_setmethods__ = {}
    for _s in [Node]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Param, name, value)
    __swig_getmethods__ = {}
    for _s in [Node]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Param, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(Param self) -> Param"""
        this = _expression.new_Param()
        try: