standard

Bindings for protocols::jd3::standard namespace

class pyrosetta.rosetta.protocols.jd3.standard.PreliminaryLarvalJob

Bases: pybind11_object

A PreliminaryLarvalJob is what gets created from the command-line options job_definition file for each input

and specified job in the Job Definition file.

The SJQ has a list of these after they are created in determine_preliminary_job_list()

assign(self: pyrosetta.rosetta.protocols.jd3.standard.PreliminaryLarvalJob, rhs: pyrosetta.rosetta.protocols.jd3.standard.PreliminaryLarvalJob) → pyrosetta.rosetta.protocols.jd3.standard.PreliminaryLarvalJob

C++: protocols::jd3::standard::PreliminaryLarvalJob::operator=(const struct protocols::jd3::standard::PreliminaryLarvalJob &) –> struct protocols::jd3::standard::PreliminaryLarvalJob &

property inner_job

property job_options

property job_tag

property pose_inputter

class pyrosetta.rosetta.protocols.jd3.standard.PreliminaryLarvalJobTracker

Bases: pybind11_object

A class for tracking the progress of all PreliminaryLarvalJobs. This tracking is partially responsible for deallocation of the input poses.

assign(self: pyrosetta.rosetta.protocols.jd3.standard.PreliminaryLarvalJobTracker, : pyrosetta.rosetta.protocols.jd3.standard.PreliminaryLarvalJobTracker) → pyrosetta.rosetta.protocols.jd3.standard.PreliminaryLarvalJobTracker

C++: protocols::jd3::standard::PreliminaryLarvalJobTracker::operator=(const class protocols::jd3::standard::PreliminaryLarvalJobTracker &) –> class protocols::jd3::standard::PreliminaryLarvalJobTracker &

get_input_poses_to_deallocate(self: pyrosetta.rosetta.protocols.jd3.standard.PreliminaryLarvalJobTracker) → pyrosetta.rosetta.utility.vector1_unsigned_long

Get a list of input poses that the JQ has not deallocated and that are no longer needed by PJNs.

C++: protocols::jd3::standard::PreliminaryLarvalJobTracker::get_input_poses_to_deallocate() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

get_job_index_ending_job_node(self: pyrosetta.rosetta.protocols.jd3.standard.PreliminaryLarvalJobTracker, job_node: int) → int

Get the ending global job index that starts for a particular preliminary job node

C++: protocols::jd3::standard::PreliminaryLarvalJobTracker::get_job_index_ending_job_node(unsigned long) –> unsigned long

get_job_index_starting_job_node(self: pyrosetta.rosetta.protocols.jd3.standard.PreliminaryLarvalJobTracker, job_node: int) → int

Get the starting global job index that starts for a particular preliminary job node

C++: protocols::jd3::standard::PreliminaryLarvalJobTracker::get_job_index_starting_job_node(unsigned long) –> unsigned long

get_job_node_assigned(self: pyrosetta.rosetta.protocols.jd3.standard.PreliminaryLarvalJobTracker, job_dag_node_index: int) → bool

Are jobs for this job_node_index assigned (IE - LarvalJobs created)?

C++: protocols::jd3::standard::PreliminaryLarvalJobTracker::get_job_node_assigned(unsigned long) const –> bool

get_job_node_complete(self: pyrosetta.rosetta.protocols.jd3.standard.PreliminaryLarvalJobTracker, job_dag_node_index: int) → bool

Are ALL jobs for this job_node_index complete?

C++: protocols::jd3::standard::PreliminaryLarvalJobTracker::get_job_node_complete(unsigned long) const –> bool

get_job_node_for_job_index(self: pyrosetta.rosetta.protocols.jd3.standard.PreliminaryLarvalJobTracker, job_id: int) → int

Get the job dag node for the global job index if tracked through

track_job_node_being_assigned during assignment of the PJN

Returns 0 if the job_id is NOT a preliminary job.

