Scippy

SCIP

Solving Constraint Integer Programs

reader_sto.c
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and library */
4 /* SCIP --- Solving Constraint Integer Programs */
5 /* */
6 /* Copyright (c) 2002-2024 Zuse Institute Berlin (ZIB) */
7 /* */
8 /* Licensed under the Apache License, Version 2.0 (the "License"); */
9 /* you may not use this file except in compliance with the License. */
10 /* You may obtain a copy of the License at */
11 /* */
12 /* http://www.apache.org/licenses/LICENSE-2.0 */
13 /* */
14 /* Unless required by applicable law or agreed to in writing, software */
15 /* distributed under the License is distributed on an "AS IS" BASIS, */
16 /* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
17 /* See the License for the specific language governing permissions and */
18 /* limitations under the License. */
19 /* */
20 /* You should have received a copy of the Apache-2.0 license */
21 /* along with SCIP; see the file LICENSE. If not visit scipopt.org. */
22 /* */
23 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
24 
25 /**@file reader_sto.c
26  * @ingroup DEFPLUGINS_READER
27  * @brief STO file reader - the stochastic information of an instance in SMPS format
28  * @author Stephen J. Maher
29  */
30 
31 
32 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
33 
34 #include "blockmemshell/memory.h"
35 #include "scip/benders_default.h"
36 #include "scip/cons_linear.h"
37 #include "scip/pub_cons.h"
38 #include "scip/pub_fileio.h"
39 #include "scip/pub_message.h"
40 #include "scip/pub_misc.h"
41 #include "scip/pub_reader.h"
42 #include "scip/pub_var.h"
43 #include "scip/reader_cor.h"
44 #include "scip/reader_sto.h"
45 #include "scip/reader_tim.h"
46 #include "scip/scip_cons.h"
47 #include "scip/scip_debug.h"
48 #include "scip/scipdefplugins.h"
49 #include "scip/scip_general.h"
50 #include "scip/scip_mem.h"
51 #include "scip/scip_message.h"
52 #include "scip/scip_numerics.h"
53 #include "scip/scip_param.h"
54 #include "scip/scip_prob.h"
55 #include "scip/scip_reader.h"
56 #include "scip/scip_var.h"
57 #include <stdlib.h>
58 #include <string.h>
59 
60 #define READER_NAME "storeader"
61 #define READER_DESC "file reader for stochastic information of stochastic programs in the SMPS file format"
62 #define READER_EXTENSION "sto"
63 
64 #define DEFAULT_USEBENDERS FALSE /**< should Benders' decomposition be used for the stochastic program? */
65 
66 /*
67  * sto reader internal methods
68  */
69 
70 #define STO_MAX_LINELEN 1024
71 #define STO_MAX_NAMELEN 256
72 
73 #define STO_DEFAULT_ARRAYSIZE 100
74 #define STO_DEFAULT_ENTRIESSIZE 20
75 #define STO_DEFAULT_BLOCKARRAYSIZE 5
76 #define STO_DEFAULT_CHILDRENSIZE 5
77 
78 #define BLANK ' '
79 
80 typedef struct StoScenario STOSCENARIO;
81 
82 /** STO reading data */
83 struct SCIP_ReaderData
84 {
85  SCIP_Bool usebenders;
86  STOSCENARIO* scenariotree; /**< the multi stage scenario tree */
87  int numscenarios; /**< the total number of scenarios in the scenario tree */
88 };
89 
90 
92 {
93  SCIP* scip; /**< the SCIP instance for the scenario. Used for benders. */
94  SCIP** subproblems; /**< the SCIP instances for the subproblems */
95  STOSCENARIO* parent; /**< parent scenario. */
96  STOSCENARIO** children; /**< children scenarios. */
97  int nchildren; /**< the number of children scenarios. */
98  int childrensize; /**< the size of the children array. */
99  int nsubproblems; /**< the number of subproblems */
100  int stagenum; /**< the number of the stage */
101  int scenarionum; /**< the scenario number of this stage */
102  const char* stagename; /**< the stage name */
103  const char* name; /**< the scenario name. */
104  SCIP_Real probability; /**< the probability for this scenario. */
105  SCIP_Real lowerbound; /**< the lower bound for this scenario */
106  /* the following describes the modifications to the constraint matrix and rhs for each scenario. */
107  const char** rownames; /**< the names of the rows with a changed value. */
108  const char** colnames; /**< the names of the columns with a changed value. */
109  SCIP_Real* values; /**< the values for the given row/column pair. */
110  int nentries; /**< the number of row/column pairs */
111  int entriessize; /**< the size of the row/colum arrays */
112 };
113 
114 
115 
116 /** enum containing all sto sections */
118 {
124 };
125 typedef enum StoSection STOSECTION;
126 
127 /** enum containing the types of stochastic information */
129 {
136 };
138 
139 /** sto input structure */
140 struct StoInput
141 {
145  int lineno;
147  char buf[STO_MAX_LINELEN];
148  const char* f0;
149  const char* f1;
150  const char* f2;
151  const char* f3;
152  const char* f4;
153  const char* f5;
154  const char* f6;
155  char probname[STO_MAX_NAMELEN];
156  char stochtype[STO_MAX_NAMELEN];
157 };
158 typedef struct StoInput STOINPUT;
159 
160 /** creates a scenario structure */
161 static
163  SCIP* scip, /**< SCIP data structure */
164  STOSCENARIO** scenariodata /**< the scenario to be created */
165  )
166 {
167  assert(scip != NULL);
168 
169  SCIPdebugMessage("Creating scenario data.\n");
170 
171  SCIP_CALL( SCIPallocBlockMemory(scip, scenariodata) );
172 
173  (*scenariodata)->scip = NULL;
174  (*scenariodata)->subproblems = NULL;
175  (*scenariodata)->parent = NULL;
176  (*scenariodata)->nchildren = 0;
177  (*scenariodata)->childrensize = STO_DEFAULT_CHILDRENSIZE;
178  (*scenariodata)->nsubproblems = 0;
179  (*scenariodata)->stagenum = -1;
180  (*scenariodata)->scenarionum = -1;
181  (*scenariodata)->stagename = NULL;
182  (*scenariodata)->name = NULL;
183  (*scenariodata)->probability = 1.0;
184  (*scenariodata)->lowerbound = -SCIPinfinity(scip);
185  (*scenariodata)->nentries = 0;
186  (*scenariodata)->entriessize = STO_DEFAULT_ENTRIESSIZE;
187 
188  SCIP_CALL( SCIPallocBlockMemoryArray(scip, &(*scenariodata)->children, (*scenariodata)->childrensize) );
189  SCIP_CALL( SCIPallocBlockMemoryArray(scip, &(*scenariodata)->rownames, (*scenariodata)->entriessize) );
190  SCIP_CALL( SCIPallocBlockMemoryArray(scip, &(*scenariodata)->colnames, (*scenariodata)->entriessize) );
191  SCIP_CALL( SCIPallocBlockMemoryArray(scip, &(*scenariodata)->values, (*scenariodata)->entriessize) );
192 
193  return SCIP_OKAY;
194 }
195 
196 /** frees the memory used for the scenario tree */
197 static
199  SCIP* scip, /**< the SCIP data structure */
200  STOSCENARIO** scenariotree /**< the scenario tree */
201  )
202 {
203  int nchildren;
204  int i;
205 
206  assert(scip != NULL);
207  assert(scenariotree != NULL);
208  assert(*scenariotree != NULL);
209 
210  SCIPdebugMessage("Freeing scenario <%s> in stage <%s>\n", (*scenariotree)->name,
211  (*scenariotree)->stagename);
212 
213  /* storing the number of children before starting the recursive freeing */
214  nchildren = (*scenariotree)->nchildren;
215 
216  while( (*scenariotree)->nchildren > 0 )
217  {
218  SCIP_CALL( freeScenarioTree(scip, &(*scenariotree)->children[(*scenariotree)->nchildren - 1]) );
219  (*scenariotree)->nchildren--;
220  }
221 
222  for( i = (*scenariotree)->nentries - 1; i >= 0; i-- )
223  {
224  SCIPfreeBlockMemoryArray(scip, &(*scenariotree)->colnames[i], strlen((*scenariotree)->colnames[i]) + 1);
225  SCIPfreeBlockMemoryArray(scip, &(*scenariotree)->rownames[i], strlen((*scenariotree)->rownames[i]) + 1);
226  }
227 
228  SCIPfreeBlockMemoryArray(scip, &(*scenariotree)->values, (*scenariotree)->entriessize);
229  SCIPfreeBlockMemoryArray(scip, &(*scenariotree)->colnames, (*scenariotree)->entriessize);
230  SCIPfreeBlockMemoryArray(scip, &(*scenariotree)->rownames, (*scenariotree)->entriessize);
231  SCIPfreeBlockMemoryArray(scip, &(*scenariotree)->children, (*scenariotree)->childrensize);
232 
233  SCIPfreeBlockMemoryArray(scip, &(*scenariotree)->name, strlen((*scenariotree)->name) + 1);
234  SCIPfreeBlockMemoryArray(scip, &(*scenariotree)->stagename, strlen((*scenariotree)->stagename) + 1);
235 
236  /* freeing the subproblem SCIP instances */
237  for( i = (*scenariotree)->nsubproblems - 1; i >= 0; i-- )
238  SCIP_CALL( SCIPfree(&(*scenariotree)->subproblems[i]) );
239 
240  /* freeing the array that stores the subproblems */
241  if( nchildren > 0 && (*scenariotree)->subproblems != NULL )
242  SCIPfreeBlockMemoryArray(scip, &(*scenariotree)->subproblems, nchildren);
243 
244  SCIPfreeBlockMemory(scip, scenariotree);
245 
246  return SCIP_OKAY;
247 }
248 
249 /** sets the SCIP pointer to the scenario */
250 static
252  STOSCENARIO* scenario, /**< the scenario */
253  SCIP* scip /**< the SCIP data structure */
254  )
255 {
256  assert(scenario != NULL);
257  assert(scip != NULL);
258 
259  scenario->scip = scip;
260 }
261 
262 /** returns the SCIP pointer to the scenario */
263 static
265  STOSCENARIO* scenario /**< the scenario */
266  )
267 {
268  assert(scenario != NULL);
269 
270  return scenario->scip;
271 }
272 
273 /** creates the subproblem array. This array will be the same size as the number of children */
274 static
276  SCIP* scip, /**< the SCIP data structure */
277  STOSCENARIO* scenario /**< the scenario */
278  )
279 {
280  assert(scip != NULL);
281  assert(scenario != NULL);
282 
283  SCIP_CALL( SCIPallocBlockMemoryArray(scip, &scenario->subproblems, scenario->nchildren) );
284 
285  return SCIP_OKAY;
286 }
287 
288 /** adds a scenario to the subproblem array */
289 static
291  STOSCENARIO* scenario, /**< the scenario */
292  SCIP* subproblem /**< the subproblems data structure */
293  )
294 {
295  assert(scenario != NULL);
296  assert(subproblem != NULL);
297 
298  assert(scenario->nsubproblems + 1 <= scenario->nchildren);
299 
300  scenario->subproblems[scenario->nsubproblems] = subproblem;
301  scenario->nsubproblems++;
302 }
303 
304 /** returns the subproblem array for the scenario */
305 static
307  STOSCENARIO* scenario /**< the scenario */
308  )
309 {
310  assert(scenario != NULL);
311 
312  return scenario->subproblems;
313 }
314 
315 /** returns the number of children for a given scenario */
316 static
318  STOSCENARIO* scenario /**< the scenario */
319  )
320 {
321  assert(scenario != NULL);
322 
323  return scenario->nchildren;
324 }
325 
326 /** returns a given child for a given scenario */
327 static
329  STOSCENARIO* scenario, /**< the scenario */
330  int childnum /**< the number of the desired child */
331  )
332 {
333  assert(scenario != NULL);
334  assert(childnum >= 0 && childnum < scenario->nchildren);
335 
336  return scenario->children[childnum];
337 }
338 
339 /** returns the parent of a scenario */
340 static
342  STOSCENARIO* scenario /**< the scenario */
343  )
344 {
345  assert(scenario != NULL);
346 
347  return scenario->parent;
348 }
349 
350 /** sets the stage name */
351 static
353  SCIP* scip, /**< the SCIP data structure */
354  STOSCENARIO* scenario, /**< the scenario */
355  const char* stagename /**< the stage name */
356  )
357 {
358  assert(scip != NULL);
359  assert(scenario != NULL);
360 
361  SCIP_CALL( SCIPduplicateBlockMemoryArray(scip, &scenario->stagename, stagename, strlen(stagename) + 1) );
362 
363  return SCIP_OKAY;
364 }
365 
366 /** returns the stage name */
367 static
369  SCIP* scip, /**< the SCIP data structure */
370  STOSCENARIO* scenario /**< the scenario */
371  )
372 {
373  assert(scip != NULL);
374  assert(scenario != NULL);
375 
376  return scenario->stagename;
377 }
378 
379 /** sets the stage num */
380 static
382  SCIP* scip, /**< the SCIP data structure */
383  STOSCENARIO* scenario, /**< the scenario */
384  int stagenum /**< the stage num */
385  )
386 {
387  assert(scip != NULL);
388  assert(scenario != NULL);
389 
390  scenario->stagenum = stagenum;
391 
392  return SCIP_OKAY;
393 }
394 
395 /** returns the stage num */
396 static
398  SCIP* scip, /**< the SCIP data structure */
399  STOSCENARIO* scenario /**< the scenario */
400  )
401 {
402  assert(scip != NULL);
403  assert(scenario != NULL);
404 
405  return scenario->stagenum;
406 }
407 
408 /** sets the scenario name */
409 static
411  SCIP* scip, /**< the SCIP data structure */
412  STOSCENARIO* scenario, /**< the scenario */
413  const char* name /**< the scenario name */
414  )
415 {
416  assert(scip != NULL);
417  assert(scenario != NULL);
418 
419  SCIP_CALL( SCIPduplicateBlockMemoryArray(scip, &scenario->name, name, strlen(name) + 1) );
420 
421  return SCIP_OKAY;
422 }
423 
424 /** returns the scenario name */
425 static
426 const char* getScenarioName(
427  STOSCENARIO* scenario /**< the scenario */
428  )
429 {
430  assert(scenario != NULL);
431 
432  return scenario->name;
433 }
434 
435 /** sets the scenario num */
436 static
438  SCIP* scip, /**< the SCIP data structure */
439  STOSCENARIO* scenario, /**< the scenario */
440  int scenarionum /**< the scenario num */
441  )
442 {
443  assert(scip != NULL);
444  assert(scenario != NULL);
445 
446  scenario->scenarionum = scenarionum;
447 
448  return SCIP_OKAY;
449 }
450 
451 /** returns the scenario num */
452 static
454  SCIP* scip, /**< the SCIP data structure */
455  STOSCENARIO* scenario /**< the scenario */
456  )
457 {
458  assert(scip != NULL);
459  assert(scenario != NULL);
460 
461  return scenario->scenarionum;
462 }
463 
464 /** sets the scenario probability */
465 static
467  SCIP* scip, /**< the SCIP data structure */
468  STOSCENARIO* scenario, /**< the scenario */
469  SCIP_Real probability /**< the scenario probability */
470  )
471 {
472  assert(scip != NULL);
473  assert(scenario != NULL);
474 
475  scenario->probability = probability;
476 
477  return SCIP_OKAY;
478 }
479 
480 /** returns the scenario probability */
481 static
483  SCIP* scip, /**< the SCIP data structure */
484  STOSCENARIO* scenario /**< the scenario */
485  )
486 {
487  assert(scip != NULL);
488  assert(scenario != NULL);
489 
490  return scenario->probability;
491 }
492 
493 /** sets the scenario lowerbound */
494 static
496  SCIP* scip, /**< the SCIP data structure */
497  STOSCENARIO* scenario, /**< the scenario */
498  SCIP_Real lowerbound /**< the scenario lowerbound */
499  )
500 {
501  assert(scip != NULL);
502  assert(scenario != NULL);
503 
504  scenario->lowerbound = lowerbound;
505 
506  return SCIP_OKAY;
507 }
508 
509 /** returns the scenario lowerbound */
510 static
512  SCIP* scip, /**< the SCIP data structure */
513  STOSCENARIO* scenario /**< the scenario */
514  )
515 {
516  assert(scip != NULL);
517  assert(scenario != NULL);
518 
519  return scenario->lowerbound;
520 }
521 
522 /** add scenario entry */
523 static
525  SCIP* scip, /**< the SCIP data structure */
526  STOSCENARIO* scenario, /**< the scenario */
527  const char* rowname, /**< the row name for the entry */
528  const char* colname, /**< the col name for the entry */
529  SCIP_Real value /**< the value for the entry */
530  )
531 {
532  assert(scip != NULL);
533  assert(scenario != NULL);
534 
535  if( scenario->nentries + 1 > scenario->entriessize )
536  {
537  int newsize;
538  newsize = SCIPcalcMemGrowSize(scip, scenario->nentries + 1);
539  SCIP_CALL( SCIPreallocBlockMemoryArray(scip, &scenario->rownames, scenario->entriessize, newsize) );
540  SCIP_CALL( SCIPreallocBlockMemoryArray(scip, &scenario->colnames, scenario->entriessize, newsize) );
541  SCIP_CALL( SCIPreallocBlockMemoryArray(scip, &scenario->values, scenario->entriessize, newsize) );
542  scenario->entriessize = newsize;
543  }
544 
545  SCIP_CALL( SCIPduplicateBlockMemoryArray(scip, &scenario->rownames[scenario->nentries], rowname, strlen(rowname) + 1) ); /*lint !e866*/
546  SCIP_CALL( SCIPduplicateBlockMemoryArray(scip, &scenario->colnames[scenario->nentries], colname, strlen(colname) + 1) ); /*lint !e866*/
547 
548  scenario->values[scenario->nentries] = value;
549  scenario->nentries++;
550 
551  return SCIP_OKAY;
552 }
553 
554 /** returns the number of entries for a scenario */
555 static
557  STOSCENARIO* scenario /**< the scenario */
558  )
559 {
560  assert(scenario != NULL);
561 
562  return scenario->nentries;
563 }
564 
565 /** returns an entry row for a scenario */
566 static
568  STOSCENARIO* scenario, /**< the scenario */
569  int entry /**< the entry number */
570  )
571 {
572  assert(scenario != NULL);
573  assert(entry >= 0 && entry < scenario->nentries);
574 
575  return scenario->rownames[entry];
576 }
577 
578 /** returns an entry column for a scenario */
579 static
581  STOSCENARIO* scenario, /**< the scenario */
582  int entry /**< the entry number */
583  )
584 {
585  assert(scenario != NULL);
586  assert(entry >= 0 && entry < scenario->nentries);
587 
588  return scenario->colnames[entry];
589 }
590 
591 /** returns an entry value for a scenario */
592 static
594  STOSCENARIO* scenario, /**< the scenario */
595  int entry /**< the entry number */
596  )
597 {
598  assert(scenario != NULL);
599  assert(entry >= 0 && entry < scenario->nentries);
600 
601  return scenario->values[entry];
602 }
603 
604 /** copies a scenario.
605  * In the case of blocks, the scenarios must be combined
606  */
607 static
609  SCIP* scip, /**< the SCIP data structure */
610  STOSCENARIO* sourcescenario, /**< the source scenario */
611  STOSCENARIO** targetscenario, /**< the target scenario */
612  SCIP_Bool copyname /**< should the name be copied? */
613  )
614 {
615  SCIP_Real probability;
616  SCIP_Real lowerbound;
617  int i;
618 
619  assert(scip != NULL);
620  assert(sourcescenario != NULL);
621  assert(targetscenario != NULL);
622 
623  /* setting the stage name */
624  if( copyname )
625  {
626  SCIP_CALL( setScenarioName(scip, (*targetscenario), sourcescenario->name) );
627  SCIP_CALL( setScenarioStageName(scip, (*targetscenario), sourcescenario->stagename) );
628  SCIP_CALL( setScenarioNum(scip, (*targetscenario), sourcescenario->scenarionum) );
629  SCIP_CALL( setScenarioStageNum(scip, (*targetscenario), sourcescenario->stagenum) );
630  }
631 
632  /* adding the entries from scenario 1 and 2 to the merged scenario */
633  for( i = 0; i < sourcescenario->nentries; i++ )
634  SCIP_CALL( addScenarioEntry(scip, (*targetscenario), sourcescenario->rownames[i], sourcescenario->colnames[i],
635  sourcescenario->values[i]) );
636 
637  /* setting the scenario probability */
638  probability = getScenarioProbability(scip, sourcescenario);
639  SCIP_CALL( setScenarioProbability(scip, (*targetscenario), probability) );
640 
641  lowerbound = getScenarioLowerbound(scip, sourcescenario);
642  SCIP_CALL( setScenarioLowerbound(scip, (*targetscenario), lowerbound) );
643 
644  return SCIP_OKAY;
645 }
646 
647 /** merge scenarios.
648  * In the case of blocks, the scenarios must be combined
649  */
650 static
652  SCIP* scip, /**< the SCIP data structure */
653  STOSCENARIO* scenario1, /**< the first scenario */
654  STOSCENARIO** mergedscenario /**< the merged scenario */
655  )
656 {
657  SCIP_Real probability;
658  int i;
659 
660  assert(scip != NULL);
661  assert(scenario1 != NULL);
662  assert(mergedscenario != NULL);
663 
664  /* adding the entries from scenario 1 and 2 to the merged scenario */
665  for( i = 0; i < scenario1->nentries; i++ )
666  SCIP_CALL( addScenarioEntry(scip, (*mergedscenario), scenario1->rownames[i], scenario1->colnames[i],
667  scenario1->values[i]) );
668 
669  /* setting the scenario probability */
670  probability = getScenarioProbability(scip, scenario1)*getScenarioProbability(scip, (*mergedscenario));
671  SCIP_CALL( setScenarioProbability(scip, (*mergedscenario), probability) );
672 
673  return SCIP_OKAY;
674 }
675 
676 /** adds a child to a given scenario */
677 static
679  SCIP* scip, /**< the SCIP data structure */
680  STOSCENARIO** parent, /**< the parent scenario */
681  STOSCENARIO* child /**< the child scenario */
682  )
683 {
684  STOSCENARIO* scenario;
685 
686  assert(parent != NULL);
687  assert((*parent) != NULL);
688  assert(child != NULL);
689 
690  if( (*parent)->nchildren + 1 > (*parent)->childrensize )
691  SCIP_CALL( SCIPensureBlockMemoryArray(scip, &(*parent)->children, &(*parent)->childrensize,
692  (*parent)->nchildren + 1) );
693 
694  SCIP_CALL( createScenarioData(scip, &scenario) );
695  SCIP_CALL( copyScenario(scip, child, &scenario, TRUE) );
696  scenario->parent = (*parent);
697 
698  (*parent)->children[(*parent)->nchildren] = scenario;
699  (*parent)->nchildren++;
700 
701  return SCIP_OKAY;
702 }
703 
704 /** recursively adds the scenarios to the reader data */
705 static
707  SCIP* scip, /**< the SCIP data structure */
708  STOSCENARIO** scenariotree, /**< the scenario tree */
709  STOSCENARIO*** scenarios, /**< the array of scenarios */
710  int* numscenarios, /**< the number of scenarios per stage */
711  int numstages, /**< the number of stages */
712  int stage /**< the number of the stage. Also the depth of the tree */
713  )
714 {
715  int stageindex;
716  int i;
717 
718  assert(scip != NULL);
719  assert(scenariotree != NULL);
720  assert(stage >= 0 && stage < numstages);
721 
722  /* finding the scenarios for this stage */
723  for( i = 0; i < numstages; i++ )
724  {
725  if( strcmp(getScenarioStageName(scip, scenarios[i][0]), SCIPtimGetStageName(scip, stage + 1)) == 0 )
726  break;
727  }
728  assert(i < numstages);
729 
730  stageindex = i;
731 
732  /* adds each scenario to the scenario tree */
733  for( i = 0; i < numscenarios[stageindex]; i++ )
734  {
735  /* adding child to the scenario tree */
736  SCIP_CALL( scenarioAddChild(scip, scenariotree, scenarios[stageindex][i]) );
737 
738  /* building the tree below the recently added child */
739  if( stage < numstages - 1 )
740  {
741  STOSCENARIO* child = getScenarioChild((*scenariotree), getScenarioNChildren((*scenariotree)) - 1);
742  SCIP_CALL( buildScenarioTree(scip, &child, scenarios, numscenarios, numstages, stage + 1) );
743  }
744  }
745 
746  return SCIP_OKAY;
747 }
748 
749 
750 /* adds the scenarios to the reader data */
751 static
753  SCIP* scip, /**< the SCIP data structure */
754  SCIP_READERDATA* readerdata, /**< the reader data */
755  STOSCENARIO*** scenarios, /**< the array of scenarios */
756  int* numscenarios, /**< the number of scenarios per stage */
757  int numscenariostages /**< the number of stages for which scenarios were collected */
758  )
759 {
760  int i;
761 
762  assert(scip != NULL);
763  assert(readerdata != NULL);
764  assert(scenarios != NULL);
765  assert(numscenariostages == SCIPtimGetNStages(scip) - 1);
766 
767  SCIP_CALL( buildScenarioTree(scip, &readerdata->scenariotree, scenarios, numscenarios, numscenariostages, 0) );
768 
769  /* setting the number of scenarios per stage in the TIME reader data */
770  for( i = 0; i < numscenariostages; i++ )
771  readerdata->numscenarios += numscenarios[i];
772 
773  return SCIP_OKAY;
774 }
775 
776 
777 /** finds a scenario with a given name */
778 static
780  STOSCENARIO* scenariotree, /**< the scenario tree to search */
781  const char* scenname /**< the name of the scenario to search */
782  )
783 {
784  STOSCENARIO* retscen;
785  int i;
786 
787  if( strcmp(getScenarioName(scenariotree), scenname) == 0 )
788  return scenariotree;
789  else
790  {
791  retscen = NULL;
792  for( i = 0; i < getScenarioNChildren(scenariotree); i++ )
793  {
794  retscen = findScenarioInTree(scenariotree->children[i], scenname);
795  if( retscen != NULL )
796  return retscen;
797  }
798  }
799 
800  return NULL;
801 }
802 
803 
804 /** inserts a scenario into the reader data scenario tree */
805 static
807  SCIP* scip, /**< the SCIP data structure */
808  SCIP_READERDATA* readerdata, /**< the reader data */
809  STOSCENARIO* scenario, /**< the scenario to insert in the scenario tree */
810  char* parentname /**< the parent scenario for the inserting scenario */
811  )
812 {
813  STOSCENARIO* parentscen;
814 
815  assert(scip != NULL);
816  assert(readerdata != NULL);
817  assert(scenario != NULL);
818 
819  /* searching for the parent scenario in the tree */
820  parentscen = findScenarioInTree(readerdata->scenariotree, parentname);
821 
822  /* adding the scenario as a child of the parent scenario */
823  SCIP_CALL( scenarioAddChild(scip, &parentscen, scenario) );
824 
825  readerdata->numscenarios++;
826 
827  return SCIP_OKAY;
828 }
829 
830 
831 /* builds the scenarios from the blocks for a given stage */
832 static
834  SCIP* scip, /**< the SCIP data structure */
835  STOSCENARIO*** blocks, /**< the block that form the scenarios */
836  STOSCENARIO*** scenarios, /**< the array to store the scenarios */
837  STOSCENARIO*** blocksforscen, /**< the blocks that will form the scenario */
838  int* numblocksforscen, /**< the number of blocks that form the scenario */
839  int numblocks, /**< the number of blocks */
840  int* numblocksperblock, /**< the number of blocks for a given block */
841  int* numscenarios, /**< the number of scenarios */
842  int* scenariossize, /**< the size of scenarios array */
843  const char* stage, /**< the stage for this scenario */
844  int stagenum, /**< the number of the stage */
845  int blocknum /**< the block number */
846  )
847 {
848  SCIP_Bool processed;
849  int i;
850  int j;
851 
852  assert(scip != NULL);
853  assert(blocks != NULL);
854  assert(scenarios != NULL);
855  assert(blocksforscen != NULL);
856 
857  processed = FALSE;
858  i = blocknum + 1;
859  while( !processed && i < numblocks )
860  {
861  /* it is only necessary to process the next block in the list the belongs to the given stage. */
862  if( strcmp(getScenarioStageName(scip, blocks[i][0]), stage) == 0 )
863  {
864  processed = TRUE;
865 
866  for( j = 0; j < numblocksperblock[i]; j++ )
867  {
868  /* adding the blocks that will build the scenario */
869  (*blocksforscen)[(*numblocksforscen)] = blocks[i][j];
870  (*numblocksforscen)++;
871  SCIP_CALL( buildScenariosFromBlocks(scip, blocks, scenarios, blocksforscen, numblocksforscen, numblocks,
872  numblocksperblock, numscenarios, scenariossize, stage, stagenum + 1, i) );
873 
874  /* the last block needs to be removed so that a new block can be used in its place */
875  (*numblocksforscen)--;
876  }
877  }
878  else
879  {
880  /* the index is only incremented if no block is processed. This is necessary because the value of i is used in
881  * the next if statement for identifying whether all blocks have been processed.
882  */
883  i++;
884  }
885  }
886 
887  /* when all blocks have been inspected, then it is possible to build the scenario */
888  if( i == numblocks )
889  {
890  char scenarioname[SCIP_MAXSTRLEN];
891 
892  /* ensuring the correct amount of memory is available */
893  if( (*numscenarios) + 1 > (*scenariossize) )
894  {
895  int newsize;
896  newsize = SCIPcalcMemGrowSize(scip, (*numscenarios) + 1);
897  SCIP_CALL( SCIPreallocBlockMemoryArray(scip, scenarios, (*scenariossize), newsize) );
898  (*scenariossize) = newsize;
899  }
900 
901  SCIP_CALL( createScenarioData(scip, &(*scenarios)[(*numscenarios)]) );
902 
903  /* setting the scenario name */
904  (void) SCIPsnprintf(scenarioname, SCIP_MAXSTRLEN, "Scenario_%s_%d", stage, (*numscenarios));
905  SCIP_CALL( setScenarioName(scip, (*scenarios)[(*numscenarios)], scenarioname) );
906  SCIP_CALL( setScenarioStageName(scip, (*scenarios)[(*numscenarios)], stage) );
907  SCIP_CALL( setScenarioNum(scip, (*scenarios)[(*numscenarios)], (*numscenarios)) );
908  SCIP_CALL( setScenarioStageNum(scip, (*scenarios)[(*numscenarios)], stagenum) );
909 
910  /* if there is only a single block for the scenario, then we simply copy the block.
911  * Otherwise, the blocks are merged into a single scenario */
912  if( (*numblocksforscen) == 1 )
913  SCIP_CALL( copyScenario(scip, (*blocksforscen)[0], &(*scenarios)[(*numscenarios)], FALSE) );
914  else
915  {
916  SCIP_CALL( copyScenario(scip, (*blocksforscen)[0], &(*scenarios)[(*numscenarios)], FALSE) );
917  for( i = 1; i < (*numblocksforscen); i++ )
918  SCIP_CALL( mergeScenarios(scip, (*blocksforscen)[i], &(*scenarios)[(*numscenarios)]) );
919  }
920 
921  (*numscenarios)++;
922  }
923 
924  return SCIP_OKAY;
925 }
926 
927 
928 /* creates the scenarios from the blocks */
929 static
931  SCIP* scip, /**< the SCIP data structure */
932  SCIP_READERDATA* readerdata, /**< the reader data */
933  STOSCENARIO*** blocks, /**< the block that form the scenarios */
934  int numblocks, /**< the number of blocks */
935  int* numblocksperblock, /**< the number of blocks for each block type */
936  int numstages /**< the number of stages */
937  )
938 {
939  STOSCENARIO*** scenarios;
940  STOSCENARIO** blocksforscen;
941  int* numscenarios;
942  int* scenariossize;
943  int numblocksforscen;
944  int stagenum;
945  char periods[SCIP_MAXSTRLEN];
946  int i;
947  int j;
948 
949  assert(scip != NULL);
950  assert(blocks != NULL);
951 
952  /* allocating the memory for the scenarios array */
953  SCIP_CALL( SCIPallocBlockMemoryArray(scip, &scenarios, numstages) );
954  SCIP_CALL( SCIPallocBufferArray(scip, &numscenarios, numstages) );
955  SCIP_CALL( SCIPallocBufferArray(scip, &scenariossize, numstages) );
956  for( i = 0; i < numstages; i++ )
957  {
958  scenariossize[i] = STO_DEFAULT_BLOCKARRAYSIZE;
959  numscenarios[i] = 0;
960  SCIP_CALL( SCIPallocBlockMemoryArray(scip, &scenarios[i], scenariossize[i]) );
961  }
962 
963  /* allocating the memory for the block for scenario array */
964  SCIP_CALL( SCIPallocBufferArray(scip, &blocksforscen, numblocks) );
965 
966  (void) SCIPsnprintf(periods, SCIP_MAXSTRLEN, "");
967 
968  stagenum = 0;
969  for( i = 0; i < numblocks; i++ )
970  {
971  numblocksforscen = 0;
972  if( strstr(periods, getScenarioStageName(scip, blocks[i][0])) == NULL )
973  {
974  /* recording the stage name as processed */
975  (void) SCIPsnprintf(periods, SCIP_MAXSTRLEN, "%s_%s", periods, getScenarioStageName(scip, blocks[i][0]));
976 
977  SCIP_CALL( buildScenariosFromBlocks(scip, blocks, &scenarios[stagenum], &blocksforscen, &numblocksforscen,
978  numblocks, numblocksperblock, &numscenarios[stagenum], &scenariossize[stagenum],
979  getScenarioStageName(scip, blocks[i][0]), stagenum, i - 1) );
980 
981  stagenum++;
982  }
983  }
984 
985  /* adding the scenarios to the reader data */
986  SCIP_CALL( setScenarioNum(scip, readerdata->scenariotree, 0) );
987  SCIP_CALL( setScenarioStageNum(scip, readerdata->scenariotree, 0) );
988  SCIP_CALL( addScenariosToReaderdata(scip, readerdata, scenarios, numscenarios, numstages) );
989 
990  SCIPfreeBufferArray(scip, &blocksforscen);
991  for( i = numstages - 1; i >= 0; i-- )
992  {
993  for( j = numscenarios[i] - 1; j >= 0; j-- )
994  SCIP_CALL( freeScenarioTree(scip, &scenarios[i][j]) );
995  SCIPfreeBlockMemoryArray(scip, &scenarios[i], scenariossize[i]);
996  }
997  SCIPfreeBufferArray(scip, &scenariossize);
998  SCIPfreeBufferArray(scip, &numscenarios);
999  SCIPfreeBlockMemoryArray(scip, &scenarios, numstages);
1000 
1001  return SCIP_OKAY;
1002 }
1003 
1004 /** creates the reader data */
1005 static
1007  SCIP* scip, /**< SCIP data structure */
1008  SCIP_READERDATA* readerdata /**< the reader data */
1009  )
1010 {
1011  assert(scip != NULL);
1012  assert(readerdata != NULL);
1013 
1014  /* creating the initial scenario */
1015  SCIP_CALL( createScenarioData(scip, &readerdata->scenariotree) );
1016 
1017  /* setting the scenario name and stage name */
1018  SCIP_CALL( setScenarioName(scip, readerdata->scenariotree, "ROOT") );
1019  SCIP_CALL( setScenarioStageName(scip, readerdata->scenariotree, SCIPtimGetStageName(scip, 0)) );
1020 
1021  return SCIP_OKAY;
1022 }
1023 
1024 /** frees the reader data */
1025 static
1027  SCIP* scip, /**< the SCIP data structure */
1028  SCIP_READERDATA* readerdata /**< the reader data */
1029  )
1030 {
1031  assert(scip != NULL);
1032  assert(readerdata != NULL);
1033 
1034  /* freeing the scenario tree */
1035  if( readerdata->scenariotree != NULL )
1036  SCIP_CALL( freeScenarioTree(scip, &readerdata->scenariotree) );
1037 
1038  SCIPfreeBlockMemory(scip, &readerdata);
1039 
1040  return SCIP_OKAY;
1041 }
1042 
1043 /** creates the sto input structure */
1044 static
1046  SCIP* scip, /**< SCIP data structure */
1047  STOINPUT** stoi, /**< sto input structure */
1048  SCIP_FILE* fp /**< file object for the input file */
1049  )
1050 {
1051  assert(stoi != NULL);
1052  assert(fp != NULL);
1053 
1054  SCIP_CALL( SCIPallocBlockMemory(scip, stoi) );
1055 
1056  (*stoi)->section = STO_STOCH;
1057  (*stoi)->stochinfotype = STO_STOCHINFO_NONE;
1058  (*stoi)->fp = fp;
1059  (*stoi)->lineno = 0;
1060  (*stoi)->haserror = FALSE;
1061  (*stoi)->buf [0] = '\0';
1062  (*stoi)->probname[0] = '\0';
1063  (*stoi)->stochtype[0] = '\0';
1064  (*stoi)->f0 = NULL;
1065  (*stoi)->f1 = NULL;
1066  (*stoi)->f2 = NULL;
1067  (*stoi)->f3 = NULL;
1068  (*stoi)->f4 = NULL;
1069  (*stoi)->f5 = NULL;
1070  (*stoi)->f6 = NULL;
1071 
1072  return SCIP_OKAY;
1073 }
1074 
1075 /** free the sto input structure */
1076 static
1078  SCIP* scip, /**< SCIP data structure */
1079  STOINPUT** stoi /**< sto input structure */
1080  )
1081 {
1082  SCIPfreeBlockMemory(scip, stoi);
1083 }
1084 
1085 /** returns the current section */
1086 static
1088  const STOINPUT* stoi /**< sto input structure */
1089  )
1090 {
1091  assert(stoi != NULL);
1092 
1093  return stoi->section;
1094 }
1095 
1096 /** returns the stochastic information type */
1097 static
1099  const STOINPUT* stoi /**< sto input structure */
1100  )
1101 {
1102  assert(stoi != NULL);
1103 
1104  return stoi->stochinfotype;
1105 }
1106 
1107 /** return the current value of field 0 */
1108 static
1109 const char* stoinputField0(
1110  const STOINPUT* stoi /**< sto input structure */
1111  )
1112 {
1113  assert(stoi != NULL);
1114 
1115  return stoi->f0;
1116 }
1117 
1118 /** return the current value of field 1 */
1119 static
1120 const char* stoinputField1(
1121  const STOINPUT* stoi /**< sto input structure */
1122  )
1123 {
1124  assert(stoi != NULL);
1125 
1126  return stoi->f1;
1127 }
1128 
1129 /** return the current value of field 2 */
1130 static
1131 const char* stoinputField2(
1132  const STOINPUT* stoi /**< sto input structure */
1133  )
1134 {
1135  assert(stoi != NULL);
1136 
1137  return stoi->f2;
1138 }
1139 
1140 /** return the current value of field 3 */
1141 static
1142 const char* stoinputField3(
1143  const STOINPUT* stoi /**< sto input structure */
1144  )
1145 {
1146  assert(stoi != NULL);
1147 
1148  return stoi->f3;
1149 }
1150 
1151 /** return the current value of field 4 */
1152 static
1153 const char* stoinputField4(
1154  const STOINPUT* stoi /**< sto input structure */
1155  )
1156 {
1157  assert(stoi != NULL);
1158 
1159  return stoi->f4;
1160 }
1161 
1162 /** return the current value of field 5 */
1163 static
1164 const char* stoinputField5(
1165  const STOINPUT* stoi /**< sto input structure */
1166  )
1167 {
1168  assert(stoi != NULL);
1169 
1170  return stoi->f5;
1171 }
1172 
1173 /** return the current value of field 6 */
1174 static
1175 const char* stoinputField6(
1176  const STOINPUT* stoi /**< sto input structure */
1177  )
1178 {
1179  assert(stoi != NULL);
1180 
1181  return stoi->f6;
1182 }
1183 
1184 /** returns if an error was detected */
1185 static
1187  const STOINPUT* stoi /**< sto input structure */
1188  )
1189 {
1190  assert(stoi != NULL);
1191 
1192  return stoi->haserror;
1193 }
1194 
1195 /** set the section in the sto input structure to given section */
1196 static
1198  STOINPUT* stoi, /**< sto input structure */
1199  STOSECTION section /**< section that is set */
1200  )
1201 {
1202  assert(stoi != NULL);
1203 
1204  stoi->section = section;
1205 }
1206 
1207 /** set the stochastic info type in the sto input structure */
1208 static
1210  STOINPUT* stoi, /**< sto input structure */
1211  STOSTOCHINFO stochinfotype /**< the stochastic infomation type */
1212  )
1213 {
1214  assert(stoi != NULL);
1215 
1216  stoi->stochinfotype = stochinfotype;
1217 }
1218 
1219 /** set the problem name in the sto input structure to given problem name */
1220 static
1222  STOINPUT* stoi, /**< sto input structure */
1223  const char* probname /**< name of the problem to set */
1224  )
1225 {
1226  assert(stoi != NULL);
1227  assert(probname != NULL);
1228  assert(strlen(probname) < sizeof(stoi->probname));
1229 
1230  (void)SCIPmemccpy(stoi->probname, probname, '\0', STO_MAX_NAMELEN - 1);
1231 }
1232 
1233 /** set the type name in the sto input structure to given objective name */
1234 static
1236  STOINPUT* stoi, /**< sto input structure */
1237  const char* stochtype /**< name of the scenario type */
1238  )
1239 {
1240  assert(stoi != NULL);
1241  assert(stochtype != NULL);
1242  assert(strlen(stochtype) < sizeof(stoi->stochtype));
1243 
1244  (void)SCIPmemccpy(stoi->stochtype, stochtype, '\0', STO_MAX_NAMELEN - 1);
1245 }
1246 
1247 static
1249  STOINPUT* stoi /**< sto input structure */
1250  )
1251 {
1252  assert(stoi != NULL);
1253 
1254  SCIPerrorMessage("Syntax error in line %d\n", stoi->lineno);
1255  stoi->section = STO_ENDATA;
1256  stoi->haserror = TRUE;
1257 }
1258 
1259 /** fill the line from \p pos up to column 80 with blanks. */
1260 static
1262  char* buf, /**< buffer to clear */
1263  unsigned int pos /**< position to start the clearing process */
1264  )
1265 {
1266  unsigned int i;
1267 
1268  for(i = pos; i < 80; i++)
1269  buf[i] = BLANK;
1270  buf[80] = '\0';
1271 }
1272 
1273 /** read a sto format data line and parse the fields. */
1274 static
1276  STOINPUT* stoi /**< sto input structure */
1277  )
1278 {
1279  unsigned int len;
1280  unsigned int i;
1281  char* s;
1282  SCIP_Bool is_marker;
1283  SCIP_Bool is_empty;
1284  char* nexttok;
1285 
1286  do
1287  {
1288  stoi->f0 = stoi->f1 = stoi->f2 = stoi->f3 = stoi->f4 = stoi->f5 = stoi->f6 = 0;
1289  is_marker = FALSE;
1290 
1291  /* Read until we have not a comment line. */
1292  do
1293  {
1294  stoi->buf[STO_MAX_LINELEN-1] = '\0';
1295  if( NULL == SCIPfgets(stoi->buf, (int) sizeof(stoi->buf), stoi->fp) )
1296  return FALSE;
1297  stoi->lineno++;
1298  }
1299  while( *stoi->buf == '*' ); /* coverity[a_loop_bound] */
1300 
1301  /* Normalize line */
1302  len = (unsigned int) strlen(stoi->buf);
1303 
1304  for( i = 0; i < len; i++ )
1305  {
1306  if( (stoi->buf[i] == '\t') || (stoi->buf[i] == '\n') || (stoi->buf[i] == '\r') )
1307  stoi->buf[i] = BLANK;
1308  }
1309 
1310  if( len < 80 )
1311  clearFrom(stoi->buf, len);
1312 
1313  SCIPdebugMessage("line %d: <%s>\n", stoi->lineno, stoi->buf);
1314 
1315  assert(strlen(stoi->buf) >= 80);
1316 
1317  /* Look for new section */
1318  if( *stoi->buf != BLANK )
1319  {
1320  stoi->f0 = SCIPstrtok(&stoi->buf[0], " ", &nexttok);
1321 
1322  assert(stoi->f0 != 0);
1323 
1324  stoi->f1 = SCIPstrtok(NULL, " ", &nexttok);
1325 
1326  return TRUE;
1327  }
1328 
1329  s = &stoi->buf[1];
1330 
1331  /* At this point it is not clear if we have a indicator field.
1332  * If there is none (e.g. empty) f1 will be the first name field.
1333  * If there is one, f2 will be the first name field.
1334  *
1335  * Initially comment marks '$' are only allowed in the beginning
1336  * of the 2nd and 3rd name field. We test all fields but the first.
1337  * This makes no difference, since if the $ is at the start of a value
1338  * field, the line will be erroneous anyway.
1339  */
1340  do
1341  {
1342  if( NULL == (stoi->f1 = SCIPstrtok(s, " ", &nexttok)) )
1343  break;
1344 
1345  if( (NULL == (stoi->f2 = SCIPstrtok(NULL, " ", &nexttok))) || (*stoi->f2 == '$') )
1346  {
1347  stoi->f2 = 0;
1348  break;
1349  }
1350 
1351  if( (NULL == (stoi->f3 = SCIPstrtok(NULL, " ", &nexttok))) || (*stoi->f3 == '$') )
1352  {
1353  stoi->f3 = 0;
1354  break;
1355  }
1356 
1357  if( (NULL == (stoi->f4 = SCIPstrtok(NULL, " ", &nexttok))) || (*stoi->f4 == '$') )
1358  {
1359  stoi->f4 = 0;
1360  break;
1361  }
1362 
1363  if( (NULL == (stoi->f5 = SCIPstrtok(NULL, " ", &nexttok))) || (*stoi->f5 == '$') )
1364  {
1365  stoi->f5 = 0;
1366  break;
1367  }
1368 
1369  if( (NULL == (stoi->f6 = SCIPstrtok(NULL, " ", &nexttok))) || (*stoi->f6 == '$') )
1370  stoi->f6 = 0;
1371  }
1372  while( FALSE );
1373 
1374  /* check for empty lines */
1375  is_empty = (stoi->f0 == NULL && stoi->f1 == NULL);
1376  }
1377  while( is_marker || is_empty );
1378 
1379  return TRUE;
1380 }
1381 
1382 /** Process STOCH section. */
1383 static
1385  SCIP* scip, /**< SCIP data structure */
1386  STOINPUT* stoi /**< sto input structure */
1387  )
1388 {
1389  assert(stoi != NULL);
1390 
1391  SCIPdebugMsg(scip, "read problem name\n");
1392 
1393  /* This has to be the Line with the NAME section. */
1394  if( !stoinputReadLine(stoi) || stoinputField0(stoi) == NULL || strcmp(stoinputField0(stoi), "STOCH") )
1395  {
1396  stoinputSyntaxerror(stoi);
1397  return SCIP_OKAY;
1398  }
1399 
1400  /* Sometimes the name is omitted. */
1401  stoinputSetProbname(stoi, (stoinputField1(stoi) == 0) ? "_STO_" : stoinputField1(stoi));
1402 
1403  /* This hat to be a new section */
1404  /* coverity[tainted_data] */
1405  if( !stoinputReadLine(stoi) || (stoinputField0(stoi) == NULL) )
1406  {
1407  stoinputSyntaxerror(stoi);
1408  return SCIP_OKAY;
1409  }
1410 
1411  /* setting the stochatic information section */
1412  if( !strncmp(stoinputField0(stoi), "BLOCKS", 6) )
1414  else if( !strncmp(stoinputField0(stoi), "SCENARIOS", 9) )
1416  else if( !strncmp(stoinputField0(stoi), "INDEP", 5) )
1418  else
1419  {
1420  stoinputSyntaxerror(stoi);
1421  return SCIP_OKAY;
1422  }
1423 
1424  /* setting the stochastic information type */
1425  if( !strncmp(stoinputField1(stoi), "DISCRETE", 8) )
1427  else if( !strncmp(stoinputField1(stoi), "UNIFORM", 7) )
1429  else if( !strncmp(stoinputField1(stoi), "NORMAL", 6) )
1431  else if( !strncmp(stoinputField1(stoi), "SUB", 3) )
1433  else if( !strncmp(stoinputField1(stoi), "LINTR", 5) )
1435  else
1436  {
1437  stoinputSyntaxerror(stoi);
1438  return SCIP_OKAY;
1439  }
1440 
1441  return SCIP_OKAY;
1442 }
1443 
1444 /** Process BLOCKS section. */
1445 static
1447  STOINPUT* stoi, /**< sto input structure */
1448  SCIP* scip, /**< SCIP data structure */
1449  SCIP_READERDATA* readerdata /**< the reader data */
1450  )
1451 {
1452  STOSCENARIO*** blocks;
1453  int numblocks;
1454  int* numblocksperblock;
1455  int blockssize;
1456  int* blocksperblocksize;
1457  char BL[] = "BL";
1458  int blocknum;
1459  int blockindex;
1460  int i;
1461  int j;
1462  char stagenames[SCIP_MAXSTRLEN];
1463  int numstages;
1464 
1465  SCIPdebugMsg(scip, "read Blocks\n");
1466 
1467  /* This has to be the Line with the name. */
1468  if( stoinputField1(stoi) == NULL )
1469  {
1470  stoinputSyntaxerror(stoi);
1471  return SCIP_OKAY;
1472  }
1473 
1474  stoinputSetStochtype(stoi, stoinputField1(stoi));
1475 
1476  /* initializing the block data */
1477  numblocks = 0;
1478  blockssize = STO_DEFAULT_ARRAYSIZE;
1480  SCIP_CALL( SCIPallocBlockMemoryArray(scip, &numblocksperblock, STO_DEFAULT_ARRAYSIZE) );
1481  SCIP_CALL( SCIPallocBlockMemoryArray(scip, &blocksperblocksize, STO_DEFAULT_ARRAYSIZE) );
1482 
1483  blockindex = 0;
1484  blocknum = 0;
1485 
1486  /* initializing the stage names record */
1487  numstages = 0;
1488  (void) SCIPsnprintf(stagenames, SCIP_MAXSTRLEN, "");
1489 
1490  /* coverity[tainted_data] */
1491  while( stoinputReadLine(stoi) )
1492  {
1493  if( stoinputField0(stoi) != NULL )
1494  {
1495  if( !strcmp(stoinputField0(stoi), "BLOCKS") )
1496  {
1498  if( strcmp(stoinputField1(stoi), "DISCRETE") )
1499  {
1500  SCIPerrorMessage("Sorry, %s blocks stucture is not currently supported.\n", stoinputField1(stoi));
1501  SCIPerrorMessage("Only DISCRETE blocks are supported.\n");
1502  goto TERMINATE;
1503  }
1504  }
1505  else if( !strcmp(stoinputField0(stoi), "ENDATA") )
1506  {
1507  SCIP_CALL( createScenariosFromBlocks(scip, readerdata, blocks, numblocks, numblocksperblock, numstages) );
1509  }
1510  else
1511  stoinputSyntaxerror(stoi);
1512 
1513  goto TERMINATE;
1514  }
1515 
1516  if( strcmp(stoinputField1(stoi), BL) == 0 )
1517  {
1518  SCIP_Bool foundblock = FALSE;
1519 
1520  /* checking whether the stage has been added previously */
1521  if( strstr(stagenames, stoinputField3(stoi)) == NULL )
1522  {
1523  /* recording the stage name as processed */
1524  (void) SCIPsnprintf(stagenames, SCIP_MAXSTRLEN, "%s_%s", stagenames, stoinputField3(stoi));
1525  numstages++;
1526  }
1527 
1528  /* determining whether a block name has previously been added */
1529  for( i = 0; i < numblocks; i++ )
1530  {
1531  if( strcmp(getScenarioName(blocks[i][0]), stoinputField2(stoi)) == 0 )
1532  {
1533  foundblock = TRUE;
1534  break;
1535  }
1536  }
1537  blocknum = i;
1538 
1539  /* if the block is found, then the memory for the blocks array must be ensured */
1540  if( foundblock )
1541  {
1542  /* ensuring enough memory is available for the blocks */
1543  if( numblocksperblock[blocknum] + 1 > blocksperblocksize[blocknum] )
1544  {
1545  int newsize;
1546  newsize = SCIPcalcMemGrowSize(scip, numblocksperblock[blocknum] + 1);
1547  SCIP_CALL( SCIPreallocBlockMemoryArray(scip, &blocks[blocknum], blocksperblocksize[blocknum], newsize) ); /*lint !e866*/
1548  blocksperblocksize[blocknum] = newsize;
1549  }
1550  }
1551  else
1552  {
1553  /* ensuring enough memory is available for the blocks */
1554  if( numblocks + 1 > blockssize )
1555  {
1556  int newsize;
1557  newsize = SCIPcalcMemGrowSize(scip, numblocks + 1);
1558  SCIP_CALL( SCIPreallocBlockMemoryArray(scip, &blocks, blockssize, newsize) );
1559  SCIP_CALL( SCIPreallocBlockMemoryArray(scip, &numblocksperblock, blockssize, newsize) );
1560  SCIP_CALL( SCIPreallocBlockMemoryArray(scip, &blocksperblocksize, blockssize, newsize) );
1561  blockssize = newsize;
1562  }
1563 
1564  blocksperblocksize[blocknum] = STO_DEFAULT_BLOCKARRAYSIZE;
1565  numblocksperblock[blocknum] = 0;
1566  SCIP_CALL( SCIPallocBlockMemoryArray(scip, &blocks[blocknum], blocksperblocksize[blocknum]) );
1567  }
1568 
1569  blockindex = numblocksperblock[blocknum];
1570 
1571  /* creating the scenario data structure */
1572  SCIP_CALL( createScenarioData(scip, &blocks[blocknum][blockindex]) );
1573 
1574  SCIP_CALL( setScenarioName(scip, blocks[blocknum][blockindex], stoinputField2(stoi)) );
1575  SCIP_CALL( setScenarioStageName(scip, blocks[blocknum][blockindex], stoinputField3(stoi)) );
1576  SCIP_CALL( setScenarioProbability(scip, blocks[blocknum][blockindex], atof(stoinputField4(stoi))) );
1577  numblocksperblock[blocknum]++;
1578 
1579  if( !foundblock )
1580  numblocks++;
1581  }
1582  else
1583  {
1584  SCIP_CALL( addScenarioEntry(scip, blocks[blocknum][blockindex], stoinputField2(stoi), stoinputField1(stoi),
1585  atof(stoinputField3(stoi))) );
1586  }
1587  }
1588  stoinputSyntaxerror(stoi);
1589 
1590 TERMINATE:
1591 
1592  /* releasing the scenario data */
1593  for( i = numblocks - 1; i >= 0; i-- )
1594  {
1595  for( j = numblocksperblock[i] - 1; j >= 0; j-- )
1596  SCIP_CALL( freeScenarioTree(scip, &blocks[i][j]) );
1597  }
1598 
1599  for( i = numblocks - 1; i >= 0; i-- )
1600  SCIPfreeBlockMemoryArray(scip, &blocks[i], blocksperblocksize[i]);
1601  SCIPfreeBlockMemoryArray(scip, &blocksperblocksize, blockssize);
1602  SCIPfreeBlockMemoryArray(scip, &numblocksperblock, blockssize);
1603  SCIPfreeBlockMemoryArray(scip, &blocks, blockssize);
1604 
1605  return SCIP_OKAY;
1606 }
1607 
1608 
1609 /** Process SCENARIOS section. */
1610 static
1612  STOINPUT* stoi, /**< sto input structure */
1613  SCIP* scip, /**< SCIP data structure */
1614  SCIP_READERDATA* readerdata /**< the reader data */
1615  )
1616 {
1617  STOSCENARIO* scenario;
1618  char SC[] = "SC";
1619  char wrongroot[] = "\'ROOT\'";
1620  char parentname[SCIP_MAXSTRLEN];
1621  char scennames[SCIP_MAXSTRLEN];
1622  char tmpname[SCIP_MAXSTRLEN];
1623  int numscenarios;
1624  SCIP_Bool addscenario;
1625 
1626  SCIPdebugMsg(scip, "read SCENARIOS\n");
1627 
1628  /* This has to be the Line with the name. */
1629  if( stoinputField1(stoi) == NULL )
1630  {
1631  stoinputSyntaxerror(stoi);
1632  return SCIP_OKAY;
1633  }
1634 
1635  stoinputSetStochtype(stoi, stoinputField1(stoi));
1636 
1637  /* initializing the scen names record */
1638  numscenarios = 0;
1639  (void) SCIPsnprintf(scennames, SCIP_MAXSTRLEN, "ROOT");
1640 
1641  scenario = NULL;
1642  addscenario = FALSE;
1643 
1644  /* initializing the root scenario in the reader data */
1645  SCIP_CALL( setScenarioNum(scip, readerdata->scenariotree, 0) );
1646  SCIP_CALL( setScenarioStageNum(scip, readerdata->scenariotree, 0) );
1647 
1648  /* coverity[tainted_data] */
1649  while( stoinputReadLine(stoi) )
1650  {
1651  if( stoinputField0(stoi) != NULL )
1652  {
1653  /* if a scenario has been created that needs to be added to the scenario tree */
1654  if( addscenario )
1655  {
1656  SCIP_CALL( insertScenarioInReaderdata(scip, readerdata, scenario, parentname) );
1657 
1658  /* freeing the scenario */
1659  SCIP_CALL( freeScenarioTree(scip, &scenario) );
1660  }
1661 
1662  if( !strcmp(stoinputField0(stoi), "SCENARIOS") )
1663  {
1665  if( strcmp(stoinputField1(stoi), "DISCRETE") )
1666  {
1667  SCIPerrorMessage("Sorry, %s scenarios is not currently supported.\n", stoinputField1(stoi));
1668  SCIPerrorMessage("Only DISCRETE scenarios are supported.\n");
1669  goto TERMINATE;
1670  }
1671  }
1672  else if( !strcmp(stoinputField0(stoi), "ENDATA") )
1674  else
1675  stoinputSyntaxerror(stoi);
1676 
1677  goto TERMINATE;
1678  }
1679 
1680  if( strcmp(stoinputField1(stoi), SC) == 0 )
1681  {
1682  int stagenum;
1683 
1684  /* if a scenario has been created that needs to be added to the scenario tree */
1685  if( addscenario )
1686  {
1687  SCIP_CALL( insertScenarioInReaderdata(scip, readerdata, scenario, parentname) );
1688 
1689  /* freeing the scenario */
1690  SCIP_CALL( freeScenarioTree(scip, &scenario) );
1691  assert(scenario == NULL);
1692  }
1693 
1694  if( strcmp(wrongroot, stoinputField3(stoi)) == 0 )
1695  (void) SCIPsnprintf(parentname, SCIP_MAXSTRLEN, "%s", "ROOT");
1696  else
1697  (void) SCIPsnprintf(parentname, SCIP_MAXSTRLEN, "%s", stoinputField3(stoi));
1698 
1699  /* checking whether the stage has been added previously */
1700  if( strstr(scennames, stoinputField2(stoi)) == NULL )
1701  {
1702  /* recording the stage name as processed */
1703  (void) SCIPsnprintf(tmpname, SCIP_MAXSTRLEN, "%s_%s", scennames, stoinputField2(stoi));
1704  (void) SCIPsnprintf(scennames, SCIP_MAXSTRLEN, "%s", tmpname);
1705  }
1706 
1707  /* checking whether the "common" scenario has been added yet */
1708  if( strstr(scennames, parentname) == NULL )
1709  {
1710  SCIPerrorMessage("Scenario <%s> needs to be read before scenario <%s>\n", parentname, stoinputField2(stoi));
1711  stoinputSyntaxerror(stoi);
1712  goto TERMINATE;
1713  }
1714 
1715  /* the "common" scenario has been added before, so a child can be added to the scenario tree */
1716  SCIP_CALL( createScenarioData(scip, &scenario) );
1717 
1718  SCIP_CALL( setScenarioName(scip, scenario, stoinputField2(stoi)) );
1719  SCIP_CALL( setScenarioStageName(scip, scenario, stoinputField5(stoi)) );
1720  SCIP_CALL( setScenarioNum(scip, scenario, numscenarios) );
1721 
1722  stagenum = SCIPtimFindStage(scip, stoinputField5(stoi));
1723  if( stagenum < 0 )
1724  {
1725  stoinputSyntaxerror(stoi);
1726  goto TERMINATE;
1727  }
1728  SCIP_CALL( setScenarioStageNum(scip, scenario, stagenum) );
1729  SCIP_CALL( setScenarioProbability(scip, scenario, atof(stoinputField4(stoi))) );
1730  if( stoinputField6(stoi) != NULL )
1731  {
1732  SCIP_CALL( setScenarioLowerbound(scip, scenario, atof(stoinputField6(stoi))) );
1733  }
1734 
1735  numscenarios++;
1736  addscenario = TRUE;
1737  }
1738  else if( addscenario )
1739  {
1740  SCIP_CALL( addScenarioEntry(scip, scenario, stoinputField2(stoi), stoinputField1(stoi),
1741  atof(stoinputField3(stoi))) );
1742  }
1743  }
1744  stoinputSyntaxerror(stoi);
1745 
1746 TERMINATE:
1747 
1748  return SCIP_OKAY;
1749 }
1750 
1751 
1752 /** Process INDEP section. */
1753 static
1755  STOINPUT* stoi, /**< sto input structure */
1756  SCIP* scip, /**< SCIP data structure */
1757  SCIP_READERDATA* readerdata /**< the reader data */
1758  )
1759 {
1760  STOSCENARIO*** blocks;
1761  int numblocks;
1762  int* numblocksperblock;
1763  int blockssize;
1764  int* blocksperblocksize;
1765  int blocknum;
1766  int blockindex;
1767  int i;
1768  int j;
1769  char stagenames[SCIP_MAXSTRLEN];
1770  int numstages;
1771  SCIP_Bool foundblock;
1772 
1773  SCIP_Real probability;
1774  char currstagename[SCIP_MAXSTRLEN];
1775 
1776  SCIPdebugMsg(scip, "read Indep\n");
1777 
1778  /* This has to be the Line with the name. */
1779  if( stoinputField1(stoi) == NULL )
1780  {
1781  stoinputSyntaxerror(stoi);
1782  return SCIP_OKAY;
1783  }
1784 
1785  stoinputSetStochtype(stoi, stoinputField1(stoi));
1786 
1787  /* initializing the block data */
1788  numblocks = 0;
1789  blockssize = STO_DEFAULT_ARRAYSIZE;
1791  SCIP_CALL( SCIPallocBlockMemoryArray(scip, &numblocksperblock, STO_DEFAULT_ARRAYSIZE) );
1792  SCIP_CALL( SCIPallocBlockMemoryArray(scip, &blocksperblocksize, STO_DEFAULT_ARRAYSIZE) );
1793 
1794  /* initializing the stage names record */
1795  numstages = 0;
1796  (void) SCIPsnprintf(stagenames, SCIP_MAXSTRLEN, "");
1797 
1798  while( stoinputReadLine(stoi) )
1799  {
1800  if( stoinputField0(stoi) != NULL )
1801  {
1802  if( !strcmp(stoinputField0(stoi), "INDEP") )
1803  {
1805  }
1806  else if( !strcmp(stoinputField0(stoi), "ENDATA") )
1807  {
1808  SCIP_CALL( createScenariosFromBlocks(scip, readerdata, blocks, numblocks, numblocksperblock, numstages) );
1810  }
1811  else
1812  stoinputSyntaxerror(stoi);
1813 
1814  goto TERMINATE;
1815  }
1816 
1817  /* if the 5th input is NULL, then the 4th input is the probability. Otherwise, the 4th input is the stage name and
1818  * the 5th input is the probability. The stage name is redundant information, but sometimes included for more
1819  * information.
1820  */
1821  if( stoinputField5(stoi) == NULL )
1822  {
1823  probability = atof(stoinputField4(stoi));
1824  (void) SCIPsnprintf(currstagename, SCIP_MAXSTRLEN, "%s", SCIPtimConsGetStageName(scip, stoinputField2(stoi)));
1825  }
1826  else
1827  {
1828  probability = atof(stoinputField5(stoi));
1829  (void) SCIPsnprintf(currstagename, SCIP_MAXSTRLEN, "%s", stoinputField4(stoi));
1830  }
1831 
1832  /* checking whether the stage has been added previously */
1833  if( strstr(stagenames, currstagename) == NULL )
1834  {
1835  /* recording the stage name as processed */
1836  (void) SCIPsnprintf(stagenames, SCIP_MAXSTRLEN, "%s_%s", stagenames, currstagename);
1837 
1838  numstages++;
1839  }
1840 
1841  foundblock = FALSE;
1842 
1843  /* determining whether a block name has previously been added */
1844  for( i = 0; i < numblocks; i++ )
1845  {
1846  if( strcmp(getScenarioName(blocks[i][0]), stoinputField2(stoi)) == 0 )
1847  {
1848  foundblock = TRUE;
1849  break;
1850  }
1851  }
1852  blocknum = i;
1853 
1854  /* if the block is found, then the memory for the blocks array must be ensured */
1855  if( foundblock )
1856  {
1857  /* ensuring enough memory is available for the blocks */
1858  if( numblocksperblock[blocknum] + 1 > blocksperblocksize[blocknum] )
1859  {
1860  int newsize;
1861  newsize = SCIPcalcMemGrowSize(scip, numblocksperblock[blocknum] + 1);
1862  SCIP_CALL( SCIPreallocBlockMemoryArray(scip, &blocks[blocknum], blocksperblocksize[blocknum], newsize) ); /*lint !e866*/
1863  blocksperblocksize[blocknum] = newsize;
1864  }
1865  }
1866  else
1867  {
1868  /* ensuring enough memory is available for the blocks */
1869  if( numblocks + 1 > blockssize )
1870  {
1871  int newsize;
1872  newsize = SCIPcalcMemGrowSize(scip, numblocks + 1);
1873  SCIP_CALL( SCIPreallocBlockMemoryArray(scip, &blocks, blockssize, newsize) );
1874  SCIP_CALL( SCIPreallocBlockMemoryArray(scip, &numblocksperblock, blockssize, newsize) );
1875  SCIP_CALL( SCIPreallocBlockMemoryArray(scip, &blocksperblocksize, blockssize, newsize) );
1876  blockssize = newsize;
1877  }
1878 
1879  blocksperblocksize[blocknum] = STO_DEFAULT_BLOCKARRAYSIZE;
1880  numblocksperblock[blocknum] = 0;
1881  SCIP_CALL( SCIPallocBlockMemoryArray(scip, &blocks[blocknum], blocksperblocksize[blocknum]) );
1882  }
1883 
1884  blockindex = numblocksperblock[blocknum];
1885 
1886  /* creating the scenario data structure */
1887  SCIP_CALL( createScenarioData(scip, &blocks[blocknum][blockindex]) );
1888 
1889  SCIP_CALL( setScenarioName(scip, blocks[blocknum][blockindex], stoinputField2(stoi)) );
1890  SCIP_CALL( setScenarioStageName(scip, blocks[blocknum][blockindex], currstagename) );
1891  SCIP_CALL( setScenarioProbability(scip, blocks[blocknum][blockindex], probability) );
1892  numblocksperblock[blocknum]++;
1893 
1894  if( !foundblock )
1895  numblocks++;
1896 
1897  SCIP_CALL( addScenarioEntry(scip, blocks[blocknum][blockindex], stoinputField2(stoi), stoinputField1(stoi),
1898  atof(stoinputField3(stoi))) );
1899  }
1900  stoinputSyntaxerror(stoi);
1901 
1902 TERMINATE:
1903 
1904  /* releasing the scenario data */
1905  for( i = numblocks - 1; i >= 0; i-- )
1906  {
1907  for( j = numblocksperblock[i] - 1; j >= 0; j-- )
1908  SCIP_CALL( freeScenarioTree(scip, &blocks[i][j]) );
1909  }
1910 
1911  for( i = numblocks - 1; i >= 0; i-- )
1912  SCIPfreeBlockMemoryArray(scip, &blocks[i], blocksperblocksize[i]);
1913  SCIPfreeBlockMemoryArray(scip, &blocksperblocksize, blockssize);
1914  SCIPfreeBlockMemoryArray(scip, &numblocksperblock, blockssize);
1915  SCIPfreeBlockMemoryArray(scip, &blocks, blockssize);
1916 
1917  return SCIP_OKAY;
1918 }
1919 
1920 
1921 /** computes the probability of a scenario */
1922 static
1924  SCIP* scip, /**< the SCIP data structure */
1925  STOSCENARIO* scenario /**< the current scenario */
1926  )
1927 {
1928  STOSCENARIO* checkscen;
1929  SCIP_Real probability;
1930 
1931  assert(scip != NULL);
1932  assert(scenario != NULL);
1933 
1934  /* computing the probability for the scenario */
1935  checkscen = scenario;
1936  probability = 1;
1937  while( checkscen != NULL )
1938  {
1939  probability *= getScenarioProbability(scip, checkscen);
1940  checkscen = getScenarioParent(checkscen);
1941  }
1942 
1943  return probability;
1944 }
1945 
1946 /** gets the variable name */
1947 static
1949  char* name, /**< the name to be returned */
1950  const char* varname, /**< the root of the variable name */
1951  int stagenum, /**< the stage number */
1952  int scenarionum /**< the scenario number */
1953  )
1954 {
1955  if( stagenum < 0 )
1956  (void) SCIPsnprintf(name, SCIP_MAXSTRLEN, "%s_00_%d", varname, scenarionum);
1957  else
1958  (void) SCIPsnprintf(name, SCIP_MAXSTRLEN, "%s_%d_%d", varname, stagenum, scenarionum);
1959 }
1960 
1961 
1962 /** add variables to the scenario */
1963 static
1965  SCIP* scip, /**< the SCIP data structure */
1966  STOSCENARIO* scenario, /**< the current scenario */
1967  SCIP_HASHMAP* varmap, /**< the variable map from the original to the subproblem variables */
1968  SCIP_VAR** vars, /**< the variables of the core problem associated with this scenario */
1969  int nvars /**< the number of variables for this scenario */
1970  )
1971 {
1972  SCIP_Real probability;
1973  int i;
1974  char name[SCIP_MAXSTRLEN];
1975 
1976  assert(scip != NULL);
1977  assert(scenario != NULL);
1978  assert(vars != NULL);
1979 
1980  /* computing the probability for the scenario */
1981  probability = computeScenarioProbability(scip, scenario);
1982 
1983  for( i = 0; i < nvars; i++ )
1984  {
1985  SCIP_VAR* var;
1986  SCIP_Real obj;
1987  SCIP_VARTYPE vartype;
1988 
1989  SCIPdebugMessage("Original problem variable <%s> is being duplicated for scenario %d\n", SCIPvarGetName(vars[i]),
1990  getScenarioNum(scip, scenario));
1991 
1992  if( SCIPvarIsDeleted(vars[i]) )
1993  continue;
1994 
1995  obj = SCIPvarGetObj(vars[i])*probability;
1996 
1997  vartype = SCIPvarGetType(vars[i]);
1998 
1999  /* creating a variable as a copy of the original variable. */
2000  getScenarioEntityName(name, SCIPvarGetName(vars[i]), getScenarioStageNum(scip, scenario), getScenarioNum(scip, scenario));
2001  SCIP_CALL( SCIPcreateVar(scip, &var, name, SCIPvarGetLbOriginal(vars[i]), SCIPvarGetUbOriginal(vars[i]),
2002  obj, vartype, SCIPvarIsInitial(vars[i]), SCIPvarIsRemovable(vars[i]), NULL, NULL, NULL,
2003  NULL, NULL) );
2004 
2005  SCIPdebugMessage("Adding variable <%s>\n", name);
2006 
2007  SCIP_CALL( SCIPaddVar(scip, var) );
2008 
2009  /* inserting the scenario variable into the hashmap */
2010  SCIP_CALL( SCIPhashmapInsert(varmap, vars[i], var) );
2011 
2012  SCIP_CALL( SCIPreleaseVar(scip, &var) );
2013  }
2014 
2015  return SCIP_OKAY;
2016 }
2017 
2018 
2019 /** finds the scenario variable to add to a constraint */
2020 static
2022  SCIP* scip, /**< the SCIP data structure */
2023  STOSCENARIO* scenario, /**< the current scenario */
2024  SCIP_VAR* consvar, /**< the variable in the constraint that is being searched for */
2025  SCIP_VAR** scenariovar /**< pointer to return the variable to be added to the constraint */
2026  )
2027 {
2028  STOSCENARIO* checkscen;
2029  char varname[SCIP_MAXSTRLEN];
2030 
2031  assert(scip != NULL);
2032  assert(scenario != NULL);
2033  assert(consvar != NULL);
2034  assert(scenariovar != NULL);
2035 
2036  (*scenariovar) = NULL;
2037 
2038  checkscen = scenario;
2039 
2040  /* NOTE: if the variable does not exist, then we need to search the preceding scenarios. In the case of
2041  * decomposition, then we only check the preceding scenario. As such, a check count is used to limit the number
2042  * of scenario checks. */
2043  while( (*scenariovar) == NULL )
2044  {
2045  assert(checkscen != NULL);
2046  if( getScenarioStageNum(scip, checkscen) == 0 )
2047  (void) SCIPsnprintf(varname, SCIP_MAXSTRLEN, "%s", SCIPvarGetName(consvar));
2048  else
2049  getScenarioEntityName(varname, SCIPvarGetName(consvar), getScenarioStageNum(scip, checkscen),
2050  getScenarioNum(scip, checkscen));
2051 
2052  (*scenariovar) = SCIPfindVar(scip, varname);
2053 
2054  checkscen = getScenarioParent(checkscen);
2055  }
2056 
2057  if( (*scenariovar) == NULL )
2058  {
2059  SCIPerrorMessage("There is no scenario variable could be found.\n");
2060  return SCIP_READERROR;
2061  }
2062 
2063  return SCIP_OKAY;
2064 }
2065 
2066 
2067 /** create variable for the decomposed scenario */
2068 static
2070  SCIP* scip, /**< the SCIP data structure */
2071  STOSCENARIO* scenario, /**< the current scenario */
2072  SCIP_VAR* consvar, /**< the variable in the constraint that is being searched for */
2073  SCIP_VAR** scenariovar, /**< pointer to return the variable to be added to the constraint */
2074  SCIP_Bool* varadded /**< pointer to indicate whether a variable has been added */
2075  )
2076 {
2077  STOSCENARIO* checkscen;
2078  SCIP_VAR* searchvar;
2079  int checkcount;
2080  char varname[SCIP_MAXSTRLEN];
2081 
2082  assert(scip != NULL);
2083  assert(scenario != NULL);
2084  assert(consvar != NULL);
2085 
2086  (*varadded) = FALSE;
2087 
2088  /* finding the scenario that the consvar belongs to */
2089  checkscen = scenario;
2090  searchvar = NULL;
2091  checkcount = 0;
2092  while( searchvar == NULL && checkcount < 2 )
2093  {
2094  assert(checkscen != NULL);
2095  if( getScenarioStageNum(scip, checkscen) == 0 )
2096  (void) SCIPsnprintf(varname, SCIP_MAXSTRLEN, "%s", SCIPvarGetName(consvar));
2097  else
2098  getScenarioEntityName(varname, SCIPvarGetName(consvar), getScenarioStageNum(scip, checkscen),
2099  getScenarioNum(scip, checkscen));
2100 
2101  /* first checking whether the variable is included in the scenario */
2102  searchvar = SCIPfindVar(scip, varname);
2103  if( searchvar != NULL )
2104  {
2105  (*scenariovar) = searchvar;
2106  return SCIP_OKAY;
2107  }
2108 
2109  searchvar = SCIPfindVar(getScenarioScip(checkscen), varname);
2110 
2111  checkscen = getScenarioParent(checkscen);
2112  checkcount++;
2113  }
2114 
2115  if( searchvar != NULL )
2116  {
2117  SCIP_VAR* var;
2118  /* creating a variable as a copy of the original variable. */
2119  SCIP_CALL( SCIPcreateVar(scip, &var, varname, SCIPvarGetLbOriginal(searchvar), SCIPvarGetUbOriginal(searchvar),
2120  0.0, SCIPvarGetType(searchvar), SCIPvarIsInitial(searchvar), SCIPvarIsRemovable(searchvar), NULL, NULL,
2121  NULL, NULL, NULL) );
2122 
2123  SCIP_CALL( SCIPaddVar(scip, var) );
2124 
2125  (*scenariovar) = var;
2126  (*varadded) = TRUE;
2127  }
2128 
2129  return SCIP_OKAY;
2130 }
2131 
2132 
2133 /** adds the constraint to the scenario problem */
2134 static
2136  SCIP* scip, /**< the SCIP data structure */
2137  SCIP* scenarioscip, /**< the scenario SCIP data structure */
2138  STOSCENARIO* scenario, /**< the current scenario */
2139  SCIP_HASHMAP* varmap, /**< the variable map from the original to the subproblem variables */
2140  SCIP_CONS** conss, /**< the constraints of the core problem associated with this scenario */
2141  int nconss, /**< the number of constraints for this scenario */
2142  SCIP_Bool decomp /**< is the problem being decomposed */
2143  )
2144 {
2145  int i;
2146  int j;
2147  char name[SCIP_MAXSTRLEN];
2148  SCIP_Bool varadded;
2149 
2150  assert(scip != NULL);
2151  assert(scenarioscip != NULL);
2152  assert(scenario != NULL);
2153  assert(conss != NULL);
2154 
2155  /* Add constraints */
2156  /* NOTE: It is assumed that the problems only have linear constraints */
2157  for( i = 0; i < nconss; i++ )
2158  {
2159  SCIP_CONS* cons;
2160  SCIP_VAR** consvars = NULL;
2161  int nconsvars;
2162  SCIP_Bool success1 = TRUE;
2163  SCIP_Bool success2 = TRUE;
2164 
2165  if( SCIPconsIsDeleted(conss[i]) )
2166  continue;
2167 
2168  /* getting the number of variables in the constraints */
2169  SCIP_CALL( SCIPgetConsNVars(scip, conss[i], &nconsvars, &success1) );
2170 
2171  if( success1 )
2172  {
2173  SCIP_CALL( SCIPallocBufferArray(scip, &consvars, nconsvars) );
2174  SCIP_CALL( SCIPgetConsVars(scip, conss[i], consvars, nconsvars, &success2) );
2175 
2176  /* If the get variable callback is not implemented for the constraint, then the success flag will be returned
2177  * as FALSE. In this case, it is not possible to build the stochastic program, so an error will be returned.
2178  */
2179  if( !success2 )
2180  {
2181  SCIPfreeBufferArrayNull(scip, consvars);
2182  }
2183  }
2184 
2185  if( !success1 || !success2 )
2186  {
2187  SCIPerrorMessage("It is not possible to copy constraint <%s>. The stochastic program can not be built.\n",
2188  SCIPconsGetName(conss[i]));
2189 
2190  return SCIP_READERROR;
2191  }
2192 
2193  assert(consvars != NULL);
2194  for( j = 0; j < nconsvars; j++ )
2195  {
2196  SCIP_VAR* scenariovar;
2197 
2198  scenariovar = NULL;
2199 
2200  varadded = FALSE;
2201 
2202  if( decomp )
2203  SCIP_CALL( getScenarioDecompVar(scenarioscip, scenario, consvars[j], &scenariovar, &varadded) );
2204  else
2205  SCIP_CALL( findScenarioVar(scenarioscip, scenario, consvars[j], &scenariovar) );
2206 
2207  if( scenariovar != NULL )
2208  {
2209  /* checking whether the variable is in the variable hashmap. If it doesn't exist, then it is added to the
2210  * variable hashmap
2211  */
2212  if( !SCIPhashmapExists(varmap, consvars[j]) )
2213  {
2214  SCIP_CALL( SCIPhashmapInsert(varmap, consvars[j], scenariovar) );
2215  }
2216  }
2217 
2218  if( varadded )
2219  {
2220  SCIP_CALL( SCIPreleaseVar(scenarioscip, &scenariovar) );
2221  }
2222  }
2223 
2224  /* creating a linear constraint as a copy of the original constraint. */
2225  getScenarioEntityName(name, SCIPconsGetName(conss[i]), getScenarioStageNum(scip, scenario), getScenarioNum(scip, scenario));
2226 
2227  /* copying the constraint from the original SCIP to the stochastic program */
2228  SCIP_CALL( SCIPgetConsCopy(scip, scenarioscip, conss[i], &cons, SCIPconsGetHdlr(conss[i]), varmap, NULL, name,
2229  SCIPconsIsInitial(conss[i]), SCIPconsIsSeparated(conss[i]), SCIPconsIsEnforced(conss[i]),
2230  SCIPconsIsChecked(conss[i]), SCIPconsIsMarkedPropagate(conss[i]), SCIPconsIsLocal(conss[i]),
2231  SCIPconsIsModifiable(conss[i]), SCIPconsIsDynamic(conss[i]), SCIPconsIsRemovable(conss[i]),
2232  SCIPconsIsStickingAtNode(conss[i]), TRUE, &success1) );
2233 
2234  /* freeing the cons vars buffer array */
2235  SCIPfreeBufferArray(scip, &consvars);
2236 
2237  /* if the copy failed, then the scenarios can not be created. */
2238  if( !success1 )
2239  {
2240  SCIPerrorMessage("It is not possible to copy constraint <%s>. The stochastic program can not be built.\n",
2241  SCIPconsGetName(conss[i]));
2242  return SCIP_READERROR;
2243  }
2244 
2245  SCIP_CALL( SCIPaddCons(scenarioscip, cons) );
2246  SCIP_CALL( SCIPreleaseCons(scenarioscip, &cons) );
2247  }
2248 
2249  return SCIP_OKAY;
2250 }
2251 
2252 /** add variables and constraint to problem */
2253 static
2255  SCIP* scip, /**< the SCIP data structure of master problem */
2256  STOSCENARIO* scenario, /**< the current scenario */
2257  SCIP_Bool decomp /**< is the problem being decomposed */
2258  )
2259 {
2260  SCIP* scenarioscip;
2261  SCIP_BENDERS* benders;
2262  SCIP_HASHMAP* varmap;
2263  SCIP_CONS** conss;
2264  SCIP_VAR** vars;
2265  SCIP_Real probability;
2266  int nconss;
2267  int nvars;
2268  int nmastervars;
2269  int nentries;
2270  int stagenum;
2271  int i;
2272  char name[SCIP_MAXSTRLEN];
2273 
2274  assert(scip != NULL);
2275  assert(scenario != NULL);
2276 
2277  stagenum = SCIPtimFindStage(scip, getScenarioStageName(scip, scenario));
2278  if( stagenum < 0 || stagenum >= SCIPtimGetNStages(scip) )
2279  {
2280  SCIPerrorMessage("Unable to build stochastic program - stage <%s> was not found\n",
2281  getScenarioStageName(scip, scenario));
2282  return SCIP_READERROR;
2283  }
2284 
2285  SCIPdebugMessage("Creating scenario at stage <%d>. Scenario: %d Stage: %d\n", stagenum, getScenarioNum(scip, scenario),
2286  getScenarioStageNum(scip, scenario));
2287 
2288  conss = SCIPtimGetStageConss(scip, stagenum);
2289  nconss = SCIPtimGetStageNConss(scip, stagenum);
2290  vars = SCIPtimGetStageVars(scip, stagenum);
2291  nvars = SCIPtimGetStageNVars(scip, stagenum);
2292 
2293  nmastervars = SCIPgetNVars(scip);
2294 
2295  /* this if 0 will be removed when the stochastic reader is merged with the Benders' branch */
2296  if( decomp )
2297  {
2298  SCIP_CALL( SCIPcreate(&scenarioscip) );
2299 
2300  getScenarioEntityName(name, SCIPgetProbName(scip), getScenarioStageNum(scip, scenario), getScenarioNum(scip, scenario));
2301 
2302  /* creating the problem */
2303  SCIP_CALL( SCIPcreateProbBasic(scenarioscip, name) );
2304 
2305  /* we explicitly enable the use of a debug solution for this main SCIP instance */
2306  SCIPenableDebugSol(scenarioscip);
2307 
2308  /* include default SCIP plugins */
2309  SCIP_CALL( SCIPincludeDefaultPlugins(scenarioscip) );
2310 
2311  /* activating the Benders' constraint handler for the scenario stages.
2312  * TODO: consider whether the two-phase method should be activated by default in the scenario stages.
2313  */
2314  SCIP_CALL( SCIPsetBoolParam(scenarioscip, "constraints/benders/active", TRUE) );
2315 
2316  /* allocating memory for the subproblems */
2317  if( getScenarioNChildren(scenario) > 0 )
2318  SCIP_CALL( createScenarioSubproblemArray(scip, scenario) );
2319  }
2320  else
2321  scenarioscip = scip;
2322 
2323  /* adding the scenarioscip to the scenario */
2324  setScenarioScip(scenario, scenarioscip);
2325 
2326  /* creating the variable hashmap to copy the constraints */
2327  SCIP_CALL( SCIPhashmapCreate(&varmap, SCIPblkmem(scenarioscip), nmastervars) );
2328 
2329  /* adding the variables to the scenario */
2330  SCIP_CALL( addScenarioVarsToProb(scenarioscip, scenario, varmap, vars, nvars) );
2331 
2332  /* adding the constraints to the scenario */
2333  SCIP_CALL( addScenarioConsToProb(scip, scenarioscip, scenario, varmap, conss, nconss, decomp) );
2334 
2335  /* destroying the hashmap */
2336  SCIPhashmapFree(&varmap);
2337 
2338  /* add the variables and constraints of the child scenarios */
2339  for( i = 0; i < getScenarioNChildren(scenario); i++ )
2340  {
2341  /* the master SCIP is always passed to the recursive function. The scenario SCIP instances are generated in the
2342  * function call. */
2343  SCIP_CALL( addScenarioVarsAndConsToProb(scip, getScenarioChild(scenario, i), decomp) );
2344  if( decomp )
2345  addScenarioSubproblem(scenario, getScenarioScip(getScenarioChild(scenario, i)));
2346  }
2347 
2348  /* adding the Benders' decomposition */
2349  if( decomp && getScenarioNChildren(scenario) > 0 )
2350  {
2352 
2353  /* getting the default Benders' decomposition */
2354  benders = SCIPfindBenders(scenarioscip, "default");
2355 
2356  /* updating the lower bounds for the subproblems */
2357  for( i = 0; i < getScenarioNChildren(scenario); i++ )
2359  getScenarioLowerbound(scenarioscip, getScenarioChild(scenario, i)));
2360  }
2361 
2362  /* computing the probability for the scenario */
2363  probability = computeScenarioProbability(scenarioscip, scenario);
2364 
2365  /* change the constraints for the given scenario */
2366  nentries = getScenarioNEntries(scenario);
2367  for( i = 0; i < nentries; i++ )
2368  {
2369  SCIP_CONS* cons;
2370  SCIP_VAR* var;
2371  char RHS[] = "RHS";
2372  char rhs[] = "rhs";
2373  char RIGHT[] = "RIGHT";
2374  char MINI[] = "MINI";
2375  char obj[] = "obj";
2376  char OBJ[] = "OBJ";
2377 
2378  /* finding the constraint associated with the row */
2379  getScenarioEntityName(name, getScenarioEntryRow(scenario, i), getScenarioStageNum(scenarioscip, scenario),
2380  getScenarioNum(scenarioscip, scenario));
2381  cons = SCIPfindCons(scenarioscip, name);
2382 
2383  if( strncmp(getScenarioEntryCol(scenario, i), RHS, 3) == 0 ||
2384  strncmp(getScenarioEntryCol(scenario, i), rhs, 3) == 0 ||
2385  strcmp(getScenarioEntryCol(scenario, i), RIGHT) == 0 )
2386  {
2387  /* if the constraint is NULL, then it is not possible to make any changes to the scenario */
2388  if( cons == NULL )
2389  {
2390  SCIPerrorMessage("There is no constraint <%s> in the current scenario.\n", name);
2391  return SCIP_READERROR;
2392  }
2393 
2394  /* if the constraint is an equality constraint, then the LHS must also be changed */
2395  if( SCIPgetLhsLinear(scenarioscip, cons) >= SCIPgetRhsLinear(scenarioscip, cons) )
2396  {
2397  SCIP_CALL( SCIPchgLhsLinear(scenarioscip, cons, getScenarioEntryValue(scenario, i)) );
2398  SCIP_CALL( SCIPchgRhsLinear(scenarioscip, cons, getScenarioEntryValue(scenario, i)) );
2399  }
2400  else if( SCIPisLT(scenarioscip, SCIPgetRhsLinear(scenarioscip, cons), SCIPinfinity(scenarioscip)) )
2401  SCIP_CALL( SCIPchgRhsLinear(scenarioscip, cons, getScenarioEntryValue(scenario, i)) );
2402  else if( SCIPisLT(scenarioscip, SCIPgetLhsLinear(scenarioscip, cons), SCIPinfinity(scenarioscip)) )
2403  SCIP_CALL( SCIPchgLhsLinear(scenarioscip, cons, getScenarioEntryValue(scenario, i)) );
2404  }
2405  else if( strstr(getScenarioEntryRow(scenario, i), MINI) != NULL ||
2406  strstr(getScenarioEntryRow(scenario, i), obj) != NULL ||
2407  strstr(getScenarioEntryRow(scenario, i), OBJ) != NULL )
2408  {
2409  /* finding the variable associated with the column */
2410  getScenarioEntityName(name, getScenarioEntryCol(scenario, i), getScenarioStageNum(scenarioscip, scenario),
2411  getScenarioNum(scenarioscip, scenario));
2412  var = SCIPfindVar(scenarioscip, name);
2413 
2414  /* changing the coefficient for the variable */
2415  if( var == NULL )
2416  {
2417  SCIPerrorMessage("There is no variable <%s> in the current scenario.\n", name);
2418  return SCIP_READERROR;
2419  }
2420  else
2421  {
2422  SCIP_CALL( SCIPchgVarObj(scenarioscip, var, getScenarioEntryValue(scenario, i)*probability) );
2423  }
2424  }
2425  else
2426  {
2427  /* if the constraint is NULL, then it is not possible to make any changes to the scenario */
2428  if( cons == NULL )
2429  {
2430  SCIPerrorMessage("There is no constraint <%s> in the current scenario.\n", name);
2431  return SCIP_READERROR;
2432  }
2433 
2434  /* finding the variable associated with the column */
2435  getScenarioEntityName(name, getScenarioEntryCol(scenario, i), getScenarioStageNum(scenarioscip, scenario),
2436  getScenarioNum(scenarioscip, scenario));
2437  var = SCIPfindVar(scenarioscip, name);
2438 
2439  if( var == NULL )
2440  {
2441  (void) SCIPsnprintf(name, SCIP_MAXSTRLEN, "%s", getScenarioEntryCol(scenario, i));
2442  var = SCIPfindVar(scenarioscip, name);
2443  }
2444 
2445  /* changing the coefficient for the variable */
2446  if( var == NULL )
2447  {
2448  SCIPerrorMessage("There is no variable <%s> in the current scenario.\n", name);
2449  return SCIP_READERROR;
2450  }
2451  else
2452  {
2453  SCIP_CALL( SCIPchgCoefLinear(scenarioscip, cons, var, getScenarioEntryValue(scenario, i)) );
2454  }
2455  }
2456  }
2457 
2458  return SCIP_OKAY;
2459 }
2460 
2461 /** removes the core variables and constriants for stage 2 and lower */
2462 static
2464  SCIP* scip /**< the SCIP data structure */
2465  )
2466 {
2467  SCIP_CONS** conss;
2468  SCIP_VAR** vars;
2469  int nconss;
2470  int nvars;
2471  int numstages;
2472  int i;
2473  int j;
2474  SCIP_Bool deleted;
2475 
2476  assert(scip != NULL);
2477 
2478  numstages = SCIPtimGetNStages(scip);
2479 
2480  /* looping through all stages to remove the variables and constraints. The first stage is not removed as these are
2481  * part of the complete problem */
2482  for( i = 1; i < numstages; i++ )
2483  {
2484  conss = SCIPtimGetStageConss(scip, i);
2485  vars = SCIPtimGetStageVars(scip, i);
2486  nconss = SCIPtimGetStageNConss(scip, i);
2487  nvars = SCIPtimGetStageNVars(scip, i);
2488 
2489  /* removing constriants */
2490  for( j = 0; j < nconss; j++ )
2491  {
2492  if( !SCIPconsIsDeleted(conss[j]) )
2493  SCIP_CALL( SCIPdelCons(scip, conss[j]) );
2494  }
2495 
2496  /* removing variables */
2497  for( j = 0; j < nvars; j++ )
2498  {
2499  if( !SCIPvarIsDeleted(vars[j]) )
2500  {
2501  SCIP_CALL( SCIPdelVar(scip, vars[j], &deleted) );
2502  assert(deleted);
2503  }
2504  }
2505  }
2506 
2507  return SCIP_OKAY;
2508 }
2509 
2510 
2511 /* build the stochastic program completely as a MIP, i.e. no decomposition */
2512 static
2514  SCIP* scip, /**< the SCIP data structure */
2515  SCIP_READERDATA* readerdata /**< the reader data */
2516  )
2517 {
2518  int i;
2519 
2520  assert(scip != NULL);
2521  assert(readerdata != NULL);
2522 
2523  /* adding all variables and constraints for stages below the first stage.
2524  * The first stage is covered by the original problem. */
2525  for( i = 0; i < getScenarioNChildren(readerdata->scenariotree); i++ )
2526  SCIP_CALL( addScenarioVarsAndConsToProb(scip, getScenarioChild(readerdata->scenariotree, i), FALSE) );
2527 
2528  /* removing the variable and constraints that were included as part of the core file */
2530 
2531  return SCIP_OKAY;
2532 }
2533 
2534 
2535 /** builds the stochastic program using Benders' decomposition */
2536 static
2538  SCIP* scip, /**< the SCIP data structure */
2539  SCIP_READERDATA* readerdata /**< the reader data */
2540  )
2541 {
2542  SCIP_BENDERS* benders;
2543  int i;
2544 
2545  assert(scip != NULL);
2546  assert(readerdata != NULL);
2547 
2548  SCIP_CALL( createScenarioSubproblemArray(scip, readerdata->scenariotree) );
2549 
2550  /* activating the Benders' constraint handler. The two-phase method is activated by default. If the user desires not
2551  * to use the two-phase method, then the setting in cons_benderslp must be explicitly changed.
2552  */
2553  SCIP_CALL( SCIPsetBoolParam(scip, "constraints/benders/active", TRUE) );
2554 
2555  setScenarioScip(readerdata->scenariotree, scip);
2556 
2557  /* adding all variables and constraints for stages below the first stage.
2558  * The first stage is covered by the original problem. */
2559  for( i = 0; i < getScenarioNChildren(readerdata->scenariotree); i++ )
2560  {
2561  SCIP_CALL( addScenarioVarsAndConsToProb(scip, getScenarioChild(readerdata->scenariotree, i), TRUE) );
2562  addScenarioSubproblem(readerdata->scenariotree, getScenarioScip(getScenarioChild(readerdata->scenariotree, i)));
2563  }
2564 
2565  /* creating the Benders' decomposition */
2566  SCIP_CALL( SCIPcreateBendersDefault(scip, getScenarioSubproblemArray(readerdata->scenariotree),
2567  getScenarioNChildren(readerdata->scenariotree)) );
2568 
2569  /* getting the default Benders' decomposition */
2570  benders = SCIPfindBenders(scip, "default");
2571 
2572  /* updating the lower bounds for the subproblems */
2573  for( i = 0; i < getScenarioNChildren(readerdata->scenariotree); i++ )
2574  {
2576  getScenarioLowerbound(scip, getScenarioChild(readerdata->scenariotree, i)));
2577  }
2578 
2579  /* removing the variable and constraints that were included as part of the core file */
2581 
2582  /* changing settings that are required for Benders' decomposition */
2584  SCIP_CALL( SCIPsetIntParam(scip, "propagating/maxrounds", 0) );
2585  SCIP_CALL( SCIPsetIntParam(scip, "propagating/maxroundsroot", 0) );
2586  SCIP_CALL( SCIPsetIntParam(scip, "heuristics/trysol/freq", 1) );
2587 
2588  /* disabling aggregation since it can affect the mapping between the master and subproblem variables */
2589  SCIP_CALL( SCIPsetBoolParam(scip, "presolving/donotaggr", TRUE) );
2590  SCIP_CALL( SCIPsetBoolParam(scip, "presolving/donotmultaggr", TRUE) );
2591 
2592  return SCIP_OKAY;
2593 }
2594 
2595 /** Read the stochastic information of an SMPS file instance in "STO File Format". */
2596 static
2598  SCIP* scip, /**< SCIP data structure */
2599  const char* filename, /**< name of the input file */
2600  SCIP_READERDATA* readerdata /**< the reader data */
2601  )
2602 {
2603  SCIP_FILE* fp;
2604  STOINPUT* stoi;
2605  SCIP_RETCODE retcode;
2606  SCIP_Bool error = TRUE;
2607  SCIP_Bool unsupported = FALSE;
2608 
2609  assert(scip != NULL);
2610  assert(filename != NULL);
2611 
2612  fp = SCIPfopen(filename, "r");
2613  if( fp == NULL )
2614  {
2615  SCIPerrorMessage("cannot open file <%s> for reading\n", filename);
2616  SCIPprintSysError(filename);
2617  return SCIP_NOFILE;
2618  }
2619 
2620  SCIP_CALL_FINALLY( stoinputCreate(scip, &stoi, fp), SCIPfclose(fp) );
2621  SCIP_CALL_TERMINATE( retcode, createReaderdata(scip, readerdata), TERMINATE );
2622 
2623  SCIP_CALL_TERMINATE( retcode, readStoch(scip, stoi), TERMINATE );
2624 
2625  /* checking for supported stochastic information types */
2627  {
2628  SCIPinfoMessage(scip, NULL, "\nSorry, currently only STO files with the stochastic information as DISCRETE are supported.\n\n");
2629  SCIPinfoMessage(scip, NULL, "NOTE: The problem provided by the COR file is loaded without stochastic information.\n\n");
2630  unsupported = TRUE;
2631  }
2632  else
2633  {
2634  if( stoinputSection(stoi) == STO_BLOCKS )
2635  {
2636  /* coverity[tainted_data] */
2637  SCIP_CALL_TERMINATE( retcode, readBlocks(stoi, scip, readerdata), TERMINATE );
2638  }
2639 
2640  if( stoinputSection(stoi) == STO_SCENARIOS )
2641  {
2642  /* if there are more than two stages, then the sto file is not read. */
2643  if( SCIPtimGetNStages(scip) > 2 )
2644  {
2645  SCIPinfoMessage(scip, NULL, "\nThe scenarios for the stochastic programs are defined in <%s> as SCENARIOS\n", filename);
2646  SCIPinfoMessage(scip, NULL, "Sorry, currently only two-stage stochastic programs are supported when scenarios are defined as SCENARIOS.\n\n");
2647  SCIPinfoMessage(scip, NULL, "NOTE: The problem provided by the COR file is loaded without stochastic information.\n\n");
2648  unsupported = TRUE;
2649  }
2650  else
2651  {
2652  SCIP_CALL_TERMINATE( retcode, readScenarios(stoi, scip, readerdata), TERMINATE );
2653  }
2654  }
2655 
2656  if( stoinputSection(stoi) == STO_INDEP )
2657  {
2658  SCIP_CALL_TERMINATE( retcode, readIndep(stoi, scip, readerdata), TERMINATE );
2659  }
2660  }
2661 
2662  if( !unsupported && stoinputSection(stoi) != STO_ENDATA )
2663  stoinputSyntaxerror(stoi);
2664 
2665  error = stoinputHasError(stoi);
2666 
2667  if( !error && !unsupported )
2668  {
2669  if( readerdata->usebenders )
2670  {
2671  SCIP_CALL_TERMINATE( retcode, buildDecompProblem(scip, readerdata), TERMINATE );
2672  }
2673  else
2674  {
2675  SCIP_CALL_TERMINATE( retcode, buildFullProblem(scip, readerdata), TERMINATE );
2676  }
2677  }
2678 
2679 /* cppcheck-suppress unusedLabel */
2680 TERMINATE:
2681  stoinputFree(scip, &stoi);
2682  SCIPfclose(fp);
2683 
2684  if( error || retcode != SCIP_OKAY )
2685  return SCIP_READERROR;
2686  else
2687  return SCIP_OKAY;
2688 }
2689 
2690 
2691 /*
2692  * Callback methods of reader
2693  */
2694 
2695 /** copy method for reader plugins (called when SCIP copies plugins) */
2696 static
2697 SCIP_DECL_READERCOPY(readerCopySto)
2698 { /*lint --e{715}*/
2699  assert(scip != NULL);
2700  assert(reader != NULL);
2701  assert(strcmp(SCIPreaderGetName(reader), READER_NAME) == 0);
2702 
2703  /* call inclusion method of reader */
2705 
2706  return SCIP_OKAY;
2707 }
2708 
2709 /** destructor of reader to free user data (called when SCIP is exiting) */
2710 static
2711 SCIP_DECL_READERFREE(readerFreeSto)
2712 {
2713  SCIP_READERDATA* readerdata;
2714 
2715  assert(strcmp(SCIPreaderGetName(reader), READER_NAME) == 0);
2716  readerdata = SCIPreaderGetData(reader);
2717  assert(readerdata != NULL);
2718 
2719  SCIP_CALL( freeReaderdata(scip, readerdata) );
2720 
2721  return SCIP_OKAY;
2722 }
2723 
2724 /** problem reading method of reader */
2725 static
2726 SCIP_DECL_READERREAD(readerReadSto)
2727 { /*lint --e{715}*/
2728  SCIP_READER* correader;
2729  SCIP_READER* timreader;
2730 
2731  assert(reader != NULL);
2732  assert(strcmp(SCIPreaderGetName(reader), READER_NAME) == 0);
2733 
2734  correader = SCIPfindReader(scip, "correader");
2735  timreader = SCIPfindReader(scip, "timreader");
2736 
2737  if( correader == NULL )
2738  {
2739  SCIPwarningMessage(scip, "It is necessary to include the \"cor\" reader\n");
2740  (*result) = SCIP_DIDNOTRUN;
2741  return SCIP_OKAY;
2742  }
2743 
2744  if( timreader == NULL )
2745  {
2746  SCIPwarningMessage(scip, "It is necessary to include the \"tim\" reader\n");
2747  (*result) = SCIP_DIDNOTRUN;
2748  return SCIP_OKAY;
2749  }
2750 
2751  /* checking whether the cor file has been read */
2752  if( !SCIPcorHasRead(correader) )
2753  {
2754  SCIPwarningMessage(scip, "The core file must be read before the time and stochastic files.\n");
2755  (*result) = SCIP_DIDNOTRUN;
2756  return SCIP_OKAY;
2757  }
2758 
2759  /* checking whether the tim file has been read */
2760  if( !SCIPtimHasRead(timreader) )
2761  {
2762  SCIPwarningMessage(scip, "The time file must be read before the stochastic files.\n");
2763  (*result) = SCIP_DIDNOTRUN;
2764  return SCIP_OKAY;
2765  }
2766 
2767  SCIP_CALL( SCIPreadSto(scip, filename, result) );
2768 
2769  return SCIP_OKAY;
2770 }
2771 
2772 /*
2773  * sto file reader specific interface methods
2774  */
2775 
2776 /** includes the sto file reader in SCIP */
2778  SCIP* scip /**< SCIP data structure */
2779  )
2780 {
2781  SCIP_READERDATA* readerdata;
2782  SCIP_READER* reader;
2783 
2784  /* create reader data */
2785  SCIP_CALL( SCIPallocBlockMemory(scip, &readerdata) );
2786  readerdata->scenariotree = NULL;
2787  readerdata->numscenarios = 0;
2788 
2789  /* include reader */
2790  SCIP_CALL( SCIPincludeReaderBasic(scip, &reader, READER_NAME, READER_DESC, READER_EXTENSION, readerdata) );
2791 
2792  /* set non fundamental callbacks via setter functions */
2793  SCIP_CALL( SCIPsetReaderCopy(scip, reader, readerCopySto) );
2794  SCIP_CALL( SCIPsetReaderFree(scip, reader, readerFreeSto) );
2795  SCIP_CALL( SCIPsetReaderRead(scip, reader, readerReadSto) );
2796 
2797  /* add decomposition parameters */
2799  "reading/" READER_NAME "/usebenders",
2800  "should Benders' decomposition be used?",
2801  &readerdata->usebenders, FALSE, DEFAULT_USEBENDERS, NULL, NULL) );
2802 
2803  return SCIP_OKAY;
2804 }
2805 
2806 
2807 /** reads the stochastic information for a stochastic program that is in SMPS format */
2809  SCIP* scip, /**< SCIP data structure */
2810  const char* filename, /**< full path and name of file to read, or NULL if stdin should be used */
2811  SCIP_RESULT* result /**< pointer to store the result of the file reading call */
2812  )
2813 {
2814  SCIP_READER* reader;
2815  SCIP_READERDATA* readerdata;
2816  SCIP_RETCODE retcode;
2817 
2818  assert(scip != NULL);
2819  assert(result != NULL);
2820 
2821  reader = SCIPfindReader(scip, READER_NAME);
2822  assert(reader != NULL);
2823  readerdata = SCIPreaderGetData(reader);
2824 
2825  retcode = readSto(scip, filename, readerdata);
2826 
2827  if( retcode == SCIP_PLUGINNOTFOUND )
2828  retcode = SCIP_READERROR;
2829 
2830  if( retcode == SCIP_NOFILE || retcode == SCIP_READERROR )
2831  return retcode;
2832 
2833  SCIP_CALL( retcode );
2834 
2835  *result = SCIP_SUCCESS;
2836 
2837  return SCIP_OKAY;
2838 }
2839 
2840 /** returns the total number of scenarios added to the problem */
2842  SCIP* scip /**< SCIP data structure */
2843  )
2844 {
2845  SCIP_READER* reader;
2846  SCIP_READERDATA* readerdata;
2847 
2848  reader = SCIPfindReader(scip, READER_NAME);
2849 
2850  assert(reader != NULL);
2851  assert(strcmp(SCIPreaderGetName(reader), READER_NAME) == 0);
2852 
2853  readerdata = SCIPreaderGetData(reader);
2854  assert(readerdata != NULL);
2855 
2856  return readerdata->numscenarios;
2857 }
enum SCIP_Result SCIP_RESULT
Definition: type_result.h:61
#define BLANK
Definition: reader_sto.c:78
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
Definition: scip_mem.h:110
static const char * stoinputField5(const STOINPUT *stoi)
Definition: reader_sto.c:1164
SCIP_Real * values
Definition: reader_sto.c:109
#define SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)
Definition: scip_mem.h:99
enum StoStochInfo STOSTOCHINFO
Definition: reader_sto.c:137
#define NULL
Definition: def.h:267
int SCIPmemccpy(char *dest, const char *src, char stop, unsigned int cnt)
Definition: misc.c:10744
#define SCIPallocBlockMemoryArray(scip, ptr, num)
Definition: scip_mem.h:93
TIM file reader - the stage information for a stochastic programming instance in SMPS format...
static SCIP_RETCODE findScenarioVar(SCIP *scip, STOSCENARIO *scenario, SCIP_VAR *consvar, SCIP_VAR **scenariovar)
Definition: reader_sto.c:2021
public methods for SCIP parameter handling
static SCIP_Real computeScenarioProbability(SCIP *scip, STOSCENARIO *scenario)
Definition: reader_sto.c:1923
SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)
Definition: cons.c:8475
static SCIP_RETCODE addScenariosToReaderdata(SCIP *scip, SCIP_READERDATA *readerdata, STOSCENARIO ***scenarios, int *numscenarios, int numscenariostages)
Definition: reader_sto.c:752
const char * name
Definition: reader_sto.c:103
public methods for memory management
static const char * getScenarioEntryRow(STOSCENARIO *scenario, int entry)
Definition: reader_sto.c:567
static STOSTOCHINFO stoinputStochInfoType(const STOINPUT *stoi)
Definition: reader_sto.c:1098
#define SCIP_MAXSTRLEN
Definition: def.h:288
SCIP_Bool SCIPvarIsInitial(SCIP_VAR *var)
Definition: var.c:17621
int childrensize
Definition: reader_sto.c:98
SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip_prob.c:2843
static SCIP_RETCODE addScenarioVarsToProb(SCIP *scip, STOSCENARIO *scenario, SCIP_HASHMAP *varmap, SCIP_VAR **vars, int nvars)
Definition: reader_sto.c:1964
int SCIPcalcMemGrowSize(SCIP *scip, int num)
Definition: scip_mem.c:139
int entriessize
Definition: reader_sto.c:111
COR file reader (MPS format of the core problem for stochastic programs)
#define SCIP_CALL_FINALLY(x, y)
Definition: def.h:422
enum StoSection STOSECTION
Definition: reader_sto.c:125
static SCIP_RETCODE setScenarioLowerbound(SCIP *scip, STOSCENARIO *scenario, SCIP_Real lowerbound)
Definition: reader_sto.c:495
const char * SCIPreaderGetName(SCIP_READER *reader)
Definition: reader.c:557
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
Definition: scip_var.c:1247
static void stoinputSetStochtype(STOINPUT *stoi, const char *stochtype)
Definition: reader_sto.c:1235
SCIP_RETCODE SCIPincludeReaderSto(SCIP *scip)
Definition: reader_sto.c:2777
#define FALSE
Definition: def.h:94
static SCIP_RETCODE addScenarioVarsAndConsToProb(SCIP *scip, STOSCENARIO *scenario, SCIP_Bool decomp)
Definition: reader_sto.c:2254
SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)
Definition: misc.c:3074
#define DEFAULT_USEBENDERS
Definition: reader_sto.c:64
static SCIP_Real getScenarioLowerbound(SCIP *scip, STOSCENARIO *scenario)
Definition: reader_sto.c:511
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_RETCODE SCIPcreateBendersDefault(SCIP *scip, SCIP **subproblems, int nsubproblems)
static SCIP_RETCODE addScenarioEntry(SCIP *scip, STOSCENARIO *scenario, const char *rowname, const char *colname, SCIP_Real value)
Definition: reader_sto.c:524
int SCIPsnprintf(char *t, int len, const char *s,...)
Definition: misc.c:10877
#define TRUE
Definition: def.h:93
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
static SCIP_RETCODE setScenarioProbability(SCIP *scip, STOSCENARIO *scenario, SCIP_Real probability)
Definition: reader_sto.c:466
SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)
Definition: cons.c:8495
SCIP_RETCODE SCIPsetPresolving(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: scip_param.c:953
#define STO_DEFAULT_ARRAYSIZE
Definition: reader_sto.c:73
const char * f5
Definition: reader_sto.c:153
static SCIP_RETCODE setScenarioNum(SCIP *scip, STOSCENARIO *scenario, int scenarionum)
Definition: reader_sto.c:437
STO file reader - the stochastic information of an instance in SMPS format.
public methods for problem variables
#define SCIPfreeBlockMemory(scip, ptr)
Definition: scip_mem.h:108
static SCIP_DECL_READERCOPY(readerCopySto)
Definition: reader_sto.c:2697
SCIP_READER * SCIPfindReader(SCIP *scip, const char *name)
Definition: scip_reader.c:235
static const char * stoinputField1(const STOINPUT *stoi)
Definition: reader_sto.c:1120
#define SCIPdebugMessage
Definition: pub_message.h:96
StoStochInfo
Definition: reader_sto.c:128
STOSCENARIO * parent
Definition: reader_sto.c:95
static SCIP ** getScenarioSubproblemArray(STOSCENARIO *scenario)
Definition: reader_sto.c:306
const char * SCIPtimConsGetStageName(SCIP *scip, const char *consname)
Definition: reader_tim.c:978
static void stoinputSetProbname(STOINPUT *stoi, const char *probname)
Definition: reader_sto.c:1221
static const char * getScenarioName(STOSCENARIO *scenario)
Definition: reader_sto.c:426
#define SCIPfreeBufferArray(scip, ptr)
Definition: scip_mem.h:136
SCIP_RETCODE SCIPcreate(SCIP **scip)
Definition: scip_general.c:307
SCIP_Bool SCIPvarIsRemovable(SCIP_VAR *var)
Definition: var.c:17631
#define SCIPallocBlockMemory(scip, ptr)
Definition: scip_mem.h:89
static SCIP_RETCODE readStoch(SCIP *scip, STOINPUT *stoi)
Definition: reader_sto.c:1384
public methods for SCIP variables
static SCIP_RETCODE getScenarioDecompVar(SCIP *scip, STOSCENARIO *scenario, SCIP_VAR *consvar, SCIP_VAR **scenariovar, SCIP_Bool *varadded)
Definition: reader_sto.c:2069
static SCIP_Bool stoinputReadLine(STOINPUT *stoi)
Definition: reader_sto.c:1275
SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)
Definition: cons.c:8485
static void getScenarioEntityName(char *name, const char *varname, int stagenum, int scenarionum)
Definition: reader_sto.c:1948
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
Definition: scip_message.c:120
static int getScenarioNEntries(STOSCENARIO *scenario)
Definition: reader_sto.c:556
#define SCIPdebugMsg
Definition: scip_message.h:78
static STOSCENARIO * getScenarioParent(STOSCENARIO *scenario)
Definition: reader_sto.c:341
SCIP_Real SCIPgetRhsLinear(SCIP *scip, SCIP_CONS *cons)
const char ** colnames
Definition: reader_sto.c:108
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
Definition: scip_message.c:208
SCIP_RETCODE SCIPcreateProbBasic(SCIP *scip, const char *name)
Definition: scip_prob.c:180
char stochtype[STO_MAX_NAMELEN]
Definition: reader_sto.c:156
static SCIP_RETCODE copyScenario(SCIP *scip, STOSCENARIO *sourcescenario, STOSCENARIO **targetscenario, SCIP_Bool copyname)
Definition: reader_sto.c:608
public methods for numerical tolerances
const char * SCIPgetProbName(SCIP *scip)
Definition: scip_prob.c:1067
SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)
Definition: misc.c:3423
#define READER_DESC
Definition: reader_sto.c:61
SCIP_VAR * SCIPfindVar(SCIP *scip, const char *name)
Definition: scip_prob.c:2685
static void addScenarioSubproblem(STOSCENARIO *scenario, SCIP *subproblem)
Definition: reader_sto.c:290
SCIP_FILE * SCIPfopen(const char *path, const char *mode)
Definition: fileio.c:153
SCIP_READERDATA * SCIPreaderGetData(SCIP_READER *reader)
Definition: reader.c:492
STOSECTION section
Definition: reader_sto.c:142
#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)
Definition: scip_mem.h:105
SCIP_Bool SCIPtimHasRead(SCIP_READER *reader)
Definition: reader_tim.c:921
SCIP_RETCODE SCIPdelVar(SCIP *scip, SCIP_VAR *var, SCIP_Bool *deleted)
Definition: scip_prob.c:1790
public methods for managing constraints
const char * f1
Definition: reader_sto.c:149
static int getScenarioStageNum(SCIP *scip, STOSCENARIO *scenario)
Definition: reader_sto.c:397
static STOSCENARIO * findScenarioInTree(STOSCENARIO *scenariotree, const char *scenname)
Definition: reader_sto.c:779
static SCIP_RETCODE removeCoreVariablesAndConstraints(SCIP *scip)
Definition: reader_sto.c:2463
SCIP * scip
Definition: reader_sto.c:93
static SCIP_RETCODE createReaderdata(SCIP *scip, SCIP_READERDATA *readerdata)
Definition: reader_sto.c:1006
const char * f6
Definition: reader_sto.c:154
static SCIP * getScenarioScip(STOSCENARIO *scenario)
Definition: reader_sto.c:264
static SCIP_RETCODE readBlocks(STOINPUT *stoi, SCIP *scip, SCIP_READERDATA *readerdata)
Definition: reader_sto.c:1446
static SCIP_Real getScenarioEntryValue(STOSCENARIO *scenario, int entry)
Definition: reader_sto.c:593
#define SCIPerrorMessage
Definition: pub_message.h:64
SCIP_RETCODE SCIPgetConsNVars(SCIP *scip, SCIP_CONS *cons, int *nvars, SCIP_Bool *success)
Definition: scip_cons.c:2622
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip_prob.c:2770
SCIP_Real SCIPvarGetLbOriginal(SCIP_VAR *var)
Definition: var.c:18025
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
static const char * stoinputField0(const STOINPUT *stoi)
Definition: reader_sto.c:1109
const char * f0
Definition: reader_sto.c:148
static SCIP_RETCODE createScenarioSubproblemArray(SCIP *scip, STOSCENARIO *scenario)
Definition: reader_sto.c:275
SCIP_Real SCIPvarGetUbOriginal(SCIP_VAR *var)
Definition: var.c:18045
static const char * stoinputField3(const STOINPUT *stoi)
Definition: reader_sto.c:1142
const char ** rownames
Definition: reader_sto.c:107
static const char * stoinputField4(const STOINPUT *stoi)
Definition: reader_sto.c:1153
#define SCIPfreeBufferArrayNull(scip, ptr)
Definition: scip_mem.h:137
SCIP_RETCODE SCIPsetBoolParam(SCIP *scip, const char *name, SCIP_Bool value)
Definition: scip_param.c:429
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
Definition: scip_mem.c:57
struct SCIP_File SCIP_FILE
Definition: pub_fileio.h:43
char * SCIPfgets(char *s, int size, SCIP_FILE *stream)
Definition: fileio.c:200
const char * SCIPconsGetName(SCIP_CONS *cons)
Definition: cons.c:8216
int nchildren
Definition: reader_sto.c:97
const char * SCIPvarGetName(SCIP_VAR *var)
Definition: var.c:17420
static SCIP_Real getScenarioProbability(SCIP *scip, STOSCENARIO *scenario)
Definition: reader_sto.c:482
void SCIPhashmapFree(SCIP_HASHMAP **hashmap)
Definition: misc.c:3108
static STOSECTION stoinputSection(const STOINPUT *stoi)
Definition: reader_sto.c:1087
int SCIPtimGetNStages(SCIP *scip)
Definition: reader_tim.c:938
static SCIP_RETCODE setScenarioName(SCIP *scip, STOSCENARIO *scenario, const char *name)
Definition: reader_sto.c:410
SCIP_CONS * SCIPfindCons(SCIP *scip, const char *name)
Definition: scip_prob.c:2947
SCIP_Real probability
Definition: reader_sto.c:104
static SCIP_RETCODE buildDecompProblem(SCIP *scip, SCIP_READERDATA *readerdata)
Definition: reader_sto.c:2537
static SCIP_RETCODE freeScenarioTree(SCIP *scip, STOSCENARIO **scenariotree)
Definition: reader_sto.c:198
const char * f3
Definition: reader_sto.c:151
#define SCIP_CALL(x)
Definition: def.h:380
#define SCIPensureBlockMemoryArray(scip, ptr, arraysizeptr, minsize)
Definition: scip_mem.h:107
static SCIP_Bool stoinputHasError(const STOINPUT *stoi)
Definition: reader_sto.c:1186
SCIP_Bool SCIPconsIsLocal(SCIP_CONS *cons)
Definition: cons.c:8455
#define STO_MAX_LINELEN
Definition: reader_sto.c:70
SCIP_RETCODE SCIPgetConsVars(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **vars, int varssize, SCIP_Bool *success)
Definition: scip_cons.c:2578
public methods for constraint handler plugins and constraints
static SCIP_RETCODE setScenarioStageNum(SCIP *scip, STOSCENARIO *scenario, int stagenum)
Definition: reader_sto.c:381
wrapper functions to map file i/o to standard or zlib file i/o
SCIP_RETCODE SCIPgetConsCopy(SCIP *sourcescip, SCIP *targetscip, SCIP_CONS *sourcecons, SCIP_CONS **targetcons, SCIP_CONSHDLR *sourceconshdlr, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *name, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool global, SCIP_Bool *valid)
Definition: scip_copy.c:1591
SCIP_RETCODE SCIPchgVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
Definition: scip_var.c:4512
STOSCENARIO ** children
Definition: reader_sto.c:96
const char * stagename
Definition: reader_sto.c:102
static const char * stoinputField2(const STOINPUT *stoi)
Definition: reader_sto.c:1131
SCIP_BENDERS * SCIPfindBenders(SCIP *scip, const char *name)
Definition: scip_benders.c:493
#define SCIPallocBufferArray(scip, ptr, num)
Definition: scip_mem.h:124
struct SCIP_ReaderData SCIP_READERDATA
Definition: type_reader.h:53
public data structures and miscellaneous methods
#define STO_MAX_NAMELEN
Definition: reader_sto.c:71
int SCIPtimFindStage(SCIP *scip, const char *stage)
Definition: reader_tim.c:1019
#define SCIP_Bool
Definition: def.h:91
SCIP_RETCODE SCIPincludeDefaultPlugins(SCIP *scip)
SCIP_RETCODE SCIPincludeReaderBasic(SCIP *scip, SCIP_READER **readerptr, const char *name, const char *desc, const char *extension, SCIP_READERDATA *readerdata)
Definition: scip_reader.c:109
static const char * getScenarioEntryCol(STOSCENARIO *scenario, int entry)
Definition: reader_sto.c:580
static SCIP_RETCODE buildScenarioTree(SCIP *scip, STOSCENARIO **scenariotree, STOSCENARIO ***scenarios, int *numscenarios, int numstages, int stage)
Definition: reader_sto.c:706
static void stoinputSetSection(STOINPUT *stoi, STOSECTION section)
Definition: reader_sto.c:1197
void SCIPprintSysError(const char *message)
Definition: misc.c:10769
STOSTOCHINFO stochinfotype
Definition: reader_sto.c:143
SCIP_CONS ** SCIPtimGetStageConss(SCIP *scip, int stagenum)
Definition: reader_tim.c:1078
static SCIP_RETCODE mergeScenarios(SCIP *scip, STOSCENARIO *scenario1, STOSCENARIO **mergedscenario)
Definition: reader_sto.c:651
#define RIGHT
Definition: rbtree.c:43
const char * f2
Definition: reader_sto.c:150
SCIP_RETCODE SCIPreadSto(SCIP *scip, const char *filename, SCIP_RESULT *result)
Definition: reader_sto.c:2808
SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)
Definition: cons.c:8236
SCIP_RETCODE SCIPsetIntParam(SCIP *scip, const char *name, int value)
Definition: scip_param.c:487
SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)
Definition: cons.c:8345
static SCIP_RETCODE readScenarios(STOINPUT *stoi, SCIP *scip, SCIP_READERDATA *readerdata)
Definition: reader_sto.c:1611
#define READER_EXTENSION
Definition: reader_sto.c:62
SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)
Definition: cons.c:8415
SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)
Definition: cons.c:8385
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
Definition: var.c:17927
SCIP_RETCODE SCIPcreateVar(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)
Definition: scip_var.c:114
static const char * getScenarioStageName(SCIP *scip, STOSCENARIO *scenario)
Definition: reader_sto.c:368
SCIP_Bool haserror
Definition: reader_sto.c:146
Constraint handler for linear constraints in their most general form, .
static SCIP_RETCODE createScenariosFromBlocks(SCIP *scip, SCIP_READERDATA *readerdata, STOSCENARIO ***blocks, int numblocks, int *numblocksperblock, int numstages)
Definition: reader_sto.c:930
SCIP_RETCODE SCIPchgRhsLinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real rhs)
int scenarionum
Definition: reader_sto.c:101
static SCIP_RETCODE setScenarioStageName(SCIP *scip, STOSCENARIO *scenario, const char *stagename)
Definition: reader_sto.c:352
char probname[STO_MAX_NAMELEN]
Definition: reader_sto.c:155
#define STO_DEFAULT_ENTRIESSIZE
Definition: reader_sto.c:74
int SCIPtimGetStageNVars(SCIP *scip, int stagenum)
Definition: reader_tim.c:1099
SCIP_RETCODE SCIPsetReaderCopy(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERCOPY((*readercopy)))
Definition: scip_reader.c:147
static SCIP_RETCODE readIndep(STOINPUT *stoi, SCIP *scip, SCIP_READERDATA *readerdata)
Definition: reader_sto.c:1754
int nsubproblems
Definition: reader_sto.c:99
int SCIPgetNVars(SCIP *scip)
Definition: scip_prob.c:1992
static void clearFrom(char *buf, unsigned int pos)
Definition: reader_sto.c:1261
static const char * stoinputField6(const STOINPUT *stoi)
Definition: reader_sto.c:1175
StoSection
Definition: reader_sto.c:117
static int getScenarioNChildren(STOSCENARIO *scenario)
Definition: reader_sto.c:317
static SCIP_RETCODE freeReaderdata(SCIP *scip, SCIP_READERDATA *readerdata)
Definition: reader_sto.c:1026
general public methods
#define READER_NAME
Definition: reader_sto.c:60
public methods for debugging
static SCIP_RETCODE scenarioAddChild(SCIP *scip, STOSCENARIO **parent, STOSCENARIO *child)
Definition: reader_sto.c:678
SCIP_Bool SCIPcorHasRead(SCIP_READER *reader)
Definition: reader_cor.c:217
SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)
Definition: scip_prob.c:1668
void SCIPbendersUpdateSubproblemLowerbound(SCIP_BENDERS *benders, int probnumber, SCIP_Real lowerbound)
Definition: benders.c:6715
int SCIPstoGetNScenarios(SCIP *scip)
Definition: reader_sto.c:2841
static SCIP_DECL_READERFREE(readerFreeSto)
Definition: reader_sto.c:2711
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
Definition: scip_cons.c:1174
#define STO_DEFAULT_BLOCKARRAYSIZE
Definition: reader_sto.c:75
public methods for message output
SCIP_Real lowerbound
Definition: reader_sto.c:105
static SCIP_RETCODE buildScenariosFromBlocks(SCIP *scip, STOSCENARIO ***blocks, STOSCENARIO ***scenarios, STOSCENARIO ***blocksforscen, int *numblocksforscen, int numblocks, int *numblocksperblock, int *numscenarios, int *scenariossize, const char *stage, int stagenum, int blocknum)
Definition: reader_sto.c:833
#define SCIP_Real
Definition: def.h:173
SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)
Definition: cons.c:8465
int lineno
Definition: reader_sto.c:145
static SCIP_RETCODE readSto(SCIP *scip, const char *filename, SCIP_READERDATA *readerdata)
Definition: reader_sto.c:2597
public methods for input file readers
#define SCIP_CALL_TERMINATE(retcode, x, TERM)
Definition: def.h:401
default Benders&#39; decomposition plugin
public methods for message handling
SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)
Definition: cons.c:8405
static int getScenarioNum(SCIP *scip, STOSCENARIO *scenario)
Definition: reader_sto.c:453
static SCIP_RETCODE stoinputCreate(SCIP *scip, STOINPUT **stoi, SCIP_FILE *fp)
Definition: reader_sto.c:1045
SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)
Definition: cons.c:8395
SCIP_RETCODE SCIPsetReaderRead(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERREAD((*readerread)))
Definition: scip_reader.c:195
#define STO_DEFAULT_CHILDRENSIZE
Definition: reader_sto.c:76
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
Definition: var.c:17585
SCIP ** subproblems
Definition: reader_sto.c:94
static SCIP_RETCODE createScenarioData(SCIP *scip, STOSCENARIO **scenariodata)
Definition: reader_sto.c:162
enum SCIP_Vartype SCIP_VARTYPE
Definition: type_var.h:73
SCIP_RETCODE SCIPchgLhsLinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real lhs)
static void stoinputSetStochInfoType(STOINPUT *stoi, STOSTOCHINFO stochinfotype)
Definition: reader_sto.c:1209
SCIP_Bool SCIPconsIsMarkedPropagate(SCIP_CONS *cons)
Definition: cons.c:8425
static STOSCENARIO * getScenarioChild(STOSCENARIO *scenario, int childnum)
Definition: reader_sto.c:328
SCIP_RETCODE SCIPhashmapInsert(SCIP_HASHMAP *hashmap, void *origin, void *image)
Definition: misc.c:3156
SCIP_VAR ** SCIPtimGetStageVars(SCIP *scip, int stagenum)
Definition: reader_tim.c:1057
int SCIPfclose(SCIP_FILE *fp)
Definition: fileio.c:232
const char * f4
Definition: reader_sto.c:152
char buf[STO_MAX_LINELEN]
Definition: reader_sto.c:147
static SCIP_RETCODE buildFullProblem(SCIP *scip, SCIP_READERDATA *readerdata)
Definition: reader_sto.c:2513
int SCIPtimGetStageNConss(SCIP *scip, int stagenum)
Definition: reader_tim.c:1120
public methods for reader plugins
public methods for global and local (sub)problems
char * SCIPstrtok(char *s, const char *delim, char **ptrptr)
Definition: misc.c:10818
SCIP_Bool SCIPvarIsDeleted(SCIP_VAR *var)
Definition: var.c:17641
default SCIP plugins
static void setScenarioScip(STOSCENARIO *scenario, SCIP *scip)
Definition: reader_sto.c:251
const char * SCIPtimGetStageName(SCIP *scip, int stagenum)
Definition: reader_tim.c:957
static SCIP_RETCODE insertScenarioInReaderdata(SCIP *scip, SCIP_READERDATA *readerdata, STOSCENARIO *scenario, char *parentname)
Definition: reader_sto.c:806
static SCIP_RETCODE addScenarioConsToProb(SCIP *scip, SCIP *scenarioscip, STOSCENARIO *scenario, SCIP_HASHMAP *varmap, SCIP_CONS **conss, int nconss, SCIP_Bool decomp)
Definition: reader_sto.c:2135
SCIP_Real SCIPgetLhsLinear(SCIP *scip, SCIP_CONS *cons)
static void stoinputFree(SCIP *scip, STOINPUT **stoi)
Definition: reader_sto.c:1077
SCIP_RETCODE SCIPsetReaderFree(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERFREE((*readerfree)))
Definition: scip_reader.c:171
SCIP_FILE * fp
Definition: reader_sto.c:144
static SCIP_DECL_READERREAD(readerReadSto)
Definition: reader_sto.c:2726
SCIP_RETCODE SCIPaddBoolParam(SCIP *scip, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: scip_param.c:57
SCIP_RETCODE SCIPchgCoefLinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPfree(SCIP **scip)
Definition: scip_general.c:339
static void stoinputSyntaxerror(STOINPUT *stoi)
Definition: reader_sto.c:1248
void SCIPenableDebugSol(SCIP *scip)
Definition: scip_debug.c:57
memory allocation routines