Changeset 1003


Ignore:
Timestamp:
Jul 15, 2008 11:57:59 AM (11 years ago)
Author:
forrest
Message:

for threads and hotstart

Location:
trunk/Cbc/src
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/Cbc/src/CbcModel.cpp

    r983 r1003  
    20332033      threadId[i].status=0;
    20342034      threadInfo[i].baseModel=this;
    2035       threadModel[i]=new CbcModel(*this);
     2035      threadModel[i]=new CbcModel(*this,true);
    20362036#ifdef COIN_HAS_CLP
    20372037      // Solver may need to know about model
     
    33963396    // delete models (here in case some point to others)
    33973397    for (i=0;i<numberThreads_;i++) {
     3398      // make sure handler will be deleted
     3399      threadModel[i]->defaultHandler_=true;
    33983400      delete threadModel[i];
    33993401    }
     
    43064308// Copy constructor.
    43074309
    4308 CbcModel::CbcModel(const CbcModel & rhs, bool noTree)
     4310CbcModel::CbcModel(const CbcModel & rhs, bool cloneHandler)
    43094311:
    43104312  continuousSolver_(NULL),
     
    43904392  solverCharacteristics_ = NULL;
    43914393  if (rhs.emptyWarmStart_) emptyWarmStart_ = rhs.emptyWarmStart_->clone() ;
    4392   if (defaultHandler_) {
     4394  if (defaultHandler_||cloneHandler) {
    43934395    handler_ = new CoinMessageHandler();
    43944396    handler_->setLogLevel(2);
     
    44104412    virginGenerator_=NULL;
    44114413  }
    4412   if (!noTree)
    4413     globalCuts_ = rhs.globalCuts_;
     4414  globalCuts_ = rhs.globalCuts_;
    44144415  numberHeuristics_ = rhs.numberHeuristics_;
    44154416  if (numberHeuristics_) {
     
    44524453  else
    44534454    referenceSolver_=NULL;
    4454   if (!noTree||!rhs.continuousSolver_)
    4455     solver_ = rhs.solver_->clone();
    4456   else
    4457     solver_ = rhs.continuousSolver_->clone();
     4455  solver_ = rhs.solver_->clone();
    44584456  if (rhs.originalColumns_) {
    44594457    int numberColumns = solver_->getNumCols();
     
    45184516    hotstartPriorities_ =NULL;
    45194517  }
    4520   if (rhs.bestSolution_&&!noTree) {
     4518  if (rhs.bestSolution_) {
    45214519    int numberColumns = solver_->getNumCols();
    45224520    bestSolution_ = new double[numberColumns];
     
    45254523    bestSolution_=NULL;
    45264524  }
    4527   if (!noTree) {
    4528     int numberColumns = solver_->getNumCols();
    4529     // Space for current solution
    4530     currentSolution_ = new double[numberColumns];
    4531     continuousSolution_ = new double[numberColumns];
    4532     usedInSolution_ = new int[numberColumns];
    4533     CoinZeroN(usedInSolution_,numberColumns);
    4534   } else {
    4535     currentSolution_=NULL;
    4536     continuousSolution_=NULL;
    4537     usedInSolution_=NULL;
    4538   }
     4525  int numberColumns = solver_->getNumCols();
     4526  // Space for current solution
     4527  currentSolution_ = new double[numberColumns];
     4528  continuousSolution_ = new double[numberColumns];
     4529  usedInSolution_ = new int[numberColumns];
     4530  CoinZeroN(usedInSolution_,numberColumns);
    45394531  testSolution_=currentSolution_;
    45404532  numberRowsAtContinuous_ = rhs.numberRowsAtContinuous_;
     
    45434535  currentNumberCuts_=rhs.currentNumberCuts_;
    45444536  maximumDepth_= rhs.maximumDepth_;
    4545   if (noTree) {
    4546     bestObjective_ = COIN_DBL_MAX;
    4547     numberSolutions_ =0;
    4548     stateOfSearch_= 0;
    4549     numberHeuristicSolutions_=0;
    4550     numberNodes_=0;
    4551     numberNodes2_=0;
    4552     numberIterations_=0;
    4553     status_=0;
    4554     subTreeModel_=NULL;
    4555     numberStoppedSubTrees_=0;
    4556     continuousObjective_=COIN_DBL_MAX;
    4557     originalContinuousObjective_=COIN_DBL_MAX;
    4558     continuousInfeasibilities_=COIN_INT_MAX;
    4559     maximumNumberCuts_=0;
    4560     tree_->cleanTree(this,-COIN_DBL_MAX,bestPossibleObjective_);
    4561     bestPossibleObjective_ = COIN_DBL_MAX;
    4562   }
    45634537  // These are only used as temporary arrays so need not be filled
    45644538  if (maximumNumberCuts_) {
     
    45754549    walkback_ = NULL;
    45764550  synchronizeModel();
     4551  if (cloneHandler) {
     4552    delete handler_;
     4553    CoinMessageHandler * handler = rhs.handler_->clone();
     4554    passInMessageHandler(handler);
     4555  }
    45774556}
    45784557 
     
    1070110680  defaultHandler_=false;
    1070210681  handler_=handler;
     10682  if (solver_)
     10683    solver_->passInMessageHandler(handler);
     10684  if (continuousSolver_)
     10685    continuousSolver_->passInMessageHandler(handler);
     10686  if (referenceSolver_)
     10687    referenceSolver_->passInMessageHandler(handler);
    1070310688}
    1070410689void
     
    1194811933                          double objectiveValue, bool checkSolution)
    1194911934{
    11950   // May be odd discontinuities - so only chaeck if asked
     11935  // May be odd discontinuities - so only check if asked
    1195111936  if (checkSolution) {
    1195211937    assert (numberColumns==solver_->getNumCols());
  • trunk/Cbc/src/CbcSolver.cpp

    r979 r1003  
    64726472                const int * originalColumns = preProcess ? process.originalColumns() : NULL;
    64736473                if (solutionIn&&useSolution>=0) {
     6474                  if (!prioritiesIn) {
     6475                    int n;
     6476                    if (preProcess) {
     6477                      int numberColumns = babModel_->getNumCols();
     6478                      // extend arrays in case SOS
     6479                      n = originalColumns[numberColumns-1]+1;
     6480                    } else {
     6481                      n = babModel_->getNumCols();
     6482                    }
     6483                    prioritiesIn = new int[n];
     6484                    for (int i=0;i<n;i++)
     6485                      prioritiesIn[i]=100;
     6486                  }
    64746487                  if (preProcess) {
    64756488                    int numberColumns = babModel_->getNumCols();
     
    64976510                        prioritiesIn2[i]=prioritiesIn2[iColumn];
    64986511                    }
    6499                     babModel_->setHotstartSolution(solutionIn2,prioritiesIn2);
     6512                    if (useSolution)
     6513                      babModel_->setHotstartSolution(solutionIn2,prioritiesIn2);
     6514                    else
     6515                      babModel_->setBestSolution(solutionIn2,numberColumns,
     6516                                                 COIN_DBL_MAX,true);
    65006517                    delete [] solutionIn2;
    65016518                    delete [] prioritiesIn2;
    65026519                  } else {
    6503                     babModel_->setHotstartSolution(solutionIn,prioritiesIn);
     6520                    if (useSolution)
     6521                      babModel_->setHotstartSolution(solutionIn,prioritiesIn);
     6522                    else
     6523                      babModel_->setBestSolution(solutionIn,babModel_->getNumCols(),
     6524                                                 COIN_DBL_MAX,true);
    65046525                  }
    65056526                }
     
    74117432                }
    74127433#endif
    7413                 if (useSolution>0) {
     7434                if (useSolution>1) {
    74147435                  // use hotstart to try and find solution
    74157436                  CbcHeuristicPartial partial(*babModel_,10000,useSolution);
     
    94149435                  delete [] newMasks;
    94159436                }
    9416                 if (printMode>2) {
     9437                if (printMode>2&&printMode<5) {
    94179438                  for (iRow=0;iRow<numberRows;iRow++) {
    94189439                    int type=printMode-3;
     
    94469467                double * columnUpper = lpSolver->columnUpper();
    94479468                if (printMode!=2) {
     9469                  if (printMode==5) {
     9470                    if (lengthName)
     9471                      fprintf(fp,"name");
     9472                    else
     9473                      fprintf(fp,"number");
     9474                    fprintf(fp,",solution\n");
     9475                  }
    94489476                  for (iColumn=0;iColumn<numberColumns;iColumn++) {
    94499477                    int type=(printMode>3) ? 1 :0;
     
    94659493                      type =0;
    94669494                    if (type) {
    9467                       fprintf(fp,"%7d ",iColumn);
    9468                       if (lengthName)
    9469                         fprintf(fp,format,columnNames[iColumn].c_str());
    9470                       fprintf(fp,"%15.8g        %15.8g\n",
    9471                               primalColumnSolution[iColumn],
    9472                               dualColumnSolution[iColumn]);
    9473                     }
     9495                      if (printMode!=5) {
     9496                        fprintf(fp,"%7d ",iColumn);
     9497                        if (lengthName)
     9498                          fprintf(fp,format,columnNames[iColumn].c_str());
     9499                        fprintf(fp,"%15.8g        %15.8g\n",
     9500                                primalColumnSolution[iColumn],
     9501                                dualColumnSolution[iColumn]);
     9502                      } else {
     9503                        char temp[100];
     9504                        if (lengthName)
     9505                          sprintf(temp,format,columnNames[iColumn].c_str());
     9506                        else
     9507                          sprintf(temp,"%7d ",iColumn);
     9508                        sprintf(temp+strlen(temp),",%15.8g",
     9509                                primalColumnSolution[iColumn]);
     9510                        int n=strlen(temp);
     9511                        int k=0;
     9512                        for (int i=0;i<n+1;i++) {
     9513                          if (temp[i]!=' ')
     9514                            temp[k++]=temp[i];
     9515                        }
     9516                        fprintf(fp,"%s\n",temp);
     9517                      }
     9518                    }
    94749519                  }
    94759520                } else {
Note: See TracChangeset for help on using the changeset viewer.