C++: protocols::jd3::standard::PreliminaryLarvalJobTracker::get_job_node_for_job_index(unsigned long) const –> unsigned long

get_preliminary_job_node_indices(self: pyrosetta.rosetta.protocols.jd3.standard.PreliminaryLarvalJobTracker) → pyrosetta.rosetta.utility.vector1_unsigned_long

C++: protocols::jd3::standard::PreliminaryLarvalJobTracker::get_preliminary_job_node_indices() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

initialize_tracker(self: pyrosetta.rosetta.protocols.jd3.standard.PreliminaryLarvalJobTracker, prelim_jobs: pyrosetta.rosetta.utility.vector1_protocols_jd3_standard_PreliminaryLarvalJob) → None

Initialize the PreliminaryLarvalJobTracker’s counters.

C++: protocols::jd3::standard::PreliminaryLarvalJobTracker::initialize_tracker(const class utility::vector1<struct protocols::jd3::standard::PreliminaryLarvalJob, class std::allocator<struct protocols::jd3::standard::PreliminaryLarvalJob> > &) –> void

input_pose_no_longer_needed(self: pyrosetta.rosetta.protocols.jd3.standard.PreliminaryLarvalJobTracker, pose_index: int) → bool

Is the input pose still needed by any Preliminary Jobs or Preliminary Job Nodes?

C++: protocols::jd3::standard::PreliminaryLarvalJobTracker::input_pose_no_longer_needed(unsigned long) const –> bool

track_deallocated_input_pose(self: pyrosetta.rosetta.protocols.jd3.standard.PreliminaryLarvalJobTracker, pose_id: int) → None

Track a deallocated input pose. (indicate that this pose id has been deallocated)

C++: protocols::jd3::standard::PreliminaryLarvalJobTracker::track_deallocated_input_pose(unsigned long) –> void

track_job_completed(self: pyrosetta.rosetta.protocols.jd3.standard.PreliminaryLarvalJobTracker, job: pyrosetta.rosetta.protocols.jd3.LarvalJob) → None

Track a completed LarvalJob.

If the LarvalJob is NOT a preliminary job, we skip it.

C++: protocols::jd3::standard::PreliminaryLarvalJobTracker::track_job_completed(class std::shared_ptr<const class protocols::jd3::LarvalJob>) –> void

track_job_node_assigned(self: pyrosetta.rosetta.protocols.jd3.standard.PreliminaryLarvalJobTracker, job_dag_node_index: int, last_global_nstruct_index_for_node: int) → None

Called when we have given out ALL Larval Jobs for a particular PJN.

C++: protocols::jd3::standard::PreliminaryLarvalJobTracker::track_job_node_assigned(unsigned long, unsigned long) –> void

track_job_node_being_assigned(self: pyrosetta.rosetta.protocols.jd3.standard.PreliminaryLarvalJobTracker, job_dag_node_index: int, global_index_start: int, global_index_end: int) → None

Called during assignment of the PJN.

C++: protocols::jd3::standard::PreliminaryLarvalJobTracker::track_job_node_being_assigned(unsigned long, unsigned long, unsigned long) –> void

class pyrosetta.rosetta.protocols.jd3.standard.StandardInnerLarvalJob

Bases: InnerLarvalJob

The %StandardInnerLarvalJob class is responsible for holding the input requirements for a given job - how many nstruct, and what the input is. %StandardInnerLarvalJobs are relatively heavy; there is no need to duplicate a series of %StandardInnerLarvalJobs for each index into nstruct. The companion Job class handles the nstruct index and has a pointer to an StandardInnerLarvalJob (which is shared across many Jobs). The JobQueen has considerable leeway in how she shares data held in the %StandardInnerLarvalJobs she creates: if all of the options for a set of %StandardInnerLarvalJob are identical, and they differ only in their input structure, then she can, e.g. share a single JobOptions object between all of them. StandardInnerLarvalJobs are serialized by the JobDistributor and shipped between nodes. For this reason, they should not be loaded with ResourceManager-managed data (that data should not get shipped between nodes, though it should be instantiatable on any node), but they may need to store Poses, as would be necessary in any multi-round protocol, where the JobResults from round i are the starting points for round i+1.

