jd3

• chunk_library
• chunk_library_inputters
• dag_node_managers
• deallocation
• full_model
• full_model_inputters
• job_distributors
• job_results
• job_summaries
• jobs
• output
• pose_inputters
• pose_outputters
• standard

Bindings for protocols::jd3 namespace

class pyrosetta.rosetta.protocols.jd3.CompletedJobOutput

Bases: pybind11_object

Each Job will return a JobStatus and a list of JobSummary/JobResult pairs. A pair’s index in th job_results vector is used as its identifier for when the JobResult is used as input for another job, or when it is to be output by the JobQueen.

property job_results

property status

class pyrosetta.rosetta.protocols.jd3.InnerLarvalJob

Bases: pybind11_object

The %InnerLarvalJob class is responsible for holding the input requirements for a given job - how many nstruct, and what the input is. %InnerLarvalJobs are relatively heavy; there is no need to duplicate a series of %InnerLarvalJobs for each index into nstruct. The companion Job class handles the nstruct index and has a pointer to an InnerLarvalJob (which is shared across many Jobs). The JobQueen has considerable leeway in how she shares data held in the %InnerLarvalJobs she creates: if all of the options for a set of %InnerLarvalJob are identical, and they differ only in their input structure, then she can, e.g. share a single JobOptions object between all of them. InnerLarvalJobs 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.InnerLarvalJob, : pyrosetta.rosetta.protocols.jd3.InnerLarvalJob) → pyrosetta.rosetta.protocols.jd3.InnerLarvalJob

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

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

same_type(self: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, 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::InnerLarvalJob::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.InnerLarvalJob, out: pyrosetta.rosetta.std.ostream) → None

C++: protocols::jd3::InnerLarvalJob::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.InputSource

Bases: pybind11_object

The %InputSource is a small class for holding data about the starting Pose for a Job and where it comes from (i.e. which of the Inputters claims responsibility for creating a Pose for this instance). The “input_tag” is a string description of the input source and will be used as the “job_tag” to control output – the input tag should not include the file extension. It is perfectly reasonable for complex Inputters to subclass from InputSource to tuck more complex data in the InputSource, though, the string-string map ought to provide considerable flexibility in storing data without deriving new subclasses.

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

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

input_tag(*args, **kwargs)

Overloaded function.

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

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

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

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

origin(*args, **kwargs)

Overloaded function.

1. origin(self: pyrosetta.rosetta.protocols.jd3.InputSource) -> str

C++: protocols::jd3::InputSource::origin() const –> const std::string &

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

C++: protocols::jd3::InputSource::origin(const std::string &) –> void

source_id(*args, **kwargs)

Overloaded function.

1. source_id(self: pyrosetta.rosetta.protocols.jd3.InputSource) -> int

C++: protocols::jd3::InputSource::source_id() const –> unsigned long

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

C++: protocols::jd3::InputSource::source_id(unsigned long) –> void

class pyrosetta.rosetta.protocols.jd3.JGJobNode

Bases: pybind11_object

add_parent(*args, **kwargs)

Overloaded function.

1. add_parent(self: pyrosetta.rosetta.protocols.jd3.JGJobNode, p: pyrosetta.rosetta.std.weak_ptr_protocols_jd3_JGResultNode_t) -> None

2. add_parent(self: pyrosetta.rosetta.protocols.jd3.JGJobNode, p: pyrosetta.rosetta.std.weak_ptr_protocols_jd3_JGResultNode_t, tell_parent_to_add_child: bool) -> None

Like humans, the JGJobNode can have more than one parent.

please only set tell_parent_to_add_child to false if you plan on adding this job node to p’s vector of children. The parent/child relationship is very complicated when only one of the two parties knows about the relationship.

C++: protocols::jd3::JGJobNode::add_parent(class std::weak_ptr<class protocols::jd3::JGResultNode>, bool) –> void

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

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

children(self: pyrosetta.rosetta.protocols.jd3.JGJobNode) → pyrosetta.rosetta.utility.vector1_std_weak_ptr_protocols_jd3_JGResultNode_t

C++: protocols::jd3::JGJobNode::children() –> class utility::vector1<class std::weak_ptr<class protocols::jd3::JGResultNode>, class std::allocator<class std::weak_ptr<class protocols::jd3::JGResultNode> > > &

global_job_id(*args, **kwargs)

Overloaded function.

1. global_job_id(self: pyrosetta.rosetta.protocols.jd3.JGJobNode) -> int

C++: protocols::jd3::JGJobNode::global_job_id() const –> unsigned long

2. global_job_id(self: pyrosetta.rosetta.protocols.jd3.JGJobNode, global_job_id: int) -> None

C++: protocols::jd3::JGJobNode::global_job_id(unsigned long) –> void

input_source_id(*args, **kwargs)

Overloaded function.

1. input_source_id(self: pyrosetta.rosetta.protocols.jd3.JGJobNode) -> int

C++: protocols::jd3::JGJobNode::input_source_id() const –> unsigned int

2. input_source_id(self: pyrosetta.rosetta.protocols.jd3.JGJobNode, input_source_id: int) -> None

C++: protocols::jd3::JGJobNode::input_source_id(unsigned int) –> void

job_dag_node(*args, **kwargs)

Overloaded function.

1. job_dag_node(self: pyrosetta.rosetta.protocols.jd3.JGJobNode) -> int

“Node” is the most over-used word in this file. This method calls node() but has a more descriptive name so that we know what type of node we are talking about.

C++: protocols::jd3::JGJobNode::job_dag_node() const –> unsigned int

2. job_dag_node(self: pyrosetta.rosetta.protocols.jd3.JGJobNode, node: int) -> None

“Node” is the most over-used word in this file. This method calls node() but has a more descriptive name so that we know what type of node we are talking about.

C++: protocols::jd3::JGJobNode::job_dag_node(unsigned int) –> void

node(*args, **kwargs)

Overloaded function.

1. node(self: pyrosetta.rosetta.protocols.jd3.JGJobNode) -> int

C++: protocols::jd3::JGJobNode::node() const –> unsigned int

2. node(self: pyrosetta.rosetta.protocols.jd3.JGJobNode, node: int) -> None

C++: protocols::jd3::JGJobNode::node(unsigned int) –> void

parents(self: pyrosetta.rosetta.protocols.jd3.JGJobNode) → pyrosetta.rosetta.utility.vector1_std_weak_ptr_protocols_jd3_JGResultNode_t

C++: protocols::jd3::JGJobNode::parents() –> class utility::vector1<class std::weak_ptr<class protocols::jd3::JGResultNode>, class std::allocator<class std::weak_ptr<class protocols::jd3::JGResultNode> > > &

remove_parent(*args, **kwargs)

Overloaded function.

1. remove_parent(self: pyrosetta.rosetta.protocols.jd3.JGJobNode, p: pyrosetta.rosetta.std.weak_ptr_protocols_jd3_JGResultNode_t) -> bool

2. remove_parent(self: pyrosetta.rosetta.protocols.jd3.JGJobNode, p: pyrosetta.rosetta.std.weak_ptr_protocols_jd3_JGResultNode_t, tell_parent_to_remove_child: bool) -> bool

please only set tell_parent_to_add_child to false if you plan on removing this job node from p’s vector of children. The parent/child relationship is very complicated when only one of the two parties knows that the relationship has ended.

C++: protocols::jd3::JGJobNode::remove_parent(class std::weak_ptr<class protocols::jd3::JGResultNode>, bool) –> bool

class pyrosetta.rosetta.protocols.jd3.JGResultNode

Bases: pybind11_object

add_child(*args, **kwargs)

Overloaded function.

1. add_child(self: pyrosetta.rosetta.protocols.jd3.JGResultNode, c: pyrosetta.rosetta.std.weak_ptr_protocols_jd3_JGJobNode_t) -> None

2. add_child(self: pyrosetta.rosetta.protocols.jd3.JGResultNode, c: pyrosetta.rosetta.std.weak_ptr_protocols_jd3_JGJobNode_t, tell_child_to_add_parent: bool) -> None

Like humans, the JGResultNode can have more than one child.

please only set tell_child_to_add_parent to false if you plan on adding this result node to c’s vector of parents. The parent/child relationship is very complicated when only one of the two parties knows about the relationship.

C++: protocols::jd3::JGResultNode::add_child(class std::weak_ptr<class protocols::jd3::JGJobNode>, bool) –> void

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

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

children(self: pyrosetta.rosetta.protocols.jd3.JGResultNode) → pyrosetta.rosetta.utility.vector1_std_weak_ptr_protocols_jd3_JGJobNode_t

Be careful here! The vector is const but the elements are not

