philote::ExplicitClient Class Reference

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

#include <explicit.h>

Inheritance diagram for philote::ExplicitClient:

Public Member Functions
	ExplicitClient ()=default
	Constructor.
	~ExplicitClient () noexcept=default
	Destructor.
void	ConnectChannel (std::shared_ptr< grpc::ChannelInterface > channel)
	Connects the client stub to a gRPC channel.
Variables	ComputeFunction (const Variables &inputs)
	Calls the remote analysis server function evaluation via gRPC.
Partials	ComputeGradient (const Variables &inputs)
	Calls the remote analysis server gradient evaluation via gRPC.
void	SetStub (std::unique_ptr< ExplicitService::StubInterface > stub)
	Set the stub (for testing purposes)
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.

Protected Attributes
std::unique_ptr< ExplicitService::StubInterface >	stub_
	explicit service stub

Detailed Description

Client class for calling a remote explicit discipline.

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

The ExplicitClient connects to a remote ExplicitDiscipline server via gRPC and provides methods to perform function and gradient evaluations.

Example: Basic Client Usage

#include <explicit.h>
#include <grpcpp/grpcpp.h>
 
int main() {
    philote::ExplicitClient 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["x"] = philote::Variable(philote::kInput, {1});
    inputs["y"] = philote::Variable(philote::kInput, {1});
    inputs.at("x")(0) = 5.0;
    inputs.at("y")(0) = -2.0;
 
    // Compute function
    philote::Variables outputs = client.ComputeFunction(inputs);
    std::cout << "f(5, -2) = " << outputs.at("f_xy")(0) << std::endl;
 
    return 0;
}

Example: Computing Gradients

// After setting up client and inputs as above...
 
// Get partial definitions
client.GetPartialDefinitions();
 
// Compute gradients
philote::Partials gradients = client.ComputeGradient(inputs);
 
// Access gradient values
double df_dx = gradients[{"f_xy", "x"}](0);
double df_dy = gradients[{"f_xy", "y"}](0);
 
std::cout << "∂f/∂x = " << df_dx << std::endl;
std::cout << "∂f/∂y = " << df_dy << std::endl;

Example: Complete Client-Server Workflow

philote::ExplicitClient 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();
std::vector<std::string> var_names = client.GetVariableNames();
 
// Step 4: Get partial definitions (if computing gradients)
client.GetPartialDefinitions();
 
// Step 5: Prepare inputs and compute
philote::Variables inputs;
for (const auto& name : var_names) {
    auto meta = client.GetVariableMeta(name);
    if (meta.type() == philote::kInput) {
        inputs[name] = philote::Variable(meta);
        inputs[name](0) = 1.0;  // Set your values
    }
}
 
philote::Variables outputs = client.ComputeFunction(inputs);
philote::Partials partials = client.ComputeGradient(inputs);

Note

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

See also

philote::ExplicitDiscipline

philote::ImplicitClient

Constructor & Destructor Documentation

ExplicitClient()

philote::ExplicitClient::ExplicitClient ( )

default

Constructor.

~ExplicitClient()

philote::ExplicitClient::~ExplicitClient ( )

defaultnoexcept

Destructor.

Member Function Documentation

ComputeFunction()

Variables philote::ExplicitClient::ComputeFunction

(

const Variables &

inputs

)

Calls the remote analysis server function 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

inputs

ComputeGradient()

Partials philote::ExplicitClient::ComputeGradient

(

const Variables &

inputs

)

Calls the remote analysis server gradient evaluation via gRPC.

Parameters

inputs

Returns

Partials

ConnectChannel()

void philote::ExplicitClient::ConnectChannel

(

std::shared_ptr< grpc::ChannelInterface >

channel

)

Connects the client stub to a gRPC channel.

Parameters

channel

SetStub()

void philote::ExplicitClient::SetStub ( std::unique_ptr< ExplicitService::StubInterface >  stub )

inline

Set the stub (for testing purposes)

Parameters

stub

Member Data Documentation

stub_

std::unique_ptr<ExplicitService::StubInterface> philote::ExplicitClient::stub_

protected

explicit service stub

---

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

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