philote::ImplicitClient Class Reference

Client class for calling a remote implicit discipline. More...

#include <implicit.h>

Inheritance diagram for philote::ImplicitClient:

Public Member Functions
	ImplicitClient ()=default
	Constructor.
	~ImplicitClient () noexcept=default
	Destructor.
void	ConnectChannel (std::shared_ptr< grpc::ChannelInterface > channel)
	Connects the client stub to a gRPC channel.
Variables	ComputeResiduals (const Variables &vars)
	Calls the remote analysis server residuals evaluation via gRPC.
Variables	SolveResiduals (const Variables &vars)
	Calls the remote analysis server to solve via gRPC.
Partials	ComputeResidualGradients (const Variables &vars)
	Calls the remote analysis server gradient evaluation via gRPC.
void	SetStub (std::unique_ptr< ImplicitService::StubInterface > stub)
	Sets the stub for testing purposes (allows dependency injection)
Public Member Functions inherited from philote::DisciplineClient
	DisciplineClient ()
	Construct a new Discipline Client object.
void	ConnectChannel (const std::shared_ptr< grpc::ChannelInterface > &channel)
	Connect to a gRPC channel.
void	GetInfo ()
	Get the discipline info.
void	SendStreamOptions ()
	Send the stream options to the server.
void	SendOptions (const philote::DisciplineOptions &options)
	Send the discipline options to the server.
void	Setup ()
	Setup the discipline.
void	GetVariableDefinitions ()
	Get the variable definitions from the server.
void	GetPartialDefinitions ()
	Get the partial definitions from the server.
std::vector< std::string >	GetVariableNames ()
	Get the variable names.
VariableMetaData	GetVariableMeta (const std::string &name)
	Get the variable meta data.
std::vector< philote::PartialsMetaData >	GetPartialsMeta ()
	Get the partials meta data.
void	SetStub (std::unique_ptr< philote::DisciplineService::StubInterface > stub)
	Set the stub.
const StreamOptions &	GetStreamOptions () const noexcept
	Get the stream options.
void	SetStreamOptions (const StreamOptions &options)
	Set the stream options.
const DisciplineProperties &	GetProperties () const noexcept
	Get the discipline properties.
void	SetProperties (const DisciplineProperties &props)
	Set the discipline properties.
const std::vector< VariableMetaData > &	GetVariableMetaAll () const noexcept
	Get the variable metadata.
void	SetVariableMeta (const std::vector< VariableMetaData > &meta)
	Set the variable metadata.
const std::vector< PartialsMetaData > &	GetPartialsMetaConst () const noexcept
	Get the partials metadata (const version)
void	SetPartialsMetaData (const std::vector< PartialsMetaData > &meta)
	Set the partials metadata.
void	SetRPCTimeout (std::chrono::milliseconds timeout)
	Set the RPC timeout for all client operations.
std::chrono::milliseconds	GetRPCTimeout () const noexcept
	Get the current RPC timeout.

Detailed Description

Client class for calling a remote implicit discipline.

This class may be inherited from or used by MDO framework developers. However, it is a fully functional Philote MDO client.

The ImplicitClient connects to a remote ImplicitDiscipline server via gRPC and provides methods to compute residuals, solve for outputs, and evaluate residual gradients.

Example: Basic Client Usage

#include <implicit.h>
#include <grpcpp/grpcpp.h>
 
int main() {
    philote::ImplicitClient client;
 
    // Connect to server
    auto channel = grpc::CreateChannel("localhost:50051",
                                      grpc::InsecureChannelCredentials());
    client.ConnectChannel(channel);
 
    // Initialize client
    client.GetInfo();
    client.Setup();
    client.GetVariableDefinitions();
 
    // Prepare inputs
    philote::Variables inputs;
    inputs["a"] = philote::Variable(philote::kInput, {1});
    inputs["b"] = philote::Variable(philote::kInput, {1});
    inputs["c"] = philote::Variable(philote::kInput, {1});
    inputs.at("a")(0) = 1.0;
    inputs.at("b")(0) = -5.0;
    inputs.at("c")(0) = 6.0;
 
    // Solve for outputs
    philote::Variables outputs = client.SolveResiduals(inputs);
    std::cout << "Solution: x = " << outputs.at("x")(0) << std::endl;
 
    return 0;
}

Example: Computing Residuals

// After setting up client and inputs...
 
// Prepare both inputs and outputs
philote::Variables vars;
vars["a"] = philote::Variable(philote::kInput, {1});
vars["b"] = philote::Variable(philote::kInput, {1});
vars["c"] = philote::Variable(philote::kInput, {1});
vars["x"] = philote::Variable(philote::kOutput, {1});
 