C++: protocols::jd3::JGResultNode::children() const –> const class utility::vector1<class std::weak_ptr<class protocols::jd3::JGJobNode>, class std::allocator<class std::weak_ptr<class protocols::jd3::JGJobNode> > > &

parent(*args, **kwargs)

Overloaded function.

1. parent(self: pyrosetta.rosetta.protocols.jd3.JGResultNode) -> pyrosetta.rosetta.std.weak_ptr_const_protocols_jd3_JGJobNode_t

C++: protocols::jd3::JGResultNode::parent() const –> class std::weak_ptr<const class protocols::jd3::JGJobNode>

2. parent(self: pyrosetta.rosetta.protocols.jd3.JGResultNode, parent: pyrosetta.rosetta.std.weak_ptr_protocols_jd3_JGJobNode_t) -> None

C++: protocols::jd3::JGResultNode::parent(class std::weak_ptr<class protocols::jd3::JGJobNode>) –> void

remove_child(*args, **kwargs)

Overloaded function.

1. remove_child(self: pyrosetta.rosetta.protocols.jd3.JGResultNode, c: pyrosetta.rosetta.std.weak_ptr_protocols_jd3_JGJobNode_t) -> bool

2. remove_child(self: pyrosetta.rosetta.protocols.jd3.JGResultNode, c: pyrosetta.rosetta.std.weak_ptr_protocols_jd3_JGJobNode_t, tell_child_to_remove_parent: bool) -> bool

please only set tell_child_to_remove_parent to false if you plan on removing this result node from c’s vector of parents. The parent/child relationship is very complicated when only one of the two parties knows that the relationship has ended.

C++: protocols::jd3::JGResultNode::remove_child(class std::weak_ptr<class protocols::jd3::JGJobNode>, bool) –> bool

result_id(*args, **kwargs)

Overloaded function.

1. result_id(self: pyrosetta.rosetta.protocols.jd3.JGResultNode) -> int

C++: protocols::jd3::JGResultNode::result_id() const –> unsigned int

2. result_id(self: pyrosetta.rosetta.protocols.jd3.JGResultNode, result_id: int) -> None

C++: protocols::jd3::JGResultNode::result_id(unsigned int) –> void

class pyrosetta.rosetta.protocols.jd3.JQKey

Bases: pybind11_object

This key can be used by to delineate other classes to store/maintain data used by the JQ

class pyrosetta.rosetta.protocols.jd3.Job

Bases: pybind11_object

%protocols::jd3::Job, which is created by the JobQueen from a LarvalJob, is responsible for executing some protocol from beginning to end in its “run” method. It must write all of its output data to the JobResult object that it creates and returns.

Note that in JD2, the currently running Job was globally accessible. That is not the case in JD3. Any data that should be output by a running job must be tucked inside the JobResult to be eventually retrieved by the JobQueen or by a JobDataOutputter at the end of execution.

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

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

run(self: pyrosetta.rosetta.protocols.jd3.Job) → pyrosetta.rosetta.protocols.jd3.CompletedJobOutput

This is the main function of the Job object. It will be invoked by the JobDistributor.

The Job will return a JobResult at the conclusion of its execution, and the JobResult will be serialized and sent to the appropriate JobQueen for processing and output. The Job itself will be discarded. Large constant data that might be shared between multiple jobs can be held by the Job object (or by classes that the Job object holds) but that data should not be put into the JobResult – large data should not be repeatedly serialized and shipped between nodes.

C++: protocols::jd3::Job::run() –> struct protocols::jd3::CompletedJobOutput

class pyrosetta.rosetta.protocols.jd3.JobDigraph

Bases: Digraph

A Digraph for storing the relationship between groups of jobs, so that each node in this graph represents a group of jobs, and if the outputs from one group are inputs to another group, then a directed edge from the first group to the second group will be in the graph. The JobDistributor will run all of the jobs in the first group before any of the jobs in the second group will start.

add_edge(*args, **kwargs)

Overloaded function.

1. add_edge(self: pyrosetta.rosetta.utility.graph.Digraph, tail_node: int, head_node: int) -> pyrosetta.rosetta.utility.graph.DirectedEdge

add a directed edge between two vertices. Invokes “create_edge” from the derived class.

Returns a pointer to the edge after its been added, allowing the calling function to immediately set data for this edge.

C++: utility::graph::Digraph::add_edge(unsigned long, unsigned long) –> class utility::graph::DirectedEdge *

2. add_edge(self: pyrosetta.rosetta.utility.graph.Digraph, example_edge: pyrosetta.rosetta.utility.graph.DirectedEdge) -> pyrosetta.rosetta.utility.graph.DirectedEdge

add an edge to this graph copying the data from an edge in another graph.

Returns a pointer to the edge after its been added, allowing the calling function to immediately set data for this edge.

C++: utility::graph::Digraph::add_edge(const class utility::graph::DirectedEdge *) –> class utility::graph::DirectedEdge *

add_node(self: pyrosetta.rosetta.utility.graph.Digraph) → None

Add a new node to the graph; preserve all of the existing edges in the graph

C++: utility::graph::Digraph::add_node() –> void

assign(self: pyrosetta.rosetta.protocols.jd3.JobDigraph, source: pyrosetta.rosetta.protocols.jd3.JobDigraph) → pyrosetta.rosetta.protocols.jd3.JobDigraph

assignment operator. source and this must have the same type.

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

const_edge_list_begin(self: pyrosetta.rosetta.utility.graph.Digraph) → pyrosetta.rosetta.utility.graph.DirectedEdgeListConstIterator

returns a const iterator to the beginning of the (unordered) edge list for the graph.

this edge list contains all the edges in the graph, not simply those for a particular vertex

C++: utility::graph::Digraph::const_edge_list_begin() const –> class utility::graph::DirectedEdgeListConstIterator

const_edge_list_end(self: pyrosetta.rosetta.utility.graph.Digraph) → pyrosetta.rosetta.utility.graph.DirectedEdgeListConstIterator

returns a const iterator to the end of the (unordered) edge list for the graph.

this edge list contains all the edges in the graph, not simply those for a particular vertex

C++: utility::graph::Digraph::const_edge_list_end() const –> class utility::graph::DirectedEdgeListConstIterator

copy_connectivity(self: pyrosetta.rosetta.utility.graph.Digraph, source: pyrosetta.rosetta.utility.graph.Digraph) → None

copy the edge connectivity from a source graph with a potentially

unknown type.

C++: utility::graph::Digraph::copy_connectivity(const class utility::graph::Digraph &) –> void

delete_edge(self: pyrosetta.rosetta.protocols.jd3.JobDigraph, edge: pyrosetta.rosetta.utility.graph.DirectedEdge) → None

remove an edge from the graph. (NEW AS OF 12/9/07) Never call C++’s

“delete” function on an edge pointer directly. Derived classes must implement this function. If they wish to use unordered_object_pools to manage their memory

C++: protocols::jd3::JobDigraph::delete_edge(class utility::graph::DirectedEdge *) –> void

drop_all_edges(self: pyrosetta.rosetta.utility.graph.Digraph) → None

delete all the edges present in the graph

C++: utility::graph::Digraph::drop_all_edges() –> void

drop_all_edges_for_node(self: pyrosetta.rosetta.utility.graph.Digraph, node: int) → None

delete all the edges for a single vertex in the graph

C++: utility::graph::Digraph::drop_all_edges_for_node(unsigned long) –> void

edge_list_begin(self: pyrosetta.rosetta.utility.graph.Digraph) → pyrosetta.rosetta.utility.graph.DirectedEdgeListIterator

returns a non-const iterator to the beginning of the (unordered) edge list for the graph.

this edge list contains all the edges in the graph, not simply those for a particular vertex

C++: utility::graph::Digraph::edge_list_begin() –> class utility::graph::DirectedEdgeListIterator

edge_list_end(self: pyrosetta.rosetta.utility.graph.Digraph) → pyrosetta.rosetta.utility.graph.DirectedEdgeListIterator

returns a non-const iterator to the end of the (unordered) edge list for the graph.

this edge list contains all the edges in the graph, not simply those for a particular vertex

C++: utility::graph::Digraph::edge_list_end() –> class utility::graph::DirectedEdgeListIterator

find_edge(self: pyrosetta.rosetta.utility.graph.Digraph, tail_node: int, head_node: int) → pyrosetta.rosetta.utility.graph.DirectedEdge

returns a pointer to the directed edge connecting nodes tail_node and head_node, if that edge exists

in the graph, o.w. returns 0. Focuses the graph on this edge for fast subsequent retrieval.

C++: utility::graph::Digraph::find_edge(unsigned long, unsigned long) –> class utility::graph::DirectedEdge *

