philote::ImplicitDiscipline Class Reference

Implicit discipline class. More...

#include <implicit.h>

Inheritance diagram for philote::ImplicitDiscipline:

Public Member Functions
	ImplicitDiscipline ()
	Construct a new Implicit Discipline object.
	~ImplicitDiscipline () noexcept
	Destroy the Implicit Discipline object.
void	RegisterServices (grpc::ServerBuilder &builder)
	Registers all services with a gRPC channel.
void	DeclarePartials (const std::string &f, const std::string &x)
	Declare a (set of) partial(s) for the discipline.
virtual void	ComputeResiduals (const philote::Variables &inputs, const philote::Variables &outputs, philote::Variables &residuals)
	Computes the residual for the discipline.
virtual void	SolveResiduals (const philote::Variables &inputs, philote::Variables &outputs)
	Solves the residuals to obtain the outputs for the discipline.
virtual void	ComputeResidualGradients (const philote::Variables &inputs, const philote::Variables &outputs, Partials &partials)
	Computes the gradients of the residuals evaluation for the discipline.
Public Member Functions inherited from philote::Discipline
	Discipline ()
	Construct a new Discipline object.
	~Discipline () noexcept
	Destroy the Discipline object.
std::map< std::string, std::string > &	options_list ()
	Gets the options list.
std::vector< philote::VariableMetaData > &	var_meta ()
	Accesses the variable meta data.
const std::vector< philote::VariableMetaData > &	var_meta () const noexcept
std::vector< philote::PartialsMetaData > &	partials_meta ()
	Accesses the partials meta data.
const std::vector< philote::PartialsMetaData > &	partials_meta () const noexcept
philote::DisciplineProperties &	properties ()
	Gets the discipline properties.
philote::StreamOptions &	stream_opts ()
	Gets the stream options.
const philote::StreamOptions &	stream_opts () const noexcept
void	AddInput (const std::string &name, const std::vector< int64_t > &shape, const std::string &units)
	Declares an input.
void	AddOutput (const std::string &name, const std::vector< int64_t > &shape, const std::string &units)
	Declares an output.
void	DeclarePartials (const std::string &f, const std::string &x)
	Declare a (set of) partial(s) for the discipline.
void	AddOption (const std::string &name, const std::string &type)
	Add an option to the discipline.
virtual void	Initialize ()
	Initialize function that sets up available options.
virtual void	Configure ()
	Configure function that is called after options are set.
virtual void	SetOptions (const google::protobuf::Struct &options_struct)
	Sets up all discipline options based on a protobuf struct that the server received from the client.
virtual void	Setup ()
	Setup function that is called by the server when the client calls the setup RPC.
virtual void	SetupPartials ()
	Setup function that is called by the server when the client calls the setup RPC.
void	SetContext (grpc::ServerContext *context) const noexcept
	Set the gRPC server context for cancellation detection.
void	ClearContext () const noexcept
	Clear the gRPC server context.
bool	IsCancelled () const noexcept
	Check if the current operation has been cancelled.

Additional Inherited Members
Protected Member Functions inherited from philote::Discipline
std::vector< int64_t >	ComputePartialShape (const std::string &f, const std::string &x, bool allow_output_as_x)
	Computes the shape for a partial derivative df/dx.
Protected Attributes inherited from philote::Discipline
std::map< std::string, std::string >	options_list_
	List of options that can be set by the client.
std::vector< philote::VariableMetaData >	var_meta_
	List of variable meta data.
std::vector< philote::PartialsMetaData >	partials_meta_
	List of partials meta data.
philote::DisciplineProperties	properties_
	Discipline properties.
philote::StreamOptions	stream_opts_
	Stream options.
grpc::ServerContext *	current_context_ = nullptr
	Current gRPC server context for cancellation detection (mutable for const correctness)

Detailed Description

Implicit discipline class.

This class should be overriden by discipline developers. The basic discipline an implicit discipline servers are private member variables of this class and are registered to a gRPC connection together via the RegisterServers member function. The discipline developer should not have to interact further with these services.

Implicit disciplines define residuals R(x,y) that must be solved to find outputs. They are suitable for analyses involving systems of equations, iterative solvers, or problems where outputs cannot be computed directly.

Example: Quadratic Equation Solver

#include <implicit.h>
#include <cmath>
 
class Quadratic : public philote::ImplicitDiscipline {
private:
    void Setup() override {
        // Coefficients as inputs
        AddInput("a", {1}, "m");
        AddInput("b", {1}, "m");
        AddInput("c", {1}, "m");
 
        // Solution as output
        AddOutput("x", {1}, "m**2");
    }
 
    void SetupPartials() override {
        DeclarePartials("x", "a");
        DeclarePartials("x", "b");
        DeclarePartials("x", "c");
        DeclarePartials("x", "x");  // Jacobian w.r.t. outputs
    }
 
    void ComputeResiduals(const philote::Variables &inputs,
                         const philote::Variables &outputs,
                         philote::Variables &residuals) override {
        double a = inputs.at("a")(0);
        double b = inputs.at("b")(0);
        double c = inputs.at("c")(0);
        double x = outputs.at("x")(0);
 
        // Residual: R = ax² + bx + c = 0
        residuals.at("x")(0) = a * std::pow(x, 2) + b * x + c;
    }
 
