예제 #1
0
 def setup(self):
     cvA = paths.FunctionCV(name="xA", f=lambda s: s.xyz[0][0])
     cvB = paths.FunctionCV(name="xB", f=lambda s: -s.xyz[0][0])
     self.stateA = paths.CVDefinedVolume(cvA, float("-inf"), -0.5)
     self.stateB = paths.CVDefinedVolume(cvB, float("-inf"), -0.5)
     interfacesA = paths.VolumeInterfaceSet(cvA, float("-inf"),
                                            [-0.5, -0.3, -0.1])
     interfacesB = paths.VolumeInterfaceSet(cvB, float("-inf"),
                                            [-0.5, -0.3, -0.1])
     self.network = paths.MSTISNetwork(
         [(self.stateA, interfacesA), (self.stateB, interfacesB)],
         ms_outers=paths.MSOuterTISInterface.from_lambdas({
             interfacesA: 0.0,
             interfacesB: 0.0
         }))
     self.no_ms_outer = paths.MSTISNetwork([(self.stateA, interfacesA),
                                            (self.stateB, interfacesB)])
예제 #2
0
    def setup(self):
        # set up the trajectories, ensembles, etc. for this test
        paths.InterfaceSet._reset()
        cv_A = paths.FunctionCV('Id', lambda s: s.xyz[0][0])
        cv_B = paths.FunctionCV('1-Id', lambda s: 1.0-s.xyz[0][0])
        self.cv_x = cv_A
        self.state_A = paths.CVDefinedVolume(cv_A,
                                             float("-inf"), 0.0).named("A")
        self.state_B = paths.CVDefinedVolume(cv_B,
                                             float("-inf"), 0.0).named("B")
        interfaces_AB = paths.VolumeInterfaceSet(cv_A, float("-inf"),
                                                 [0.0, 0.1, 0.2])
        interfaces_BA = paths.VolumeInterfaceSet(cv_B, float("-inf"),
                                                 [0.0, 0.1, 0.2])

        # trajectory that crosses each interface, one state-to-state
        self.trajs_AB = [make_tis_traj_fixed_steps(i) for i in [0, 1, 2]]
        self.trajs_AB += [make_1d_traj([(-0.5 + i) * 0.1
                                        for i in range(12)])]

        self.trajs_BA = [make_tis_traj_fixed_steps(i, reverse=True)
                         for i in [0, 1, 2]]
        self.trajs_BA += [make_1d_traj([1.0 - (-0.5 + i) * 0.1
                                        for i in range(12)])]

        # set up mistis
        self.mistis = paths.MISTISNetwork([
            (self.state_A, interfaces_AB, self.state_B),
            (self.state_B, interfaces_BA, self.state_A)
        ])
        mover_stub_mistis = MoverWithSignature(self.mistis.all_ensembles,
                                               self.mistis.all_ensembles)

        mistis_ssets = self._make_fake_sampling_sets(self.mistis)
        self.mistis_steps = self._make_fake_steps(mistis_ssets,
                                                  mover_stub_mistis)

        self.mistis_weighted_trajectories = steps_to_weighted_trajectories(
            self.mistis_steps,
            self.mistis.sampling_ensembles
        )

        # TODO: set up mstis
        self.mstis = paths.MSTISNetwork([
            (self.state_A, interfaces_AB),
            (self.state_B, interfaces_BA)
        ])
        mover_stub_mstis = MoverWithSignature(self.mstis.all_ensembles,
                                              self.mstis.all_ensembles)
        mstis_ssets = self._make_fake_sampling_sets(self.mstis)
        self.mstis_steps = self._make_fake_steps(mstis_ssets,
                                                 mover_stub_mstis)

        self.mstis_weighted_trajectories = steps_to_weighted_trajectories(
            self.mstis_steps,
            self.mstis.sampling_ensembles
        )
 def setup(self):
     paths.InterfaceSet._reset()
     cvA = paths.FunctionCV(name="xA", f=lambda s: s.xyz[0][0])
     cvB = paths.FunctionCV(name="xB", f=lambda s: -s.xyz[0][0])
     self.stateA = paths.CVDefinedVolume(cvA, float("-inf"), -0.5)
     self.stateB = paths.CVDefinedVolume(cvB, float("-inf"), -0.5)
     interfacesA = paths.VolumeInterfaceSet(cvA, float("-inf"),
                                            [-0.5, -0.3, -0.1])
     interfacesB = paths.VolumeInterfaceSet(cvB, float("-inf"),
                                            [-0.5, -0.3, -0.1])
     self.network = paths.MSTISNetwork(
         [(self.stateA, interfacesA), (self.stateB, interfacesB)],
         ms_outers=paths.MSOuterTISInterface.from_lambdas({
             interfacesA: 0.0,
             interfacesB: 0.0
         }))
     self.basic_scheme = DefaultScheme(self.network)
     self.root_mover = self.basic_scheme.move_decision_tree()
def make_mstis_network():
    opA = paths.CoordinateFunctionCV(name="opA", f=circle, center=[-0.5, -0.5])
    opB = paths.CoordinateFunctionCV(name="opB", f=circle, center=[0.5, -0.5])
    opC = paths.CoordinateFunctionCV(name="opC", f=circle, center=[0.0, 0.4])
    stateA = paths.CVDefinedVolume(opA, 0.0, 0.2).named("A")
    stateB = paths.CVDefinedVolume(opB, 0.0, 0.2).named("B")
    stateC = paths.CVDefinedVolume(opC, 0.0, 0.2).named("C")

    interfacesA = paths.VolumeInterfaceSet(opA, 0.0, [0.2, 0.3, 0.4])
    interfacesB = paths.VolumeInterfaceSet(opB, 0.0, [0.2, 0.3, 0.4])
    interfacesC = paths.VolumeInterfaceSet(opC, 0.0, [0.2, 0.3, 0.4])

    ms_outers = paths.MSOuterTISInterface.from_lambdas(
        {ifaces: 0.5
         for ifaces in [interfacesA, interfacesB, interfacesC]}
    )

    mstis = paths.MSTISNetwork(
        [(stateA, interfacesA),
         (stateB, interfacesB),
         (stateC, interfacesC)],
        ms_outers=ms_outers
    )
    return mstis