find_job_edge(self: pyrosetta.rosetta.protocols.jd3.JobDigraph, tail_node: int, head_node: int) → pyrosetta.rosetta.protocols.jd3.JobDirectedEdge

returns a pointer to the directed edge connecting nodes tail_node and head_node, if that edge exists

in the graph, o.w. returns 0. Focuses the graph on this edge for fast subsequent retrieval.

C++: protocols::jd3::JobDigraph::find_job_edge(unsigned long, unsigned long) –> class protocols::jd3::JobDirectedEdge *

focused_edge(self: pyrosetta.rosetta.utility.graph.Digraph) → pyrosetta.rosetta.utility.graph.DirectedEdge

returns a pointer to the focused edge

C++: utility::graph::Digraph::focused_edge() –> class utility::graph::DirectedEdge *

getTotalMemoryUsage(self: pyrosetta.rosetta.utility.graph.Digraph) → int

returns a count of all the memory used by every vertex and edge in a graph

by invoking the polymorphic count_static_memory and count_dynamic_memory of each (possibly derived) node and edge object as well as for the (possibly derived) graph class.

C++: utility::graph::Digraph::getTotalMemoryUsage() const –> unsigned long

get_edge_exists(self: pyrosetta.rosetta.utility.graph.Digraph, tail_node: int, head_node: int) → bool

is an edge already present in the graph? O(V) worst case. O(1) iff all vertices have O(1) edges

C++: utility::graph::Digraph::get_edge_exists(unsigned long, unsigned long) const –> bool

get_job_node(self: pyrosetta.rosetta.protocols.jd3.JobDigraph, index: int) → pyrosetta.rosetta.protocols.jd3.JobDirectedNode

C++: protocols::jd3::JobDigraph::get_job_node(unsigned long) –> class protocols::jd3::JobDirectedNode *

get_node(self: pyrosetta.rosetta.utility.graph.Digraph, index: int) → pyrosetta.rosetta.utility.graph.DirectedNode

C++: utility::graph::Digraph::get_node(unsigned long) –> class utility::graph::DirectedNode *

get_self_ptr(self: pyrosetta.rosetta.utility.graph.Digraph) → pyrosetta.rosetta.utility.graph.Digraph

C++: utility::graph::Digraph::get_self_ptr() –> class std::shared_ptr<class utility::graph::Digraph>

num_edges(self: pyrosetta.rosetta.utility.graph.Digraph) → int

C++: utility::graph::Digraph::num_edges() const –> unsigned long

num_nodes(self: pyrosetta.rosetta.utility.graph.Digraph) → int

the number of nodes in the graph

C++: utility::graph::Digraph::num_nodes() const –> unsigned long

output_connectivity(self: pyrosetta.rosetta.utility.graph.Digraph, os: pyrosetta.rosetta.std.ostream) → None

send an edge list to the stream os.

C++: utility::graph::Digraph::output_connectivity(std::ostream &) const –> void

output_dimacs(self: pyrosetta.rosetta.utility.graph.Digraph, os: pyrosetta.rosetta.std.ostream) → None

describe this graph in dimacs form to the stream os.

C++: utility::graph::Digraph::output_dimacs(std::ostream &) const –> void

print_vertices(self: pyrosetta.rosetta.utility.graph.Digraph) → None

send summary information to the screen for all vertices in the graph

C++: utility::graph::Digraph::print_vertices() const –> void

set_num_nodes(self: pyrosetta.rosetta.utility.graph.Digraph, num_nodes: int) → None

set the number of nodes in the graph – deletes any existing edges in the graph

C++: utility::graph::Digraph::set_num_nodes(unsigned long) –> void

class pyrosetta.rosetta.protocols.jd3.JobDigraphUpdater

Bases: pybind11_object

This class defines the set of operations that a JobQueen can perform to update the JobDigraph that she originally gave to the JobDistributor. In particular, the JobQueen may only update the JobDigraph by adding new nodes to the graph (which will receive incrementally larger indexes) and then adding edges to the graph such that the head node for the edge must land on one of the newly added nodes in the graph. The JobDistributor will hand the JobQueen a JobDigraphUpdater through the JobQueen’s update_job_digraph method, and in this call, the JobQueen may add as many nodes as she wishes, and as many edges that land on those new nodes, but when the method exits, those nodes petrify: the JobQueen may not add any more edges that land on those new nodes.

add_edge_to_new_node(self: pyrosetta.rosetta.protocols.jd3.JobDigraphUpdater, tail_node: int, head_node: int) → None

Add an edge to the graph where the head_node for this edge has to be one of the nodes added

to the graph since the creation of this updater

C++: protocols::jd3::JobDigraphUpdater::add_edge_to_new_node(unsigned long, unsigned long) –> void

add_node(*args, **kwargs)

Overloaded function.

1. add_node(self: pyrosetta.rosetta.protocols.jd3.JobDigraphUpdater) -> None

Add a new node to the JobDigraph that this class holds.

C++: protocols::jd3::JobDigraphUpdater::add_node() –> void

2. add_node(self: pyrosetta.rosetta.protocols.jd3.JobDigraphUpdater, node_type_label: str) -> None

Add a new node to the JobDigraph that this class holds, setting the node type

C++: protocols::jd3::JobDigraphUpdater::add_node(std::string) –> void

job_dag(self: pyrosetta.rosetta.protocols.jd3.JobDigraphUpdater) → pyrosetta.rosetta.protocols.jd3.JobDigraph

Read access to the JobDigraph that the updater holds

C++: protocols::jd3::JobDigraphUpdater::job_dag() const –> class std::shared_ptr<const class protocols::jd3::JobDigraph>

orig_num_nodes(self: pyrosetta.rosetta.protocols.jd3.JobDigraphUpdater) → int

C++: protocols::jd3::JobDigraphUpdater::orig_num_nodes() const –> unsigned long

class pyrosetta.rosetta.protocols.jd3.JobDirectedEdge

Bases: DirectedEdge

A run-of-the-mill directed edge to use in JobDigraphs

copy_from(self: pyrosetta.rosetta.protocols.jd3.JobDirectedEdge, source: pyrosetta.rosetta.utility.graph.DirectedEdge) → None

copy-from for use in Digraph::operator= and copy ctors. The source node

must be a JobDirectedEdge

C++: protocols::jd3::JobDirectedEdge::copy_from(const class utility::graph::DirectedEdge *) –> void

count_dynamic_memory(self: pyrosetta.rosetta.protocols.jd3.JobDirectedEdge) → int

how much memory is dynamically allocated by this edge – must be recursively invoked

by a derived class.

C++: protocols::jd3::JobDirectedEdge::count_dynamic_memory() const –> unsigned long

count_static_memory(self: pyrosetta.rosetta.protocols.jd3.JobDirectedEdge) → int

how much memory is statically allocated by this edge

C++: protocols::jd3::JobDirectedEdge::count_static_memory() const –> unsigned long

get_head_node(self: pyrosetta.rosetta.utility.graph.DirectedEdge) → pyrosetta.rosetta.utility.graph.DirectedNode

returns a pointer to the head node

C++: utility::graph::DirectedEdge::get_head_node() –> class utility::graph::DirectedNode *

get_head_node_ind(self: pyrosetta.rosetta.utility.graph.DirectedEdge) → int

returns the index of the upper node

C++: utility::graph::DirectedEdge::get_head_node_ind() const –> unsigned long

get_other_ind(self: pyrosetta.rosetta.utility.graph.DirectedEdge, node_index: int) → int

returns the index of the one node given the index of the other.

node_index must be one of the two nodes that this edge is incident upon.

C++: utility::graph::DirectedEdge::get_other_ind(unsigned long) const –> unsigned long

get_other_node(self: pyrosetta.rosetta.utility.graph.DirectedEdge, node_index: int) → pyrosetta.rosetta.utility.graph.DirectedNode

returns a non-const pointer to one node given the index of the other.

node_index must be one of the two nodes that this edge is incident upon.

C++: utility::graph::DirectedEdge::get_other_node(unsigned long) –> class utility::graph::DirectedNode *

get_tail_node(self: pyrosetta.rosetta.utility.graph.DirectedEdge) → pyrosetta.rosetta.utility.graph.DirectedNode

returns a pointer to the tail node

C++: utility::graph::DirectedEdge::get_tail_node() –> class utility::graph::DirectedNode *

get_tail_node_ind(self: pyrosetta.rosetta.utility.graph.DirectedEdge) → int

returns the index of the tail node

C++: utility::graph::DirectedEdge::get_tail_node_ind() const –> unsigned long

is_head_node(self: pyrosetta.rosetta.utility.graph.DirectedEdge, node_index: int) → bool

