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