add_input_job_result_index(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, job_result_id: Tuple[int, int]) → None

Add a required input by the pair representing 1) the global index of the job

that produced the JobResult, and 2) the index of that JobResult among all the results produced by that job.

C++: protocols::jd3::InnerLarvalJob::add_input_job_result_index(struct std::pair<unsigned long, unsigned long>) –> void

append_input_source(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, setting: protocols::jd3::InputSource) → None

Append a InputSource to the vector of them

C++: protocols::jd3::InnerLarvalJob::append_input_source(class std::shared_ptr<const class protocols::jd3::InputSource>) –> void

assign(self: pyrosetta.rosetta.protocols.jd3.standard.StandardInnerLarvalJob, : pyrosetta.rosetta.protocols.jd3.standard.StandardInnerLarvalJob) → pyrosetta.rosetta.protocols.jd3.standard.StandardInnerLarvalJob

C++: protocols::jd3::standard::StandardInnerLarvalJob::operator=(const class protocols::jd3::standard::StandardInnerLarvalJob &) –> class protocols::jd3::standard::StandardInnerLarvalJob &

bad(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) → bool

Has this job been labeled as bad?

C++: protocols::jd3::InnerLarvalJob::bad() const –> bool

clear_input_sources(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) → None

Clear the vector of InputSources

C++: protocols::jd3::InnerLarvalJob::clear_input_sources() –> void

const_data_map(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) → pyrosetta.rosetta.basic.datacache.ConstDataMap

Write access to the ConstDataMap that the %InnerLarvalJob holds. The objects pointed

to by the const data map can be shared between two %InnerLarvalJobs, but the data maps themselves should not be shared.

C++: protocols::jd3::InnerLarvalJob::const_data_map() –> class basic::datacache::ConstDataMap &

input_job_result_indices(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) → pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_unsigned_long_t

The list of the JobResults required to mature this %LarvalJob, by global index of the

already-executed (Lavral)Jobs

C++: protocols::jd3::InnerLarvalJob::input_job_result_indices() const –> const class utility::vector1<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > &

input_source(*args, **kwargs)

Overloaded function.

1. input_source(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, setting: protocols::jd3::InputSource) -> None

Set the single InputSource for this job

C++: protocols::jd3::InnerLarvalJob::input_source(class std::shared_ptr<const class protocols::jd3::InputSource>) –> void

2. input_source(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) -> protocols::jd3::InputSource

Read access to the InputSource object that describes how the Pose for

this job should be constructed. Requires that there is only a single InputSource for this job.

C++: protocols::jd3::InnerLarvalJob::input_source() const –> const class protocols::jd3::InputSource &

3. input_source(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, index: int) -> protocols::jd3::InputSource

Retrieve a particular InputSource

C++: protocols::jd3::InnerLarvalJob::input_source(unsigned long) const –> const class protocols::jd3::InputSource &

input_source_cop(*args, **kwargs)

Overloaded function.

1. input_source_cop(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) -> protocols::jd3::InputSource

C++: protocols::jd3::InnerLarvalJob::input_source_cop() const –> const class std::shared_ptr<const class protocols::jd3::InputSource> &

2. input_source_cop(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, index: int) -> protocols::jd3::InputSource

C++: protocols::jd3::InnerLarvalJob::input_source_cop(unsigned long) const –> const class std::shared_ptr<const class protocols::jd3::InputSource> &

input_tag(*args, **kwargs)

Overloaded function.

1. input_tag(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) -> str

Return the input tag – a string that describes the input structure, but that

is in no way a complete description of the job. The job_tag instead should be looked to as the name to use to identify information about this job: a single input structure may be used for multiple jobs.

