コード例 #1
0
    def make_system(self, H, c_ops, tlist=None, args={}, options=None):
        if options is None:
            options = self.options
        else:
            self.options = options
        var = _collapse_args(args)

        ss = SolverSystem()
        ss.td_c_ops = []
        ss.td_n_ops = []
        ss.args = args
        ss.col_args = var
        
        if type(c_ops) is list:
            
            for c in c_ops: # Accounts for nested list format of c_ops
                cevo = QobjEvo(c, args, tlist=tlist)
                cdc = cevo._cdc()
                cevo.compile()
                cdc.compile()
                ss.td_c_ops.append(cevo)
                ss.td_n_ops.append(cdc)

            if isinstance(H, (list, Qobj, QobjEvo)):
                H_td = QobjEvo(H, args, tlist=tlist)
                H_td *= -1j
                for c in ss.td_n_ops:
                    H_td += -0.5 * c
                if options.rhs_with_state:
                    H_td._check_old_with_state()
                H_td.compile()
                ss.H_td = H_td
                ss.makefunc = _qobjevo_set
                ss.set_args = _qobjevo_args # <- redundant
                ss.type = "QobjEvo"
            elif callable(H):
                ss.h_func = H
                ss.Hc_td = -0.5 * sum(ss.td_n_ops)
                ss.Hc_td.compile()
                ss.with_state = options.rhs_with_state
                ss.makefunc = _func_set
                ss.set_args = _func_args # <- redundant
                ss.type = "callback"
        else:
            raise Exception("Format of c_ops not supported.")

        solver_safe["mcsolve"] = ss
        self.ss = ss
        self.reset()
コード例 #2
0
    def make_system(self, H, c_ops, tlist=None, args={}, options=None):
        if options is None:
            options = self.options
        else:
            self.options = options
        var = _collapse_args(args)

        ss = SolverSystem()
        ss.td_c_ops = []
        ss.td_n_ops = []
        ss.args = args
        ss.col_args = var
        for c in c_ops:
            cevo = QobjEvo(c, args, tlist=tlist)
            cdc = cevo._cdc()
            cevo.compile()
            cdc.compile()
            ss.td_c_ops.append(cevo)
            ss.td_n_ops.append(cdc)

        try:
            H_td = QobjEvo(H, args, tlist=tlist)
            H_td *= -1j
            for c in ss.td_n_ops:
                H_td += -0.5 * c
            if options.rhs_with_state:
                H_td._check_old_with_state()
            H_td.compile()
            ss.H_td = H_td
            ss.makefunc = _qobjevo_set
            ss.set_args = _qobjevo_args
            ss.type = "QobjEvo"

        except:
            ss.h_func = H
            ss.Hc_td = -0.5 * sum(ss.td_n_ops)
            ss.Hc_td.compile()
            ss.with_state = options.rhs_with_state
            ss.makefunc = _func_set
            ss.set_args = _func_args
            ss.type = "callback"

        solver_safe["mcsolve"] = ss
        self.ss = ss
        self.reset()
コード例 #3
0
    def make_diag_system(self, H, c_ops):
        ss = SolverSystem()
        ss.td_c_ops = []
        ss.td_n_ops = []

        H_ = H.copy()
        H_ *= -1j
        for c in c_ops:
            H_ += -0.5 * c.dag() * c

        w, v = np.linalg.eig(H_.full())
        arg = np.argsort(np.abs(w))
        eig = w[arg]
        U = v.T[arg].T
        Ud = U.T.conj()

        for c in c_ops:
            c_diag = Qobj(Ud @ c.full() @ U, dims=c.dims)
            cevo = QobjEvo(c_diag)
            cdc = cevo._cdc()
            cevo.compile()
            cdc.compile()
            ss.td_c_ops.append(cevo)
            ss.td_n_ops.append(cdc)

        ss.H_diag = eig
        ss.Ud = Ud
        ss.U = U
        ss.args = {}
        ss.type = "Diagonal"
        solver_safe["mcsolve"] = ss

        if self.e_ops and not self.e_ops.isfunc:
            e_ops = [
                Qobj(Ud @ e.full() @ U, dims=e.dims) for e in self.e_ops.e_ops
            ]
            self.e_ops = ExpectOps(e_ops)
        self.ss = ss
        self.reset()