C++: utility::graph::DirectedEdge::is_head_node(unsigned long) –> bool

is_tail_node(self: pyrosetta.rosetta.utility.graph.DirectedEdge, node_index: int) → bool

C++: utility::graph::DirectedEdge::is_tail_node(unsigned long) –> bool

same_edge(self: pyrosetta.rosetta.utility.graph.DirectedEdge, tail_node: int, head_node: int) → bool

Is this the same edge as another edge (tail_node,head_node)? Note:

this graph does not work for multi-graphs. DirectedEdges must be unique.

C++: utility::graph::DirectedEdge::same_edge(unsigned long, unsigned long) const –> bool

set_pos_in_owners_list(self: pyrosetta.rosetta.utility.graph.DirectedEdge, edge_iterator: pyrosetta.rosetta.utility.graph.DirectedEdgeListIterator) → None

called only by class Digraph, this function gives the DirectedEdge the data it needs

to later delete itself from its owner’s edge list in constant time.

C++: utility::graph::DirectedEdge::set_pos_in_owners_list(class utility::graph::DirectedEdgeListIterator) –> void

class pyrosetta.rosetta.protocols.jd3.JobDirectedNode

Bases: DirectedNode

A node to use in JobDigraphs that holds information about how much work has completed for the set of jobs that it represents.

add_incoming_edge(self: pyrosetta.rosetta.protocols.jd3.JobDirectedNode, edge_ptr: pyrosetta.rosetta.utility.graph.DirectedEdge, : pyrosetta.rosetta.utility.graph.DirectedEdgeListIterator) → None

C++: protocols::jd3::JobDirectedNode::add_incoming_edge(class utility::graph::DirectedEdge *, class utility::graph::DirectedEdgeListIterator &) –> void

add_outgoing_edge(self: pyrosetta.rosetta.utility.graph.DirectedNode, edge_ptr: utility::graph::DirectedEdge, : pyrosetta.rosetta.utility.graph.DirectedEdgeListIterator) → None

adds an edge pointer to node’s edge list as an outgoing edge

i.e. this node is the tail of the arrow; returns an iterator to the new list element. Virtual so derived classes can observe when incoming edges are added.

C++: utility::graph::DirectedNode::add_outgoing_edge(class utility::graph::DirectedEdge *, class utility::graph::DirectedEdgeListIterator &) –> void

all_jobs_completed(*args, **kwargs)

Overloaded function.

1. all_jobs_completed(self: pyrosetta.rosetta.protocols.jd3.JobDirectedNode, setting: bool) -> None

C++: protocols::jd3::JobDirectedNode::all_jobs_completed(bool) –> void

2. all_jobs_completed(self: pyrosetta.rosetta.protocols.jd3.JobDirectedNode) -> bool

C++: protocols::jd3::JobDirectedNode::all_jobs_completed() const –> bool

all_jobs_started(*args, **kwargs)

Overloaded function.

1. all_jobs_started(self: pyrosetta.rosetta.protocols.jd3.JobDirectedNode, setting: bool) -> None

C++: protocols::jd3::JobDirectedNode::all_jobs_started(bool) –> void

2. all_jobs_started(self: pyrosetta.rosetta.protocols.jd3.JobDirectedNode) -> bool

C++: protocols::jd3::JobDirectedNode::all_jobs_started() const –> bool

const_edge_list_begin(self: pyrosetta.rosetta.utility.graph.DirectedNode) → pyrosetta.rosetta.utility.graph.DirectedEdgeListConstIterator

returns a const iterator to the beginning of its edge list

C++: utility::graph::DirectedNode::const_edge_list_begin() const –> class utility::graph::DirectedEdgeListConstIterator

const_edge_list_end(self: pyrosetta.rosetta.utility.graph.DirectedNode) → pyrosetta.rosetta.utility.graph.DirectedEdgeListConstIterator

returns a const iterator to the end of its edge list

C++: utility::graph::DirectedNode::const_edge_list_end() const –> class utility::graph::DirectedEdgeListConstIterator

const_incoming_edge_list_begin(self: pyrosetta.rosetta.utility.graph.DirectedNode) → pyrosetta.rosetta.utility.graph.DirectedEdgeListConstIterator

returns a const iterator to the beginning of its incoming-edge list

C++: utility::graph::DirectedNode::const_incoming_edge_list_begin() const –> class utility::graph::DirectedEdgeListConstIterator

const_incoming_edge_list_end(self: pyrosetta.rosetta.utility.graph.DirectedNode) → pyrosetta.rosetta.utility.graph.DirectedEdgeListConstIterator

returns a const iterator to the end of its lower-edge list

C++: utility::graph::DirectedNode::const_incoming_edge_list_end() const –> class utility::graph::DirectedEdgeListConstIterator

const_outgoing_edge_list_begin(self: pyrosetta.rosetta.utility.graph.DirectedNode) → pyrosetta.rosetta.utility.graph.DirectedEdgeListConstIterator

returns a const iterator to the beginning of its outgoing-edge list

C++: utility::graph::DirectedNode::const_outgoing_edge_list_begin() const –> class utility::graph::DirectedEdgeListConstIterator

const_outgoing_edge_list_end(self: pyrosetta.rosetta.utility.graph.DirectedNode) → pyrosetta.rosetta.utility.graph.DirectedEdgeListConstIterator

returns a const iterator to the end of its outgoing-edge list

C++: utility::graph::DirectedNode::const_outgoing_edge_list_end() const –> class utility::graph::DirectedEdgeListConstIterator

copy_from(self: pyrosetta.rosetta.protocols.jd3.JobDirectedNode, source: pyrosetta.rosetta.utility.graph.DirectedNode) → None

invoked during graph assignment operators to copy any

node data from one graph to another graph. The source node must be the same type as this node.

C++: protocols::jd3::JobDirectedNode::copy_from(const class utility::graph::DirectedNode *) –> void

count_dynamic_memory(self: pyrosetta.rosetta.protocols.jd3.JobDirectedNode) → int

memory accounting scheme

C++: protocols::jd3::JobDirectedNode::count_dynamic_memory() const –> unsigned long

count_static_memory(self: pyrosetta.rosetta.protocols.jd3.JobDirectedNode) → int

memory accounting scheme

C++: protocols::jd3::JobDirectedNode::count_static_memory() const –> unsigned long

drop_all_edges(self: pyrosetta.rosetta.utility.graph.DirectedNode) → None

deletes all edges incident upon this node

C++: utility::graph::DirectedNode::drop_all_edges() –> void

drop_edge(self: pyrosetta.rosetta.utility.graph.DirectedNode, edge_iterator: pyrosetta.rosetta.utility.graph.DirectedEdgeListIterator) → None

removes an edge iterator from the node’s edge list. Only called by DirectedEdge class.

C++: utility::graph::DirectedNode::drop_edge(class utility::graph::DirectedEdgeListIterator) –> void

edge_list_begin(self: pyrosetta.rosetta.utility.graph.DirectedNode) → pyrosetta.rosetta.utility.graph.DirectedEdgeListIterator

returns a non-const iterator to the beginning of its edge list

C++: utility::graph::DirectedNode::edge_list_begin() –> class utility::graph::DirectedEdgeListIterator

edge_list_end(self: pyrosetta.rosetta.utility.graph.DirectedNode) → pyrosetta.rosetta.utility.graph.DirectedEdgeListIterator

returns a non-const iterator to the end of its edge list

C++: utility::graph::DirectedNode::edge_list_end() –> class utility::graph::DirectedEdgeListIterator

find_edge_from(self: pyrosetta.rosetta.utility.graph.DirectedNode, head_node: int) → utility::graph::DirectedEdge

a “slow” (linear) search for an edge.

C++: utility::graph::DirectedNode::find_edge_from(unsigned long) –> class utility::graph::DirectedEdge *

find_edge_to(self: pyrosetta.rosetta.utility.graph.DirectedNode, tail_node: int) → utility::graph::DirectedEdge

a “slow” (linear) search for an edge.

C++: utility::graph::DirectedNode::find_edge_to(unsigned long) –> class utility::graph::DirectedEdge *

get_node_index(self: pyrosetta.rosetta.utility.graph.DirectedNode) → int

the index for this node

C++: utility::graph::DirectedNode::get_node_index() const –> unsigned long

get_node_label(self: pyrosetta.rosetta.protocols.jd3.JobDirectedNode) → str

Get this Node’s primary type

Can be used to create the Job for this Job Node. Ex. Linear set of 2 stages per input structure, we would use 2 node labels to construct Jobs for each input based on a common job.

C++: protocols::jd3::JobDirectedNode::get_node_label() const –> std::string

