Variables
int	MAX_KIC_BUILD_ATTEMPTS = 10000

list	args

	p = Pose()

	starting_p = Pose()

	scorefxn_low = create_score_function( 'cen_std' )

	scorefxn_high = create_score_function( 'standard', 'score12' )

	pymol = rosetta.PyMOLMover()

int	loop_begin = 145

int	loop_end = 155

int	loop_cut = 150

	my_loop = Loop( loop_begin, loop_end, loop_cut )

	my_loops = Loops()

	movemap = MoveMap()

	kic_mover = KinematicMover()

	to_centroid = protocols.simple_moves.SwitchResidueTypeSetMover( 'centroid' )

	to_fullatom = protocols.simple_moves.SwitchResidueTypeSetMover( 'fa_standard' )

	recover_sidechains = protocols.simple_moves.ReturnSidechainMover( starting_p )

	task_pack = TaskFactory.create_packer_task( starting_p )

	pack = protocols.minimization_packing.PackRotamersMover( scorefxn_high, task_pack )

	mm = MoveMap()

float	tol = 0.001

string	min_type = "linmin"

	linmin_mover = protocols.minimization_packing.MinMover( mm, scorefxn_low, min_type, tol, True )

	starting_p_centroid = Pose()

bool	success = False

int	outer_cycles = 10

int	inner_cycles = 30

float	init_temp = 2.0

float	final_temp = 1.0

	gamma = math.pow( ( final_temp/init_temp ),( 1.0/( outer_cycles*inner_cycles ) ) )

float	kT = init_temp

	mc = MonteCarlo( p, scorefxn_low, kT )

	kic_start = randrange( loop_begin, loop_end - 1 )

	kic_end = randrange( kic_start+2, loop_end+1 )

tuple	middle_offset = ( kic_end - kic_start ) / 2

tuple	kic_middle = kic_start + middle_offset

	rms = loop_rmsd( p, starting_p, my_loops )

	loop_refine = LoopMover_Refine_KIC( my_loops )

Variable Documentation

◆ args

list loops_kic.args

Initial value:

 =  [ "app",
          "-database minirosetta_database", \
          "-loops:fast" ]

◆ final_temp

float loops_kic.final_temp = 1.0

◆ gamma

loops_kic.gamma = math.pow( ( final_temp/init_temp ),( 1.0/( outer_cycles*inner_cycles ) ) )

◆ init_temp

float loops_kic.init_temp = 2.0

◆ inner_cycles

int loops_kic.inner_cycles = 30

◆ kic_end

loops_kic.kic_end = randrange( kic_start+2, loop_end+1 )

◆ kic_middle

tuple loops_kic.kic_middle = kic_start + middle_offset

◆ kic_mover

loops_kic.kic_mover = KinematicMover()

Referenced by main().

◆ kic_start

loops_kic.kic_start = randrange( loop_begin, loop_end - 1 )

◆ kT

float loops_kic.kT = init_temp

◆ linmin_mover

loops_kic.linmin_mover = protocols.minimization_packing.MinMover( mm, scorefxn_low, min_type, tol, True )

◆ loop_begin

int loops_kic.loop_begin = 145

◆ loop_cut

int loops_kic.loop_cut = 150

◆ loop_end

int loops_kic.loop_end = 155

◆ loop_refine

loops_kic.loop_refine = LoopMover_Refine_KIC( my_loops )

◆ MAX_KIC_BUILD_ATTEMPTS

int loops_kic.MAX_KIC_BUILD_ATTEMPTS = 10000

◆ mc

loops_kic.mc = MonteCarlo( p, scorefxn_low, kT )

◆ middle_offset

tuple loops_kic.middle_offset = ( kic_end - kic_start ) / 2

Referenced by KIC_loop_close(), loop_closure_test(), main(), and test_kc().

◆ min_type

string loops_kic.min_type = "linmin"

◆ mm

loops_kic.mm = MoveMap()

◆ movemap

loops_kic.movemap = MoveMap()

◆ my_loop

loops_kic.my_loop = Loop( loop_begin, loop_end, loop_cut )

◆ my_loops

loops_kic.my_loops = Loops()

◆ outer_cycles

int loops_kic.outer_cycles = 10

◆ p

loops_kic.p = Pose()

◆ pack

loops_kic.pack = protocols.minimization_packing.PackRotamersMover( scorefxn_high, task_pack )

◆ pymol

loops_kic.pymol = rosetta.PyMOLMover()

◆ recover_sidechains

loops_kic.recover_sidechains = protocols.simple_moves.ReturnSidechainMover( starting_p )

◆ rms

loops_kic.rms = loop_rmsd( p, starting_p, my_loops )

Referenced by aa2sim_all(), aa2sim_ca(), aa2sim_sc(), PoseWrap.absrms_to_orig_subsubs(), alignhelix(), DeleteSegments.apply(), InterfaceStrandFinderMover.apply(), LoopHashRelax_Sampler.apply(), Foldptn.apply(), MinPackMinMover.apply(), RosettaHolesMover.apply(), HDdesignMover.apply(), DetectSymmetry.apply(), CrystCluster.apply(), automorph_rmsd(), ExposedStrandMover.bb_rmsd(), numeric::model_quality.calc_rms_fast(), CAtrace.CAtrace(), check_jump(), compute_intrinsic_deviation(), do_align(), dock(), go_main(), harvest_motifs_one(), main(), numeric::model_quality.maxsub(), processChild(), PoseWrap.rms_to_orig_subsubs(), run(), ScoreFragmentSetMover.run(), SolutionRescoreMover.run(), HubDenovo.run(), run_parallel_docking(), RMS_ScoringScheme.score(), set_basic_dock_options(), sicdock_thread_num(), superimpose_pose(), and test_refold().

◆ scorefxn_high

loops_kic.scorefxn_high = create_score_function( 'standard', 'score12' )

◆ scorefxn_low

loops_kic.scorefxn_low = create_score_function( 'cen_std' )

◆ starting_p

loops_kic.starting_p = Pose()

◆ starting_p_centroid

loops_kic.starting_p_centroid = Pose()

◆ success

bool loops_kic.success = False

Referenced by apps::pilot::AlignChunkMover.apply(), protocols::abinitio::JumpSpecificAbrelax.close_loops(), numeric::Calculator.compute(), utility::file.create_directory_recursive(), protocols::abinitio::JumpSpecificAbrelax.fold(), apps::pilot::HelixMover.get_helix_vectors(), main(), numeric.read_tensor_from_file(), GetURLHandler.ReportResult(), GetURLHandler.ReportResultAndDie(), ThisApplication.run(), run(), apps::pilot::HelixMover.slide_non_ideal_helix(), SymmAbRelaxTest(), and numeric.write_tensor_to_file().

◆ task_pack

loops_kic.task_pack = TaskFactory.create_packer_task( starting_p )

◆ to_centroid

loops_kic.to_centroid = protocols.simple_moves.SwitchResidueTypeSetMover( 'centroid' )

◆ to_fullatom

loops_kic.to_fullatom = protocols.simple_moves.SwitchResidueTypeSetMover( 'fa_standard' )

Variables