    void SolveResiduals(const philote::Variables &inputs,
                       philote::Variables &outputs) override {
        double a = inputs.at("a")(0);
        double b = inputs.at("b")(0);
        double c = inputs.at("c")(0);
 
        // Quadratic formula: x = (-b + √(b² - 4ac)) / 2a
        outputs.at("x")(0) = (-b + std::sqrt(std::pow(b, 2) - 4*a*c)) / (2*a);
    }
 
    void ComputeResidualGradients(const philote::Variables &inputs,
                                 const philote::Variables &outputs,
                                 philote::Partials &partials) override {
        double a = inputs.at("a")(0);
        double b = inputs.at("b")(0);
        double x = outputs.at("x")(0);
 
        // ∂R/∂a, ∂R/∂b, ∂R/∂c, ∂R/∂x
        partials[{"x", "a"}](0) = std::pow(x, 2);
        partials[{"x", "b"}](0) = x;
        partials[{"x", "c"}](0) = 1.0;
        partials[{"x", "x"}](0) = 2*a*x + b;
    }
};

Example: Simple Implicit Equation

// Solve: x² - y = 0 for y
class SimpleImplicit : public philote::ImplicitDiscipline {
private:
    void Setup() override {
        AddInput("x", {1}, "m");
        AddOutput("y", {1}, "m**2");
    }
 
    void SetupPartials() override {
        DeclarePartials("y", "x");
        DeclarePartials("y", "y");
    }
 
    void ComputeResiduals(const philote::Variables &inputs,
                         const philote::Variables &outputs,
                         philote::Variables &residuals) override {
        double x = inputs.at("x")(0);
        double y = outputs.at("y")(0);
        residuals.at("y")(0) = std::pow(x, 2) - y;
    }
 
    void SolveResiduals(const philote::Variables &inputs,
                       philote::Variables &outputs) override {
        double x = inputs.at("x")(0);
        outputs.at("y")(0) = std::pow(x, 2);
    }
 
    void ComputeResidualGradients(const philote::Variables &inputs,
                                 const philote::Variables &outputs,
                                 philote::Partials &partials) override {
        double x = inputs.at("x")(0);
        partials[{"y", "x"}](0) = 2.0 * x;
        partials[{"y", "y"}](0) = -1.0;
    }
};

Example: Starting an Implicit Server

#include <grpcpp/grpcpp.h>
 
int main() {
    std::string address("localhost:50051");
    Quadratic discipline;
 
    grpc::ServerBuilder builder;
    builder.AddListeningPort(address, grpc::InsecureServerCredentials());
    discipline.RegisterServices(builder);
 
    std::unique_ptr<grpc::Server> server = builder.BuildAndStart();
    std::cout << "Server listening on " << address << std::endl;
    server->Wait();
 
    return 0;
}

Note

For implicit disciplines, you must implement both ComputeResiduals() and SolveResiduals(). ComputeResiduals evaluates R(x,y), while SolveResiduals finds y such that R(x,y) = 0.

Thread Safety: This class is NOT inherently thread-safe. Concurrent calls to ComputeResiduals, SolveResiduals, or ComputeResidualGradients from multiple RPC handlers will access the same instance without synchronization. User-defined implementations should add appropriate locks if they modify shared state or if thread safety is required.

See also

philote::ImplicitClient

philote::ExplicitDiscipline

Constructor & Destructor Documentation

ImplicitDiscipline()

philote::ImplicitDiscipline::ImplicitDiscipline

(

)

Construct a new Implicit Discipline object.

~ImplicitDiscipline()

philote::ImplicitDiscipline::~ImplicitDiscipline ( )

noexcept

Destroy the Implicit Discipline object.

Member Function Documentation

ComputeResidualGradients()

virtual void philote::ImplicitDiscipline::ComputeResidualGradients ( const philote::Variables &  inputs, const philote::Variables &  outputs, Partials &  partials  )

virtual

Computes the gradients of the residuals evaluation for the discipline.

This function should be overridden by the developer of the discipline, if applicable (not every discipline can provide partials).

Parameters

inputs

input variables for the discipline (continuous and discrete)

ComputeResiduals()

virtual void philote::ImplicitDiscipline::ComputeResiduals ( const philote::Variables &  inputs, const philote::Variables &  outputs, philote::Variables &  residuals  )

virtual

Computes the residual for the discipline.

This function should be overridden by the developer of the discipline.

Parameters

inputs

input variables for the discipline (continuous and discrete)

Returns

philote::Variables

DeclarePartials()

void philote::ImplicitDiscipline::DeclarePartials	(	const std::string &	f,
		const std::string &	x
	)

Declare a (set of) partial(s) for the discipline.

Parameters

f
x

RegisterServices()

void philote::ImplicitDiscipline::RegisterServices

(

grpc::ServerBuilder &

builder

)

Registers all services with a gRPC channel.

Parameters

builder

SolveResiduals()

virtual void philote::ImplicitDiscipline::SolveResiduals ( const philote::Variables &  inputs, philote::Variables &  outputs  )

virtual

Solves the residuals to obtain the outputs for the discipline.

This function should be overridden by the developer of the discipline.

Parameters

inputs	input variables for the discipline
outputs	output variables for the discipline (will be assigned during the function call)

---

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

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