incoming_edge_list_begin(self: pyrosetta.rosetta.utility.graph.DirectedNode) → pyrosetta.rosetta.utility.graph.DirectedEdgeListIterator

returns a non-const iterator to the beginning of its incoming-edge list

C++: utility::graph::DirectedNode::incoming_edge_list_begin() –> class utility::graph::DirectedEdgeListIterator

incoming_edge_list_end(self: pyrosetta.rosetta.utility.graph.DirectedNode) → pyrosetta.rosetta.utility.graph.DirectedEdgeListIterator

returns a non-const iterator to the end of its lower-edge list

C++: utility::graph::DirectedNode::incoming_edge_list_end() –> class utility::graph::DirectedEdgeListIterator

indegree(self: pyrosetta.rosetta.utility.graph.DirectedNode) → int

the number of incoming edges

C++: utility::graph::DirectedNode::indegree() const –> unsigned long

n_predecessors_w_outstanding_jobs(self: pyrosetta.rosetta.protocols.jd3.JobDirectedNode) → int

C++: protocols::jd3::JobDirectedNode::n_predecessors_w_outstanding_jobs() const –> unsigned long

num_edges(self: pyrosetta.rosetta.utility.graph.DirectedNode) → int

the number of edges incident on this node, which may include a loop edge

C++: utility::graph::DirectedNode::num_edges() const –> unsigned long

num_neighbors_counting_self(self: pyrosetta.rosetta.utility.graph.DirectedNode) → int

the number of neighbors counting “self” as a neighbor.

C++: utility::graph::DirectedNode::num_neighbors_counting_self() const –> unsigned long

outdegree(self: pyrosetta.rosetta.utility.graph.DirectedNode) → int

the number of outgoing edges

C++: utility::graph::DirectedNode::outdegree() const –> unsigned long

outgoing_edge_list_begin(self: pyrosetta.rosetta.utility.graph.DirectedNode) → pyrosetta.rosetta.utility.graph.DirectedEdgeListIterator

returns a non-const iterator to the beginning of its outgoing-edge list

C++: utility::graph::DirectedNode::outgoing_edge_list_begin() –> class utility::graph::DirectedEdgeListIterator

outgoing_edge_list_end(self: pyrosetta.rosetta.utility.graph.DirectedNode) → pyrosetta.rosetta.utility.graph.DirectedEdgeListIterator

returns a non-const iterator to the end of its outgoing-edge list

C++: utility::graph::DirectedNode::outgoing_edge_list_end() –> class utility::graph::DirectedEdgeListIterator

print(self: pyrosetta.rosetta.utility.graph.DirectedNode) → None

send summaray data about this node to the screen

C++: utility::graph::DirectedNode::print() const –> void

set_node_label(self: pyrosetta.rosetta.protocols.jd3.JobDirectedNode, node_label: str) → None

Set the primary node type label.

Can be used to create the Job for this Job Node. Ex. Linear set of 2 stages per input structure, we would use 2 node labels to construct Jobs for each input based on a common job.

C++: protocols::jd3::JobDirectedNode::set_node_label(const std::string &) –> void

class pyrosetta.rosetta.protocols.jd3.JobDistributor

Bases: pybind11_object

OK – I don’t know what the division of labor between a JobDistributor base class and a JobDistributor subclass, so I’m just going to start writing a simple JobDistributor and then follow it by writing an MPI job distributor and then I’ll see what shakes out.

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

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

go(self: pyrosetta.rosetta.protocols.jd3.JobDistributor, queen: protocols::jd3::JobQueen) → None

The main method for executing a protocol.

C++: protocols::jd3::JobDistributor::go(class std::shared_ptr<class protocols::jd3::JobQueen>) –> void

class pyrosetta.rosetta.protocols.jd3.JobDistributorFactory

Bases: pybind11_object

static create_job_distributor() → pyrosetta.rosetta.protocols.jd3.JobDistributor

C++: protocols::jd3::JobDistributorFactory::create_job_distributor() –> class std::shared_ptr<class protocols::jd3::JobDistributor>

class pyrosetta.rosetta.protocols.jd3.JobGenealogist

Bases: pybind11_object

all_job_results_for_node(self: pyrosetta.rosetta.protocols.jd3.JobGenealogist, job_dag_node: int, container_for_output: pyrosetta.rosetta.std.list_std_pair_unsigned_long_unsigned_long_t) → None

This method populates the list with every JobResultID for this job dag node

C++: protocols::jd3::JobGenealogist::all_job_results_for_node(unsigned long, class std::list<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > &) const –> void

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

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

discard_job_result(*args, **kwargs)

Overloaded function.

1. discard_job_result(self: pyrosetta.rosetta.protocols.jd3.JobGenealogist, job_dag_node: int, global_job_id: int, result_id: int) -> None

At the end of job_results_that_should_be_discarded(), call this funciton for every JobResultID in the list

C++: protocols::jd3::JobGenealogist::discard_job_result(unsigned long, unsigned long, unsigned long) –> void

2. discard_job_result(self: pyrosetta.rosetta.protocols.jd3.JobGenealogist, job_dag_node: int, id: Tuple[int, int]) -> None

At the end of job_results_that_should_be_discarded(), call this funciton for every JobResultID in the list

C++: protocols::jd3::JobGenealogist::discard_job_result(unsigned long, const struct std::pair<unsigned long, unsigned long> &) –> void

garbage_collection(self: pyrosetta.rosetta.protocols.jd3.JobGenealogist, job_dag_node: int, delete_downstream_job_if_it_has_no_results: bool, container_for_discarded_result_ids: pyrosetta.rosetta.std.list_std_pair_unsigned_long_unsigned_long_t) → None

return every job result id in this job_dag_node that does not have any jobs spawned after it.

Consider the patter Job1 -> Result1 -> Job5 and Job5 has no children (results). Should Job1/Result1 be garbage collected? If so, set delete_downstream_job_if_it_has_no_results to true.

C++: protocols::jd3::JobGenealogist::garbage_collection(unsigned long, bool, class std::list<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > > &) –> void

get_const_job_node(self: pyrosetta.rosetta.protocols.jd3.JobGenealogist, job_dag_node: int, global_job_id: int) → pyrosetta.rosetta.protocols.jd3.JGJobNode

C++: protocols::jd3::JobGenealogist::get_const_job_node(unsigned long, unsigned long) const –> class std::shared_ptr<const class protocols::jd3::JGJobNode>

input_source_for_job(self: pyrosetta.rosetta.protocols.jd3.JobGenealogist, job_dag_node: int, global_job_id: int) → int

C++: protocols::jd3::JobGenealogist::input_source_for_job(unsigned long, unsigned long) const –> unsigned long

newick_tree(self: pyrosetta.rosetta.protocols.jd3.JobGenealogist) → str

This returns the connectivity of the graph as a newick tree. If you graph is not a tree, this will have duplicate elements.

C++: protocols::jd3::JobGenealogist::newick_tree() const –> std::string

note_job_completed(*args, **kwargs)

Overloaded function.

1. note_job_completed(self: pyrosetta.rosetta.protocols.jd3.JobGenealogist, job_node: pyrosetta.rosetta.std.weak_ptr_protocols_jd3_JGJobNode_t, nresults: int) -> None

Creates nresults new JGResultNodes for this job_node

C++: protocols::jd3::JobGenealogist::note_job_completed(class std::weak_ptr<class protocols::jd3::JGJobNode>, unsigned long) –> void

2. note_job_completed(self: pyrosetta.rosetta.protocols.jd3.JobGenealogist, dag_node_id: int, global_job_id: int, nresults: int) -> None

wrapper for the other overload. This one is designed to more closely match the argument provided to JobQueen::note_job_completed

C++: protocols::jd3::JobGenealogist::note_job_completed(unsigned long, unsigned long, unsigned long) –> void

print_all_nodes(self: pyrosetta.rosetta.protocols.jd3.JobGenealogist) → None

This is more for debugging than anything. Print the global_job_ids for every job dag node to the screen

C++: protocols::jd3::JobGenealogist::print_all_nodes() –> void

register_new_job(*args, **kwargs)

Overloaded function.

1. register_new_job(self: pyrosetta.rosetta.protocols.jd3.JobGenealogist, job_dag_node_id: int, global_job_id: int, input_source_id: int) -> pyrosetta.rosetta.protocols.jd3.JGJobNode

register a new job that does not depend on a previous job result but rather takes a pose directly from an input source

C++: protocols::jd3::JobGenealogist::register_new_job(unsigned long, unsigned long, unsigned long) –> class std::shared_ptr<class protocols::jd3::JGJobNode>

