Scippy

GCG

Branch-and-Price & Column Generation for Everyone

cons_decomp.h
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program */
4 /* GCG --- Generic Column Generation */
5 /* a Dantzig-Wolfe decomposition based extension */
6 /* of the branch-cut-and-price framework */
7 /* SCIP --- Solving Constraint Integer Programs */
8 /* */
9 /* Copyright (C) 2010-2021 Operations Research, RWTH Aachen University */
10 /* Zuse Institute Berlin (ZIB) */
11 /* */
12 /* This program is free software; you can redistribute it and/or */
13 /* modify it under the terms of the GNU Lesser General Public License */
14 /* as published by the Free Software Foundation; either version 3 */
15 /* of the License, or (at your option) any later version. */
16 /* */
17 /* This program is distributed in the hope that it will be useful, */
18 /* but WITHOUT ANY WARRANTY; without even the implied warranty of */
19 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
20 /* GNU Lesser General Public License for more details. */
21 /* */
22 /* You should have received a copy of the GNU Lesser General Public License */
23 /* along with this program; if not, write to the Free Software */
24 /* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.*/
25 /* */
26 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
27 
28 /**@file cons_decomp.h
29 * @ingroup DECOMP
30  * @brief constraint handler for structure detection
31  * @author Martin Bergner
32  * @author Michael Bastubbe
33  * @author Hanna Franzen
34  *
35  * This constraint handler manages the structure detection process. It will run all registered structure detectors in an
36  * iterative refinement scheme. Afterwards some post-processing detectors might be called.
37  */
38 
39 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
40 
41 #ifndef GCG_CONS_DECOMP_H__
42 #define GCG_CONS_DECOMP_H__
43 
44 #include "scip/scip.h"
45 #include "type_detector.h"
46 #include "type_varclassifier.h"
47 #include "type_consclassifier.h"
48 #include "type_scoretype.h"
49 
50 
51 #ifdef __cplusplus
52 extern "C" {
53 #endif
54 
55 
56 /** forward declarations */
59 
60 struct Detprobdata_Wrapper;
61 
62 /**
63  * @brief returns the data of the provided consclassifier
64  * @returns data of the provided consclassifier
65  */
66 extern
68  DEC_CONSCLASSIFIER* classifier /**< Classifier data structure */
69  );
70 
71 /**
72  * @brief returns the name of the provided classifier
73  * @returns name of the given classifier
74  */
75 extern
76 const char* DECconsClassifierGetName(
77  DEC_CONSCLASSIFIER* classifier /**< classifier data structure */
78  );
79 
80 /**
81  * @brief returns the data of the provided varclassifier
82  * @returns data of the provided varclassifier
83  */
84 extern
86  DEC_VARCLASSIFIER* classifier /**< Classifier data structure */
87  );
88 
89 /**
90  * @brief returns the name of the provided classifier
91  * @returns name of the given classifier
92  */
93 extern
94 const char* DECvarClassifierGetName(
95  DEC_VARCLASSIFIER* classifier /**< classifier data structure */
96  );
97 
98 /** @brief Gets the character of the detector
99  * @returns detector character */
100 extern
101 char DECdetectorGetChar(
102  DEC_DETECTOR* detector /**< pointer to detector */
103  );
104 
105 /**
106  * @brief returns the data of the provided detector
107  * @returns data of the provided detector
108  */
109 extern
111  DEC_DETECTOR* detector /**< Detector data structure */
112  );
113 
114 /**
115  * @brief returns the name of the provided detector
116  * @returns name of the given detector
117  */
118 extern
119 const char* DECdetectorGetName(
120  DEC_DETECTOR* detector /**< detector data structure */
121  );
122 
123 /** @brief interface method to detect the structure including presolving
124  * @returns SCIP return code */
125 extern
126 SCIP_RETCODE DECdetectStructure(
127  SCIP* scip, /**< SCIP data structure */
128  SCIP_RESULT* result /**< Result pointer to indicate whether some structure was found */
129  );
130 
131 /**
132  * @brief searches for the consclassifier with the given name and returns it or NULL if classifier is not found
133  * @returns consclassifier pointer or NULL if consclassifier with given name is not found
134  */
135 extern
137  SCIP* scip, /**< SCIP data structure */
138  const char* name /**< the name of the searched consclassifier */
139  );
140 
141 /**
142  * @brief searches for the varclassifier with the given name and returns it or NULL if classifier is not found
143  * @returns varclassifier pointer or NULL if varclassifier with given name is not found
144  */
145 extern
147  SCIP* scip, /**< SCIP data structure */
148  const char* name /**< the name of the searched varclassifier */
149  );
150 
151 
152 /**
153  * @brief searches for the detector with the given name and returns it or NULL if detector is not found
154  * @returns detector pointer or NULL if detector with given name is not found
155  */
156 extern
158  SCIP* scip, /**< SCIP data structure */
159  const char* name /**< the name of the searched detector */
160  );
161 
162 /** @brief Gets the best known decomposition
163  *
164  * @note caller has to free returned DEC_DECOMP
165  * @returns the decomposition if available and NULL otherwise */
166 extern
168  SCIP* scip, /**< SCIP data structure */
169  SCIP_Bool printwarnings /**< should warnings pre printed */
170  );
171 
172 /** @brief Gets the currently considered best partialdec
173  *
174  * If there is a partialdec marked to be returned (e.g. by /DECwriteAllDecomps), it is written.
175  * Else, the currently "best" decomp is returned.
176  *
177  * @returns partialdec to write if one can be found, or partialdecwrapper->partialdec = NULL otherwise */
178 extern
179 SCIP_RETCODE DECgetPartialdecToWrite(
180  SCIP* scip, /**< SCIP data structure */
181  SCIP_Bool transformed, /**< is the problem transformed yet */
182  PARTIALDECOMP_WRAPPER* partialdecwrapper /**< partialdec wrapper to output */
183  );
184 
185 /**
186  * @brief returns the remaining time of scip that the decomposition may use
187  * @returns remaining time that the decompositon may use
188  */
189 extern
190 SCIP_Real DECgetRemainingTime(
191  SCIP* scip /**< SCIP data structure */
192  );
193 
194 /**
195  * @brief includes one constraint classifier
196  * @returns scip return code
197  */
198 extern
199 SCIP_RETCODE DECincludeConsClassifier(
200  SCIP* scip, /**< scip data structure */
201  const char* name, /**< name of the classifier */
202  const char* description, /**< describing main idea of this classifier */
203  int priority, /**< priority of the classifier */
204  SCIP_Bool enabled, /**< whether the classifier should be enabled by default */
205  DEC_CLASSIFIERDATA* classifierdata, /**< classifierdata the associated classifier data (or NULL) */
206  DEC_DECL_FREECONSCLASSIFIER((*freeClassifier)), /**< destructor of classifier (or NULL) */
207  DEC_DECL_CONSCLASSIFY((*classify)) /**< the method that will classify constraints or variables (must not be NULL) */
208  );
209 
210 /**
211  * @brief includes one detector
212  * @returns scip return code
213  */
214 extern
215 SCIP_RETCODE DECincludeDetector(
216  SCIP* scip, /**< scip data structure */
217  const char* name, /**< name of the detector */
218  const char decchar, /**< char that is used in detector chain history for this detector */
219  const char* description, /**< describing main idea of this detector */
220  int freqCallRound, /**< frequency the detector gets called in detection loop, i.e. it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r - minCallRound) mod freqCallRound == 0 */
221  int maxCallRound, /**< last detection round the detector gets called */
222  int minCallRound, /**< first round the detector gets called (offset in detection loop) */
223  int freqCallRoundOriginal, /**< frequency the detector gets called in detection loop while detecting of the original problem */
224  int maxCallRoundOriginal, /**< last round the detector gets called while detecting of the original problem */
225  int minCallRoundOriginal, /**< first round the detector gets called (offset in detection loop) while detecting of the original problem */
226  int priority, /**< priority of the detector */
227  SCIP_Bool enabled, /**< whether the detector should be enabled by default */
228  SCIP_Bool enabledFinishing, /**< whether the finishing should be enabled */
229  SCIP_Bool enabledPostprocessing, /**< whether the postprocessing should be enabled */
230  SCIP_Bool skip, /**< whether the detector should be skipped if others found structure */
231  SCIP_Bool usefulRecall, /**< is it useful to call this detector on a descendant of the propagated partialdec */
232  DEC_DETECTORDATA *detectordata, /**< the associated detector data (or NULL) */
233  DEC_DECL_FREEDETECTOR((*freeDetector)), /**< destructor of detector (or NULL) */
234  DEC_DECL_INITDETECTOR((*initDetector)), /**< initialization method of detector (or NULL) */
235  DEC_DECL_EXITDETECTOR((*exitDetector)), /**< deinitialization method of detector (or NULL) */
236  DEC_DECL_PROPAGATEPARTIALDEC((*propagatePartialdecDetector)), /**< method to refine a partial decomposition inside detection loop (or NULL) */
237  DEC_DECL_FINISHPARTIALDEC((*finishPartialdecDetector)), /**< method to complete a partial decomposition when called in detection loop (or NULL) */
238  DEC_DECL_POSTPROCESSPARTIALDEC((*postprocessPartialdecDetector)), /**< method to postprocess a complete decomposition, called after detection loop (or NULL) */
239  DEC_DECL_SETPARAMAGGRESSIVE((*setParamAggressiveDetector)), /**< method that is called if the detection emphasis setting aggressive is chosen */
240  DEC_DECL_SETPARAMDEFAULT((*setParamDefaultDetector)), /**< method that is called if the detection emphasis setting default is chosen */
241  DEC_DECL_SETPARAMFAST((*setParamFastDetector)) /**< method that is called if the detection emphasis setting fast is chosen */
242  );
243 
244 /**
245  * @brief includes one variable classifier
246  * @returns scip return code
247  */
248 extern
249 SCIP_RETCODE DECincludeVarClassifier(
250  SCIP* scip, /**< scip data structure */
251  const char* name, /**< name of the classifier */
252  const char* description, /**< description of the classifier */
253  int priority, /**< priority how early classifier is invoked */
254  SCIP_Bool enabled, /**< whether the classifier should be enabled by default */
255  DEC_CLASSIFIERDATA* classifierdata,/**< classifierdata the associated classifier data (or NULL) */
256  DEC_DECL_FREEVARCLASSIFIER((*freeClassifier)), /**< destructor of classifier (or NULL) */
257  DEC_DECL_VARCLASSIFY((*classify)) /**< method that will classify variables (must not be NULL) */
258  );
259 
260 /** @brief writes out a list of all detectors */
261 extern
263  SCIP* scip /**< SCIP data structure */
264  );
265 
266 /** @brief write out all known decompositions
267  * @returns SCIP return code */
268 extern
269 SCIP_RETCODE DECwriteAllDecomps(
270  SCIP* scip, /**< SCIP data structure */
271  char* directory, /**< directory for decompositions */
272  char* extension, /**< the file extension for the export */
273  SCIP_Bool original, /**< should decomps for original problem be written */
274  SCIP_Bool presolved /**< should decomps for preoslved problem be written */
275  );
276 
277 /** @brief writes all selected decompositions
278  * @returns scip return code
279 */
280 extern
281 SCIP_RETCODE DECwriteSelectedDecomps(
282  SCIP* scip, /**< SCIP data structure */
283  char* directory, /**< directory for decompositions */
284  char* extension /**< extension for decompositions */
285  );
286 
287 /** @brief adds a candidate for block number and counts how often a candidate is added */
288 extern
290  SCIP* scip, /**< SCIP data structure */
291  SCIP_Bool origprob, /**< which DETPROBDATA that should be modified */
292  int candidate /**< proposed amount of blocks */
293 );
294 
295 /**
296  * @brief adds the given decomposition structure
297  * @returns scip return code
298  */
299 extern
300 SCIP_RETCODE GCGconshdlrDecompAddDecomp(
301  SCIP* scip, /**< SCIP data structure */
302  DEC_DECOMP* decomp, /**< DEC_DECOMP data structure */
303  SCIP_Bool select /**< select the decomposition as candidate */
304  );
305 
306 /**
307  * @brief creates and adds a basic partialdecomp (all cons/vars are assigned to master)
308  *
309  * @returns id of partialdec
310  */
311 extern
313  SCIP* scip, /**< SCIP data structure */
314  SCIP_Bool presolved /**< create basic partialdecomp for presolved if true, otherwise for original */
315  );
316 
317 /**
318  * @brief creates a pure matrix partialdecomp (i.e. all cons/vars to one single block)
319  *
320  * matrix is added to list of all partialdecs
321  * @returns id of matrix partialdec
322  */
323 extern
325  SCIP* scip, /**< SCIP data structure */
326  SCIP_Bool presolved /**< create matrix for presolved if true, otherwise for original */
327  );
328 
329 /**
330  * @brief adds a decomp that exists before the detection is called
331  * @note this method should only be called if there is no partialdec for this decomposition
332  * @returns scip return code
333  */
334 extern
336  SCIP* scip, /**< SCIP data structure */
337  DEC_DECOMP* decomp /**< decomposition data structure */
338  );
339 
340 /**
341  * @brief adds given time to total score calculation time
342  * @return scip return code
343  */
344 extern
345 SCIP_RETCODE GCGconshdlrDecompAddScoreTime(
346  SCIP* scip, /**< SCIP data structure */
347  SCIP_Real time /**< time to add */
348  );
349 
350 /** @brief adds a candidate for block size given by the user */
351 extern
353  SCIP* scip, /**< SCIP data structure */
354  int candidate /**< candidate for block size */
355  );
356 
357 /**
358  * @brief checks if two pricing problems are identical based on information from detection
359  * @returns scip return code
360  */
361 extern
363  SCIP* scip, /**< scip scip data structure */
364  int partialdecid, /**< partialdecid id of the partial decompostion for which the pricing problems are checked for identity */
365  int probnr1, /**< index of first block to check */
366  int probnr2, /**< index of second block to check */
367  SCIP_Bool* identical /**< bool pointer to score the result of the check*/
368  );
369 
370 /**
371  * @brief calculates the benders score of a partialdec
372  *
373  * in detail:
374  * bendersscore = max ( 0., 1 - ( 1 - blockareascore + (1 - borderareascore - bendersareascore ) ) ) with
375  * blockareascore = blockarea / totalarea
376  * borderareascore = borderarea / totalarea
377  * bendersareascore = bendersarea /totalarea with
378  * bendersarea = A + B - PENALTY with
379  * A = nmasterconshittingonlyblockvars * nblockvarshittngNOmasterconss
380  * B = nlinkingvarshittingonlyblockconss * nblockconsshittingonlyblockvars
381  * PENALTY = \f$\sum_{b=1}^(\text{nblocks}) \sum_{\text{blockvars }bv\text{ of block }b\text{ hitting a master constraint}} \sum_{\text{all blocks }b2 != b} \text{nblockcons}(b2)\f$
382  *
383  * @note experimental feature
384  * @return scip return code
385  */
386 extern
388  SCIP* scip, /**< SCIP data structure */
389  int partialdecid, /**< id of partialdec the score is calculated for */
390  SCIP_Real* score /**< score pointer to store the calculated score */
391  );
392 
393 /**
394  * @brief calculates the border area score of a partialdec
395  *
396  * 1 - fraction of border area to complete area
397  * @return scip return code
398  */
399 extern
401  SCIP* scip, /**< SCIP data structure */
402  int partialdecid, /**< id of partialdec the score is calculated for */
403  SCIP_Real* score /**< score pointer to store the calculated score */
404  );
405 
406 /**
407  * @brief calculates and adds block size candidates using constraint classifications and variable classifications
408  */
409 extern
411  SCIP* scip, /**< SCIP data structure */
412  SCIP_Bool transformed /**< whether to find the candidates for the transformed problem, otherwise the original */
413 );
414 
415 /**
416  * @brief calculates the classic score of a partialdec
417  *
418  * @return scip return code
419  */
420 extern
422  SCIP* scip, /**< SCIP data structure */
423  int partialdecid, /**< id of partialdec the score is calculated for */
424  SCIP_Real* score /**< score pointer to store the calculated score */
425  );
426 
427 /**
428  * @brief calculates the maxforeseeingwhiteagg score of a partialdec
429  *
430  * maximum foreseeing white area score with respect to aggregatable blocks
431  * (i.e. maximize fraction of white area score considering problem with copied linking variables
432  * and corresponding master constraints;
433  * white area is nonblock and nonborder area, stairlinking variables count as linking)
434  * @return scip return code
435  */
436 extern
438  SCIP* scip, /**< SCIP data structure */
439  int partialdecid, /**< id of partialdec the score is calculated for */
440  SCIP_Real* score /**< score pointer to store the calculated score */
441  );
442 
443 /**
444  * @brief calculates the maximum foreseeing white area score of a partialdec
445  *
446  * maximum foreseeing white area score
447  * (i.e. maximize fraction of white area score considering problem with copied linking variables and
448  * corresponding master constraints; white area is nonblock and nonborder area, stairlinking variables count as linking)
449  * @return scip return code
450  */
451 extern
453  SCIP* scip, /**< SCIP data structure */
454  int partialdecid, /**< id of partialdec the score is calculated for */
455  SCIP_Real* score /**< score pointer to store the calculated score */
456  );
457 
458 /**
459  * @brief calculates the maximum white area score of a partialdec
460  *
461  * score corresponding to the max white measure according to aggregated blocks
462  * @return scip return code
463  */
464 extern
466  SCIP* scip, /**< SCIP data structure */
467  int partialdecid, /**< id of partialdec the score is calculated for */
468  SCIP_Real* score /**< score pointer to store the calculated score */
469  );
470 
471 /**
472  * @brief calculates the setpartitioning maximum foreseeing white area score of a partialdec
473  *
474  * setpartitioning maximum foreseeing white area score
475  * (i.e. convex combination of maximum foreseeing white area score and
476  * a boolean score rewarding a master containing only setppc and cardinality constraints)
477  * @return scip return code
478  */
479 extern
481  SCIP* scip, /**< SCIP data structure */
482  int partialdecid, /**< id of partialdec the score is calculated for */
483  SCIP_Real* score /**< score pointer to store the calculated score */
484  );
485 
486 /**
487  * @brief calculates the setpartfwhiteagg score of a partialdec
488  *
489  * setpartitioning maximum foreseeing white area score with respect to aggregateable
490  * (i.e. convex combination of maximum foreseeing white area score and a boolean score
491  * rewarding a master containing only setppc and cardinality constraints)
492  * @return scip return code
493  */
494 extern
496  SCIP* scip, /**< SCIP data structure */
497  int partialdecid, /**< id of partialdec the score is calculated for */
498  SCIP_Real* score /**< score pointer to store the calculated score */
499  );
500 
501 /**
502  * @brief calculates the strong decomposition score of a partialdec
503  * @return scip return code
504  */
505 extern
507  SCIP* scip, /**< SCIP data structure */
508  int partialdecid, /**< id of partialdec the score is calculated for */
509  SCIP_Real* score /**< score pointer to store the calculated score */
510  );
511 
512 /**
513  * @brief check whether partialdecs are consistent
514  *
515  * Checks whether
516  * 1) the predecessors of all finished partialdecs in both detprobdatas can be found
517  * 2) selected list is synchron with selected information in partialdecs
518  * 3) selected exists is synchronized with selected list
519  *
520  * @returns true if partialdec information is consistent */
521  extern
523  SCIP* scip /**< SCIP data structure **/
524  );
525 
526 /**
527  * @brief run classification of vars and cons
528  *
529  * @returns scip return code
530  */
531 extern
532 SCIP_RETCODE GCGconshdlrDecompClassify(
533  SCIP* scip, /**< SCIP data structure */
534  SCIP_Bool transformed /**< whether to classify the transformed problem, otherwise the original */
535 );
536 
537 /**
538  * @brief for two identical pricing problems a corresponding varmap is created
539  * @param scip scip data structure
540  * @param hashorig2pricingvar mapping from orig to pricingvar
541  * @param partialdecid id of the partial decompostion for which the pricing problems are checked for identity
542  * @param probnr1 index of first block
543  * @param probnr2 index of second block
544  * @param scip1 subscip of first block
545  * @param scip2 subscip of second block
546  * @param varmap mapping from orig to pricingvar
547  * @returns scip return code
548  */
549 extern
551  SCIP* scip,
552  SCIP_HASHMAP** hashorig2pricingvar,
553  int partialdecid,
554  int probnr1,
555  int probnr2,
556  SCIP* scip1,
557  SCIP* scip2,
558  SCIP_HASHMAP* varmap
559  );
560 
561 /**
562  * @brief decreases the counter for created decompositions and returns it
563  * @returns number of created decompositions that was recently decreased
564  */
565 extern
567  SCIP* scip /**< SCIP data structure **/
568  );
569 
570 /** @brief deregisters partialdecs in the conshdlr
571  *
572  * Use this function for deletion of ALL the partialdecs.
573  */
574 extern
576  SCIP* scip, /**< SCIP data structure */
577  SCIP_Bool original /**< iff TRUE the status with respect to the original problem is returned */
578  );
579 
580 /** @brief Frees Detprobdata of the original and transformed/presolved problem.
581  *
582  * @note Does not free Detprobdata of the original problem if GCGconshdlrDecompFreeOrigOnExit is set to false.
583  */
585  SCIP* scip /**< SCIP data structure */
586  );
587 
588 /**
589  * @brief sets freeing of detection data of original problem during exit to true
590  *
591  * used before calling SCIPfreeTransform(),
592  * set to true to revoke presolving
593  * (e.g. if unpresolved decomposition is used, and transformation is not successful)
594  */
595 extern
597  SCIP* scip, /**< SCIP data structure */
598  SCIP_Bool free /**< whether to free orig data */
599  );
600 
601 /**
602  * @brief returns block number user candidate with given index
603  * @param scip SCIP data structure
604  * @param index index of block number user candidate that should be returned
605  * @returns block number user candidate with given index
606  */
607 extern
609  SCIP* scip,
610  int index
611  );
612 
613 /**
614  * @brief returns the total detection time
615  * @param scip SCIP data structure
616  * @returns total detection time
617  */
618 extern
620  SCIP* scip
621  );
622 
623 /** @brief returns an array containing all decompositions
624  *
625  * Updates the decomp decomposition structure by converting all finished partialdecs into decompositions and replacing the
626  * old list in the conshdlr.
627  *
628  * @returns decomposition array
629  * */
630 extern
632  SCIP* scip /**< SCIP data structure */
633  );
634 
635 /** @brief Gets an array of all detectors
636  *
637  * @returns array of detectors */
638 extern
640  SCIP* scip /**< SCIP data structure */
641  );
642 
643 /** @brief Gets a list of ids of the current partialdecs that are finished
644  *
645  * @note recommendation: when in doubt plan for as many ids as partialdecs
646  * @see GCGconshdlrDecompGetNPartialdecs
647  * @returns scip return code */
648 extern
650  SCIP* scip, /**< SCIP data structure */
651  int** idlist, /**< id list to output to */
652  int* listlength /**< length of output list */
653  );
654 
655 /** @brief Gets a list of ids of the current partialdecs
656  *
657  * @note recommendation: when in doubt plan for as many ids as partialdecs
658  * @see GCGconshdlrDecompGetNPartialdecs
659  * @returns scip return code */
660 extern
662  SCIP* scip, /**< SCIP data structure */
663  int** idlist, /**< id list to output to */
664  int* listlength /**< length of output list */
665 );
666 
667 /**
668  * @brief returns the number of block candidates given by the user
669  * @returns number of block candidates given by the user
670  */
671 extern
673  SCIP* scip /**< SCIP data structure */
674  );
675 
676 /** @brief gets block number of partialdec with given id
677  * @returns block number of partialdec
678  */
679 extern
681  SCIP* scip, /**< SCIP data structure */
682  int id /**< id of partialdec */
683  );
684 
685 /** @brief gets the number of decompositions (= amount of finished partialdecs)
686  *
687  * @returns number of decompositions */
688 extern
690  SCIP* scip /**< SCIP data structure */
691  );
692 
693 /** @brief Gets the number of all detectors
694  * @returns number of detectors */
695 extern
697  SCIP* scip /**< SCIP data structure */
698  );
699 
700 /** @brief Gets the next partialdec id managed by cons_decomp
701  * @returns the next partialdec id managed by cons_decomp */
702 extern
704  SCIP* scip /**< SCIP data structure **/
705  );
706 
707 /** @brief gets number of active constraints during the detection of the decomp with given id
708  *
709  * Gets the number of constraints that were active while detecting the decomposition originating from the partialdec with the
710  * given id, this method is used to decide if the problem has changed since detection, if so the aggregation information
711  * needs to be recalculated
712  *
713  * @note if the partialdec is not complete the function returns -1
714  *
715  * @returns number of constraints that were active while detecting the decomposition
716  */
717 extern
719  SCIP* scip, /**< SCIP data structure */
720  int id /**< id of the partialdec the information is asked for */
721  );
722 
723 /** @brief gets number of linking variables of partialdec with given id
724  * @returns number of linking variables of partialdec
725  */
726 extern
728  SCIP* scip, /**< SCIP data structure */
729  int id /**< id of partialdec */
730  );
731 
732 /** @brief gets number of master constraints of partialdec with given id
733  * @returns number of master constraints of partialdec
734  */
735 extern
737  SCIP* scip, /**< SCIP data structure */
738  int id /**< id of partialdec */
739  );
740 
741 /** @brief gets number of master variables of partialdec with given id
742  * @returns number of master variables of partialdec
743  */
744 extern
746  SCIP* scip, /**< SCIP data structure */
747  int id /**< id of partialdec */
748  );
749 
750 /** @brief gets number of open constraints of partialdec with given id
751  * @returns total number of open constraints of partialdec
752  */
753 extern
755  SCIP* scip, /**< SCIP data structure */
756  int id /**< id of partialdec */
757  );
758 
759 /** @brief gets number of open variables of partialdec with given id
760  * @returns total number of open variables of partialdec
761  */
762 extern
764  SCIP* scip, /**< SCIP data structure */
765  int id /**< id of partialdec */
766  );
767 
768 /** @brief Gets the number of finished partialdecs available for the original problem
769  * @returns number of partialdecs */
770 extern
772  SCIP* scip /**< SCIP data structure */
773  );
774 
775 /** @brief Gets the number of finished partialdecs available for the transformed problem
776  * @returns number of partialdecs */
777 extern
779  SCIP* scip /**< SCIP data structure */
780  );
781 
782 /** @brief Gets the number of open partialdecs available for the original problem
783  * @returns number of partialdecs */
784 extern
786  SCIP* scip /**< SCIP data structure */
787 );
788 
789 /** @brief Gets the number of open partialdecs available for the transformed problem
790  * @returns number of partialdecs */
791 extern
793  SCIP* scip /**< SCIP data structure */
794 );
795 
796 /** @brief Gets the number of all partialdecs
797  * @returns number of Partialdecs */
798 extern
800  SCIP* scip /**< SCIP data structure */
801  );
802 
803 /** @brief Gets the number of partialdecs available for the original problem
804  * @returns number of partialdecs */
805 extern
807  SCIP* scip /**< SCIP data structure */
808  );
809 
810 /** @brief Gets the number of partialdecs available for the transformed problem
811  * @returns number of partialdecs */
812 extern
814  SCIP* scip /**< SCIP data structure */
815  );
816 
817 /** @brief gets number of stairlinking variables of partialdec with given id
818  * @returns total number of stairlinking variables of partialdec
819  */
820 extern
822  SCIP* scip, /**< SCIP data structure */
823  int id /**< id of partialdec */
824  );
825 
826 /** @brief Gets wrapped PARTIALDECOMP with given id
827  *
828  * @returns SCIP return code */
829 extern
831  SCIP* scip, /**< SCIP data structure */
832  int partialdecid, /**< id of PARTIALDECOMP */
833  PARTIALDECOMP_WRAPPER* pwr /**< wrapper for output PARTIALDECOMP */
834  );
835 
836 /** @brief gets score of partialdec with given id
837  * @returns score in respect to current score type
838  */
839 extern
841  SCIP* scip, /**< SCIP data structure */
842  int id /**< id of partialdec */
843  );
844 
845 /** @brief gets total score computation time
846  * @returns total score computation time
847  */
848 extern
850  SCIP* scip /**< SCIP data structure */
851 );
852 
853 /**
854  * @brief Gets the currently selected scoretype
855  * @returns the currently selected scoretype
856  */
857 extern
859  SCIP* scip /**< SCIP data structure */
860  );
861 
862 /** @brief Gets a list of ids of all currently selected partialdecs
863  * @returns list of partialdecs */
864 extern
866  SCIP* scip, /**< SCIP data structure */
867  int** idlist, /**< id list to output to */
868  int* listlength /**< length of output list */
869  );
870 
871 /**
872  * @brief counts up the counter for created decompositions and returns it
873  * @returns number of created decompositions that was recently increased
874  */
875  extern
877  SCIP* scip /**< SCIP data structure **/
878  );
879 
880 /** @brief gets whether partialdec with given id is presolved
881  * @returns true iff partialdec is presolved
882  */
883 extern
885  SCIP* scip, /**< SCIP data structure */
886  int id /**< id of partialdec */
887  );
888 
889 /** @brief gets whether partialdec with given id is selected
890  * @returns true iff partialdec is selected
891  */
892 extern
894  SCIP* scip, /**< SCIP data structure */
895  int id /**< id of partialdec */
896  );
897 
898 /**
899  * @brief returns whether or not a detprobdata structure for the original problem exists
900  * @returns true iff an original detprobdata exists
901  */
902 extern
904  SCIP* scip /**< SCIP data structure */
905  );
906 
907 /**
908  * @brief returns whether or not an original decompositions exists in the data structures
909  * @returns true iff an origial decomposition exist
910  */
911 extern
913  SCIP* scip /**< SCIP data structure */
914  );
915 
916 /**
917  * @brief returns whether or not a detprobdata structure for the presolved problem exists
918  * @returns true iff a presolved detprobdata exists
919  */
920 extern
922  SCIP* scip /**< SCIP data structure */
923  );
924 
925 /** @brief display statistics about detectors
926  * @returns SCIP return code */
927 extern
929  SCIP* scip, /**< SCIP data structure */
930  FILE* file /**< output file or NULL for standard output */
931  );
932 
933 /**
934  * @brief selects/unselects a partialdecomp
935  *
936  * @returns SCIP return code
937  */
938 extern
940  SCIP* scip, /**< SCIP data structure */
941  int partialdecid, /**< id of partialdecomp */
942  SCIP_Bool select /**< select/unselect */
943  );
944 
945 /** @brief sets detector parameters values
946  *
947  * sets detector parameters values to
948  *
949  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all detector parameters
950  * - SCIP_PARAMSETTING_FAST such that the time spend for detection is decreased
951  * - SCIP_PARAMSETTING_AGGRESSIVE such that the detectors produce more decompositions
952  * - SCIP_PARAMSETTING_OFF which turns off all detection
953  *
954  * @returns SCIP return code
955  */
956 extern
957 SCIP_RETCODE GCGconshdlrDecompSetDetection(
958  SCIP* scip, /**< SCIP data structure */
959  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
960  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
961  );
962 
963 /**
964  * @brief Sets the currently used scoretype
965  */
966 extern
968  SCIP* scip, /**< SCIP data structure */
969  SCORETYPE sctype /**< new scoretype */
970  );
971 
972 /**
973  * @brief translates n best unpresolved partialdec to a complete presolved one
974  * @param scip SCIP data structure
975  * @param n number of partialdecs that should be translated
976  * @param completeGreedily whether or not to complete the decomposition greedily
977  * @returns SCIP return code
978  */
979 extern
981  SCIP* scip,
982  int n,
983  SCIP_Bool completeGreedily
984 );
985 
986 /**
987  * @brief translates unpresolved partialdec to a complete presolved one
988  * @param scip SCIP data structure
989  * @returns SCIP return code
990  */
991  extern
993  SCIP* scip
994  );
995 
996 /** Gets whether the detection already took place
997  * @returns true if detection took place, false otherwise */
998 extern
999 SCIP_Bool GCGdetectionTookPlace(
1000  SCIP* scip, /**< SCIP data structure */
1001  SCIP_Bool original /**< iff TRUE the status with respect to the original problem is returned */
1002  );
1003 
1004 /**
1005  * method to eliminate duplicate constraint names and name unnamed constraints
1006  * @return SCIP return code
1007  */
1008 extern
1010  SCIP* scip /**< SCIP data structure */
1011  );
1012 
1013 /**
1014  * @brief creates the constraint handler for decomp and includes it in SCIP
1015  * @returns scip return code
1016  */
1017 extern
1018 SCIP_RETCODE SCIPincludeConshdlrDecomp(
1019  SCIP* scip /**< SCIP data structure */
1020  );
1021 
1022 #ifdef __cplusplus
1023 }
1024 #endif
1025 
1026 #endif
SCIP_RETCODE GCGconshdlrDecompCreateVarmapForPartialdecId(SCIP *scip, SCIP_HASHMAP **hashorig2pricingvar, int partialdecid, int probnr1, int probnr2, SCIP *scip1, SCIP *scip2, SCIP_HASHMAP *varmap)
for two identical pricing problems a corresponding varmap is created
SCIP_RETCODE GCGconshdlrDecompSelectPartialdec(SCIP *scip, int partialdecid, SCIP_Bool select)
selects/unselects a partialdecomp
DEC_CLASSIFIERDATA * DECconsClassifierGetData(DEC_CONSCLASSIFIER *classifier)
returns the data of the provided consclassifier
#define DEC_DECL_CONSCLASSIFY(x)
SCIP_RETCODE GCGconshdlrDecompAddPreexistingDecomp(SCIP *scip, DEC_DECOMP *decomp)
adds a decomp that exists before the detection is called
type definitions for detectors in GCG projects
unsigned int GCGconshdlrDecompGetNOpenPartialdecsOrig(SCIP *scip)
Gets the number of open partialdecs available for the original problem.
SCIP_RETCODE GCGconshdlrDecompGetPartialdecsList(SCIP *scip, int **idlist, int *listlength)
Gets a list of ids of the current partialdecs.
int GCGconshdlrDecompGetNMasterConssByPartialdecId(SCIP *scip, int id)
gets number of master constraints of partialdec with given id
void GCGconshdlrDecompFreeOrigOnExit(SCIP *scip, SCIP_Bool free)
sets freeing of detection data of original problem during exit to true
const char * DECconsClassifierGetName(DEC_CONSCLASSIFIER *classifier)
returns the name of the provided classifier
SCIP_RETCODE GCGconshdlrDecompCalcSetPartForseeingWhiteScore(SCIP *scip, int partialdecid, SCIP_Real *score)
calculates the setpartitioning maximum foreseeing white area score of a partialdec
unsigned int GCGconshdlrDecompGetNOpenPartialdecsTransformed(SCIP *scip)
Gets the number of open partialdecs available for the transformed problem.
int GCGconshdlrDecompGetNStairlinkingVarsByPartialdecId(SCIP *scip, int id)
gets number of stairlinking variables of partialdec with given id
DEC_DETECTORDATA * DECdetectorGetData(DEC_DETECTOR *detector)
returns the data of the provided detector
SCIP_Real GCGconshdlrDecompGetCompleteDetectionTime(SCIP *scip)
returns the total detection time
char DECdetectorGetChar(DEC_DETECTOR *detector)
Gets the character of the detector.
SCIP_RETCODE GCGconshdlrDecompTranslateOrigPartialdecs(SCIP *scip)
translates unpresolved partialdec to a complete presolved one
SCIP_RETCODE SCIPconshdlrDecompRepairConsNames(SCIP *scip)
DEC_DECL_FREEDETECTOR(freeNeighborhoodmaster)
#define DEC_DECL_FREECONSCLASSIFIER(x)
type definition for score type
#define DEC_DECL_EXITDETECTOR(x)
Definition: type_detector.h:80
SCIP_RETCODE SCIPincludeConshdlrDecomp(SCIP *scip)
creates the constraint handler for decomp and includes it in SCIP
DEC_CLASSIFIERDATA * DECvarClassifierGetData(DEC_VARCLASSIFIER *classifier)
returns the data of the provided varclassifier
SCIP_RETCODE DECincludeDetector(SCIP *scip, const char *name, const char decchar, const char *description, int freqCallRound, int maxCallRound, int minCallRound, int freqCallRoundOriginal, int maxCallRoundOriginal, int minCallRoundOriginal, int priority, SCIP_Bool enabled, SCIP_Bool enabledFinishing, SCIP_Bool enabledPostprocessing, SCIP_Bool skip, SCIP_Bool usefulRecall, DEC_DETECTORDATA *detectordata, DEC_DECL_FREEDETECTOR((*freeDetector)), DEC_DECL_INITDETECTOR((*initDetector)), DEC_DECL_EXITDETECTOR((*exitDetector)), DEC_DECL_PROPAGATEPARTIALDEC((*propagatePartialdecDetector)), DEC_DECL_FINISHPARTIALDEC((*finishPartialdecDetector)), DEC_DECL_POSTPROCESSPARTIALDEC((*postprocessPartialdecDetector)), DEC_DECL_SETPARAMAGGRESSIVE((*setParamAggressiveDetector)), DEC_DECL_SETPARAMDEFAULT((*setParamDefaultDetector)), DEC_DECL_SETPARAMFAST((*setParamFastDetector)))
includes one detector
#define DEC_DECL_INITDETECTOR(x)
Definition: type_detector.h:70
unsigned int GCGconshdlrDecompGetNPartialdecsTransformed(SCIP *scip)
Gets the number of partialdecs available for the transformed problem.
int GCGconshdlrDecompGetNDecomps(SCIP *scip)
gets the number of decompositions (= amount of finished partialdecs)
SCIP_RETCODE GCGconshdlrDecompAddDecomp(SCIP *scip, DEC_DECOMP *decomp, SCIP_Bool select)
adds the given decomposition structure
unsigned int GCGconshdlrDecompGetNPartialdecs(SCIP *scip)
Gets the number of all partialdecs.
SCIP_Bool GCGconshdlrDecompIsPresolvedByPartialdecId(SCIP *scip, int id)
gets whether partialdec with given id is presolved
#define DEC_DECL_SETPARAMAGGRESSIVE(x)
DEC_DECL_PROPAGATEPARTIALDEC(detectorPropagatePartialdecIsomorph)
SCIP_RETCODE GCGconshdlrDecompCalcStrongDecompositionScore(SCIP *scip, int partialdecid, SCIP_Real *score)
calculates the strong decomposition score of a partialdec
SCIP_Bool GCGconshdlrDecompIsSelectedByPartialdecId(SCIP *scip, int id)
gets whether partialdec with given id is selected
DEC_VARCLASSIFIER * DECfindVarClassifier(SCIP *scip, const char *name)
searches for the varclassifier with the given name and returns it or NULL if classifier is not found
SCIP_RETCODE DECdetectStructure(SCIP *scip, SCIP_RESULT *result)
interface method to detect the structure including presolving
int GCGconshdlrDecompGetNOpenConssByPartialdecId(SCIP *scip, int id)
gets number of open constraints of partialdec with given id
DEC_DETECTOR ** GCGconshdlrDecompGetDetectors(SCIP *scip)
Gets an array of all detectors.
SCIP_Bool GCGconshdlrDecompOrigPartialdecExists(SCIP *scip)
returns whether or not an original decompositions exists in the data structures
DEC_CONSCLASSIFIER * DECfindConsClassifier(SCIP *scip, const char *name)
searches for the consclassifier with the given name and returns it or NULL if classifier is not found
int GCGconshdlrDecompGetNBlockNumberCandidates(SCIP *scip)
returns the number of block candidates given by the user
SCIP_RETCODE GCGconshdlrDecompClassify(SCIP *scip, SCIP_Bool transformed)
run classification of vars and cons
SCIP_RETCODE GCGconshdlrDecompCalcClassicScore(SCIP *scip, int partialdecid, SCIP_Real *score)
calculates the classic score of a partialdec
int GCGconshdlrDecompGetNOpenVarsByPartialdecId(SCIP *scip, int id)
gets number of open variables of partialdec with given id
int GCGconshdlrDecompAddMatrixPartialdec(SCIP *scip, SCIP_Bool presolved)
creates a pure matrix partialdecomp (i.e. all cons/vars to one single block)
SCIP_RETCODE DECincludeConsClassifier(SCIP *scip, const char *name, const char *description, int priority, SCIP_Bool enabled, DEC_CLASSIFIERDATA *classifierdata, DEC_DECL_FREECONSCLASSIFIER((*freeClassifier)), DEC_DECL_CONSCLASSIFY((*classify)))
includes one constraint classifier
SCIP_RETCODE DECgetPartialdecToWrite(SCIP *scip, SCIP_Bool transformed, PARTIALDECOMP_WRAPPER *partialdecwrapper)
Gets the currently considered best partialdec.
int GCGconshdlrDecompGetBlockNumberCandidate(SCIP *scip, int index)
returns block number user candidate with given index
#define DEC_DECL_VARCLASSIFY(x)
int GCGconshdlrDecompGetNLinkingVarsByPartialdecId(SCIP *scip, int id)
gets number of linking variables of partialdec with given id
SCIP_Bool GCGdetectionTookPlace(SCIP *scip, SCIP_Bool original)
SCIP_RETCODE DECwriteAllDecomps(SCIP *scip, char *directory, char *extension, SCIP_Bool original, SCIP_Bool presolved)
write out all known decompositions
type definitions for constraints classifier in GCG projects
int GCGconshdlrDecompGetNDetectors(SCIP *scip)
Gets the number of all detectors.
void GCGconshdlrDecompFreeDetprobdata(SCIP *scip)
Frees Detprobdata of the original and transformed/presolved problem.
SCIP_Real DECgetRemainingTime(SCIP *scip)
returns the remaining time of scip that the decomposition may use
#define DEC_DECL_SETPARAMFAST(x)
void GCGconshdlrDecompAddCandidatesNBlocks(SCIP *scip, SCIP_Bool origprob, int candidate)
adds a candidate for block number and counts how often a candidate is added
SCIP_RETCODE GCGconshdlrDecompCalcMaxWhiteScore(SCIP *scip, int partialdecid, SCIP_Real *score)
calculates the maximum white area score of a partialdec
#define DEC_DECL_POSTPROCESSPARTIALDEC(x)
DEC_DECOMP * DECgetBestDecomp(SCIP *scip, SCIP_Bool printwarnings)
Gets the best known decomposition.
SCIP_RETCODE DECwriteSelectedDecomps(SCIP *scip, char *directory, char *extension)
writes all selected decompositions
void GCGconshdlrDecompSetScoretype(SCIP *scip, SCORETYPE sctype)
Sets the currently used scoretype.
void GCGconshdlrDecompAddUserCandidatesNBlocks(SCIP *scip, int candidate)
adds a candidate for block size given by the user
#define DEC_DECL_FREEVARCLASSIFIER(x)
SCIP_RETCODE GCGconshdlrDecompCalcMaxForeseeingWhiteAggScore(SCIP *scip, int partialdecid, SCIP_Real *score)
calculates the maxforeseeingwhiteagg score of a partialdec
SCIP_RETCODE GCGconshdlrDecompPrintDetectorStatistics(SCIP *scip, FILE *file)
display statistics about detectors
int GCGconshdlrDecompIncreaseNCallsCreateDecomp(SCIP *scip)
counts up the counter for created decompositions and returns it
SCIP_RETCODE GCGconshdlrDecompCalcSetPartForWhiteAggScore(SCIP *scip, int partialdecid, SCIP_Real *score)
calculates the setpartfwhiteagg score of a partialdec
#define DEC_DECL_SETPARAMDEFAULT(x)
void DECprintListOfDetectors(SCIP *scip)
writes out a list of all detectors
unsigned int GCGconshdlrDecompGetNPartialdecsOrig(SCIP *scip)
Gets the number of partialdecs available for the original problem.
void GCGconshdlrDecompDeregisterPartialdecs(SCIP *scip, SCIP_Bool original)
deregisters partialdecs in the conshdlr
unsigned int GCGconshdlrDecompGetNFinishedPartialdecsOrig(SCIP *scip)
Gets the number of finished partialdecs available for the original problem.
int GCGconshdlrDecompAddBasicPartialdec(SCIP *scip, SCIP_Bool presolved)
creates and adds a basic partialdecomp (all cons/vars are assigned to master)
int GCGconshdlrDecompGetNBlocksByPartialdecId(SCIP *scip, int id)
gets block number of partialdec with given id
unsigned int GCGconshdlrDecompGetNFinishedPartialdecsTransformed(SCIP *scip)
Gets the number of finished partialdecs available for the transformed problem.
SCIP_RETCODE GCGconshdlrDecompGetPartialdecFromID(SCIP *scip, int partialdecid, PARTIALDECOMP_WRAPPER *pwr)
Gets wrapped PARTIALDECOMP with given id.
SCIP_RETCODE GCGconshdlrDecompTranslateNBestOrigPartialdecs(SCIP *scip, int n, SCIP_Bool completeGreedily)
translates n best unpresolved partialdec to a complete presolved one
SCIP_RETCODE DECincludeVarClassifier(SCIP *scip, const char *name, const char *description, int priority, SCIP_Bool enabled, DEC_CLASSIFIERDATA *classifierdata, DEC_DECL_FREEVARCLASSIFIER((*freeClassifier)), DEC_DECL_VARCLASSIFY((*classify)))
includes one variable classifier
SCIP_Bool GCGconshdlrDecompPresolvedDetprobdataExists(SCIP *scip)
returns whether or not a detprobdata structure for the presolved problem exists
type definitions for variable classifier in GCG projects
DEC_DECOMP ** GCGconshdlrDecompGetDecomps(SCIP *scip)
returns an array containing all decompositions
SCIP_Bool GCGconshdlrDecompOrigDetprobdataExists(SCIP *scip)
returns whether or not a detprobdata structure for the original problem exists
SCIP_RETCODE GCGconshdlrDecompCalcBorderAreaScore(SCIP *scip, int partialdecid, SCIP_Real *score)
calculates the border area score of a partialdec
SCIP_RETCODE GCGconshdlrDecompAddScoreTime(SCIP *scip, SCIP_Real time)
adds given time to total score calculation time
SCIP_RETCODE GCGconshdlrDecompSetDetection(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
sets detector parameters values
SCIP_RETCODE GCGconshdlrDecompGetSelectedPartialdecs(SCIP *scip, int **idlist, int *listlength)
Gets a list of ids of all currently selected partialdecs.
int GCGconshdlrDecompGetNFormerDetectionConssForID(SCIP *scip, int id)
gets number of active constraints during the detection of the decomp with given id
SCORETYPE GCGconshdlrDecompGetScoretype(SCIP *scip)
Gets the currently selected scoretype.
SCIP_RETCODE GCGconshdlrDecompGetFinishedPartialdecsList(SCIP *scip, int **idlist, int *listlength)
Gets a list of ids of the current partialdecs that are finished.
float GCGconshdlrDecompGetScoreByPartialdecId(SCIP *scip, int id)
gets score of partialdec with given id
SCIP_Bool GCGconshdlrDecompCheckConsistency(SCIP *scip)
check whether partialdecs are consistent
enum scoretype SCORETYPE
SCIP_RETCODE GCGconshdlrDecompArePricingprobsIdenticalForPartialdecid(SCIP *scip, int partialdecid, int probnr1, int probnr2, SCIP_Bool *identical)
checks if two pricing problems are identical based on information from detection
const char * DECvarClassifierGetName(DEC_VARCLASSIFIER *classifier)
returns the name of the provided classifier
DEC_DETECTOR * DECfindDetector(SCIP *scip, const char *name)
searches for the detector with the given name and returns it or NULL if detector is not found
SCIP_Real GCGconshdlrDecompGetScoreTotalTime(SCIP *scip)
gets total score computation time
int GCGconshdlrDecompGetNextPartialdecID(SCIP *scip)
Gets the next partialdec id managed by cons_decomp.
void GCGconshdlrDecompCalcCandidatesNBlocks(SCIP *scip, SCIP_Bool transformed)
calculates and adds block size candidates using constraint classifications and variable classificatio...
#define DEC_DECL_FINISHPARTIALDEC(x)
const char * DECdetectorGetName(DEC_DETECTOR *detector)
returns the name of the provided detector
int GCGconshdlrDecompGetNMasterVarsByPartialdecId(SCIP *scip, int id)
gets number of master variables of partialdec with given id
SCIP_RETCODE GCGconshdlrDecompCalcBendersScore(SCIP *scip, int partialdecid, SCIP_Real *score)
calculates the benders score of a partialdec
int GCGconshdlrDecompDecreaseNCallsCreateDecomp(SCIP *scip)
decreases the counter for created decompositions and returns it
SCIP_RETCODE GCGconshdlrDecompCalcMaxForseeingWhiteScore(SCIP *scip, int partialdecid, SCIP_Real *score)
calculates the maximum foreseeing white area score of a partialdec