C++: protocols::jd3::InnerLarvalJob::input_tag() const –> std::string

2. input_tag(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, setting: str) -> None

Set the input tag – if it is not set, then the InputSources will be used,

the file names / tags being concatenated together, separated by underscores.

C++: protocols::jd3::InnerLarvalJob::input_tag(const std::string &) –> void

job_node(*args, **kwargs)

Overloaded function.

1. job_node(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) -> int

Return the job node this InnerLarvalJob belongs to

If the Job Node has not been set, we return 0.

C++: protocols::jd3::InnerLarvalJob::job_node() const –> unsigned long

2. job_node(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, setting: int) -> None

Set the Job Node for this ILJ

C++: protocols::jd3::InnerLarvalJob::job_node(unsigned long) –> void

job_tag(*args, **kwargs)

Overloaded function.

1. job_tag(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) -> str

Return the job tag – a string that describes what task is being performed and

and (usually) what input structure that job is being performed upon. This is the tag can be defined by the user in the job-definition XML file.

Can be overridden by child classes that require distinct logic.

C++: protocols::jd3::InnerLarvalJob::job_tag() const –> std::string

2. job_tag(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, setting: str) -> None

Set the job tag. If not set, then the input tag will be returned.

C++: protocols::jd3::InnerLarvalJob::job_tag(const std::string &) –> void

jobdef_tag(*args, **kwargs)

Overloaded function.

1. jobdef_tag(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) -> pyrosetta.rosetta.utility.tag.Tag

C++: protocols::jd3::InnerLarvalJob::jobdef_tag() const –> class std::shared_ptr<const class utility::tag::Tag>

2. jobdef_tag(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, setting: pyrosetta.rosetta.utility.tag.Tag) -> None

C++: protocols::jd3::InnerLarvalJob::jobdef_tag(class std::shared_ptr<const class utility::tag::Tag>) –> void

n_input_sources(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) → int

Return the number of pose input sources for this job.

C++: protocols::jd3::InnerLarvalJob::n_input_sources() const –> unsigned long

nstruct_max(*args, **kwargs)

Overloaded function.

1. nstruct_max(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) -> int

The number of job replicates to be performed for this %InnerLarvalJob.

C++: protocols::jd3::InnerLarvalJob::nstruct_max() const –> unsigned long

2. nstruct_max(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, setting: int) -> None

Set the total number of Nstruct for this InnerLarvelJob (IE - how many LarvalJobs will we need?)

C++: protocols::jd3::InnerLarvalJob::nstruct_max(unsigned long) –> void

outputter(*args, **kwargs)

Overloaded function.

1. outputter(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) -> str

Return the outputter class; i.e. the key used by the PoseOutputterFactory

C++: protocols::jd3::InnerLarvalJob::outputter() const –> std::string

2. outputter(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, setting: str) -> None

Set the outputter class for this job; i.e. the key used by the PoseOutputterFactory

C++: protocols::jd3::InnerLarvalJob::outputter(const std::string &) –> void

preliminary_job_node(self: pyrosetta.rosetta.protocols.jd3.standard.StandardInnerLarvalJob) → pyrosetta.rosetta.utility.StrongT_unsigned_long_protocols_jd3_PrelimJobNodeID_t

Return the job node this StandardInnerLarvalJob belongs to

If the Job Node has not been set, we return 0.

C++: protocols::jd3::standard::StandardInnerLarvalJob::preliminary_job_node() const –> struct utility::StrongT<unsigned long, struct protocols::jd3::PrelimJobNodeID_>

same_type(self: pyrosetta.rosetta.protocols.jd3.standard.StandardInnerLarvalJob, other: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) → bool

returns true if this is the same type as other;

does not call other.same_type()

C++: protocols::jd3::standard::StandardInnerLarvalJob::same_type(const class protocols::jd3::InnerLarvalJob &) const –> bool

set_bad(*args, **kwargs)

Overloaded function.

1. set_bad(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) -> None

