We have a user who wants to solve an optimization problem that has intermediate discrete variables using a gradient-based method. They're running into this error. I know we could restructure the problem to not use discrete variables, but could I also treat this error as a warning given that the discrete variable doesn't change? Or is there a fundamental reason that the derivs wouldn't propagate correctly. To be clear, we're using approx_totals at the model level.
Here is a small test case exhibiting this:
import openmdao.api as om
import numpy as np
class DiscreteComp(om.ExplicitComponent):
def setup(self):
self.add_input('a', 2.)
self.add_discrete_output('b', val=0)
def compute(self, inputs, outputs, discrete_inputs, discrete_outputs):
discrete_outputs['b'] = 2 * inputs['a']
class DummyComp(om.ExplicitComponent):
def setup(self):
self.add_input('a', 2.)
self.add_discrete_input('b', 1)
self.add_output('c')
def compute(self, inputs, outputs, discrete_inputs, discrete_outputs):
b = discrete_inputs['b']
outputs['c'] = inputs['a']**2 * b
prob = om.Problem()
prob.model.add_subsystem('discrete_comp', DiscreteComp(), promotes=['*'])
prob.model.add_subsystem('dummy_comp', DummyComp(), promotes=['*'])
prob.driver = om.pyOptSparseDriver()
prob.driver.options['optimizer'] = 'SLSQP'
prob.model.add_design_var('a', lower=-10, upper=10)
prob.model.add_objective('c')
prob.model.approx_totals()
prob.setup()
# run the optimization
prob.run_driver()
which gives this output:
Traceback (most recent call last):
File "tmp.py", line 39, in <module>
prob.run_driver()
File "/home/john/anaconda3/envs/weis/lib/python3.8/site-packages/openmdao/core/problem.py", line 685, in run_driver
return self.driver.run()
File "/home/john/anaconda3/envs/weis/lib/python3.8/site-packages/openmdao/drivers/pyoptsparse_driver.py", line 480, in run
raise self._exc_info
File "/home/john/anaconda3/envs/weis/lib/python3.8/site-packages/openmdao/drivers/pyoptsparse_driver.py", line 643, in _gradfunc
sens_dict = self._compute_totals(of=self._quantities,
File "/home/john/anaconda3/envs/weis/lib/python3.8/site-packages/openmdao/core/driver.py", line 892, in _compute_totals
total_jac = _TotalJacInfo(problem, of, wrt, use_abs_names,
File "/home/john/anaconda3/envs/weis/lib/python3.8/site-packages/openmdao/core/total_jac.py", line 209, in __init__
raise RuntimeError("Total derivative %s '%s' depends upon "
RuntimeError: Total derivative with respect to '_auto_ivc.v0' depends upon discrete output variables ['discrete_comp.b'].
Given your example, there is a reason that OpenMDAO raises this error. Discrete outputs are not passed through the same data system as continuous one. Only the continuous outputs have access to the derivative system. While it is possible to have this intermediate discrete variable here, and take a finite-difference over the whole thing, you only get away with it because you really have a continuous calculation there.
If the output had been really discrete, then its not mathematically valid to take a derivative or make finite-difference approximation across the compute. This is why OpenMDAO raises the error.
There are admittedly some corner cases where you could argue that OpenMDAO should let you do this. For example if your output c was computed as:
outputs['c'] = floor(inputs['a'])
and you knew that you would limit the value of a to between 1 and 2. You know that c would always be exactly 1. Hence you could say that its valid to differentiate across this since the discrete variable never changes in value and hence the function is differentiable within these bounds.
If you wanted to use OpenMDAO to finite difference this you have two options:
Even though it's a discrete value, list it as a continuous one anyway. This works around OpenMDAO's validity check, but its totally up to you to make sure the values are really never changing with the ranges you are taking derivatives around. If you decide to implement analytic derivatives, simply don't declare one for the discrete output with respect to anything.
Move the discrete calculations into the setup phase and pass the information around as options. This forces you to absolutely respect the "never changes" paradigm since setup only happens once. It does require some redesign.
If you don't like OpenMDAO's nanny-ing you can always comment out the error :) You obviously do this at your own risk ... but thats one of the values of open source software!
My personal recommendation is option #2. This is really the best overall design, and forces you to be sure the discrete calculations never change during an opt.
Related
When running the optimization driver on a large model I recieve:
DerivativesWarning:Constraints or objectives [('max_current.current_constraint.current_constraint', inds=[0]), ('max_current.continuous_current_constraint.continuous_current_constraint', inds=[0])] cannot be impacted by the design variables of the problem.
I read the answer to a similar question posed here.
The values do change as the design variables change, and the two constraints are satisfied during the course of optimization.
I had assumed this was due to those components' ExecComp using a maximum(), as this is the only place in my model I use a maximum function, however when setting up a simple problem with a maximum() function in a similar manner I do not receive an error.
My model uses explicit components that are looped, there are connections in the bottom left of the N2 diagram and NLBGS is converging the whole model. I currently am thinking it is due to the use of only explicit components and the NLBGS instead of implicit components.
Thank you for any insight you can give in resolving this warning.
Below is a simple script using maximum() that does not report errors. (I was so sure that was it) As I create a minimum working example that gives the error in a similar way to my larger model I will upload it.
import openmdao.api as om
prob=om.Problem()
prob.driver = om.ScipyOptimizeDriver()
prob.driver.options['optimizer'] = 'SLSQP'
prob.driver.options['tol'] = 1e-6
prob.driver.options['maxiter'] = 80
prob.driver.options['disp'] = True
indeps = prob.model.add_subsystem('indeps', om.IndepVarComp())
indeps.add_output('x', val=2.0, units=None)
prob.model.promotes('indeps', outputs=['*'])
prob.model.add_subsystem('y_func_1',
om.ExecComp('y_func_1 = x'),
promotes_inputs=['x'],
promotes_outputs=['y_func_1'])
prob.model.add_subsystem('y_func_2',
om.ExecComp('y_func_2 = x**2'),
promotes_inputs=['x'],
promotes_outputs=['y_func_2'])
prob.model.add_subsystem('y_max',
om.ExecComp('y_max = maximum( y_func_1 , y_func_2 )'),
promotes_inputs=['y_func_1',
'y_func_2'],
promotes_outputs=['y_max'])
prob.model.add_subsystem('y_check',
om.ExecComp('y_check = y_max - 1.1'),
promotes_inputs=['*'],
promotes_outputs=['*'])
prob.model.add_constraint('y_check', lower=0.0)
prob.model.add_design_var('x', lower=0.0, upper=2.0)
prob.model.add_objective('x')
prob.setup()
prob.run_driver()
print(prob.get_val('x'))
There is a problem with the maximum function in this context. Technically a maximum function is not differentiable; at least not when the index of which value is max is subject to change. If the maximum value is not subject to change, then it is differentiable... but you didn't need the max function anyway.
One correct, differentiable way to handle a max when doing gradient based things is to use a KS function. OpenMDAO provides the KSComp which implements it. There are other kinds of functions (like p-norm that you could use as well).
However, even though maximum is not technically differentiable ... you can sort-of/kind-of get away with it. At least, numpy (which ExecComp uses) lets you apply complex-step differentiation to the maximum function and it seems to give a non-zero derivative. So while its not technically correct, you can maybe get rid of it. At least, its not likely to be the core of your problem.
You mention using NLBGS, and that you have components which are looped. Your test case is purely feed forward though (here is the N2 from your test case).
. That is an important difference.
The problem here is with your derivatives, not with the maximum function. Since you have a nonlinear solver, you need to do something to get the derivatives right. In the example Sellar optimization, the model uses this line: prob.model.approx_totals(), which tells OpenMDAO to finite-difference across the whole model (including the nonlinear solver). This is simple and keeps the example compact. It also works regardless of whether your components define derivatives or not. It is however, slow and suffers from numerical difficulties. So use on "real" problems at your own risk.
If you don't include that (and your above example does not, so I assume your real problem does not either) then you're basically telling OpenMDAO that you want to use analytic derivatives (yay! they are so much more awesome). That means that you need to have a Linear solver to match your nonlinear one. For most problems that you start out with, you can simply put a DirectSolver right at the top of the model and it will all work out. For more advanced models, you need a more complex linear solver structure... but thats a different question.
Give this a try:
prob.model.linear_solver = om.DirectSolver()
That should give you non-zero total derivatives regardless of whether you have coupling (loops) or not.
I have problem where I have implemented analytical derivatives for some components and I'm using complex step for the rest. There is a cyclic dependency between them so I also use a solver to converge them. It converges when I use NonlinearBlockGS. But when I use NewtonSolver in combination with a linear solver the optimization fails (Iteration limit exceeded), even with high iteration count. But I found that it converges easily and works perfectly when I use prob.model.approx_totals(). I read that approx_totals uses fd or cs to find the model gradients. So I have two questions.
In general, Will I lose the benefits from the mixed-analytical approach when I use approx_totals()? Is there a way to find the derivatives of whole model (or group) with mixed analytical strategy ? (Anyway In my case the explicitcomponents which are coupled use 'complex step`. But I'm just curious about this.)
In general (not in this scenario), will Openmdao automatically detect the mixed strategy or should I specify it some how ?
I will also be grateful, if you could point me to some examples where mixed derivatives are used. I didnt have any luck finding them myself.
Edit:Adding Example. I am not able to reproduce the issue in a sample code. Also I dont want to waste your time with my code(there more than 30 ExplicitComponents and 7 Groups). So I made a simple structure below to explain it better. In this there are 7 components A to G and only F and G doesn't have analytical derivatives and uses FD.
import openmdao.api as om
import numpy as np
class ComponentA_withDerivatives(om.ExplicitComponent):
def setup(self):
#setup inputs and outputs
def setup_partials(self):
#partial declaration
def compute(self, inputs, outputs):
def compute_partials(self, inputs, J):
#Partial definition
class ComponentB_withDerivatives(om.ExplicitComponent):
.....
class ComponentC_withDerivatives(om.ExplicitComponent):
......
class ComponentD_withDerivatives(om.ExplicitComponent):
......
class ComponentE_withDerivatives(om.ExplicitComponent):
......
class ComponentF(om.ExplicitComponent):
def setup(self):
#setup inputs and outputs
self.declare_partials(of='*', wrt='*', method='fd')
def compute(self,inputs,outputs):
# Computation
class ComponentG(om.ExplicitComponent):
def setup(self):
#setup inputs and outputs
self.declare_partials(of='*', wrt='*', method='fd')
def compute(self,inputs,outputs):
# Computation
class GroupAB(om.Group):
def setup(self):
self.add_subsystem('A', ComponentA_withDerivatives(), promotes_inputs=['x','y'], promotes_outputs=['z'])
self.add_subsystem('B', ComponentB_withDerivatives(), promotes_inputs=['x','y','w','u'], promotes_outputs=['k'])
class GroupCD(om.Group):
def setup(self):
self.add_subsystem('C', ComponentC_withDerivatives(), .....)
self.add_subsystem('D', ComponentD_withDerivatives(), ...)
class Final(om.Group):
def setup(self):
cycle1 = self.add_subsystem('cycle1', om.Group(), promotes=['*'])
cycle1.add_subsystem('GroupAB', GroupAB())
cycle1.add_subsystem('ComponentF', ComponentF())
cycle1.linear_solver = om.DirectSolver()
cycle1.nonlinear_solver = om.NewtonSolver(solve_subsystems=True)
cycle2 = self.add_subsystem('cycle2', om.Group(), promotes=['*'])
cycle2.add_subsystem('GroupCD', GroupCD())
cycle2.add_subsystem('ComponentE_withDerivatives', ComponentE_withDerivatives())
cycle2.linear_solver = om.DirectSolver()
cycle2.nonlinear_solver = om.NewtonSolver(solve_subsystems=True)
self.add_subsystem('ComponentG', ComponentG(), promotes_inputs=['a1','a2','a3'], promotes_outputs=['b1'])
prob = om.Problem()
prob.model = Final()
prob.driver = om.pyOptSparseDriver()
prob.driver.options['optimizer'] = 'SNOPT'
prob.driver.options['print_results']= True
## Design Variables
## Costraints
## Objectives
# Setup
prob.setup()
##prob.model.approx_totals(method='fd')
prob.run_model()
prob.run_driver()
Here this doesn't work. The cycle1 doesn't converge. The code works when I completely remove cycle1 or use NonlinearBlockGS instead of Newton or if I uncomment prob.model.approx_total(method='FD'). (no problem with cycle2. Work with Newton)
So if I don't use approx_totals(), I am assuming Openmdao uses a mixed strategy. Or should I manually mention it somehow ? And when I do use approx_totals() , will I lose the benefits from the analytical derivatives that I do have?
The code example you provided isn't runnable, so I'll have to make a few guesses. You call both run_model() and run_driver(). You bothered to include an optimizer in your sample code though, and you've show approx_totals to be called at the top of the model hierarchy.
So when you say it does not work, I will assume you mean that the optimizer doesn't converge.
You have understood the behavior of approx_totals correctly. When you set that at the top of your model, then OpenMDAO will FD the relevant variables from the group level. In this case, that means you will also be FD-ing across the solver itself. You say that this seems to work, but the mixed analytic approach does not.
In general, Will I lose the benefits from the mixed-analytical approach when I use approx_totals()?
Yes. You are no long using a mixed approach. You are just FD-ing across the model monolithically.
Is there a way to find the derivatives of whole model (or group) with mixed analytical strategy ?
OpenMDAO is computing total derivatives with a mixed strategy when you don't use approx_totals. The issue is that for your model, it seems not to be working.
In general (not in this scenario), will Openmdao automatically detect the mixed strategy?
It will "detect" it (it doesn't actually detect anything, but the underlying algorithms will use a mixed strategy UNLESS you tell it not to with approx_totals. Again, the issue is not that a mixed strategy is not being used, but that it is not working.
So why isn't the mixed strategy working?
I can only guess, since I can't run the code... so YMMV.
You mention that you are using complex-step for partials of your explicit components. Complex-step is a much more accurate approximation scheme than FD, but it is not without its own flaws. Not every computation is complex-safe. Some can be re-written to be complex-safe, others can not.
By "complex-safe" I mean that the computation correctly handles the complex-part to give a derivatives.
Two commonly used-complex-safe methods are np.linalg.norm and np.abs. Both will happily accept complex-numbers and give you an answer, but it is not the correct answer for when you need derivatives.
Because of this, OpenMDAO ships with a set of custom functions that are cs-safe --- custom norm and abs are provided.
What typically happens with non cs-safe methods is that the complex-part somehow gets dropped off and you get 0 partial derivatives. Wrong partials, wrong totals.
To check this, make sure you call check_partials on your components that are being complex-stepped, using a finite-difference check. You'll probably find some discrepancies.
The fixes available to you are:
Switch those components to use FD partials. Less accurate, but will probably work
Correct whatever problems in your compute are making your code non-cs-safe. Use OpenMDAO's custom functions if thats the problem, or possibly you need to be more careful about how you allocate and use numpy arrays in your compute (if you're allocating your own arrays, then you need to be careful to make sure they are complex too!).
I am struggling with an error regarding a singular entry in the group caused by an implicit component, and I don't manage to figure out how to solve it.
We created a louvered fin heat exchanger model, based on the effectiveness-NTU method. It uses an ImplicitComponent to solve the system in such a way that the "guessed" outlet temperatures (used to calculate fluid properties) are equal to the actual outlet temperatures calculated based on the actual heat transfer. This components seems to run fine and the N2 diagram of this base heat exchanger can be found here.
Among others, two inputs are the mass flow rates of the cold and hot side (see indeps in original N2). However, the validation data uses cold side flow velocity and hot side volumetric flow rate instead of mass flow rates. Although not direct group inputs, these properties are calculated within the heat exchanger group. Manually changing the mass flow rates until the flow velocity and volumetric flow rate meet that of the validation data works fine. But I figured I could add an additional implicit component around the heat exchanger group to do that work for me. The resulting N2 diagram can be found here. However, this implicit component results in an error:
Traceback (most recent call last):
File "...\openmdao\solvers\linear\direct.py", line 275, in _linearize
self._lu = scipy.sparse.linalg.splu(matrix)
File "...\scipy\sparse\linalg\dsolve\linsolve.py", line 326, in splu
ilu=False, options=_options)
RuntimeError: Factor is exactly singular
During handling of the above exception, another exception occurred:
Traceback (most recent call last):
File "louveredfin3.py", line 91, in <module>
p.run_model()
File "...\openmdao\core\problem.py", line 527, in run_model
self.model.run_solve_nonlinear()
File "...\openmdao\core\system.py", line 3734, in run_solve_nonlinear
self._solve_nonlinear()
File "...\openmdao\core\group.py", line 1886, in _solve_nonlinear
self._nonlinear_solver.solve()
File "...\openmdao\solvers\solver.py", line 597, in solve
raise err
File "...\openmdao\solvers\solver.py", line 593, in solve
self._solve()
File "...\openmdao\solvers\solver.py", line 384, in _solve
self._single_iteration()
File "...\openmdao\solvers\nonlinear\newton.py", line 230, in _single_iteration
self._linearize()
File "...\openmdao\solvers\nonlinear\newton.py", line 161, in _linearize
self.linear_solver._linearize()
File "...\openmdao\solvers\linear\direct.py", line 278, in _linearize
raise RuntimeError(format_singular_error(system, matrix))
RuntimeError: Singular entry found in Group (<model>) for column associated with state/residual 'ConvertInputs.m_dot_hot' index 0.
What does this error mean in practical terms? Is the solver not able to reduce the residual by changing the output (m_dot_hot and m_dot_cold in this case)? However, if this is the case I am failing to understand why, as manually changing the mass flow rates does result in a change in 'V_cold' and 'flowrate_hot'.
As an alternative I tried to use only one solver for all the components on the same level (N2 here), but this results in the same error. Also removing the original temperature implicit component (i.e. only having one implicit component, which changes the mass flow rate) did not solve the problem.
In case it helps, the implicit component looks like this (using single values instead of array with length n for the time being):
class ConvertInputs(om.ImplicitComponent):
def initialize(self):
self.options.declare('n', default=1, desc='length of the array')
def setup(self):
self.add_input('flowrate_hot_required', val=1.33, desc='required flowrate', units='L/s')
self.add_input('flowrate_hot', val=1.33, desc='actual flowrate', units='L/s')
self.add_input('V_cold_required', val=8., desc='required air velocity', units='m/s')
self.add_input('V_cold', val=8., desc='actual air velocity', units='m/s')
self.add_output('m_dot_hot', val=1.296, desc='hot side mass flow rate', units='kg/s')
self.add_output('m_dot_cold', val=1.655, desc='cold side mass flow rate', units='kg/s')
self.declare_partials('*', '*', method='fd')
def apply_nonlinear(self, inputs, outputs, residuals):
residuals['m_dot_hot'] = inputs['flowrate_hot'] - inputs['flowrate_hot_required']
residuals['m_dot_cold'] = inputs['V_cold'] - inputs['V_cold_required']
and the related lines in FluidProperties like this:
outputs['flowrate_hot'] = inputs['m_dot_hot'] / (outputs['rho_hot_in']*1e-3)
outputs['V_cold'] = inputs['m_dot_cold'] / (outputs['rho_cold_in'] * inputs['A_flow_cold'])
The solvers used are the NewtonSolver (solve_subsystems=True) and DirectSolver. Additionally I double checked that the derivatives are declared everywhere (e.g. self.declare_partials(' * ', ' * ', method='fd') in all components for now), but no success so far.
EDIT – based on the answer from Justin:
Thank you for the answer and the tips! I implemented the BalanceComp replacing the top-level implicit component, but unfortunately it did not make a difference. Setting maxiter=0 for the top solver still throws the error, but the lower solver seems to solve without problem:
+
+ ========
+ original
+ ========
+ NL: Newton 0 ; 14.3235199 1
+ NL: Newton 1 ; 0.0668341831 0.00466604463
+ NL: Newton 2 ; 0.000273898972 1.91223229e-05
+ NL: Newton 3 ; 1.17390481e-06 8.1956448e-08
+ NL: Newton 4 ; 5.0212449e-09 3.50559425e-10
+ NL: Newton 5 ; 2.14662005e-11 1.49866797e-12
+ NL: Newton Converged
NL: Newton 0 ; 0.252556049 1
Traceback (most recent call last):
[…]
RuntimeError: Factor is exactly singular
To get a feeling for the magnitudes: using only the HX subsystem and manually changing the indeps “m_dot_hot” and “m_dot_cold” with stepsize 1e-6:
Diff. flowrate_hot = -1.0271477852707989e-06
Diff. V_cold = -4.6808071525461514e-06
I did not realise yet that you can actually add bounds to the implicit component, that is very useful and I added them for both implicit components. Unfortunately, no improvement for the error from that neither. Setting the partials to complex step for the top-level implicit component and the FluidProperties did also not improve the situation. Should this be done for all components or only the involved ones here?.
However, I noticed the following when printing the “m_dot_* ” outputs in the implicit component, and the “m_dot_* ” inputs in the FluidProperties component in apply_nonlinear() and compute() respectively. It shows that after the heat exchanger subsystem has solved, the top-level implicit component “m_dot_* ” outputs change with the stepsize of 1e-6 as I would expect it to do for gradient calculation. However, the inputs in FluidProperties are not printed anymore at all after this and the singular error occurs soon after. Hence, to me it seems that the lower level FluidProperties compute method is not called anymore. Since no analytical derivatives are given or values set (i.e. only FD is used of all output w.r.t. all inputs), it appears to me that the FluidProperties component is never executed with the “m_dot_* ” stepsize and the gradient is not (successfully or correctly) calculated. Nevertheless, the N2 chart shows that the inputs/outputs of top-level to subsystem are correctly connected. Can this be a pointer to something specifically going wrong?
Your error (RuntimeError: Singular entry found in Group (<model>) for column associated with state/residual 'ConvertInputs.m_dot_hot' index 0.) indicates that, all of the partial derivatives in that column are 0.
Practically, that means that as far as OpenMDAO is concerned changes to 'ConvertInputs.m_dot_hot' don't affect any of the residuals in your model.
One thing you can try is to use the BalanceComp from OpenMDAO's standard library. This component is deigned specifically for what you were trying to accomplish, but has derivatives already defined. This is a small chance that this will fix your problem, but likely not.
What I recommend is the following:
Set the max_iter option on your top level newton solver to 0 (the sub-solves will still run). Then you can run your model and manually change your guess for m_dot_hot to see if you really can manually converge it in the model with the coupling built in. Perhaps there is a bug in the way you did the connections in this model that is causing the problem. You said that you could manually converge the original model, this step will make sure that you coupled model also has a solution
I noticed that you did not define any bounds on your design variables. Perhaps the solver is driving m_dot_hot to 0 or a negative number in its iterations. I suggest setting both lower and upper bounds to something reasonable as follows
self.add_output('m_dot_hot', val=1.296, desc='hot side mass flow rate', units='kg/s', lower=1e-4, upper=10)
self.add_output('m_dot_cold', val=1.655, desc='cold side mass flow rate', units='kg/s', lower=1e-4, upper=10)
For OpenMDAO V3.0 and up, the default for the newton solver is to use the bounds enforcing line search which will respect these limits when trying to converge
Consider switching to the cs method for your partial derivatives. Its possible that the FD values are just not very good (at least with the default step sizes and you're getting 0s that are numerical instead of physical.
I have a group with coupled disciplines which is nested in a model where all other components are uncoupled. I have assigned a nonlinear Newton and linear direct solvers to the coupled group.
When I try to run the model with default "RunOnce" solver everything is OK, but as soon as I try to run optimization I get following error raised from linear_block_gs.py:
File "...\openmdao\core\group.py", line 1790, in _apply_linear scope_out, scope_in)
File "...\openmdao\core\explicitcomponent.py", line 339, in _apply_linear
self.compute_jacvec_product(*args)
File "...\Thermal_Cycle.py", line 51, in compute_jacvec_product
d_inputs['T'] = slope * deff_dT / alp_sc
File "...\openmdao\vectors\vector.py", line 363, in setitem
raise KeyError(msg.format(name)) KeyError: 'Variable name "T" not found.'
Below is the N2 diagram of the model. Variable "T" which is mentioned in the error comes from implicit "temp" component and is fed back to "sc" component (file Thermal_Cycle.py in the error msg) as input.
N2 diagram
The error disappears when I assign DirectSolver on top of the whole model. My impression was that "RunOnce" would work as long as groups with implicit components have appropriate solvers applied to them as suggested here and is done in my case. Why does it not work when trying to compute total derivatives of the model, i.e. why compute_jacvec_product cannot find coupled variable "T"?
The reason I want to use "RunOnce" solver is that optimization with DirecSolver on top becomes very long as my variable vector "T" increases. I suspect it should be much faster with linear "RunOnce"?
I think this example of the compute_jacvec_product method might be helpful.
The problem is that, depending on the solver configuration or the structure of the model, OpenMDAO may only need some of the partials that you provide in this method. For example, your matrix-free component might have two inputs, but only one is connected, so OpenMDAO does not need the derivative with respect to the unconnected input, and in fact, does not allocate space for it in the d_inputs or d_outputs vectors.
So, to fix the problem, you just need to put an if statement before assigning the value, just like in the example.
Based on the N2, I think that I agree with your strategy of putting the direct solver down around the coupling only. That should work fine, however it looks like you're implementing a linear operator in your component, based on:
File "...\Thermal_Cycle.py", line 51, in compute_jacvec_product d_inputs['T'] = slope * deff_dT / alp_sc
You shouldn't use direct solver with matrix-free partials. The direct solver computes an inverse, which requires the full assembly of the matrix. The only reason it works at all is that OM has some fall-back functionality to manually assemble the jacobian by passing columns of the identity matrix through the compute_jacvec_product method.
This fallback mechanism is there to make things work, but its very slow (you end up calling compute_jacvec_product A LOT).
The error you're getting, and why it works when you put the direct solver higher up in the model, is probably due to a lack of necessary if conditions in your compute_jacvec_product implementation.
See the docs on explicit component for some examples, but the key insight is to realize that not every single variable will be present when doing a jacvec product (it depends on what kind of solve is being done --- i.e. one for Newton vs one for total derivatives of the whole model).
So those if-checks are needed to check if variables are relevant. This is done, because for expensive codes (i.e. CFD) some of these operations are quite expensive and you don't want to do them unless you need to.
Are your components so big that you can't use the compute_partials function? Have you tried specifying the sparsity in your jacobian? Usually the matrix-free partial derivative methods are not needed until you start working with really big PDE solvers with 1e6 or more implicit outputs variables.
Without seeing some code, its hard to comment with more detail, but in summary:
You shouldn't use compute_jacvec_product in combination with direct solver. If you really need matrix-free partials, then you need to switch to iterative linear solvers liket PetscKrylov.
If you can post the code for the the component in Thermal_Cycle.py that has the compute_jacvec_product I could give a more detailed recommendation on how to handle the partial derivatives in that case.
I am currently trying to do some optimization for locations on a map using OpenMDAO 1.7.2. The (preexisting) modules that do the calculations only support integer coordinates (resolution of one meter).
For now I am optimizing using an IndepVarComp for each direction each containing a float vector. These values are then rounded before using them, but this is quite inefficient because the solver mainly tries variations smaller below one.
When I attempt to initialize an IndepVarComp with an integer vector the first iteration works fine (uses inital values), but in the second iteration fails, because the data in IndepVarComp is set to an empty ndarray.
Looking through the OpenMDAO source code I found out that this is because
indep_var_comp._init_unknowns_dict['x']['size'] == 0
which happens in Component's _add_variable() method whenever the data type is not differentiable.
Here is an example problem which illustrates how defining an integer IndepVarComp fails:
from openmdao.api import Component, Group, IndepVarComp, Problem, ScipyOptimizer
INITIAL_X = 1
class ResultCalculator(Component):
def __init__(self):
super(ResultCalculator, self).__init__()
self.add_param('x', INITIAL_X)
self.add_output('y', 0.)
def solve_nonlinear(self, params, unknowns, resids):
unknowns['y'] = (params['x'] - 3) ** 2 - 4
problem = Problem()
problem.root = Group()
problem.root.add('indep_var_comp', IndepVarComp('x', INITIAL_X))
problem.root.add('calculator', ResultCalculator())
problem.root.connect('indep_var_comp.x', 'calculator.x')
problem.driver = ScipyOptimizer()
problem.driver.options['optimizer'] = 'COBYLA'
problem.driver.add_desvar('indep_var_comp.x')
problem.driver.add_objective('calculator.y')
problem.setup()
problem.run()
Which fails with
ValueError: setting an array element with a sequence.
Note that everythings works out fine if I set INITIAL_X = 0..
How am I supposed to optimize for integers?
if you want to use integer variables, you need to pick a different kind of optimizer. You won't be able to force COBYLA to respect the integrality. Additionally, if you do have some kind of integer rounding causing discontinuities in your analyses then you really can't be using COBYLA (or any other continuous optimizer) at all. They all make a fundamental assumption about smoothness of the function which you would be violating.
It sounds like you should possibly consider using a particle swarm or genetic algorithm for your problem. Alternatively, you could focus on making the analyses smooth and differentiable and scale some of your inputs to get more reasonable resolution. You can also loosen the convergence tolerance of the optimizer to have it stop iterating once it gets below physical significance in your design variables.