2. register_new_job(self: pyrosetta.rosetta.protocols.jd3.JobGenealogist, job_dag_node_id: int, global_job_id: int, job_dag_node_id_of_parent: int, global_job_id_of_parent: int, result_id_of_parent: int) -> pyrosetta.rosetta.protocols.jd3.JGJobNode

register a new job that depends on a single parent job result

C++: protocols::jd3::JobGenealogist::register_new_job(unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) –> class std::shared_ptr<class protocols::jd3::JGJobNode>

3. register_new_job(self: pyrosetta.rosetta.protocols.jd3.JobGenealogist, job_dag_node_id: int, global_job_id: int, job_dag_node_id_of_parent: int, id: Tuple[int, int]) -> pyrosetta.rosetta.protocols.jd3.JGJobNode

register a new job that depends on a single parent job result

C++: protocols::jd3::JobGenealogist::register_new_job(unsigned long, unsigned long, unsigned long, const struct std::pair<unsigned long, unsigned long> &) –> class std::shared_ptr<class protocols::jd3::JGJobNode>

4. register_new_job(self: pyrosetta.rosetta.protocols.jd3.JobGenealogist, job_dag_node_id: int, global_job_id: int, parent: pyrosetta.rosetta.std.weak_ptr_protocols_jd3_JGResultNode_t) -> pyrosetta.rosetta.protocols.jd3.JGJobNode

register a new job that depends on a single parent job result

C++: protocols::jd3::JobGenealogist::register_new_job(unsigned long, unsigned long, class std::weak_ptr<class protocols::jd3::JGResultNode>) –> class std::shared_ptr<class protocols::jd3::JGJobNode>

5. register_new_job(self: pyrosetta.rosetta.protocols.jd3.JobGenealogist, job_dag_node_id: int, global_job_id: int, parents: pyrosetta.rosetta.utility.vector1_std_weak_ptr_protocols_jd3_JGResultNode_t) -> pyrosetta.rosetta.protocols.jd3.JGJobNode

register a new job that depends on multiple parent job results

C++: protocols::jd3::JobGenealogist::register_new_job(unsigned long, unsigned long, const class utility::vector1<class std::weak_ptr<class protocols::jd3::JGResultNode>, class std::allocator<class std::weak_ptr<class protocols::jd3::JGResultNode> > > &) –> class std::shared_ptr<class protocols::jd3::JGJobNode>

class pyrosetta.rosetta.protocols.jd3.JobOutputIndex

Bases: pybind11_object

The %JobOutputIndex holds the four relevant counts for describing the “name” for an output (e.g. a Pose) that is going to be written out to disk

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

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

property n_primary_outputs

property n_secondary_outputs

property primary_output_index

property secondary_output_index

class pyrosetta.rosetta.protocols.jd3.JobQueen

Bases: pybind11_object

The %JobQueen class (think of a queen bee) has quite a few responsibilities: - determining what jobs should be run and representing them as larval job objects - taking a larval job object and maturing it into a fully functional Job that can be run - processing the JobResult produced by a Job when it runs - determining the number of rounds of larval-job creation and job execution that should

be performed.

The %JobQueen is responsible for creating all of the LarvalJobs, grouped into “batches” which are dispatched by the JobDistributor; the queen then matures the larval jobs into the mature form (a Job, e.g. a Mover/Pose pair) and gives them up to the JobDistributor to actually execute the work. The JobDistributor then actually calls the Job’s “run” method, which produces a JobResult. It then hands this JobResult (e.g. a Pose or several Poses) back to the %JobQueen for output. In fact, in MPI contexts, the JobDistributor guarantees that it will hand all of the completed JobResults for a single batch to a single %JobQueen, so that she can compute aggregate statistics (e.g. averaging energies) or can look at the

results from that round of jobs and decide which to carry forward into the next

round of execution.

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

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

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

The JobDistributor guarnatees that exactly one JobQueen will see every

JobSummary generated within a Job batch. This guarantee allows the JobQueen to aggregate data across all of the Jobs so that Rosetta is able to compute data from structures instead of forcing that computation into accessory scripts.

C++: protocols::jd3::JobQueen::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.JobQueen) → pyrosetta.rosetta.std.list_std_shared_ptr_protocols_jd3_deallocation_DeallocationMessage_t

Are there any deallocation messages that the JobQueen would like to have delivered

to the JobQueens living on remote hosts? If there are none, the derived JobQueen may return an empty list. The JobDistributor guarantees to send the deallocation message to all remote hosts. The JobDistributor will ask the JobQueen on the head node for a set of deallocation messages after each set of jobs from determine_job_list have been distributed. (i.e., before the next call to determine_job_list is made).

C++: protocols::jd3::JobQueen::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.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

The JobDistributor asks the JobQueen for a list of jobs that should be performed.

This function neither knows nor cares what jobs are already complete on disk/memory - it just figures out what ones should exist given the input. The JobDistributor tells the %JobQueen which node in the JobDAG it is requesting jobs for, and puts a limit on the number of LarvalJobs that the JobQueen should return. The JobDistributor will call this function repeatedly for a single node until the %JobQueen returns an empty list, at which point, the JobDistributor will consider the node’s jobs exhausted.

C++: protocols::jd3::JobQueen::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> > >

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

Send all buffered output to disk – called by the JobDistributor right before it shuts down

if it hits an error or catches an exception that it cannot ignore.

C++: protocols::jd3::JobQueen::flush() –> void

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

The JobQueen must be able to determine if a particular job has already

been output. The JobQueen returns “true” if the job has already been written, and “false” otherwise. Used for overwrite behavior.

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

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

All JobQueens must describe their job input XML format in the form of an XSD

(XML Schema Definition), and they must validate their job input files against their XSDs. If the JobDistributor is awakened with the flag “jd3::output_job_xsd <output file>” on the command line, then the JobDistributor will write out the XSD to the output file.

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

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

The JobDistributor, to manage memory use, asks the JobQueen which JobResults may be

discarded because they will not be used in the future. The JobDistributor will exit with an error message if the %JobQueen gives it a LarvalJob that lists one of these discarded JobResults as a required input for that LarvalJob.

C++: protocols::jd3::JobQueen::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.JobQueen) → pyrosetta.rosetta.std.list_std_shared_ptr_protocols_jd3_output_OutputSpecification_t

The JobDistributor asks the JobQueen which JobResults should be queued for output.

The JobQueen should reply by returning a list of OutputSpecification objects. Each OutputSpecification indicates a particular JobResult using the JobResultID object that the Specification holds. It also indicates how the JobResult should be output by whatever object will be doing to job outputting. The JobQueen should ask for a given JobResult to be output only once. After a job result is output, the JobDistributor will discard the JobResult, so the JobQueen should not tell the JobDistributor to output a job if it will be used as an input to another job in the future. Note that this method will only be called on the master-node JobQueen (aka JQ0), but that she will not necessarily be the JobQueen to actually return the ResultOutputter for the jobs that will be output. The JobDistributor holds the option to distribute output to other nodes

C++: protocols::jd3::JobQueen::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.JobQueen, job: protocols::jd3::LarvalJob, status: pyrosetta.rosetta.protocols.jd3.JobStatus, nresults: int) → None

The JobDistributor will call this function to inform the JobQueen that

a job has “completed” – in the sense that it will not be run in the future. It does not guarantee that the job was run on this CPU or that it successfully completed anywhere. The JobStatus indicates whether the job completed or whether it failed. The nresults count lists how many JobSummary/JobResult pairs were produced by the completed job.

C++: protocols::jd3::JobQueen::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.JobQueen, message: protocols::jd3::deallocation::DeallocationMessage) → None

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

a remote JobQueen

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

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

JobQueens may optionally define an XSD for their resource definition file

which is fed to their resource manager (if they control one). If the JobDistributor is awakened with the flag “jd3::output_resource_xsd <output file>” on the command line, and if the derived JobQueen defines an XSD for resources she uses, then the JobDistributor will write out the resource definition XSD to the output file. The derived queen may return an empty string to indicate that no resources are definable for the resource manager.

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

result_outputter(self: pyrosetta.rosetta.protocols.jd3.JobQueen, output_specification: protocols::jd3::output::OutputSpecification) → protocols::jd3::output::ResultOutputter

The JobDistributor will ask the JobQueen to provide an outputter for a result

giving it an annotated-with-job-distributor-specific-prefix OutputSpecification. The JobQueen must guarantee that a distinct ResultOutputter is given for each distinct JD prefix and that no two ResultOutputters share non-(bitwise-)constant data as the JobDistributor may use multiple threads to perform output. Note that the JobQueen that creates the outputter may not have been the JobQueen to request that output be performed. This function is thus similar to mature_larval_job: it requires that the JobQueen make few assumptions about the state of her data in order for this behavior to translate from the VanillaJobDistributor to the MPIWorkPoolJobDistributor.

