loops = protocols.loops.Loops()
loops.add_loop(loop1)
loops.add_loop(loop2)

# Loop Building
reference_pose = pose_from_file("../test/data/test_in.pdb")
score = get_score_function()

import tempfile

output = tempfile.mkstemp()[1]

jd = PyJobDistributor(output, 1, score)

lrms = loop_rmsd(pose, reference_pose, loops, True)
jd.additional_decoy_info = " LRMSD: " + str(lrms)

# High-Resolution Loop Protocol
loop_refine = LoopMover_Refine_CCD(loops)
# loop_refine.apply(pose)  # takes too long

# KIC
loops = protocols.loops.Loops()
loops.add_loop(loop1)

set_single_loop_fold_tree(pose, loop1)

sw_low = SwitchResidueTypeSetMover("centroid")
sw_low.apply(pose)
kic_perturb = protocols.loops.loop_mover.perturb.LoopMover_Perturb_KIC(loops)
# kic_perturb.apply(pose)  # won't show in Pymol for efficiency # takes too long
def sample_single_loop_modeling(pdb_filename,
                                loop_begin,
                                loop_end,
                                loop_cutpoint,
                                frag_filename,
                                frag_length,
                                outer_cycles_low=2,
                                inner_cycles_low=5,
                                init_temp_low=2.0,
                                final_temp_low=0.8,
                                outer_cycles_high=5,
                                inner_cycles_high=10,
                                init_temp_high=2.2,
                                final_temp_high=0.6,
                                jobs=1,
                                job_output='loop_output'):
    """
    Performs simple single loop construction on the input  <pdb_filename>
        with loop from  <loop_begin>  to  <loop_end>  with a
        cutpoint at  <loop_cutpoint>  using fragments of length  <frag_length>
        in the file  <frag_filename>.  <jobs>  trajectories are performed,
        each using a low resolution (centroid) simulated annealing with
        <outer_cycles>  rounds and  <inner_cycles>  steps per round decrementing
        "temperature" from  <init_temp>  to  <final_temp>  geometrically.
        Output structures are named  <job_output>_(job#).pdb.

    """
    # 1. create a pose from the desired PDB file
    p = Pose()
    pose_from_file(p, pdb_filename)

    # 2. create a reference copy of the pose in fullatom
    starting_p = Pose()
    starting_p.assign(p)

    #### if you are constructing multiple loops simultaneously, changes will
    ####    occur in most of the steps below

    # 3. create the Loop object
    #    (note: Loop objects merely specify residues, they contain no
    #         conformation data)
    my_loop = protocols.loops.Loop(loop_begin, loop_end, loop_cutpoint)
    #### if using multiple loops, add additional Loop objects
    # 4. use the Loop to set the pose FoldTree
    protocols.loops.set_single_loop_fold_tree(p, my_loop)
    #### alternate FoldTree setup, if you uncomment the lines below,
    ####    comment-out the set_single_loop_foldtree line above (line 189)
    #### -create an empty FoldTree
    #ft = FoldTree()
    #### -make it a single edge the length of pose
    #ft.simple_tree(p.total_residue())
    #### -insert a jump corresponding to the single loop region
    #ft.add_jump(loop_begin - 2, loop_end + 2, loop_cutpoint)
    #### -give the pose this FoldTree (set it to this object), this will
    ####     erase any previous FoldTree held by the pose
    #p.fold_tree(ft)
    #### there is also a fold_tree_from_loops method in exposed which sets up
    ####    a FoldTree but it is different from set_single_loop_foldtree in
    ####    that is creates jumps +/- 1 residue from their corresponding loop
    ####    endpoints and requires a third argument, the FoldTree to setup

    # 5. sets the cut-point residues as cut-point variants
    protocols.loops.add_single_cutpoint_variant(p, my_loop)

    # 6. create the MoveMap, allow the loop region backbone and
    #    all chi torsions to be free
    movemap = MoveMap()
    movemap.set_bb_true_range(loop_begin, loop_end)
    movemap.set_chi(True)  # sets all chi torsions free

    # 7. setup the fragment Mover
    # this "try--except" is used to catch improper fragment files
    try:
        fragset = core.fragment.ConstantLengthFragSet(frag_length,
                                                      frag_filename)
        #### the ConstantLengthFragSet is overloaded, this same
        ####    ConstantLengthFragSet can be obtained with different syntax
        # to obtain custom fragments, see Generating Fragment Files below
    except:
        raise IOError('Make sure frag_length matches the fragments in\n\
            frag_file and that frag_file is valid')
    fragment_mover = protocols.simple_moves.ClassicFragmentMover(
        fragset, movemap)

    # 8. create a Mover for loop modeling using CCD (low resolution)
    ccd_closure = protocols.loops.loop_closure.ccd.CCDLoopClosureMover(
        my_loop, movemap)

    # 9. create ScoreFunctions
    # for centroid, use the default centroid ScoreFunction with chainbreak on
    scorefxn_low = create_score_function('cen_std')
    # the chainbreak ScoreType exists to penalize broken bonds
    # try creating a broken pose in the interpreter and use a ScoreFunction
    #    with a chainbreak score to investigate its impact, the score is 0.0
    #    except when a bond is broken
    # this penalizes failures caused by CCD failing to close the loop
    scorefxn_low.set_weight(core.scoring.chainbreak, 1)
    # for fullatom, used for packing and scoring final output
    scorefxn_high = get_fa_scorefxn(
    )  #  create_score_function_ws_patch('standard', 'score12')

    # 10. setup sidechain packing Mover
    task_pack = core.pack.task.TaskFactory.create_packer_task(starting_p)
    task_pack.restrict_to_repacking()  # prevents design, packing only
    task_pack.or_include_current(True)  # considers original sidechains
    pack = protocols.minimization_packing.PackRotamersMover(
        scorefxn_high, task_pack)

    # 11. setup the high resolution refinement
    # by creating a Loops object,
    #    (note: Loops is basically a list of Loop objects),
    sample_loops = protocols.loops.Loops()
    # giving it the loop to remodel,
    sample_loops.add_loop(my_loop)
    # and creating a fullatom CCD Mover (high resolution)
    # this Mover is somewhat abnormal since it handles everything itself, it:
    #    -creates its own MoveMap for the loop regions
    #    -creates its own ScoreFunction (default to get_fa_scorefxn())
    #    -creates its own FoldTree for the pose based on the loops
    #    -creates its own MonteCarlo object for monitoring the pose
    #    -performs "simulated annealing" with 3 outer cycles and 90 inner
    #        cycles, very similar to the protocol outlined ere
    #    -creates its own backbone Movers (SmallMover, ShearMover)
    #    -creates its own PackRotamersMover, it does NOT restrict repacking
    #        to the loop regions and can alter all sidechain conformations
    loop_refine = LoopMover_Refine_CCD(sample_loops)
    # some of these parameters or objects can be set but the protocol
    #    executed by this Mover is effectively untouchable
    #loop_refine.set_score_function(scorefxn_high)    # in beta v2 and above
    loop_refine.temp_initial(init_temp_high)
    loop_refine.temp_final(init_temp_high)
    loop_refine.outer_cycles(outer_cycles_high)
    loop_refine.max_inner_cycles(inner_cycles_high)

    # 12. create centroid <--> fullatom conversion Movers
    to_centroid = SwitchResidueTypeSetMover('centroid')
    to_fullatom = SwitchResidueTypeSetMover('fa_standard')
    # and a Mover to recover sidechain conformations
    #    when a protocol samples backbone torsion space in centroid,
    #    the sidechain conformations are neglected, when it is transferred
    #    to fullatom, we typically set the sidechain conformations to their
    #    "original" values and perform sidechain packing,
    #    a ReturnSidechainMover saves a pose's sidechains (in this case
    #    staring_pose) and when applied, inserts these conformations
    #    into the input pose
    recover_sidechains = protocols.simple_moves.ReturnSidechainMover(
        starting_p)

    # 13. create a reference copy of the pose in centroid
    # the first stage of each trajectory is in centroid
    #    so a centroid reference is needed and the pose must start in centroid
    to_centroid.apply(p)
    starting_p_centroid = Pose()
    starting_p_centroid.assign(p)

    # 14. create the geometric "temperature" increment for simulated annealing
    gamma = pow((final_temp_low / init_temp_low),
                (1.0 / (outer_cycles_low * inner_cycles_low)))

    # 15. create a PyMOLMover for exporting structures to PyMOL
    pymov = PyMOLMover()
    # uncomment the line below to load structures into successive states
    #pymov.keep_history(True)
    scorefxn_high(starting_p)  # for exporting the scores
    pymov.apply(starting_p)
    pymov.send_energy(starting_p)

    # 16. create a (Py)JobDistributor
    # a PyJobDistributor uses the job_output argument to name all output files
    #    and performs the specified number (int) of jobs
    # a ScoreFunction is required since the PyJobDistributor output .fasc file
    #    contains scoring information about each output PDB
    jd = PyJobDistributor(job_output, jobs, scorefxn_high)
    jd.native_pose = starting_p

    # 17. perform the loop modeling protocol
    counter = 0  # for exporting to PyMOL
    while not jd.job_complete:
        # a. set necessary variables for the new trajectory
        # -reload the starting pose (centroid)
        p.assign(starting_p_centroid)
        # -change the pose's PDBInfo.name, for exporting to PyMOL
        counter += 1
        p.pdb_info().name(job_output + '_' + str(counter) + '_cen')
        # -reset the starting "temperature" (to init_temp)
        kT = init_temp_low
        # -create a MonteCarlo object for this trajectory
        #    a MonteCarlo object assesses pass/fail by the Metropolis Criteria
        #    and also records information on the lowest scoring pose
        mc = MonteCarlo(p, scorefxn_low, kT)

        # b. "randomize" the loop
        #### this section may change if you intend to use multiple loops or
        ####    alter the sampling method to "randomize" the loop
        # -by breaking it open,
        for i in range(loop_begin, loop_end + 1):
            p.set_phi(i, -180)
            p.set_psi(i, 180)
        pymov.apply(p)
        # -and then inserting fragments
        #    the number of insertions performed is somewhat arbitrary
        for i in range(loop_begin, loop_end + 1):
            fragment_mover.apply(p)
        pymov.apply(p)
        ####

        # low resolution loop modeling:
        # c. simulated annealing incrementing kT geometrically
        #    from init_temp to final_temp
        #### this section may change if you intend to use multiple loops or
        ####    alter the sampling method for low resolution modeling
        for i in range(1, outer_cycles_low + 1):
            # -start with the lowest scoring pose
            mc.recover_low(p)  # loads mc's lowest scoring pose into p
            # -take several steps of in the simulated annealing by
            for j in range(1, inner_cycles_low + 1):
                # >increasing the "temperature"
                kT = kT * gamma
                mc.set_temperature(kT)
                # >inserting a fragment,
                fragment_mover.apply(p)
                pymov.apply(p)
                # >performing CCD,
                ccd_closure.apply(p)
                pymov.apply(p)
                # >and assessing the Metropolis Criteria
                mc.boltzmann(p)
        ####

        # the LoopMover_Refine_CCD makes A LOT of moves, DO NOT expect to
        #    see useful results if you use the PyMOLMover keep_history option, the large
        #    number of intermediates will slow processing to a halt

        # d. convert the best structure (lowest scoring) into fullatom by:
        # -recovering the best (centroid) structure (lowest scoring),
        mc.recover_low(p)  # loads mc's lowest scoring pose into p
        # -switching the ResidueTypeSet to fullatom (from centroid),
        to_fullatom.apply(p)
        # -recovering the original sidechain conformations,
        recover_sidechains.apply(p)
        # -and packing the result (since the backbone conformation has changed)
        pack.apply(p)
        pymov.apply(p)
        p.pdb_info().name(job_output + '_' + str(counter) + '_fa')

        # high-resolution refinement:
        #### this section may change if you intend to use multiple loops or
        ####    alter the sampling method for high resolution refinement
        # e. apply the LoopMover_Refine_CCD
        loop_refine.apply(p)

        # f. output the decoy (pose result from this trajectory)
        #    include the loop RMSD (Lrsmd)
        # -output a PDB file using the PyJobDistributor
        lrms = protocols.loops.loop_rmsd(p, starting_p, sample_loops, True)
        jd.additional_decoy_info = ' Lrmsd: ' + str(lrms)
        jd.output_decoy(p)
        # -export the structure to PyMOL
        pymov.apply(p)
        pymov.send_energy(p)
                                              working_pose_info, 
                                              native_pose, 
                                              native_pose_info, 
                                              sf, 
                                              2, # Fc-FcR interface JUMP_NUM
                                              jd.current_num, 
                                              GlycanModelProtocol.metrics_dump_dir, 
                                              input_args.utility_dir, 
                                              MC_acceptance_rate = GlycanModelProtocol.mc_acceptance, 
                                              native_constraint_file = GlycanModelProtocol.constraint_file )
    except:
        metrics = ''
        pass

    # add the metric data to the .fasc file
    jd.additional_decoy_info = metrics

    # dump the decoy
    jd.output_decoy( working_pose )
    # zip up the decoy pose, if desired
    if input_args.zip_decoy:
        os.popen( "gzip %s" %working_pose.pdb_info().name() )

    # increment the decoy number counter
    cur_decoy_num += 1

    #for res_num in native_Fc_glycan_nums_except_core_GlcNAc:
    #    print "Res num", res_num, "Reset phi:", GlycanModelProtocol.reset_pose.phi( res_num ), "end phi:", working_pose.phi( res_num )
    #    print "Res num", res_num, "Reset psi:", GlycanModelProtocol.reset_pose.psi( res_num ), "end psi:", working_pose.psi( res_num )
    #    print "Res num", res_num, "Reset omega:", GlycanModelProtocol.reset_pose.omega( res_num ), "end omega:", working_pose.omega( res_num )
    #    print