vars.at("a")(0) = 1.0;
vars.at("b")(0) = -5.0;
vars.at("c")(0) = 6.0;
vars.at("x")(0) = 2.0;  // Guess
 
// Compute residual
philote::Variables residuals = client.ComputeResiduals(vars);
std::cout << "R(x=2) = " << residuals.at("x")(0) << std::endl;

Example: Computing Residual Gradients

// Get partial definitions
client.GetPartialDefinitions();
 
// Compute residual gradients
philote::Partials gradients = client.ComputeResidualGradients(vars);
 
// Access gradient values
double dR_da = gradients[{"x", "a"}](0);
double dR_db = gradients[{"x", "b"}](0);
double dR_dc = gradients[{"x", "c"}](0);
double dR_dx = gradients[{"x", "x"}](0);
 
std::cout << "∂R/∂a = " << dR_da << std::endl;
std::cout << "∂R/∂b = " << dR_db << std::endl;
std::cout << "∂R/∂c = " << dR_dc << std::endl;
std::cout << "∂R/∂x = " << dR_dx << std::endl;

Example: Complete Implicit Client Workflow

philote::ImplicitClient client;
auto channel = grpc::CreateChannel("localhost:50051",
                                  grpc::InsecureChannelCredentials());
client.ConnectChannel(channel);
 
// Step 1: Get discipline information
client.GetInfo();
 
// Step 2: Setup the discipline
client.Setup();
 
// Step 3: Get variable definitions
client.GetVariableDefinitions();
 
// Step 4: Prepare inputs
philote::Variables inputs;
inputs["a"] = philote::Variable(philote::kInput, {1});
inputs["a"](0) = 1.0;
// ... set other inputs
 
// Step 5: Solve for outputs
philote::Variables outputs = client.SolveResiduals(inputs);
 
// Step 6 (optional): Verify solution by computing residuals
philote::Variables combined = inputs;
for (const auto& [name, var] : outputs) {
    combined[name] = var;
}
philote::Variables residuals = client.ComputeResiduals(combined);
// residuals should be near zero
 
// Step 7 (optional): Compute gradients
client.GetPartialDefinitions();
philote::Partials partials = client.ComputeResidualGradients(combined);

Note

For implicit disciplines, variables passed to ComputeResiduals() must include both inputs and outputs. SolveResiduals() only requires inputs and returns the solved outputs.

Thread Safety: This class is NOT thread-safe. Each thread should create its own ImplicitClient instance. Concurrent calls to ComputeResiduals, SolveResiduals, or ComputeResidualGradients on the same instance will cause data races. The underlying gRPC stub is thread-safe, so multiple ImplicitClient instances can safely share a channel.

See also

philote::ImplicitDiscipline

philote::ExplicitClient

Constructor & Destructor Documentation

ImplicitClient()

philote::ImplicitClient::ImplicitClient ( )

default

Constructor.

~ImplicitClient()

philote::ImplicitClient::~ImplicitClient ( )

defaultnoexcept

Destructor.

Member Function Documentation

ComputeResidualGradients()

Partials philote::ImplicitClient::ComputeResidualGradients

(

const Variables &

vars

)

Calls the remote analysis server gradient evaluation via gRPC.

Parameters

vars	inputs and outputs for the discipline

Returns

Partials

ComputeResiduals()

Variables philote::ImplicitClient::ComputeResiduals

(

const Variables &

vars

)

Calls the remote analysis server residuals evaluation via gRPC.

Unlike the analysis server, this function does not need to be overridden, as it contains all logic necessary to retrieve the remote function evaluation.

Parameters

vars	inputs and outputs for the discipline

ConnectChannel()

void philote::ImplicitClient::ConnectChannel

(

std::shared_ptr< grpc::ChannelInterface >

channel

)

Connects the client stub to a gRPC channel.

Parameters

channel

SetStub()

void philote::ImplicitClient::SetStub ( std::unique_ptr< ImplicitService::StubInterface >  stub )

inline

Sets the stub for testing purposes (allows dependency injection)

Parameters

stub	The stub to inject

SolveResiduals()

Variables philote::ImplicitClient::SolveResiduals

(

const Variables &

vars

)

Calls the remote analysis server to solve via gRPC.

Unlike the analysis server, this function does not need to be overridden, as it contains all logic necessary to retrieve the remote function evaluation.

Parameters

vars	inputs and outputs for the discipline

---

The documentation for this class was generated from the following file:

• /home/runner/work/Philote-Cpp/Philote-Cpp/include/implicit.h