C++: protocols::jd3::JobQueen::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.JobQueen, updater: pyrosetta.rosetta.protocols.jd3.JobDigraphUpdater) → None

The JobQueen is allowed to update the JobDigraph over the course of execution

but only in a particular way: by adding new nodes, and then by adding edges that land on those new nodes. The JobQueen is not allowed to add edges that land on an old node.

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

class pyrosetta.rosetta.protocols.jd3.JobResult

Bases: pybind11_object

%JobResult class holds the output that’s generated by a Job over the course of its execution. The %JobResult is handed by the JobQueen to the JobOutputWriter objects, each of which have the opportunity to pull data out of the JobResult class.

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

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

status(self: pyrosetta.rosetta.protocols.jd3.JobResult) → pyrosetta.rosetta.protocols.jd3.JobStatus

C++: protocols::jd3::JobResult::status() const –> enum protocols::jd3::JobStatus

class pyrosetta.rosetta.protocols.jd3.JobStatus

Bases: pybind11_object

Members:

jd3_job_status_success

jd3_job_previously_executed

jd3_job_status_inputs_were_bad

jd3_job_status_failed_w_exception

jd3_job_status_failed_retry

jd3_job_status_failed_max_retries

jd3_job_status_failed_do_not_retry

jd3_job_previously_executed = <JobStatus.jd3_job_previously_executed: 1>

jd3_job_status_failed_do_not_retry = <JobStatus.jd3_job_status_failed_do_not_retry: 6>

jd3_job_status_failed_max_retries = <JobStatus.jd3_job_status_failed_max_retries: 5>

jd3_job_status_failed_retry = <JobStatus.jd3_job_status_failed_retry: 4>

jd3_job_status_failed_w_exception = <JobStatus.jd3_job_status_failed_w_exception: 3>

jd3_job_status_inputs_were_bad = <JobStatus.jd3_job_status_inputs_were_bad: 2>

jd3_job_status_success = <JobStatus.jd3_job_status_success: 0>

property name

property value

class pyrosetta.rosetta.protocols.jd3.JobSummary

Bases: pybind11_object

%JobSummary class holds the output that’s generated by a Job over the course of its execution. The %JobSummary is handed by the JobQueen to the JobOutputWriter objects, each of which have the opportunity to pull data out of the JobSummary class.

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

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

class pyrosetta.rosetta.protocols.jd3.JobTracker

Bases: pybind11_object

A simple class for tracking job progress within JD3.

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

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

clone(self: pyrosetta.rosetta.protocols.jd3.JobTracker) → pyrosetta.rosetta.protocols.jd3.JobTracker

C++: protocols::jd3::JobTracker::clone() const –> class std::shared_ptr<class protocols::jd3::JobTracker>

completed_jobs(self: pyrosetta.rosetta.protocols.jd3.JobTracker) → pyrosetta.rosetta.numeric.DiscreteIntervalEncodingTree_unsigned_long_t

Read access for which jobs have completed and how; if a job-id is a member

of this DIET, then it has completed (either in success or failure).

C++: protocols::jd3::JobTracker::completed_jobs() const –> const class numeric::DiscreteIntervalEncodingTree<unsigned long> &

completed_jobs_for_node(self: pyrosetta.rosetta.protocols.jd3.JobTracker, job_dag_node: int) → pyrosetta.rosetta.numeric.DiscreteIntervalEncodingTree_unsigned_long_t

C++: protocols::jd3::JobTracker::completed_jobs_for_node(unsigned long) const –> const class numeric::DiscreteIntervalEncodingTree<unsigned long> &

current_job_index(self: pyrosetta.rosetta.protocols.jd3.JobTracker) → int

Get the current larval job index

C++: protocols::jd3::JobTracker::current_job_index() const –> unsigned long

failed_jobs(self: pyrosetta.rosetta.protocols.jd3.JobTracker) → pyrosetta.rosetta.numeric.DiscreteIntervalEncodingTree_unsigned_long_t

Read access for which jobs have completed and how; if a job-id is a member

of this DIET, then it completed unsuccessfully.

C++: protocols::jd3::JobTracker::failed_jobs() const –> const class numeric::DiscreteIntervalEncodingTree<unsigned long> &

increment_current_job_index(self: pyrosetta.rosetta.protocols.jd3.JobTracker) → None

Increment the current job index tracked by the JobTracker.

Used to set the job_index for LarvalJobs during determine_job_list

C++: protocols::jd3::JobTracker::increment_current_job_index() –> void

last_job_for_input_source_id(self: pyrosetta.rosetta.protocols.jd3.JobTracker, input_pose_index: int) → int

Last job index of a particular pose id from all starting jobs.

C++: protocols::jd3::JobTracker::last_job_for_input_source_id(unsigned long) const –> unsigned long

last_jobs_for_inputs_sources(self: pyrosetta.rosetta.protocols.jd3.JobTracker) → pyrosetta.rosetta.std.map_unsigned_long_unsigned_long

Get the map of last job indexes and input source ids

C++: protocols::jd3::JobTracker::last_jobs_for_inputs_sources() const –> const class std::map<unsigned long, unsigned long, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, unsigned long> > > &

started_jobs(self: pyrosetta.rosetta.protocols.jd3.JobTracker) → pyrosetta.rosetta.numeric.DiscreteIntervalEncodingTree_unsigned_long_t

Read access for jobs have been given out to the JD through determine_job_list.

C++: protocols::jd3::JobTracker::started_jobs() const –> const class numeric::DiscreteIntervalEncodingTree<unsigned long> &

started_jobs_for_node(self: pyrosetta.rosetta.protocols.jd3.JobTracker, job_dag_node: int) → pyrosetta.rosetta.numeric.DiscreteIntervalEncodingTree_unsigned_long_t

Read access to all job indexes started for a particular job node.

C++: protocols::jd3::JobTracker::started_jobs_for_node(unsigned long) const –> const class numeric::DiscreteIntervalEncodingTree<unsigned long> &

successful_jobs(self: pyrosetta.rosetta.protocols.jd3.JobTracker) → pyrosetta.rosetta.numeric.DiscreteIntervalEncodingTree_unsigned_long_t

Read access for which jobs have completed and how; if a job-id is a member

of this DIET, then it completed successfully.

C++: protocols::jd3::JobTracker::successful_jobs() const –> const class numeric::DiscreteIntervalEncodingTree<unsigned long> &

track_completed_job(self: pyrosetta.rosetta.protocols.jd3.JobTracker, key: pyrosetta.rosetta.protocols.jd3.JQKey, larval_job: protocols::jd3::LarvalJob, status: pyrosetta.rosetta.protocols.jd3.JobStatus) → None

Note the completed job by Job Dag node and by Status.

Only the JobQueen is allowed to call this method.

C++: protocols::jd3::JobTracker::track_completed_job(class protocols::jd3::JQKey, const class protocols::jd3::LarvalJob &, enum protocols::jd3::JobStatus) –> void

track_starting_job_list(self: pyrosetta.rosetta.protocols.jd3.JobTracker, key: pyrosetta.rosetta.protocols.jd3.JQKey, starting_jobs: pyrosetta.rosetta.std.list_std_shared_ptr_protocols_jd3_LarvalJob_t) → None

C++: protocols::jd3::JobTracker::track_starting_job_list(class protocols::jd3::JQKey, const class std::list<class std::shared_ptr<class protocols::jd3::LarvalJob>, class std::allocator<class std::shared_ptr<class protocols::jd3::LarvalJob> > > &) –> void

class pyrosetta.rosetta.protocols.jd3.LarvalJob

Bases: pybind11_object

%protocols::jd3::LarvalJob, which is initialized by the JobQueen, during its intitialize_job_list method, is an immature form of the. It is matured into a Job that can be run by the JobQueen’s mature_job method. A LarvalJob may be one of several LarvalJobs that have the same inputs, but differ in their random number seed (i.e. replicates); two jobs that share the same input are meant to point to the same “InnerLarvalJob” to avoid spending too much memory representing identical data.

Note that in JD2, the currently running Job was globally accessible. That is not the case in JD3. Any data that should be output by a running job must be tucked by a Mover inside the JobOutputData to be eventually retrieved by the JobQueen or by a JobDataOutputter at the end of execution.

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

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

bad(*args, **kwargs)

Overloaded function.

1. bad(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) -> bool

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

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

C++: protocols::jd3::LarvalJob::bad(bool) –> void

completed(*args, **kwargs)

Overloaded function.

1. completed(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) -> bool

C++: protocols::jd3::LarvalJob::completed() const –> bool

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

C++: protocols::jd3::LarvalJob::completed(bool) –> void