2. set_bad(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, setting: bool) -> None

Store the fact that this job is bad, for some reason or another, e.g. it has

malformed inputs.

C++: protocols::jd3::InnerLarvalJob::set_bad(bool) –> void

show(self: pyrosetta.rosetta.protocols.jd3.standard.StandardInnerLarvalJob, out: pyrosetta.rosetta.std.ostream) → None

C++: protocols::jd3::standard::StandardInnerLarvalJob::show(std::ostream &) const –> void

sources_same(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, other: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) → bool

Determine if two jobs are defined with the same set of InputSources

C++: protocols::jd3::InnerLarvalJob::sources_same(const class protocols::jd3::InnerLarvalJob &) const –> bool

class pyrosetta.rosetta.protocols.jd3.standard.StandardJobQueen

Bases: JobQueen

The %StandardJobQueen is meant to handle the most common form of Rosetta jobs where a protocol is applied to a single input structure to generate a single output structure. Most JobQueens in Rosetta will to derive from this JobQueen. To make the process of deriving new JobQueens easy, this class’s API has been carefully designed to be easy to work with and the class itself has been designed to do as much heavy lifting as possible and to leave only the responsibilities that the %StandardJobQueen could not perform to the derived classes.

assign(self: pyrosetta.rosetta.protocols.jd3.standard.StandardJobQueen, : pyrosetta.rosetta.protocols.jd3.standard.StandardJobQueen) → pyrosetta.rosetta.protocols.jd3.standard.StandardJobQueen

C++: protocols::jd3::standard::StandardJobQueen::operator=(const class protocols::jd3::standard::StandardJobQueen &) –> class protocols::jd3::standard::StandardJobQueen &

completed_job_summary(self: pyrosetta.rosetta.protocols.jd3.standard.StandardJobQueen, job: pyrosetta.rosetta.protocols.jd3.LarvalJob, result_index: pyrosetta.rosetta.utility.StrongT_unsigned_long_protocols_jd3_ResultIndex_t, summary: pyrosetta.rosetta.protocols.jd3.JobSummary) → None

As each job completes, this function is called for each result coming from a LarvalJob.

Override this method to store any results you need.

C++: protocols::jd3::standard::StandardJobQueen::completed_job_summary(class std::shared_ptr<const class protocols::jd3::LarvalJob>, struct utility::StrongT<unsigned long, struct protocols::jd3::ResultIndex_>, class std::shared_ptr<class protocols::jd3::JobSummary>) –> void

create_and_set_initial_job_dag(self: pyrosetta.rosetta.protocols.jd3.JobQueen) → pyrosetta.rosetta.protocols.jd3.JobDigraph

Creates the initial job dag using create_initial_job_dag function and sets it to the JQ.

Decorator to create_initial_job_dag

C++: protocols::jd3::JobQueen::create_and_set_initial_job_dag() –> class std::shared_ptr<class protocols::jd3::JobDigraph>

deallocation_messages(self: pyrosetta.rosetta.protocols.jd3.standard.StandardJobQueen) → pyrosetta.rosetta.std.list_std_shared_ptr_protocols_jd3_deallocation_DeallocationMessage_t

Resource Management ///

C++: protocols::jd3::standard::StandardJobQueen::deallocation_messages() –> class std::list<class std::shared_ptr<class protocols::jd3::deallocation::DeallocationMessage>, class std::allocator<class std::shared_ptr<class protocols::jd3::deallocation::DeallocationMessage> > >

determine_job_list(self: pyrosetta.rosetta.protocols.jd3.standard.StandardJobQueen, job_dag_node_index: pyrosetta.rosetta.utility.StrongT_unsigned_long_protocols_jd3_JobDAGNodeID_t, max_njobs: int) → pyrosetta.rosetta.std.list_std_shared_ptr_protocols_jd3_LarvalJob_t

Create a list of LarvalJobs for each Node Index. Only can create max_njobs to save memory.

