//------------------------------------------------------------------------------ bool Minimize::Execute() { #ifdef DEBUG_MINIMIZE_EXEC // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ debug ~~~~ MessageInterface::ShowMessage ("Minimize::Execute() optimizerDataFinalized=%d\n optimizer=%p, objective=%p\n", optimizerDataFinalized, optimizer, objective); MessageInterface::ShowMessage (" objectiveName=%s\n", objectiveName.c_str()); if (objective) MessageInterface::ShowMessage(" objective=%s\n", objective->GetDescription().c_str()); #endif // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ end debug ~~~~ bool retval = true; if (!optimizerDataFinalized) { // Tell the optimizer about the objective function Real minData[1]; minData[0] = objective->EvaluateReal(); //minData[1] = tolerance; objId = optimizer->SetSolverResults(minData, objectiveName, "Objective"); optimizerDataFinalized = true; return retval; } Real val = -999.999; // Evaluate variable and pass it to the optimizer if (objective != NULL) { val = objective->EvaluateReal(); #ifdef DEBUG_MINIMIZE_EXEC // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ debug ~~~~ MessageInterface::ShowMessage (" objective=%s, %p\n", objective->GetDescription().c_str(), objective); MessageInterface::ShowMessage(" Parameter target: %s val = %lf\n", objective->GetDescription().c_str(), val); #endif // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ end debug ~~~~ optimizer->SetResultValue(objId, val, "Objective"); } else { // ERROR ERROR - should I throw an exception here? *********** TBD ************** MessageInterface::ShowMessage( "Minimize: Warning - objective function is NULL\n"); val = -999.999; //val = goalObject->GetRealParameter(parmId); // again,no clue optimizer->SetResultValue(objId, val, "Objective"); #ifdef DEBUG_MINIMIZE_EXEC // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ debug ~~~~ MessageInterface::ShowMessage(" Object target: val = %lf\n", val); #endif // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ end debug ~~~~ } //targeter->SetResultValue(goalId, val); BuildCommandSummary(true); return retval; }
//--------------------------------------------------------------------------- bool PenUp::Execute() { for (unsigned int ii = 0; ii < thePlotList.size(); ii++) { if (thePlotList.at(ii)) if (!(thePlotList.at(ii)->TakeAction("PenUp"))) return false; } // Build command summary BuildCommandSummary(true); return true; }
//------------------------------------------------------------------------------ bool EndTarget::Execute() { #ifdef DEBUG_TARGET_COMMANDS if (next) MessageInterface::ShowMessage( wxT("End Target points to a %s command\n"), next->GetTypeName().c_str()); else MessageInterface::ShowMessage( wxT("EndTarget does not reconnect to Target comamnd\n")); #endif BuildCommandSummary(true); return true; }
//------------------------------------------------------------------------------ // Execute //------------------------------------------------------------------------------ bool EndOptimize::Execute() { #ifdef DEBUG_OPTIMIZER_COMMANDS if (next) MessageInterface::ShowMessage( "End Optimize points to a %s command\n", next->GetTypeName().c_str()); else MessageInterface::ShowMessage( "EndOptimize does not reconnect to Optimize comamnd\n"); #endif BuildCommandSummary(true); return true; }
//--------------------------------------------------------------------------- bool PenDown::Execute() { #ifdef DEBUG_PENDOWN MessageInterface::ShowMessage ("PenDown::Execute() thePlotList.size()=%d\n", thePlotList.size()); #endif for (unsigned int ii = 0; ii < thePlotList.size(); ii++) { if (thePlotList.at(ii)) if (!(thePlotList.at(ii)->TakeAction("PenDown"))) return false; } // Build command summary BuildCommandSummary(true); #ifdef DEBUG_PENDOWN MessageInterface::ShowMessage("PenDown::Execute() returning true\n"); #endif return true; }
//------------------------------------------------------------------------------ bool NonlinearConstraint::Execute() { #ifdef DEBUG_NONLINEAR_CONSTRAINT_EXEC MessageInterface::ShowMessage (wxT("NonlinearConstraint::Execute() optimizerDataFinalized=%d\n, optimizer=%s, ") wxT("arg1=%p, arg2=%p\n"), optimizerDataFinalized, optimizer, arg1, arg2); MessageInterface::ShowMessage (wxT(" arg1Name=%s\n"), arg1Name.c_str()); MessageInterface::ShowMessage (wxT(" arg2Name=%s\n"), arg2Name.c_str()); #endif bool retval = true; if (!optimizerDataFinalized) { // Tell the optimizer about the constraint Real conData[1]; conData[0] = 54321.0; // objective function value here ......... constraintId = optimizer->SetSolverResults(conData, arg1Name, isIneqString); optimizerDataFinalized = true; return retval; } //#ifdef DEBUG_NLC_VALUES // MessageInterface::ShowMessage("NLC:Execute - desiredValue = %.12f\n", // desiredValue); //#endif Real constraintValue = -999.99; // Evaluate variable and pass it to the optimizer if ( (arg1 != NULL) && (arg2 != NULL) ) { desiredValue = arg2->EvaluateReal(); constraintValue = arg1->EvaluateReal(); #ifdef DEBUG_NLC_VALUES MessageInterface::ShowMessage(wxT("NLC:Execute - desiredValue = %.12f\n"), desiredValue); MessageInterface::ShowMessage(wxT("NLC:Execute - (1) constraintValue = %.12f\n"), constraintValue); #endif switch (op) { case EQUAL: case LESS_THAN_OR_EQUAL: constraintValue = constraintValue - desiredValue; break; case GREATER_THAN_OR_EQUAL: constraintValue = desiredValue - constraintValue; break; default: break; } #ifdef DEBUG_NLC_VALUES MessageInterface::ShowMessage(wxT("NLC:Execute - (2) constraintValue now = %.12f\n"), constraintValue); #endif optimizer->SetResultValue(constraintId, constraintValue, isIneqString); #ifdef DEBUG_NONLINEAR_CONSTRAINT_EXEC MessageInterface::ShowMessage (wxT(" constraint=%s, %p\n"), constraint->GetTypeName().c_str(), constraint); MessageInterface::ShowMessage(wxT(" Parameter target: %s constraintValue = %lf\n"), constraint->GetTypeName().c_str(), constraintValue); #endif } else { // isn't this an error??? //constraintValue = -999.99; // what to do here? //constraintValue = constraintObject->GetRealParameter(parmId); // again,no clue optimizer->SetResultValue(constraintId, constraintValue, isIneqString); #ifdef DEBUG_NONLINEAR_CONSTRAINT_EXEC MessageInterface::ShowMessage(wxT(" Object target: constraintValue = %lf\n"), constraintValue); #endif } BuildCommandSummary(true); return retval; }
//------------------------------------------------------------------------------ bool Target::Execute() { #ifdef DEBUG_TARGET_EXEC MessageInterface::ShowMessage (wxT("Target::Execute() entered, theSolver=<%p>'%s'\n"), (GmatBase*)theSolver, theSolver->GetName().c_str()); MessageInterface::ShowMessage (wxT("maxIter=%d\n"), theSolver->GetIntegerParameter(theSolver->GetParameterID(wxT("MaximumIterations")))); MessageInterface::ShowMessage (wxT("currentFunction=<%p>'%s'\n"), currentFunction, currentFunction ? ((GmatBase*)currentFunction)->GetName().c_str() : wxT("NULL")); #endif // If targeting inside a function, we need to reinitialize since the local solver is // cloned in Initialize(). All objects including solvers are initialized in // assignment command which happens after Target::Initialize(). (LOJ: 2009.03.17) if (currentFunction != NULL && !targeterInFunctionInitialized) { Initialize(); targeterInFunctionInitialized = true; } bool retval = true; // Drive through the state machine. Solver::SolverState state = theSolver->GetState(); #ifdef DEBUG_TARGET_COMMANDS MessageInterface::ShowMessage(wxT("TargetExecute(%c%c%c%d)\n"), (commandExecuting?wxT('Y'):wxT('N')), (commandComplete?wxT('Y'):wxT('N')), (branchExecuting?wxT('Y'):wxT('N')), state); MessageInterface::ShowMessage(wxT(" targeterConverged=%d\n"), targeterConverged); #endif // Attempt to reset if recalled if (commandComplete) { commandComplete = false; commandExecuting = false; specialState = Solver::INITIALIZING; } if (!commandExecuting) { #ifdef DEBUG_TARGET_COMMANDS MessageInterface::ShowMessage( wxT("Entered Targeter while command is not executing\n")); #endif FreeLoopData(); StoreLoopData(); retval = SolverBranchCommand::Execute(); #ifdef DEBUG_TARGETER MessageInterface::ShowMessage(wxT("Resetting the Differential Corrector\n")); #endif theSolver->TakeAction(wxT("Reset")); state = theSolver->GetState(); } if (branchExecuting) { retval = ExecuteBranch(); if (!branchExecuting) { if ((state == Solver::FINISHED) || (specialState == Solver::FINISHED)) { PenDownSubscribers(); LightenSubscribers(1); commandComplete = true; } else { PenUpSubscribers(); } } } else { GmatCommand *currentCmd; publisher->SetRunState(Gmat::SOLVING); switch (startMode) { case RUN_INITIAL_GUESS: #ifdef DEBUG_START_MODE MessageInterface::ShowMessage( wxT("Running as RUN_INITIAL_GUESS, specialState = %d, currentState = %d\n"), specialState, theSolver->GetState()); #endif switch (specialState) { case Solver::INITIALIZING: // Finalize initialization of the targeter data currentCmd = branch[0]; targeterConverged = false; while (currentCmd != this) { wxString type = currentCmd->GetTypeName(); if ((type == wxT("Target")) || (type == wxT("Vary")) || (type == wxT("Achieve"))) currentCmd->Execute(); currentCmd = currentCmd->GetNext(); } StoreLoopData(); specialState = Solver::NOMINAL; break; case Solver::NOMINAL: // Execute the nominal sequence if (!commandComplete) { branchExecuting = true; ResetLoopData(); } specialState = Solver::RUNSPECIAL; break; case Solver::RUNSPECIAL: // Run once more to publish the data from the converged state if (!commandComplete) { ResetLoopData(); branchExecuting = true; publisher->SetRunState(Gmat::SOLVEDPASS); } theSolver->Finalize(); specialState = Solver::FINISHED; // Final clean-up targeterConverged = true; break; case Solver::FINISHED: specialState = Solver::INITIALIZING; break; default: break; } break; case RUN_SOLUTION: #ifdef DEBUG_START_MODE MessageInterface::ShowMessage( wxT("Running as RUN_SOLUTION, state = %d\n"), state); #endif throw SolverException( wxT("Run Solution is not yet implemented for the Target ") wxT("command\n")); break; case RUN_AND_SOLVE: default: #ifdef DEBUG_START_MODE MessageInterface::ShowMessage( wxT("Running as RUN_AND_SOLVE or default, state = %d\n"), state); #endif switch (state) { case Solver::INITIALIZING: // Finalize initialization of the targeter data currentCmd = branch[0]; targeterConverged = false; while (currentCmd != this) { wxString type = currentCmd->GetTypeName(); if ((type == wxT("Target")) || (type == wxT("Vary")) || (type == wxT("Achieve"))) { currentCmd->Execute(); if ((type == wxT("Vary")) && (targeterRunOnce)) currentCmd->TakeAction(wxT("SolverReset")); } currentCmd = currentCmd->GetNext(); } StoreLoopData(); GetActiveSubscribers(); SetSubscriberBreakpoint(); break; case Solver::NOMINAL: // Execute the nominal sequence if (!commandComplete) { branchExecuting = true; ApplySubscriberBreakpoint(); PenDownSubscribers(); LightenSubscribers(1); ResetLoopData(); } break; case Solver::CHECKINGRUN: // Check for convergence; this is done in the targeter state // machine, so this case is a NoOp for the Target command break; case Solver::PERTURBING: branchExecuting = true; ApplySubscriberBreakpoint(); PenDownSubscribers(); LightenSubscribers(4); ResetLoopData(); break; case Solver::CALCULATING: // Calculate the next set of variables to use; this is // performed in the targeter -- nothing to be done here break; case Solver::FINISHED: // Final clean-up targeterConverged = true; targeterRunOnce = true; // Run once more to publish the data from the converged state if (!commandComplete) { ResetLoopData(); branchExecuting = true; ApplySubscriberBreakpoint(); PenDownSubscribers(); LightenSubscribers(1); publisher->SetRunState(Gmat::SOLVEDPASS); } break; case Solver::ITERATING: // Intentional fall-through default: throw CommandException( wxT("Invalid state in the Targeter state machine")); } break; } } if (!branchExecuting) { theSolver->AdvanceState(); if (theSolver->GetState() == Solver::FINISHED) { publisher->FlushBuffers(); targeterConverged = true; } } // Pass spacecraft data to the targeter for reporting in debug mode if (targeterInDebugMode) { wxString dbgData = wxT(""); for (ObjectArray::iterator i = localStore.begin(); i < localStore.end(); ++i) { dbgData += (*i)->GetGeneratingString() + wxT("\n---\n"); } theSolver->SetDebugString(dbgData); } BuildCommandSummary(true); #ifdef DEBUG_TARGET_EXEC MessageInterface::ShowMessage (wxT("Target::Execute() returning %d, theSolver=<%p>'%s'\n"), retval, theSolver, theSolver->GetName().c_str()); #endif return retval; }
//------------------------------------------------------------------------------ bool EndFiniteBurn::Execute() { ValidateThrusters(); // Only do this if the FiniteBurn is the one this command controls... bool forceActive = false; for (std::vector<PhysicalModel*>::iterator j = transientForces->begin(); j != transientForces->end(); ++j) { if (((*j)->GetName()) == thrustName) { // ... and if it is set for the right spacecraft StringArray burnSatNames = (*j)->GetRefObjectNameArray(Gmat::SPACECRAFT); bool foundSats = false; UnsignedInt numberFound = 0; for (UnsignedInt i = 0; i < satNames.size(); ++i) { if (find(burnSatNames.begin(), burnSatNames.end(), satNames[i]) != burnSatNames.end()) { foundSats = true; ++numberFound; } } if (foundSats) { #ifdef DEBUG_TRANSIENT_FORCES MessageInterface::ShowMessage("EndFiniteBurn::Execute(): The burn " "is active\n"); #endif forceActive = true; if (numberFound != satNames.size()) MessageInterface::ShowMessage("*** WARNING *** Turning off the " "finite burn %s, but the EndFiniteBurn command did not " "list all of the spacecraft that are no longer " "maneuvering.\n", burnName.c_str()); break; } } } if (forceActive) { // Turn off all of the referenced thrusters for (std::vector<Thruster*>::iterator i = thrusters.begin(); i != thrusters.end(); ++i) { Thruster *th = *i; #ifdef DEBUG_END_MANEUVER_EXE MessageInterface::ShowMessage ("EndFiniteBurn::Execute() Deactivating engine <%p>'%s'\n", th, th->GetName().c_str()); #endif th->SetBooleanParameter(th->GetParameterID("IsFiring"), false); #ifdef DEBUG_END_MANEUVER_EXE MessageInterface::ShowMessage ("Checking to see if engine is inactive: returned %s\n", (th->GetBooleanParameter(th->GetParameterID("IsFiring")) ? "true" : "false")); #endif } // Tell active spacecraft that they are no longer firing for (std::vector<Spacecraft*>::iterator s=sats.begin(); s!=sats.end(); ++s) { #ifdef DEBUG_END_MANEUVER_EXE MessageInterface::ShowMessage ("EndFiniteBurn::Execute() Deactivating maneuvers on Spacecraft " "<%p>'%s'\n", *s, (*s)->GetName().c_str()); #endif /// todo: Be sure that no other maneuver has the spacecraft maneuvering; /// for R2013a this is not an issue since only 1 burn per spacecraft is /// allowed. We'll need to fix this when that restriction is removed. (*s)->IsManeuvering(false); } // Remove the force from the list of transient forces for (std::vector<PhysicalModel*>::iterator j = transientForces->begin(); j != transientForces->end(); ++j) { if (((*j)->GetName()) == thrustName) { #ifdef DEBUG_TRANSIENT_FORCES MessageInterface::ShowMessage ("EndFiniteBurn::Execute() Removing burnForce<%p>'%s' from " "transientForces\n", *j, (*j)->GetName().c_str()); #endif transientForces->erase(j); break; } } // Reset maneuvering to Publisher so that any subscriber can do its own action if (!sats.empty()) { Real epoch = sats[0]->GetEpoch(); publisher->SetManeuvering(this, false, epoch, satNames, "end of finite " "maneuver"); } #ifdef DEBUG_END_MANEUVER_EXE MessageInterface::ShowMessage("EndFiniteBurn::Execute() Current TransientForces list:\n"); for (std::vector<PhysicalModel*>::iterator j = transientForces->begin(); j != transientForces->end(); ++j) MessageInterface::ShowMessage(" %s\n", (*j)->GetName().c_str()); #endif } BuildCommandSummary(true); return true; }
//------------------------------------------------------------------------------ bool EndIf::Execute() { BuildCommandSummary(true); return true; }
//------------------------------------------------------------------------------ bool If::Execute() { bool retval = true; if (branchExecuting) { #ifdef DEBUG_IF_EXEC MessageInterface::ShowMessage (wxT("In If::Execute - Branch Executing -------------\n")); #endif retval = ExecuteBranch(branchToExecute); #ifdef DEBUG_IF_EXEC MessageInterface::ShowMessage (wxT("In If:: retval returned from ExecuteBranch = %s\n"), (retval? wxT("true") : wxT("false"))); MessageInterface::ShowMessage (wxT(" branchExecuting=%d\n"), branchExecuting); #endif if (!branchExecuting) { commandComplete = true; commandExecuting = false; } } else { #ifdef DEBUG_IF_EXEC MessageInterface::ShowMessage (wxT("In If::Execute - Branch NOT Executing -------------\n")); #endif if (!commandExecuting) ConditionalBranch::Execute(); //if (EvaluateCondition(0)) // must deal with multiple conditions later if (EvaluateAllConditions()) { #ifdef DEBUG_IF_EXEC MessageInterface::ShowMessage (wxT("In If::Execute all conditions are true - executing first branch\n")); #endif branchToExecute = 0; branchExecuting = true; commandComplete = false; commandExecuting = true; } else if ((Integer)branch.size() > 1) // there could be an 'Else' { #ifdef DEBUG_IF_EXEC MessageInterface::ShowMessage (wxT("In If::Execute some conditions are FALSE - executing second branch\n")); #endif branchExecuting = true; branchToExecute = 1; // @todo - add ElseIf (more than two branches) commandComplete = false; commandExecuting = true; } else { #ifdef DEBUG_IF_EXEC MessageInterface::ShowMessage (wxT("In If::Execute - conditions are FALSE - no other branch to execute\n")); //("In If::Execute - ERROR with number of branches - more than two not yet implemented\n"); #endif branchToExecute = 0; commandComplete = true; commandExecuting = false; branchExecuting = false; // try this - shouldn't matter } } BuildCommandSummary(true); #ifdef DEBUG_IF_EXEC MessageInterface::ShowMessage (wxT("If::BuildCommandSummary completed\n")); #endif return retval; } // Execute()
//------------------------------------------------------------------------------ bool BeginFiniteBurn::Execute() { ValidateThrusters(); // Turn on all of the referenced thrusters #ifdef DEBUG_BEGIN_MANEUVER_EXE MessageInterface::ShowMessage ("BeginFiniteBurn::Execute() <%p>'%s' entered\n " "There are %d thruster(s) in use\n", this, GetGeneratingString(Gmat::NO_COMMENTS).c_str(), thrusters.size()); #endif for (std::vector<Thruster*>::iterator i = thrusters.begin(); i != thrusters.end(); ++i) { Thruster *th = *i; #ifdef DEBUG_BEGIN_MANEUVER_EXE MessageInterface::ShowMessage ("Activating engine <%p>'%s'\n", th, th->GetName().c_str()); #endif th->SetBooleanParameter(th->GetParameterID("IsFiring"), true); #ifdef DEBUG_BEGIN_MANEUVER_EXE MessageInterface::ShowMessage ("Checking to see if engine is active: returned %s\n", (th->GetBooleanParameter(th->GetParameterID("IsFiring")) ? "true" : "false")); #endif } // Tell active spacecraft that they are now firing for (std::vector<Spacecraft*>::iterator s=sats.begin(); s!=sats.end(); ++s) { (*s)->IsManeuvering(true); } if (transientForces == NULL) throw CommandException("Transient force list was NOT initialized; " "ABORTING RUN!!!\n\n"); // Insert the force into the list of transient forces if not found if (transientForces->size() == 0) { #ifdef DEBUG_TRANSIENT_FORCES MessageInterface::ShowMessage ("BeginFiniteBurn::Execute() Adding first burnForce<%p>'%s' to " "transientForces\n", burnForce, burnForce->GetName().c_str()); #endif transientForces->push_back(burnForce); } else { bool alreadyThere = false; for (std::vector<PhysicalModel*>::iterator i = transientForces->begin(); i !=transientForces->end(); ++i) { if ((*i)->IsOfType("FiniteThrust")) { FiniteThrust *transient = (FiniteThrust*)(*i); if (transient == burnForce) { alreadyThere = true; } if ((*transient) == (*burnForce)) { MessageInterface::ShowMessage("Burn activated by the line\n " "%s\noverlaps with an active finite burn. No new finite " "burn will be applied.\n", GetGeneratingString(Gmat::NO_COMMENTS).c_str()); alreadyThere = true; } } } if (alreadyThere == false) { #ifdef DEBUG_TRANSIENT_FORCES MessageInterface::ShowMessage("BeginFiniteBurn::Execute() Adding " "burnForce<%p>'%s' to transientForces\n", burnForce, burnForce->GetName().c_str()); #endif transientForces->push_back(burnForce); } } // Set maneuvering to Publisher so that any subscriber can do its own action if (!sats.empty()) { Real epoch = sats[0]->GetEpoch(); publisher->SetManeuvering(this, true, epoch, satNames, "begin of finite maneuver"); } #ifdef DEBUG_BEGIN_MANEUVER_EXE MessageInterface::ShowMessage ("There are %d transient force(s)\n", transientForces->size()); MessageInterface::ShowMessage("Current TransientForces list:\n"); for (std::vector<PhysicalModel*>::iterator j = transientForces->begin(); j != transientForces->end(); ++j) MessageInterface::ShowMessage(" %s\n", (*j)->GetName().c_str()); #endif BuildCommandSummary(true); return true; }
//------------------------------------------------------------------------------ bool BeginScript::Execute() { BuildCommandSummary(true); return true; }
//------------------------------------------------------------------------------ bool NoOp::Execute() { BuildCommandSummary(true); return true; }
//------------------------------------------------------------------------------ bool Set::Execute() { #ifdef DEBUG_SET_EXEC MessageInterface::ShowMessage("Set::Execute() entered\n"); #endif bool retval = false, valueSet = false; if (theInterface == NULL) throw CommandException("The FileInterface object \"" + interfaceName + "\" was not found."); if (theInterface->Open() == 0) { retval = theInterface->LoadData(); if (theInterface->Close() != 0) { MessageInterface::ShowMessage("The interface failed to close\n"); } if (retval) { UnsignedInt parmCount = 0; StringArray allItems = theInterface->GetStringArrayParameter("SupportedFields"); std::string theItem, theParmString; if (loadAll) parmCount = allItems.size(); else parmCount = selections.size(); std::stringstream parametersNotSet; for (UnsignedInt i = 0; i < parmCount; ++i) { theItem = (loadAll ? allItems[i] : selections[i]); DataReader::readerDataType fieldType = theInterface->GetReaderParameterType(theItem); if (SetTargetParameterData(fieldType, theItem)) valueSet = true; else parametersNotSet << " The parameter " << theItem << " did not set data on the object " << targetName << "; either the field is missing from the " << "file or the field value is not valid.\n"; } if (parametersNotSet.str().length() > 0) //if (loadAll) // MessageInterface::ShowMessage("*** Warning *** Loading failed " // "for the following parameters:\n%sin the line\n%s\n", // parametersNotSet.str().c_str(), // GetGeneratingString(Gmat::NO_COMMENTS).c_str()); //else throw CommandException("Error loading data from a DataInterface:\n" + parametersNotSet.str() + "in the line\n" + GetGeneratingString(Gmat::NO_COMMENTS)); } #ifdef DEBUG_SET_EXEC else MessageInterface::ShowMessage("Set::Execute() LoadData returned " "false\n"); #endif } #ifdef DEBUG_SET_EXEC else MessageInterface::ShowMessage("Set::Execute(): The interface did not " "open\n"); #endif BuildCommandSummary(); return retval && valueSet; }