MAiNGO
ubpDagObj.h
Go to the documentation of this file.
1 /**********************************************************************************
2  * Copyright (c) 2019 Process Systems Engineering (AVT.SVT), RWTH Aachen University
3  *
4  * This program and the accompanying materials are made available under the
5  * terms of the Eclipse Public License 2.0 which is available at
6  * http://www.eclipse.org/legal/epl-2.0.
7  *
8  * SPDX-License-Identifier: EPL-2.0
9  *
10  **********************************************************************************/
11 
12 #pragma once
13 
14 #include "logger.h"
15 #include "settings.h"
16 
17 #include "fadiff.h"
18 #include "ffunc.hpp"
19 
20 #include <utility>
21 #include <vector>
22 
23 
24 namespace maingo {
25 
26 
27 namespace ubp {
28 
29 
37 struct DagObj {
42  mc::FFGraph DAG;
43  std::vector<mc::FFVar> vars;
44  mc::FFSubgraph subgraph;
45  std::vector<mc::FFVar> functions;
46  std::vector<mc::FFVar> resultVars;
48  std::vector<fadbad::F<double>> adPoint;
49  std::vector<fadbad::F<double>> fadbadArray;
50  std::vector<fadbad::F<double>> resultAD;
51  std::vector<fadbad::F<double>> resultADobj;
52  std::vector<fadbad::F<double>> resultADineq;
53  std::vector<fadbad::F<double>> resultADeq;
54  std::vector<fadbad::F<double>> resultADineqSquash;
55  std::vector<fadbad::F<double>> resultADineqSquashIneq;
56  std::vector<fadbad::F<double>> resultADineqEq;
58  std::vector<fadbad::F<fadbad::F<double>>> resultAD2ndOrder;
59  std::vector<fadbad::F<fadbad::F<double>>> fadbadArray2ndOrder;
60  std::vector<fadbad::F<fadbad::F<double>>> adPoint2ndOrder;
62  std::vector<double> doublePoint;
63  std::vector<double> doubleArray;
64  std::vector<double> resultDouble;
65  std::vector<double> resultDoubleObj;
66  std::vector<double> resultDoubleIneq;
67  std::vector<double> resultDoubleEq;
68  std::vector<double> resultDoubleIneqSquash;
69  std::vector<double> resultDoubleIneqSquashIneq;
70  std::vector<double> resultDoubleIneqEq;
72  std::vector<mc::FFVar> functionsObj;
73  std::vector<mc::FFVar> functionsIneq;
74  std::vector<mc::FFVar> functionsEq;
75  std::vector<mc::FFVar> functionsIneqSquash;
76  std::vector<mc::FFVar> functionsIneqSquashIneq;
77  std::vector<mc::FFVar> functionsIneqEq;
78  mc::FFSubgraph subgraphObj;
79  mc::FFSubgraph subgraphIneq;
80  mc::FFSubgraph subgraphEq;
81  mc::FFSubgraph subgraphIneqSquash;
82  mc::FFSubgraph subgraphIneqSquashIneq;
83  mc::FFSubgraph subgraphIneqEq;
85  std::shared_ptr<Settings> maingoSettings;
86  std::shared_ptr<Logger> logger;
87  bool warningFlag;
104  DagObj(mc::FFGraph& DAG, const std::vector<mc::FFVar>& DAGvars, const std::vector<mc::FFVar>& DAGfunctions,
105  const std::vector<babBase::OptimizationVariable>& variables, const unsigned nineq, const unsigned neq,
106  const unsigned nineqSquash, std::shared_ptr<std::vector<Constraint>> constraintProperties, std::shared_ptr<Settings> settingsIn, std::shared_ptr<Logger> loggerIn):
107  maingoSettings(settingsIn),
108  logger(loggerIn)
109  {
110  const unsigned nvar = variables.size();
111  const unsigned nobj = 1;
112 
113  // Copy DAG for upper bounding solver
114  for (unsigned int i = 0; i < nvar; i++) {
115  mc::FFVar Y; // Create a new DAG variable
116  this->vars.push_back(Y); // Add the new DAG variable to the vars vector
117  this->vars[i].set(&this->DAG); // Add the new DAG variable to the DAG
118  }
119  this->resultVars.resize(DAGfunctions.size());
120  DAG.eval(DAGfunctions.size(), DAGfunctions.data(), this->resultVars.data(), nvar, DAGvars.data(), this->vars.data()); // Get functions and write them to resultVars
121  this->functions.resize(1 + nineq + neq + nineqSquash);
122  // Note that the constraints in constraintProperties are in a different order than in MAiNGO.cpp!
123  // Here it is obj, ineq, squash ineq, eq
124  for (size_t i = 0; i < constraintProperties->size(); i++) {
125  unsigned index = (*constraintProperties)[i].indexNonconstant;
126  switch ((*constraintProperties)[i].type) {
127  case OBJ:
128  this->functions[i] = this->resultVars[index];
129  break;
130  case INEQ:
131  this->functions[i] = this->resultVars[index];
132  break;
133  case INEQ_SQUASH:
134  this->functions[i] = this->resultVars[index];
135  break;
136  case EQ:
137  this->functions[i] = this->resultVars[index];
138  break;
139  case INEQ_REL_ONLY:
140  case EQ_REL_ONLY:
141  default: // In upper bounding solver, we don't use relaxation only constraints
142  break;
143  }
144  }
145 
146  // Get the list of operations used in the DAG
147  // It is needed for the call of proper DAG functions
148  this->subgraph = this->DAG.subgraph(this->functions.size(), this->functions.data());
149  // Get operations of each function in the DAG
150  this->functionsObj.resize(nobj);
151  this->functionsIneq.resize(nineq);
152  this->functionsEq.resize(neq);
153  this->functionsIneqSquash.resize(nineqSquash);
154  this->functionsIneqSquashIneq.resize(nineq + nineqSquash);
155  this->functionsIneqEq.resize(nineq + neq + nineqSquash);
156  // Get each function, let's do it in one loop
157  // Think of the order obj, ineq, squash ineq, eq which is different from the original one in MAiNGO.cpp
158  for (size_t i = 0; i < constraintProperties->size(); i++) {
159  unsigned index = (*constraintProperties)[i].indexNonconstantUBP;
160  unsigned indexType = (*constraintProperties)[i].indexTypeNonconstant;
161  switch ((*constraintProperties)[i].type) {
162  case OBJ:
163  this->functionsObj[i] = this->functions[index];
164  break;
165  case INEQ:
166  this->functionsIneq[indexType] = this->functions[index];
167  this->functionsIneqSquashIneq[indexType] = this->functions[index];
168  this->functionsIneqEq[indexType] = this->functions[index];
169  break;
170  case INEQ_SQUASH:
171  this->functionsIneqSquash[indexType] = this->functions[index];
172  this->functionsIneqSquashIneq[indexType + nineq] = this->functions[index];
173  this->functionsIneqEq[indexType + nineq] = this->functions[index];
174  break;
175  case EQ:
176  this->functionsEq[indexType] = this->functions[index];
177  this->functionsIneqEq[indexType + nineq + nineqSquash] = this->functions[index]; // all inequalities first
178  break;
179  case INEQ_REL_ONLY:
180  case EQ_REL_ONLY:
181  default: // In upper bounding solver, we don't use relaxation only constraints
182  break;
183  }
184  }
185  // Get operations of each function
186  this->subgraphObj = this->DAG.subgraph(this->functionsObj.size(), this->functionsObj.data());
187  this->subgraphIneq = this->DAG.subgraph(this->functionsIneq.size(), this->functionsIneq.data());
188  this->subgraphEq = this->DAG.subgraph(this->functionsEq.size(), this->functionsEq.data());
189  this->subgraphIneqSquash = this->DAG.subgraph(this->functionsIneqSquash.size(), this->functionsIneqSquash.data());
190  this->subgraphIneqSquashIneq = this->DAG.subgraph(this->functionsIneqSquashIneq.size(), this->functionsIneqSquashIneq.data());
191  this->subgraphIneqEq = this->DAG.subgraph(this->functionsIneqEq.size(), this->functionsIneqEq.data());
192 
193  // Allocate memory for the corresponding vectors
194  this->adPoint.resize(nvar);
195  this->fadbadArray.resize(this->subgraph.l_op.size());
196  this->doublePoint.resize(nvar);
197  this->doubleArray.resize(this->subgraph.l_op.size());
198  this->resultAD.resize(this->functions.size());
199  this->resultADobj.resize(this->functionsObj.size());
200  this->resultADineq.resize(this->functionsIneq.size());
201  this->resultADeq.resize(this->functionsEq.size());
202  this->resultADineqEq.resize(this->functionsIneqEq.size());
203  this->resultADineqSquash.resize(this->functionsIneqSquash.size());
204  this->resultADineqSquashIneq.resize(this->functionsIneqSquashIneq.size());
205  this->resultDouble.resize(this->functions.size());
206  this->resultDoubleObj.resize(this->functionsObj.size());
207  this->resultDoubleIneq.resize(this->functionsIneq.size());
208  this->resultDoubleEq.resize(this->functionsEq.size());
209  this->resultDoubleIneqSquash.resize(this->functionsIneqSquash.size());
210  this->resultDoubleIneqSquashIneq.resize(this->functionsIneqSquashIneq.size());
211  this->resultDoubleIneqEq.resize(this->functionsIneqEq.size());
212  this->adPoint2ndOrder.resize(nvar);
213  this->fadbadArray2ndOrder.resize(this->subgraph.l_op.size());
214  this->resultAD2ndOrder.resize(this->functions.size());
215 
216  this->warningFlag = false;
217  }
218 };
219 
220 
221 } // end namespace ubp
222 
223 
224 } // end namespace maingo
Definition: constraint.h:40
std::vector< mc::FFVar > functions
Definition: ubpDagObj.h:45
Definition: constraint.h:41
std::vector< fadbad::F< double > > fadbadArray
Definition: ubpDagObj.h:49
std::vector< fadbad::F< double > > resultADineq
Definition: ubpDagObj.h:52
std::vector< mc::FFVar > functionsIneqSquash
Definition: ubpDagObj.h:75
std::vector< fadbad::F< double > > resultADobj
Definition: ubpDagObj.h:51
bool warningFlag
Definition: ubpDagObj.h:87
mc::FFSubgraph subgraphIneq
Definition: ubpDagObj.h:79
mc::FFSubgraph subgraphIneqSquash
Definition: ubpDagObj.h:81
std::vector< fadbad::F< double > > resultADineqEq
Definition: ubpDagObj.h:56
mc::FFSubgraph subgraphIneqEq
Definition: ubpDagObj.h:83
mc::FFSubgraph subgraph
Definition: ubpDagObj.h:44
std::vector< mc::FFVar > functionsObj
Definition: ubpDagObj.h:72
std::vector< fadbad::F< double > > resultADineqSquashIneq
Definition: ubpDagObj.h:55
Definition: constraint.h:42
std::vector< fadbad::F< double > > resultAD
Definition: ubpDagObj.h:50
std::vector< double > resultDoubleIneqSquash
Definition: ubpDagObj.h:68
std::vector< double > doublePoint
Definition: ubpDagObj.h:62
Definition: constraint.h:43
std::vector< fadbad::F< fadbad::F< double > > > resultAD2ndOrder
Definition: ubpDagObj.h:58
mc::FFSubgraph subgraphObj
Definition: ubpDagObj.h:78
Definition: constraint.h:44
std::vector< mc::FFVar > functionsIneqEq
Definition: ubpDagObj.h:77
namespace holding all essentials of MAiNGO
Definition: aleModel.h:25
std::vector< mc::FFVar > functionsIneq
Definition: ubpDagObj.h:73
std::vector< mc::FFVar > functionsEq
Definition: ubpDagObj.h:74
std::vector< fadbad::F< fadbad::F< double > > > fadbadArray2ndOrder
Definition: ubpDagObj.h:59
std::vector< fadbad::F< double > > resultADeq
Definition: ubpDagObj.h:53
Struct for storing all needed Directed acyclic Graph objects for the upper bounding solver...
Definition: ubpDagObj.h:37
std::vector< fadbad::F< double > > resultADineqSquash
Definition: ubpDagObj.h:54
Definition: constraint.h:45
std::vector< double > resultDoubleIneqEq
Definition: ubpDagObj.h:70
std::vector< mc::FFVar > functionsIneqSquashIneq
Definition: ubpDagObj.h:76
std::vector< double > resultDoubleIneq
Definition: ubpDagObj.h:66
std::vector< double > resultDoubleIneqSquashIneq
Definition: ubpDagObj.h:69
std::vector< double > resultDoubleObj
Definition: ubpDagObj.h:65
std::vector< mc::FFVar > vars
Definition: ubpDagObj.h:43
std::vector< mc::FFVar > resultVars
Definition: ubpDagObj.h:46
std::vector< double > doubleArray
Definition: ubpDagObj.h:63
mc::FFSubgraph subgraphIneqSquashIneq
Definition: ubpDagObj.h:82
std::shared_ptr< Settings > maingoSettings
Definition: ubpDagObj.h:85
std::vector< double > resultDouble
Definition: ubpDagObj.h:64
mc::FFGraph DAG
Definition: ubpDagObj.h:42
std::vector< fadbad::F< fadbad::F< double > > > adPoint2ndOrder
Definition: ubpDagObj.h:60
std::vector< double > resultDoubleEq
Definition: ubpDagObj.h:67
mc::FFSubgraph subgraphEq
Definition: ubpDagObj.h:80
DagObj(mc::FFGraph &DAG, const std::vector< mc::FFVar > &DAGvars, const std::vector< mc::FFVar > &DAGfunctions, const std::vector< babBase::OptimizationVariable > &variables, const unsigned nineq, const unsigned neq, const unsigned nineqSquash, std::shared_ptr< std::vector< Constraint >> constraintProperties, std::shared_ptr< Settings > settingsIn, std::shared_ptr< Logger > loggerIn)
Constructor.
Definition: ubpDagObj.h:104
std::shared_ptr< Logger > logger
Definition: ubpDagObj.h:86
std::vector< fadbad::F< double > > adPoint
Definition: ubpDagObj.h:48