defines_retry_limit(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) → bool

C++: protocols::jd3::LarvalJob::defines_retry_limit() const –> bool

inner_job(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) → pyrosetta.rosetta.protocols.jd3.InnerLarvalJob

read access to the inner-job

C++: protocols::jd3::LarvalJob::inner_job() const –> class std::shared_ptr<const class protocols::jd3::InnerLarvalJob>

input_job_result_indices(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) → 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 and the result_index for that job.

C++: protocols::jd3::LarvalJob::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_tag(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) → str

The input tag (a short string, generally), is used to specify the input structure,

but is not a complete description of the LarvalJob, and certainly not the identifier with which to identify output structures.

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

job_index(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) → pyrosetta.rosetta.utility.StrongT_unsigned_long_protocols_jd3_GlobalJobID_t

The “global” index for this job among all jobs created by the JobQueen

C++: protocols::jd3::LarvalJob::job_index() const –> struct utility::StrongT<unsigned long, struct protocols::jd3::GlobalJobID_>

job_node(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) → int

What is the Job Node for this LarvalJob?

Returned from the InnerLarvalJob

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

job_tag(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) → str

The job tag is a combination of the input tag and any other data that the

JobQueen uses to describe the job, or that has been provided by the user in the job-definition XML file.

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

job_tag_with_index_suffix(*args, **kwargs)

Overloaded function.

1. job_tag_with_index_suffix(self: pyrosetta.rosetta.protocols.jd3.LarvalJob, output_index: pyrosetta.rosetta.protocols.jd3.JobOutputIndex) -> str

2. job_tag_with_index_suffix(self: pyrosetta.rosetta.protocols.jd3.LarvalJob, output_index: pyrosetta.rosetta.protocols.jd3.JobOutputIndex, min_digits: int) -> str

For output purposes, construct a string for a particular output of this job given

a JobOutputIndex.

C++: protocols::jd3::LarvalJob::job_tag_with_index_suffix(const struct protocols::jd3::JobOutputIndex &, const unsigned long) const –> std::string

nonconst_inner_job(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) → pyrosetta.rosetta.protocols.jd3.InnerLarvalJob

write access to the inner-job; this should be reserved for the JobQueen only

as she edits the inner job during its construction

C++: protocols::jd3::LarvalJob::nonconst_inner_job() const –> class std::shared_ptr<class protocols::jd3::InnerLarvalJob>

nstruct_index(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) → pyrosetta.rosetta.utility.StrongT_unsigned_long_protocols_jd3_NStructIndex_t

The index used to identify which job this is out of many that have identical inputs

but different random number seeds (controlled by the command-line flag “nstruct”)

C++: protocols::jd3::LarvalJob::nstruct_index() const –> struct utility::StrongT<unsigned long, struct protocols::jd3::NStructIndex_>

nstruct_max(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) → int

The total number of jobs with the same inputs, but different random number seeds.

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

retry_limit(*args, **kwargs)

Overloaded function.

1. retry_limit(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) -> int

C++: protocols::jd3::LarvalJob::retry_limit() const –> unsigned long

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

C++: protocols::jd3::LarvalJob::retry_limit(unsigned long) –> void

set_status_prefix(self: pyrosetta.rosetta.protocols.jd3.LarvalJob, prefix: str) → None

C++: protocols::jd3::LarvalJob::set_status_prefix(const std::string &) –> void

set_status_suffix(self: pyrosetta.rosetta.protocols.jd3.LarvalJob, suffix: str) → None

C++: protocols::jd3::LarvalJob::set_status_suffix(const std::string &) –> void

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

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

status_prefix(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) → str

C++: protocols::jd3::LarvalJob::status_prefix() const –> const std::string &

status_suffix(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) → str

C++: protocols::jd3::LarvalJob::status_suffix() const –> const std::string &

to_do(self: pyrosetta.rosetta.protocols.jd3.LarvalJob) → bool

C++: protocols::jd3::LarvalJob::to_do() const –> bool

pyrosetta.rosetta.protocols.jd3.add_residue_selectors_to_datamap(tag: pyrosetta.rosetta.utility.tag.Tag, datamap: pyrosetta.rosetta.basic.datacache.DataMap) → None

Add all residue selectors to a given datamap from a tag.

C++: protocols::jd3::add_residue_selectors_to_datamap(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

pyrosetta.rosetta.protocols.jd3.append_residue_selector_subelements(job_definition_xsd: utility::tag::XMLSchemaDefinition, job_ct_gen: utility::tag::XMLSchemaComplexTypeGenerator) → None

Append Residue Selector elements for your JD file.

C++: protocols::jd3::append_residue_selector_subelements(class utility::tag::XMLSchemaDefinition &, class utility::tag::XMLSchemaComplexTypeGenerator &) –> void

pyrosetta.rosetta.protocols.jd3.append_single_scorefxn_subelement(job_definition_xsd: utility::tag::XMLSchemaDefinition, job_ct_gen: utility::tag::XMLSchemaComplexTypeGenerator) → None

Append the ability to have a SINGLE ScoreFunction set.

Used to have the scorefunction defined for the entire job.

C++: protocols::jd3::append_single_scorefxn_subelement(class utility::tag::XMLSchemaDefinition &, class utility::tag::XMLSchemaComplexTypeGenerator &) –> void

class pyrosetta.rosetta.protocols.jd3.compare_job_nodes

Bases: pybind11_object

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

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

pyrosetta.rosetta.protocols.jd3.nstruct_for_job(job_tag: pyrosetta.rosetta.utility.tag.Tag) → int

Get the nstruct from the job_tag, or fallback to the cmd-line

C++: protocols::jd3::nstruct_for_job(class std::shared_ptr<const class utility::tag::Tag>) –> unsigned long

pyrosetta.rosetta.protocols.jd3.option_type_from_key(key: pyrosetta.rosetta.utility.options.OptionKey) → pyrosetta.rosetta.utility.options.OptionTypes

Get the OptionType from a key

C++: protocols::jd3::option_type_from_key(const class utility::options::OptionKey &) –> enum utility::options::OptionTypes

pyrosetta.rosetta.protocols.jd3.options_for_job(option_keys: pyrosetta.rosetta.std.list_utility_keys_VariantKey_utility_options_OptionKey_t, inner_job: pyrosetta.rosetta.protocols.jd3.InnerLarvalJob, common_block_tags: pyrosetta.rosetta.utility.tag.Tag) → pyrosetta.rosetta.utility.options.OptionCollection

Create a local options collection from an InnerLarvalJob.

C++: protocols::jd3::options_for_job(const class std::list<class utility::keys::VariantKey<class utility::options::OptionKey>, class std::allocator<class utility::keys::VariantKey<class utility::options::OptionKey> > > &, const class protocols::jd3::InnerLarvalJob &, class std::shared_ptr<const class utility::tag::Tag>) –> class std::shared_ptr<class utility::options::OptionCollection>

pyrosetta.rosetta.protocols.jd3.options_from_tag(option_keys: pyrosetta.rosetta.std.list_utility_keys_VariantKey_utility_options_OptionKey_t, job_options_tags: pyrosetta.rosetta.utility.tag.Tag, common_block_tags: pyrosetta.rosetta.utility.tag.Tag) → pyrosetta.rosetta.utility.options.OptionCollection

Create a local options collection from a tag.

C++: protocols::jd3::options_from_tag(const class std::list<class utility::keys::VariantKey<class utility::options::OptionKey>, class std::allocator<class utility::keys::VariantKey<class utility::options::OptionKey> > > &, class std::shared_ptr<const class utility::tag::Tag>, class std::shared_ptr<const class utility::tag::Tag>) –> class std::shared_ptr<class utility::options::OptionCollection>

pyrosetta.rosetta.protocols.jd3.parse_single_residue_selector(tag: pyrosetta.rosetta.utility.tag.Tag, selector_name: str) → pyrosetta.rosetta.core.select.residue_selector.ResidueSelector

Return a single residue selector from tag.

C++: protocols::jd3::parse_single_residue_selector(class std::shared_ptr<const class utility::tag::Tag>, const std::string &) –> class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>

pyrosetta.rosetta.protocols.jd3.print_job_template() → None

Prints the job template to a Tracer.

C++: protocols::jd3::print_job_template() –> void

pyrosetta.rosetta.protocols.jd3.value_attribute_type_for_option(key: pyrosetta.rosetta.utility.options.OptionTypes) → utility::tag::XMLSchemaType

Get the XMLSchemaType for an option key.

Used during SJQ’s xsd parsing

C++: protocols::jd3::value_attribute_type_for_option(const enum utility::options::OptionTypes &) –> class utility::tag::XMLSchemaType