The %StandardJobQueen manages the process of creating the list of LarvalJobs that

will later be matured into actual jobs and run by the JobDistributor. It is not recommended that derived job queens override this method; doing so will mean that some of the data the SJQ relies on will not be initialized – see comments on the SJQs data members below to understand the consequences of overriding this method.

It is recommended to override next_batch_of_larval_jobs_for_job_node instead of this method

However, if you do override this - especially for more complicated protocols - be sure to call similar functions here

C++: protocols::jd3::standard::StandardJobQueen::determine_job_list(struct utility::StrongT<unsigned long, struct protocols::jd3::JobDAGNodeID_>, unsigned long) –> class std::list<class std::shared_ptr<class protocols::jd3::LarvalJob>, class std::allocator<class std::shared_ptr<class protocols::jd3::LarvalJob> > >

determine_job_list_and_track(self: pyrosetta.rosetta.protocols.jd3.JobQueen, job_dag_node_index: pyrosetta.rosetta.utility.StrongT_unsigned_long_protocols_jd3_JobDAGNodeID_t, max_njobs: int) → pyrosetta.rosetta.std.list_std_shared_ptr_protocols_jd3_LarvalJob_t

Call determine_job_list in derived classes and track the jobs using the JobTracker.

Decorator to determine_job_list

C++: protocols::jd3::JobQueen::determine_job_list_and_track(struct utility::StrongT<unsigned long, struct protocols::jd3::JobDAGNodeID_>, unsigned long) –> class std::list<class std::shared_ptr<class protocols::jd3::LarvalJob>, class std::allocator<class std::shared_ptr<class protocols::jd3::LarvalJob> > >

determine_preliminary_job_list_from_xml_file(self: pyrosetta.rosetta.protocols.jd3.standard.StandardJobQueen, job_def_string: str) → None

Read from an input string representing the contents of the job-definiton XML file

and construct a set of PreliminaryLarvalJobs; this function is primarily useful for testing, but could be used to organize jobs by an enterprising job distributor or by another JobQueen.

C++: protocols::jd3::standard::StandardJobQueen::determine_preliminary_job_list_from_xml_file(const std::string &) –> void

flush(self: pyrosetta.rosetta.protocols.jd3.standard.StandardJobQueen) → None

C++: protocols::jd3::standard::StandardJobQueen::flush() –> void

has_job_previously_been_output(self: pyrosetta.rosetta.protocols.jd3.standard.StandardJobQueen, job: pyrosetta.rosetta.protocols.jd3.LarvalJob) → bool

Checks the outputter to see if the job already has been output. Used for JD override behavior.

Gets the outputter from the Job, which is cached in the SJQ.

You should not need to override this method

C++: protocols::jd3::standard::StandardJobQueen::has_job_previously_been_output(class std::shared_ptr<const class protocols::jd3::LarvalJob>) –> bool

static job_def_complex_type_name(type: str) → str

Naming function for the complexTypes in the job-definition XSD

C++: protocols::jd3::standard::StandardJobQueen::job_def_complex_type_name(const std::string &) –> std::string

job_definition_xsd(self: pyrosetta.rosetta.protocols.jd3.standard.StandardJobQueen) → str

The %StandardJobQueen assembles the XSD from virtual functions she invokes on

the derived %JobQueen: append_job_tag_subelements, append_common_tag_subelements, and add_option/add_options.

C++: protocols::jd3::standard::StandardJobQueen::job_definition_xsd() const –> std::string

job_results_that_should_be_discarded(self: pyrosetta.rosetta.protocols.jd3.standard.StandardJobQueen) → pyrosetta.rosetta.std.list_std_pair_unsigned_long_unsigned_long_t

The IDs of jobs that should be discarded, IE not kept in memory for the next set of job nodes.

Override this method to note which jobs we don’t need for the next set of Job Nodes.

C++: protocols::jd3::standard::StandardJobQueen::job_results_that_should_be_discarded() –> class std::list<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > >

jobs_that_should_be_output(self: pyrosetta.rosetta.protocols.jd3.standard.StandardJobQueen) → pyrosetta.rosetta.std.list_std_shared_ptr_protocols_jd3_output_OutputSpecification_t

By default outputs all recently finished jobs for JD output (stored in recent_successes_).

Override this method if you want to cull these lists

C++: protocols::jd3::standard::StandardJobQueen::jobs_that_should_be_output() –> class std::list<class std::shared_ptr<class protocols::jd3::output::OutputSpecification>, class std::allocator<class std::shared_ptr<class protocols::jd3::output::OutputSpecification> > >

note_job_completed(self: pyrosetta.rosetta.protocols.jd3.standard.StandardJobQueen, job: pyrosetta.rosetta.protocols.jd3.LarvalJob, status: pyrosetta.rosetta.protocols.jd3.JobStatus, nresults: int) → None

The JD calls this function on completion of a LarvalJob, after updating the JobTracker

If you override this method, call the SJQs version first for PJN tracking and output.

C++: protocols::jd3::standard::StandardJobQueen::note_job_completed(class std::shared_ptr<const class protocols::jd3::LarvalJob>, enum protocols::jd3::JobStatus, unsigned long) –> void

note_job_completed_and_track(self: pyrosetta.rosetta.protocols.jd3.JobQueen, job: protocols::jd3::LarvalJob, status: pyrosetta.rosetta.protocols.jd3.JobStatus, nresults: int) → None

Call note_job_completed in derived classes and track the job using the JobTracker.

Decorator to note_job_completed

C++: protocols::jd3::JobQueen::note_job_completed_and_track(class std::shared_ptr<const class protocols::jd3::LarvalJob>, enum protocols::jd3::JobStatus, unsigned long) –> void

process_deallocation_message(self: pyrosetta.rosetta.protocols.jd3.standard.StandardJobQueen, message: pyrosetta.rosetta.protocols.jd3.deallocation.DeallocationMessage) → None

A deallocation message first sent to the JobDistributor on this host originating from

a remote JobQueen. If a derived JobQueen has deallocation messages she needs to recieve, she should override derived_process_deallocation_message.

C++: protocols::jd3::standard::StandardJobQueen::process_deallocation_message(class std::shared_ptr<class protocols::jd3::deallocation::DeallocationMessage>) –> void

resource_definition_xsd(self: pyrosetta.rosetta.protocols.jd3.standard.StandardJobQueen) → str

C++: protocols::jd3::standard::StandardJobQueen::resource_definition_xsd() const –> std::string

result_outputter(self: pyrosetta.rosetta.protocols.jd3.standard.StandardJobQueen, spec: pyrosetta.rosetta.protocols.jd3.output.OutputSpecification) → pyrosetta.rosetta.protocols.jd3.output.ResultOutputter

Return the bag of of PoseOutputters (in the form of a MultipleOutputter) for the

Pose that has been requested and specified by a particular OutputSpecification;

This function guarantees that for each individual outputter-name (respecting the JD-provided filename suffix) that a separate set of PoseOutputters are returned so that multiple threads can potentially output at the same time.

You should not need to override this method.

C++: protocols::jd3::standard::StandardJobQueen::result_outputter(const class protocols::jd3::output::OutputSpecification &) –> class std::shared_ptr<class protocols::jd3::output::ResultOutputter>

update_job_dag(self: pyrosetta.rosetta.protocols.jd3.standard.StandardJobQueen, updater: pyrosetta.rosetta.protocols.jd3.JobDigraphUpdater) → None

The %StandardJobQueen’s implementation is to not update the JobDAG at all: the

most basic protocol defines a job DAG with only a single node.

Override this method if you have a need for updating the job dag during your protocol.

C++: protocols::jd3::standard::StandardJobQueen::update_job_dag(class protocols::jd3::JobDigraphUpdater &) –> void