DotProductComp

DotProductComp#

DotProductComp performs a dot product between two compatible inputs. It may be vectorized to provide the result at one or more points simultaneously.

\[ c_i = \bar{a}_i \cdot \bar{b}_i \]

DotProductComp Options#

The default vec_size is 1, providing the dot product of \(a\) and \(b\) at a single point. The lengths of \(a\) and \(b\) are provided by option length.

Other options for DotProductComp allow the user to rename the input variables \(a\) and \(b\) and the output \(c\), as well as specifying their units.

Option	Default	Acceptable Values	Acceptable Types	Description
a_name	a	N/A	['str']	The variable name for input vector a.
a_units	N/A	N/A	['str']	The units for vector a.
always_opt	False	[True, False]	['bool']	If True, force nonlinear operations on this component to be included in the optimization loop even if this component is not relevant to the design variables and responses.
b_name	b	N/A	['str']	The variable name for input vector b.
b_units	N/A	N/A	['str']	The units for vector b.
c_name	c	N/A	['str']	The variable name for output vector c.
c_units	N/A	N/A	['str']	The units for vector c.
derivs_method	N/A	['jax', 'cs', 'fd', None]	N/A	The method to use for computing derivatives
distributed	False	[True, False]	['bool']	If True, set all variables in this component as distributed across multiple processes
length	3	N/A	['int']	The length of vectors a and b
run_root_only	False	[True, False]	['bool']	If True, call compute, compute_partials, linearize, apply_linear, apply_nonlinear, and compute_jacvec_product only on rank 0 and broadcast the results to the other ranks.
use_jit	True	[True, False]	['bool']	If True, attempt to use jit on compute_primal, assuming jax or some other AD package is active.
vec_size	1	N/A	['int']	The number of points at which the dot product is computed

DotProductComp Constructor#

The call signature for the DotProductComp constructor is:

DotProductComp.__init__(**kwargs)[source]

Initialize the Dot Product component.

DotProductComp Usage#

There are often situations when numerous products need to be computed, essentially in parallel. You can reduce the number of components required by having one DotProductComp perform multiple operations. This is also convenient when the different operations have common inputs.

The add_product method is used to create additional products after instantiation.

DotProductComp.add_product(c_name, a_name='a', b_name='b', c_units=None, a_units=None, b_units=None, vec_size=1, length=3)[source]

Add a new output product to the dot product component.

Parameters:

c_namestr
The name of the vector product output.

a_namestr
The name of the first vector input.

b_namestr
The name of the second input.

c_unitsstr or None
The units of the output.

a_unitsstr or None
The units of input a.

b_unitsstr or None
The units of input b.

vec_sizeint
The number of points at which the dot vector product should be computed simultaneously. The shape of the output is (vec_size,).

lengthint
The length of the vectors a and b. Their shapes are (vec_size, length).

DotProductComp Example#

In the following example DotProductComp is used to compute instantaneous power as the dot product of force and velocity at 100 points simultaneously. Note the use of a_name, b_name, and c_name to assign names to the inputs and outputs. Units are assigned using a_units, b_units, and c_units. Note that no internal checks are performed to ensure that c_units are consistent with a_units and b_units.

import numpy as np
import openmdao.api as om

n = 24

p = om.Problem()

dp_comp = om.DotProductComp(vec_size=n, length=3, a_name='F', b_name='v', c_name='P',
                            a_units='N', b_units='m/s', c_units='W')

p.model.add_subsystem(name='dot_prod_comp', subsys=dp_comp,
                     promotes_inputs=[('F', 'force'), ('v', 'vel')])

p.setup()

p.set_val('force', np.random.rand(n, 3))
p.set_val('vel', np.random.rand(n, 3))

p.run_model()

# Verify the results against numpy.dot in a for loop.
expected = []
for i in range(n):
    a_i = p.get_val('force')[i, :]
    b_i = p.get_val('vel')[i, :]
    expected.append(np.dot(a_i, b_i))

    actual_i = p.get_val('dot_prod_comp.P')[i]
    rel_error = np.abs(expected[i] - actual_i)/actual_i
    assert rel_error < 1e-9, f"Relative error: {rel_error}"

print(p.get_val('dot_prod_comp.P', units='kW'))

[0.00068562 0.00072057 0.00117205 0.0015567  0.00104921 0.00051744
00018226 0.00164949 0.00079751 0.00052353 0.00032403 0.00106047
00061695 0.00022829 0.00041126 0.00113463 0.00022403 0.001156
00115794 0.00099083 0.00092807 0.00054739 0.00024405 0.00050694]

DotProductComp Example with Multiple Products#

When defining multiple products:

An input name in one call to add_product may not be an output name in another call, and vice-versa.
The units and shape of variables used across multiple products must be the same in each one.

n = 24

p = om.Problem()

dp_comp = om.DotProductComp(vec_size=n, length=3,
                            a_name='F', b_name='d', c_name='W',
                            a_units='N', b_units='m', c_units='J')

dp_comp.add_product(vec_size=n, length=3,
                    a_name='F', b_name='v', c_name='P',
                    a_units='N', b_units='m/s', c_units='W')

p.model.add_subsystem(name='dot_prod_comp', subsys=dp_comp,
                      promotes_inputs=[('F', 'force'), ('d', 'disp'), ('v', 'vel')])

p.setup()

p.set_val('force', np.random.rand(n, 3))
p.set_val('disp', np.random.rand(n, 3))
p.set_val('vel', np.random.rand(n, 3))

p.run_model()

# Verify the results against numpy.dot in a for loop.
expected_P = []
expected_W = []
for i in range(n):
    a_i = p.get_val('force')[i, :]

    b_i = p.get_val('disp')[i, :]
    expected_W.append(np.dot(a_i, b_i))

    actual_i = p.get_val('dot_prod_comp.W')[i]
    rel_error = np.abs(actual_i - expected_W[i])/actual_i
    assert rel_error < 1e-9, f"Relative error: {rel_error}"

    b_i = p.get_val('vel')[i, :]
    expected_P.append(np.dot(a_i, b_i))

    actual_i = p.get_val('dot_prod_comp.P')[i]
    rel_error = np.abs(expected_P[i] - actual_i)/actual_i
    assert rel_error < 1e-9, f"Relative error: {rel_error}"

print(p.get_val('dot_prod_comp.W', units='kJ'))

[0.00118242 0.00014144 0.00067452 0.00136012 0.00062161 0.00079028
00028692 0.000489   0.00014357 0.0010525  0.00016647 0.00080595
00066198 0.00046875 0.00065834 0.00152385 0.00059788 0.0008289
00097372 0.0002767  0.00083098 0.00065034 0.00119515 0.00111019]

print(p.get_val('dot_prod_comp.P', units='kW'))

[0.0011266  0.00042485 0.00039464 0.00172758 0.00065245 0.00052071
00033327 0.00054481 0.00100186 0.0014187  0.00062516 0.00074532
00079174 0.00061654 0.00092923 0.00055399 0.00097203 0.00103596
00128484 0.00053552 0.00140314 0.00061729 0.00062225 0.00135333]