class to build optimization loops More...

#include <OptimizerLoop.hxx>

Inheritance diagram for YACS::ENGINE::OptimizerLoop:

[legend]

Collaboration diagram for YACS::ENGINE::OptimizerLoop:

[legend]

Public Member Functions
	OptimizerLoop (const std::string &name, const std::string &algLibWthOutExt, const std::string &symbolNameToOptimizerAlgBaseInstanceFactory, bool algInitOnFile, bool initAlgo=true, Proc *procForTypes=NULL)

	OptimizerLoop (const OptimizerLoop &other, ComposedNode *father, bool editionOnly)

	~OptimizerLoop ()

void	init (bool start=true)

void	exUpdateState ()
	Update the node state. More...

int	getNumberOfInputPorts () const

InputPort *	edGetPortForOutPool ()

InputPort *	edGetAlgoInitPort ()

OutputPort *	edGetAlgoResultPort ()

InputPort *	getInputPort (const std::string &name) const
	Get an input port given its name. More...

std::list< InputPort * >	getSetOfInputPort () const

std::list< InputPort * >	getLocalInputPorts () const
	redefined on derived class of ComposedNode. by default a ComposedNode has no port by itself More...

void	selectRunnableTasks (std::vector< Task * > &tasks)

void	getReadyTasks (std::vector< Task * > &tasks)

YACS::Event	updateStateOnFinishedEventFrom (Node *node)

void	checkNoCyclePassingThrough (Node *node)

virtual void	accept (Visitor *visitor)

virtual std::string	getSymbol () const

virtual std::string	getAlgLib () const
	Return the name of the algorithm library. More...

virtual void	setAlgorithm (const std::string &alglib, const std::string &symbol, bool checkLinks=true, Proc *procForTypes=NULL)
	Set the algorithm library name and factory name (symbol in library) to create the algorithm and change it if the node is not connected. More...

virtual void	checkBasicConsistency () const
	Check validity for the node. More...

virtual std::string	typeName ()

int	getNumberOfOutputPorts () const

std::list< OutputPort * >	getSetOfOutputPort () const

std::list< OutputPort * >	getLocalOutputPorts () const
	redefined on derived class of ComposedNode. by default a ComposedNode has no port by itself More...

OutPort *	getOutPort (const std::string &name) const

OutputPort *	getOutputPort (const std::string &name) const
	Get an output port given its name. More...

YACS::Event	finalize ()

Public Member Functions inherited from YACS::ENGINE::DynParaLoop
Node *	edRemoveNode ()

Node *	edRemoveInitNode ()

Node *	edRemoveFinalizeNode ()

Node *	edSetNode (Node *DISOWNnode)

Node *	edSetInitNode (Node *DISOWNnode)

Node *	edSetFinalizeNode (Node *DISOWNnode)

virtual bool	edAddDFLink (OutPort start, InPort end)
	Connect an OutPort to an InPort and add control link if necessary. More...

InputPort *	edGetNbOfBranchesPort ()

unsigned	getNumberOfEltsConsumed () const

int	getBranchIDOfNode (Node *node) const

OutputPort *	edGetSamplePort ()

bool	isPlacementPredictableB4Run () const
	For the moment false is returned : impovement about it coming soon. More...

void	edRemoveChild (Node *node)
	Remove a child node. More...

bool	isLoop () const override

virtual bool	edAddChild (Node *DISOWNnode)

std::list< Node * >	edGetDirectDescendants () const

unsigned	getNumberOfBranchesCreatedDyn () const

Node *	getChildByShortName (const std::string &name) const

Node *	getChildByNameExec (const std::string &name, unsigned id) const

std::vector< Node * >	getNodes () const

ComplexWeight *	getWeight ()

void	setWeight (double loopWeight)

void	getWeightRegardingDPL (ComplexWeight *weight)

bool	isMultiplicitySpecified (unsigned &value) const

void	forceMultiplicity (unsigned value)

virtual std::string	getErrorReport ()
	returns a string that contains an error report if the node is in error More...

Node *	getInitNode ()

Node *	getExecNode ()

Node *	getFinalizeNode ()

int	getMaxLevelOfParallelism () const

void	partitionRegardingDPL (const PartDefinition pd, std::map< ComposedNode , YACS::BASES::AutoRefCnt< PartDefinition > > &zeMap)

virtual void	cleanDynGraph ()

Public Member Functions inherited from YACS::ENGINE::ComposedNode
virtual	~ComposedNode ()

bool	isFinished ()

virtual void	resetState (int level)
	Reset the state of the node and its children depending on the parameter level. More...

std::string	getName () const

std::string	getTaskName (Task *task) const

DeploymentTree	getDeploymentTree () const
	Essentially for test. Use checkDeploymentTree instead to be sure that returned DeploymentTree is consistent. More...

DeploymentTree	checkDeploymentTree (bool deep) const
	Perform check of deployment consistency of the current graph. More...

std::vector< Task * >	getNextTasks (bool &isMore)

void	notifyFrom (const Task sender, YACS::Event event, const Executor execInst)
	Notify the node a task has emitted an event. More...

bool	edAddLink (OutPort start, InPort end)
	Add a dataflow link between two data ports. More...

bool	edAddLink (OutGate start, InGate end)
	Add a controlflow link between two control ports. More...

bool	edAddCFLink (Node nodeS, Node nodeE)
	Add a controlflow link between two nodes. More...

void	edRemoveCFLink (Node nodeS, Node nodeE)
	Remove a controlflow link. More...

void	edRemoveLink (OutPort start, InPort end)
	Remove a dataflow link. More...

void	edRemoveLink (OutGate start, InGate end)
	Remove a controlflow link. More...

virtual bool	isRepeatedUnpredictablySeveralTimes () const

virtual void	removeRecursivelyRedundantCL ()

std::list< ElementaryNode * >	getRecursiveConstituents () const

std::list< Node * >	getAllRecursiveNodes ()
	Get all children nodes elementary and composed including this node. More...

virtual std::list< Node * >	getAllRecursiveConstituents ()
	Idem getAllRecursiveNodes, but this node is NOT included. More...

std::list< ProgressWeight >	getProgressWeight () const
	Get the progress weight for all elementary nodes. More...

std::string	getInPortName (const InPort *) const
	Get the input port name. More...

std::string	getOutPortName (const OutPort *) const

std::set< OutPort * >	getAllOutPortsLeavingCurrentScope () const
	List all output ports of children nodes that are linked to out of scope input ports. More...

std::set< InPort * >	getAllInPortsComingFromOutsideOfCurrentScope () const
	List all input ports that are linked to out of scope ports. More...

std::list< InputDataStreamPort * >	getSetOfInputDataStreamPort () const

std::list< OutputDataStreamPort * >	getSetOfOutputDataStreamPort () const

InputDataStreamPort *	getInputDataStreamPort (const std::string &name) const

OutputDataStreamPort *	getOutputDataStreamPort (const std::string &name) const

std::vector< std::pair< OutPort , InPort > >	getSetOfInternalLinks () const

virtual std::vector< std::pair< OutPort , InPort > >	getSetOfLinksLeavingCurrentScope () const

void	checkConsistency (LinkInfo &info) const

virtual std::vector< std::pair< InPort , OutPort > >	getSetOfLinksComingInCurrentScope () const

virtual void	edUpdateState ()
	update the status of the node More...

ComposedNode *	getRootNode () const

bool	isNodeAlreadyAggregated (const Node *node) const
	Check that Node 'node' is already a direct son of this. More...

virtual bool	isNameAlreadyUsed (const std::string &name) const

Node *	isInMyDescendance (Node *nodeToTest) const
	Returns the parent of a node that is the direct child of this node. More...

std::string	getChildName (const Node *node) const

virtual std::string	getMyQualifiedName (const Node *directSon) const

Node *	getChildByName (const std::string &name) const

void	loaded ()

void	connected ()

virtual void	cleanNodes ()
	Clean the composed node in case of not clean exit. More...

virtual std::string	getProgress () const

void	setProperty (const std::string &name, const std::string &value) override

std::string	getProperty (const std::string &name) override

Public Member Functions inherited from YACS::ENGINE::Node
virtual	~Node ()

Node *	clone (ComposedNode *father, bool editionOnly=true) const
	This method MUST NEVER BE VIRTUAL More...

Node *	cloneWithoutCompAndContDeepCpy (ComposedNode *father, bool editionOnly=true) const
	This method MUST NEVER BE VIRTUAL More...

void	setState (YACS::StatesForNode theState)
	Sets the given state for node. More...

virtual YACS::StatesForNode	getState () const

virtual YACS::StatesForNode	getEffectiveState () const
	Return the node state in the context of its father. More...

virtual YACS::StatesForNode	getEffectiveState (const Node *) const
	Return the effective state of a node in the context of this one (its father) More...

std::string	getColorState (YACS::StatesForNode state) const
	Return the color associated to a state. More...

InGate *	getInGate ()

OutGate *	getOutGate ()

const std::string &	getName () const

void	setName (const std::string &name)
	Change the name of the node. More...

ComposedNode *	getFather () const

const std::string	getId () const

bool	exIsControlReady () const

std::list< Node * >	getOutNodes () const

virtual void	writeDot (std::ostream &os) const
	Dump to the input stream a dot representation of the node. More...

void	writeDotInFile (const std::string &fileName) const

virtual void	exFailedState ()
	Notify this node that its execution has failed. More...

virtual void	exDisabledState ()
	Notify this node that it has been disabled. More...

std::list< InPort * >	getSetOfInPort () const

std::list< OutPort * >	getSetOfOutPort () const

virtual std::set< InputPort * >	edGetSetOfUnitializedInputPort () const
	Becomes deprecated soon. Replaced by ComposedNode::CheckConsistency. More...

virtual bool	edAreAllInputPortInitialized () const
	Becomes deprecated soon. Replaced by ComposedNode::CheckConsistency. More...

InPort *	getInPort (const std::string &name) const

InPropertyPort *	getInPropertyPort () const

std::list< ComposedNode * >	getAllAscendanceOf (ComposedNode *levelToStop=0) const

bool	operator> (const Node &other) const

bool	operator< (const Node &other) const

std::string	getImplementation () const

DynParaLoop *	getClosestDPLAmongAncestors () const

std::map< std::string, std::string >	getProperties ()

std::map< std::string, std::string >	getPropertyMap ()

virtual void	setProperties (std::map< std::string, std::string > properties)

virtual Proc *	getProc ()

virtual const Proc *	getProc () const

std::string	getQualifiedName () const
	same as Node::getName() in most cases, but differs for children of switch More...

int	getNumId ()
	return node instance identifiant, unique for each node instance More...

std::vector< std::pair< std::string, int > >	getDPLScopeInfo (ComposedNode *gfn)

virtual void	applyDPLScope (ComposedNode *gfn)

virtual void	sendEvent (const std::string &event)
	emit notification to all observers registered with the dispatcher More...

virtual void	sendEvent2 (const std::string &event, void *something)
	emit notification to all observers registered with the dispatcher More...

virtual std::string	getErrorDetails () const

virtual void	setErrorDetails (const std::string &error)

virtual void	modified ()
	Sets Node in modified state and its father if it exists. More...

virtual int	isModified ()

virtual int	isValid ()
	indicates if the node is valid (returns 1) or not (returns 0) More...

virtual std::string	getContainerLog ()
	returns a string that contains the name of the container log file if it exists More...

virtual void	ensureLoading ()
	Put this node into TOLOAD state when possible. More...

virtual void	getCoupledNodes (std::set< Task * > &coupledNodes)

Public Member Functions inherited from YACS::ENGINE::Scheduler
virtual	~Scheduler ()

Protected Member Functions
virtual YACS::Event	updateStateOnFailedEventFrom (Node node, const Executor execInst)
	Method used to notify the node that a child node has failed. More...

void	buildDelegateOf (InPort &port, OutPort initialStart, const std::list< ComposedNode * > &pointsOfView)

void	buildDelegateOf (std::pair< OutPort , OutPort > &port, InPort finalTarget, const std::list< ComposedNode > &pointsOfView)

void	checkControlDependancy (OutPort start, InPort end, bool cross, std::map< ComposedNode , std::list< OutPort >, SortHierarc > &fw, std::vector< OutPort * > &fwCross, std::map< ComposedNode , std::list< OutPort >, SortHierarc > &bw, LinkInfo &info) const

void	checkCFLinks (const std::list< OutPort * > &starts, InputPort *end, unsigned char &alreadyFed, bool direction, LinkInfo &info) const
	check control flow links More...

void	checkLinkPossibility (OutPort start, const std::list< ComposedNode > &pointsOfViewStart, InPort end, const std::list< ComposedNode > &pointsOfViewEnd)

void	cleanInterceptors ()

void	launchMaxOfSamples (bool first)

bool	isFullyLazy () const

bool	isFullyBusy (unsigned &branchId) const

void	initInterceptors (unsigned nbOfBr)

void	pushValueOutOfScopeForCase (unsigned branchId)

Node *	simpleClone (ComposedNode *father, bool editionOnly=true) const

virtual void	loadAlgorithm ()
	Load the algorithm from the dynamic library. More...

Protected Member Functions inherited from YACS::ENGINE::DynParaLoop
	DynParaLoop (const std::string &name, TypeCode *typeOfDataSplitted, std::unique_ptr< NbBranchesAbstract > &&branchManager)

virtual	~DynParaLoop ()

	DynParaLoop (const DynParaLoop &other, ComposedNode *father, bool editionOnly)

void	prepareInputsFromOutOfScope (int branchNb)

void	putValueOnBranch (Any *val, unsigned branchId, bool first)

TypeOfNode	getIdentityOfNotifyerNode (const Node *node, unsigned &id)

InputPort *	getDynInputPortByAbsName (int branchNb, const std::string &name, bool initNodeAdmitted)

virtual void	forwardExecStateToOriginalBody (Node *execNode)

std::vector< Node * >	cloneAndPlaceNodesCoherently (const std::vector< Node * > &origNodes)
	Clone nodes and make their placement consistent with the placement of the original ones. More...

Node *	checkConsistencyAndSetNode (Node &nodeToReplace, Node DISOWNnode)
	This method is used to factorize methods edSetNode, edSetInitNode and edSetFinalizeNode. More...

Node *	removeNode (Node *&nodeToRemove)
	This method is used to factorize methods edRemoveNode, edRemoveInitNode and edRemoveFinalizeNode. More...

virtual void	shutdown (int level)
	Stop all pending activities of the composed node. More...

Protected Member Functions inherited from YACS::ENGINE::ComposedNode
	ComposedNode (const std::string &name)

	ComposedNode (const ComposedNode &other, ComposedNode *father)

void	performDuplicationOfPlacement (const Node &other)
	performs a duplication of placement using clone method of containers and components. clone behaviour is driven by attachOnCloning attribute. More...

void	performShallowDuplicationOfPlacement (const Node &other)
	performs a also duplication of placement but here containers and components are not copied at all whatever the value of attachedOnCloning. More...

void	edDisconnectAllLinksWithMe ()

YACS::Event	updateStateFrom (Node node, YACS::Event event, const Executor execInst)
	Update node state on receiving event from a node. More...

virtual YACS::Event	updateStateOnStartEventFrom (Node *node)
	Method used to notify the node that a child node has started. More...

virtual void	getDelegateOf (InPort &port, OutPort initialStart, const std::list< ComposedNode * > &pointsOfView)

virtual void	getDelegateOf (std::pair< OutPort , OutPort > &port, InPort finalTarget, const std::list< ComposedNode > &pointsOfView)

virtual void	releaseDelegateOf (InPort &port, OutPort initialStart, const std::list< ComposedNode * > &pointsOfView)

virtual void	releaseDelegateOf (OutPort portDwn, OutPort portUp, InPort finalTarget, const std::list< ComposedNode > &pointsOfView)

void	checkInMyDescendance (Node *nodeToTest) const
	Check if a node is in the descendance of this node. More...

template<class PORT >
std::string	getPortName (const PORT *port) const

void	checkNoCrossHierachyWith (Node *node) const

virtual void	performCFComputations (LinkInfo &info) const
	perform recursively all CF computations. More...

virtual void	destructCFComputations (LinkInfo &info) const
	destroy recursively all results of initial computations. More...

Node *	getLowestNodeDealingAll (const std::list< OutPort * > &ports) const

void	checkLinksCoherenceRegardingControl (const std::vector< OutPort * > &starts, InputPort *end, LinkInfo &info) const

void	solveObviousOrDelegateCFLinks (const std::list< OutPort * > &starts, InputPort *end, unsigned char &alreadyFed, bool direction, LinkInfo &info) const

Protected Member Functions inherited from YACS::ENGINE::Node
	Node (const std::string &name)

	Node (const Node &other, ComposedNode *father)

virtual void	exForwardFailed ()

virtual void	exForwardFinished ()

Protected Attributes
Pool	_myPool

bool	_algInitOnFile

std::string	_symbol

std::string	_alglib

AnyInputPort	_algoInitPort

::YACS::BASES::DynLibLoader *	_loader

OptimizerAlgBase *	_alg

AnyInputPort	_retPortForOutPool

std::vector< bool >	_initNodeUpdated

bool	_convergenceReachedWithOtherCalc

FakeNodeForOptimizerLoop *	_nodeForSpecialCases

std::vector< AnyInputPort * >	_interceptorsForOutPool

std::map< InputPort , std::vector< InputPort > >	_interceptors
	outputports interceptors leaving current scope. More...

AnyOutputPort	_algoResultPort

Protected Attributes inherited from YACS::ENGINE::DynParaLoop
Node *	_node

Node *	_initNode

Node *	_finalizeNode

unsigned	_nbOfEltConsumed

std::vector< int >	_execIds

std::unique_ptr< NbBranchesAbstract >	_nbOfBranches

AnyOutputPort	_splittedPort

std::vector< Node * >	_execNodes

std::vector< Node * >	_execInitNodes

std::vector< Node * >	_execFinalizeNodes

int	_initializingCounter

int	_unfinishedCounter

int	_failedCounter

ComplexWeight	_weight

double	_loopWeight

Protected Attributes inherited from YACS::ENGINE::Node
InGate	_inGate

OutGate	_outGate

InPropertyPort *	_inPropertyPort

std::string	_name

ComposedNode *	_father

YACS::StatesForNode	_state

int	_modified

std::string	_errorDetails

int	_numId

std::string	_implementation

std::map< std::string, std::string >	_propertyMap

Node *	_eventReceiver =nullptr

Static Protected Attributes
static const int	NOT_RUNNING_BRANCH_ID =-1973012217

static const int	NOT_INITIALIZED_BRANCH_ID =-1973

static const char	NAME_OF_ALGO_INIT_PORT [] = "algoInit"

static const char	NAME_OF_OUT_POOL_INPUT [] = "evalResults"

static const char	NAME_OF_ALGO_RESULT_PORT [] = "algoResults"

Static Protected Attributes inherited from YACS::ENGINE::DynParaLoop
static const char	NAME_OF_SPLITTED_SEQ_OUT [] = "evalSamples"

static const char	OLD_NAME_OF_SPLITTED_SEQ_OUT [] = "SmplPrt"

Static Protected Attributes inherited from YACS::ENGINE::ComposedNode
static const unsigned char	FED_ST = 2

static const unsigned char	FREE_ST = 0

static const unsigned char	FED_DS_ST = 1

Static Protected Attributes inherited from YACS::ENGINE::Node
static const char	SEP_CHAR_IN_PORT [] ="."

static int	_total = 0

Private Member Functions
TypeCode *	checkTypeCode (TypeCode tc, const char portName)

Friends
class	FakeNodeForOptimizerLoop

Additional Inherited Members
Static Public Member Functions inherited from YACS::ENGINE::ComposedNode
static ComposedNode *	getLowestCommonAncestor (Node node1, Node node2)
	Retrieves the lowest common ancestor of 2 nodes. More...

static std::string	getLowestCommonAncestorStr (const std::string &node1, const std::string &node2)

Static Public Member Functions inherited from YACS::ENGINE::Node
static std::string	getStateName (YACS::StatesForNode state)
	Return the name of a state. More...

static void	checkValidityOfNodeName (const std::string &name)

Public Attributes inherited from YACS::ENGINE::Node
YACS::Colour	_colour

Static Public Attributes inherited from YACS::ENGINE::ComposedNode
static const char	SEP_CHAR_BTW_LEVEL [] ="."

Static Public Attributes inherited from YACS::ENGINE::Node
static std::map< int, Node * >	idMap

Protected Types inherited from YACS::ENGINE::DynParaLoop
enum	TypeOfNode { INIT_NODE = 5 , WORK_NODE = 6 , FINALIZE_NODE = 7 }

Static Protected Member Functions inherited from YACS::ENGINE::ComposedNode
static bool	splitNamesBySep (const std::string &globalName, const char separator[], std::string &firstPart, std::string &lastPart, bool priority)
	Splits name globalName in 2 parts using separator. More...

Static Protected Member Functions inherited from YACS::ENGINE::Node
static void	checkValidityOfPortName (const std::string &name)

static ComposedNode *	checkHavingCommonFather (Node node1, Node node2)

Detailed Description

class to build optimization loops

Definition at line 56 of file OptimizerLoop.hxx.

Constructor & Destructor Documentation

◆ OptimizerLoop() [1/2]

OptimizerLoop::OptimizerLoop	(	const std::string &	name,
		const std::string &	algLibWthOutExt,
		const std::string &	symbolNameToOptimizerAlgBaseInstanceFactory,
		bool	algInitOnFile,
		bool	initAlgo = `true`,
		Proc *	procForTypes = `NULL`
	)

Definition at line 98 of file OptimizerLoop.cxx.

                                                                                    :
         DynParaLoop(name,Runtime::_tc_string,std::unique_ptr<NbBranchesAbstract>(new NbBranches(this))),_algInitOnFile(algInitOnFile),_alglib(algLibWthOutExt),
         _algoInitPort(NAME_OF_ALGO_INIT_PORT, this, Runtime::_tc_string, true),
         _loader(NULL),_alg(0),_convergenceReachedWithOtherCalc(false),
         _retPortForOutPool(NAME_OF_OUT_POOL_INPUT,this,Runtime::_tc_string),
         _nodeForSpecialCases(0), _algoResultPort(NAME_OF_ALGO_RESULT_PORT, this, Runtime::_tc_string)
 {
   //We need this because calling a virtual method in a constructor does not call the most derived method but the method of the class
   //A derived class must take care to manage that 
   if(initAlgo)
     setAlgorithm(algLibWthOutExt,symbolNameToOptimizerAlgBaseInstanceFactory, procForTypes);
 }

References setAlgorithm().

Referenced by simpleClone().

◆ OptimizerLoop() [2/2]

OptimizerLoop::OptimizerLoop	(	const OptimizerLoop &	other,
		ComposedNode *	father,
		bool	editionOnly
	)

Definition at line 113 of file OptimizerLoop.cxx.

                                                                                               :
   DynParaLoop(other,father,editionOnly),_algInitOnFile(other._algInitOnFile),_alglib(other._alglib),
   _convergenceReachedWithOtherCalc(false),_loader(NULL),_alg(0),_algoInitPort(other._algoInitPort,this),
   _retPortForOutPool(other._retPortForOutPool,this),_nodeForSpecialCases(0),
   _algoResultPort(other._algoResultPort, this)
 {
   //Don't call setAlgorithm here because it will be called several times if the class is derived. Call it in simpleClone for cloning
   
   // Create the links to evalResults port
   set<OutPort *> fromPortsToReproduce=other._retPortForOutPool.edSetOutPort();
   for(set<OutPort *>::iterator iter=fromPortsToReproduce.begin();iter!=fromPortsToReproduce.end();iter++)
     edAddLink(getOutPort(other.getPortName(*iter)),&_retPortForOutPool);
 }

References _retPortForOutPool, YACS::ENGINE::ComposedNode::edAddLink(), YACS::ENGINE::InPort::edSetOutPort(), getOutPort(), and YACS::ENGINE::ComposedNode::getPortName().

◆ ~OptimizerLoop()

OptimizerLoop::~OptimizerLoop ( )

Definition at line 127 of file OptimizerLoop.cxx.

 {
   if(_alg)
     _alg->decrRef();
   cleanDynGraph();
   cleanInterceptors();
   delete _loader;
   delete _nodeForSpecialCases;
 }

References _alg, _loader, _nodeForSpecialCases, YACS::ENGINE::DynParaLoop::cleanDynGraph(), cleanInterceptors(), and YACS::ENGINE::RefCounter::decrRef().

Member Function Documentation

◆ accept()

void OptimizerLoop::accept ( Visitor * visitor )

virtual

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 695 of file OptimizerLoop.cxx.

 {
   visitor->visitOptimizerLoop(this);
 }

References YACS::ENGINE::Visitor::visitOptimizerLoop().

◆ buildDelegateOf() [1/2]

void OptimizerLoop::buildDelegateOf	(	InPort *&	port,
		OutPort *	initialStart,
		const std::list< ComposedNode * > &	pointsOfView
	)

protectedvirtual

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 475 of file OptimizerLoop.cxx.

 {
   DynParaLoop::buildDelegateOf(port,initialStart,pointsOfView);
   if(port==&_retPortForOutPool)
   {
     std::string linkName("(");
     linkName += initialStart->getName()+" to "+port->getName()+")";
     throw Exception(std::string("Illegal OptimizerLoop link: \
 The 'evalResults' port must be linked within the scope of the loop.")
                     + linkName);
   }
 }

References _retPortForOutPool, YACS::ENGINE::DynParaLoop::buildDelegateOf(), and YACS::ENGINE::DataPort::getName().

◆ buildDelegateOf() [2/2]

void OptimizerLoop::buildDelegateOf	(	std::pair< OutPort , OutPort > &	port,
		InPort *	finalTarget,
		const std::list< ComposedNode * > &	pointsOfView
	)

protectedvirtual

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 488 of file OptimizerLoop.cxx.

 {
   DynParaLoop::buildDelegateOf(port,finalTarget,pointsOfView);
   if(port.first != &_algoResultPort)
   {
     std::string linkName("(");
     linkName += port.first->getName()+" to "+finalTarget->getName()+")";
     throw Exception(std::string("Illegal OptimizerLoop link: \
 Only the algorithm result port can be linked to a port outside the scope of the loop.")
                     + linkName);
   }
  
   string typeOfPortInstance=(port.first)->getNameOfTypeOfCurrentInstance();
   if(typeOfPortInstance!=OutputPort::NAME)
     throw Exception("OptimizerLoop::buildDelegateOf : not implemented for DS because not specified ");
 }

References _algoResultPort, YACS::ENGINE::DynParaLoop::buildDelegateOf(), YACS::ENGINE::DataPort::getName(), and YACS::ENGINE::OutputPort::NAME.

◆ checkBasicConsistency()

void OptimizerLoop::checkBasicConsistency ( ) const

virtual

Check validity for the node.

Throw an exception if the node is not valid

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 802 of file OptimizerLoop.cxx.

 {
   DEBTRACE("OptimizerLoop::checkBasicConsistency");
   if (_alglib == "")
     throw Exception("No library specified for the OptimizerLoop control algorithm");
   if (_symbol == "")
     throw Exception("No symbol specified for the OptimizerLoop control algorithm");
   if(_alg == NULL)
     throw YACS::Exception("Problem during library loading: "+_errorDetails);
  
   DynParaLoop::checkBasicConsistency();
 }

References _alg, _alglib, YACS::ENGINE::Node::_errorDetails, _symbol, YACS::ENGINE::DynParaLoop::checkBasicConsistency(), and DEBTRACE.

◆ checkCFLinks()

void OptimizerLoop::checkCFLinks	(	const std::list< OutPort * > &	starts,
		InputPort *	end,
		unsigned char &	alreadyFed,
		bool	direction,
		LinkInfo &	info
	)		const

protectedvirtual

check control flow links

Parameters

starts	If different of 0, must aggregate at leat 1 element.
end	:
alreadyFed	in/out parameter. Indicates if 'end' ports is already and surely set or fed by an another port.
direction	If true : forward direction else backward direction.
info	: informations collectedduring the check

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 517 of file OptimizerLoop.cxx.

 {
   if(end==&_retPortForOutPool)
     solveObviousOrDelegateCFLinks(starts,end,alreadyFed,direction,info);
   else
     DynParaLoop::checkCFLinks(starts,end,alreadyFed,direction,info);
 }

References _retPortForOutPool, YACS::ENGINE::DynParaLoop::checkCFLinks(), and YACS::ENGINE::ComposedNode::solveObviousOrDelegateCFLinks().

◆ checkControlDependancy()

void OptimizerLoop::checkControlDependancy	(	OutPort *	start,
		InPort *	end,
		bool	cross,
		std::map< ComposedNode , std::list< OutPort >, SortHierarc > &	fw,
		std::vector< OutPort * > &	fwCross,
		std::map< ComposedNode , std::list< OutPort >, SortHierarc > &	bw,
		LinkInfo &	info
	)		const

protectedvirtual

Parameters

start	: start port
end	: end port
cross	indicates if start -> end link is a DS link behind.
fw	out parameter.
fwCross	out parameter storing links where a cross has been detected.
bw	out parameter where backward links are stored.
info	: collected information

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 505 of file OptimizerLoop.cxx.

 {
   if(end==&_retPortForOutPool)
     fw[(ComposedNode *)this].push_back(start);
   else
     DynParaLoop::checkControlDependancy(start,end,cross,fw,fwCross,bw,info);
 }

References _retPortForOutPool, and YACS::ENGINE::DynParaLoop::checkControlDependancy().

◆ checkLinkPossibility()

void OptimizerLoop::checkLinkPossibility	(	OutPort *	start,
		const std::list< ComposedNode * > &	pointsOfViewStart,
		InPort *	end,
		const std::list< ComposedNode * > &	pointsOfViewEnd
	)

protectedvirtual

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 525 of file OptimizerLoop.cxx.

 {
   DynParaLoop::checkLinkPossibility(start, pointsOfViewStart, end, pointsOfViewEnd);
   std::string linkName("(");
   linkName += start->getName()+" to "+end->getName()+")";
  
   // Yes, it should be possible to link back the result port to any input port of the loop.
   if(end == _nbOfBranches->getPort() || end == &_algoInitPort)
     if(start != &_algoResultPort)
       throw Exception(std::string("Illegal OptimizerLoop link.") + linkName);
     else
       return;
  
   if(start == &_algoResultPort)
     throw Exception(std::string("Illegal OptimizerLoop link: \
 The 'algoResult' port can't be linked within the scope of the loop.") + linkName);
   
   if(end == &_retPortForOutPool && isInMyDescendance(start->getNode())!=_node)
     throw Exception(std::string("Illegal OptimizerLoop link: \
 The 'evalResults' port can only be linked to the working node.") + linkName);
 }

References _algoInitPort, _algoResultPort, YACS::ENGINE::DynParaLoop::_nbOfBranches, YACS::ENGINE::DynParaLoop::_node, _retPortForOutPool, YACS::ENGINE::DynParaLoop::checkLinkPossibility(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::Port::getNode(), and YACS::ENGINE::ComposedNode::isInMyDescendance().

◆ checkNoCyclePassingThrough()

void OptimizerLoop::checkNoCyclePassingThrough ( Node * node )

virtual

Implements YACS::ENGINE::ComposedNode.

Definition at line 471 of file OptimizerLoop.cxx.

472 {

473 }

◆ checkTypeCode()

TypeCode * OptimizerLoop::checkTypeCode	(	TypeCode *	tc,
		const char *	portName
	)

private

Definition at line 744 of file OptimizerLoop.cxx.

 {
   if (tc == NULL) {
     ostringstream errorMsg;
     errorMsg << "The algorithm specified for OptimizerLoop node \"" << getName() <<
                 "\" provided an invalid type for port \"" << portName << "\"";
     throw Exception(errorMsg.str());
   }
   return tc;
 }

References YACS::ENGINE::ComposedNode::getName().

Referenced by setAlgorithm().

◆ cleanInterceptors()

void OptimizerLoop::cleanInterceptors ( )

protected

Definition at line 548 of file OptimizerLoop.cxx.

 {
   // At this point all garanties taken let's clean all.
   map<InputPort *,vector<InputPort *> >::iterator iter=_interceptors.begin();
   for(;iter!=_interceptors.end();iter++)
     for(vector<InputPort *>::iterator iter2=(*iter).second.begin();iter2!=(*iter).second.end();iter2++)
       delete (*iter2);
   _interceptors.clear();
   for(vector<AnyInputPort *>::iterator iter3=_interceptorsForOutPool.begin();iter3!=_interceptorsForOutPool.end();iter3++)
     delete (*iter3);
   _interceptorsForOutPool.clear();
 }

References _interceptors, and _interceptorsForOutPool.

Referenced by init(), and ~OptimizerLoop().

◆ edGetAlgoInitPort()

InputPort* YACS::ENGINE::OptimizerLoop::edGetAlgoInitPort ( )

inline

Definition at line 86 of file OptimizerLoop.hxx.

86 { return &_algoInitPort; }

Referenced by YACS::HMI::EditionOptimizerLoop::onModifyInitFile(), and YACS::HMI::EditionOptimizerLoop::update().

◆ edGetAlgoResultPort()

OutputPort* YACS::ENGINE::OptimizerLoop::edGetAlgoResultPort ( )

inline

Definition at line 87 of file OptimizerLoop.hxx.

87 { return &_algoResultPort; }

Referenced by YACS::HMI::EditionOptimizerLoop::update().

◆ edGetPortForOutPool()

InputPort* YACS::ENGINE::OptimizerLoop::edGetPortForOutPool ( )

inline

Definition at line 85 of file OptimizerLoop.hxx.

85 { return &_retPortForOutPool; }

Referenced by YACS::HMI::CommandSetAlgo::localExecute(), YACS::HMI::CommandSetAlgo::localReverse(), and YACS::HMI::EditionOptimizerLoop::update().

◆ exUpdateState()

void OptimizerLoop::exUpdateState ( )

virtual

Update the node state.

Note: : Update the '_state' attribute. Typically called by 'this->_inGate' when 'this->_inGate' is ready.

Called by InGate::exNotifyFromPrecursor

Reimplemented from YACS::ENGINE::Node.

Definition at line 161 of file OptimizerLoop.cxx.

 {
   if(_state == YACS::DISABLED)
     return;
   delete _nodeForSpecialCases;
   _nodeForSpecialCases = NULL;
   try
     {
       if(_inGate.exIsReady())
         {
           setState(YACS::TOACTIVATE);
           // Force termination in case the previous algorithm did not finish properly (manual stop)
           _alg->finishProxy();
           _myPool.destroyAll();
  
           // Initialize and launch the algorithm
           _alg->initializeProxy(_algoInitPort.getValue());
           if (_alg->hasError()) {
             string error = _alg->getError();
             _alg->finishProxy();
             throw Exception(error);
           }
  
           //internal graph update
           int i;
           int nbOfBr=_nbOfBranches->getIntValue();
           _alg->setNbOfBranches(nbOfBr);
  
           _alg->startProxy();
           if (_alg->hasError()) {
             string error = _alg->getError();
             _alg->finishProxy();
             throw Exception(error);
           }
  
           if(nbOfBr==0)
             {
               // A number of branches of 0 is acceptable if there are no output ports
               // leaving OptimizerLoop
               bool normal = getAllOutPortsLeavingCurrentScope().empty();
               _nodeForSpecialCases = new FakeNodeForOptimizerLoop(this, normal,
                   "OptimizerLoop has no branch to run the internal node(s)");
               return;
             }
           _execNodes.resize(nbOfBr);
           _execIds.resize(nbOfBr);
           if(_initNode)
             {
               _execInitNodes.resize(nbOfBr);
               _initNodeUpdated.resize(nbOfBr);
               for(i=0;i<nbOfBr;i++)
                 _initNodeUpdated[i]=false;
             }
           _initializingCounter = 0;
           if (_finalizeNode)
             _execFinalizeNodes.resize(nbOfBr);
           vector<Node *> origNodes;
           origNodes.push_back(_initNode);
           origNodes.push_back(_node);
           origNodes.push_back(_finalizeNode);
           for(i=0;i<nbOfBr;i++)
             {
               _execIds[i]=NOT_INITIALIZED_BRANCH_ID;
               vector<Node *> clonedNodes = cloneAndPlaceNodesCoherently(origNodes);
               if(_initNode)
                 _execInitNodes[i] = clonedNodes[0];
               _execNodes[i] = clonedNodes[1];
               if(_finalizeNode)
                 _execFinalizeNodes[i] = clonedNodes[2];
               prepareInputsFromOutOfScope(i);
             }
           initInterceptors(nbOfBr);
           int id;
           unsigned char priority;
           Any *val=_myPool.getNextSampleWithHighestPriority(id,priority);
           if(!val)
             {
               // It is acceptable to have no sample to launch if there are no output ports
               // leaving OptimizerLoop
               std::set<OutPort *> setOutPort = getAllOutPortsLeavingCurrentScope();
               // Special in the special
               // We do not check algoResult
               setOutPort.erase(&_algoResultPort);
               bool normal = setOutPort.empty();
               _nodeForSpecialCases = new FakeNodeForOptimizerLoop(this, normal,
                   string("The algorithm of OptimizerLoop with name ") + _name +
                   " returns no sample to launch");
               _alg->finishProxy();
               return;
             }
           launchMaxOfSamples(true);
         }
     }
   catch (const exception & e)
     {
       _nodeForSpecialCases = new FakeNodeForOptimizerLoop(this, false,
           string("An error happened in the control algorithm of OptimizerLoop \"") + _name +
           "\": " + e.what());
     }
 }

◆ finalize()

YACS::Event OptimizerLoop::finalize ( )

Definition at line 411 of file OptimizerLoop.cxx.

 {
   //update internal node (definition node) state
   if (_node)
     {
       _node->setState(YACS::DONE);
       ComposedNode* compNode = dynamic_cast<ComposedNode*>(_node);
       if (compNode)
         {
           std::list<Node *> aChldn = compNode->getAllRecursiveConstituents();
           std::list<Node *>::iterator iter=aChldn.begin();
           for(;iter!=aChldn.end();iter++)
             (*iter)->setState(YACS::DONE);
         }
     }
   _algoResultPort.put(_alg->getAlgoResultProxy());
   _alg->finishProxy();
   if (_finalizeNode == NULL)
     {
       // No finalize node, we just finish OptimizerLoop at the end of exec nodes execution
       setState(YACS::DONE);
       return YACS::FINISH;
     }
   else
     {
       // Run the finalize nodes, the OptimizerLoop will be done only when they all finish
       _unfinishedCounter = 0;  // This counter indicates how many branches are not finished
       for (int i=0 ; i<_nbOfBranches->getIntValue() ; i++)
         if (_execIds[i] == NOT_RUNNING_BRANCH_ID)
           {
             DEBTRACE("Launching finalize node for branch " << i)
             _execFinalizeNodes[i]->exUpdateState();
             _unfinishedCounter++;
           }
         else
           // There should not be any running branch at this point
           YASSERT(_execIds[i] == NOT_INITIALIZED_BRANCH_ID)
       return YACS::NOEVENT;
     }
 }

References _alg, _algoResultPort, YACS::ENGINE::DynParaLoop::_execFinalizeNodes, YACS::ENGINE::DynParaLoop::_execIds, YACS::ENGINE::DynParaLoop::_finalizeNode, YACS::ENGINE::DynParaLoop::_nbOfBranches, YACS::ENGINE::DynParaLoop::_node, YACS::ENGINE::DynParaLoop::_unfinishedCounter, DEBTRACE, YACS::DONE, YACS::FINISH, YACS::ENGINE::OptimizerAlgBase::finishProxy(), YACS::ENGINE::OptimizerAlgBase::getAlgoResultProxy(), YACS::ENGINE::ComposedNode::getAllRecursiveConstituents(), yacsorb.CORBAEngineTest::i, YACS::NOEVENT, NOT_INITIALIZED_BRANCH_ID, NOT_RUNNING_BRANCH_ID, YACS::ENGINE::AnyOutputPort::put(), YACS::ENGINE::Node::setState(), and YASSERT.

Referenced by updateStateOnFinishedEventFrom().

◆ getAlgLib()

std::string OptimizerLoop::getAlgLib ( ) const

virtual

Return the name of the algorithm library.

Definition at line 793 of file OptimizerLoop.cxx.

 {
   return _alglib;
 }

References _alglib.

Referenced by YACS::HMI::EditionOptimizerLoop::onModifyLib(), YACS::HMI::EditionOptimizerLoop::update(), and YACS::ENGINE::VisitorSaveSchema::visitOptimizerLoop().

◆ getInputPort()

InputPort * OptimizerLoop::getInputPort ( const std::string & name ) const

virtual

Get an input port given its name.

Contrary to YACS::ENGINE::ComposedNode::getOutputPort, this method is NOT recursive and so the leaf of type ElementaryNode aggregating this InputPort is directly invoked.

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 267 of file OptimizerLoop.cxx.

 {
   if (name == NAME_OF_ALGO_INIT_PORT)
     return (InputPort *)&_algoInitPort;
   else if (name == NAME_OF_OUT_POOL_INPUT)
     return (InputPort *)&_retPortForOutPool;
   else
     return DynParaLoop::getInputPort(name);
 }

References _algoInitPort, _retPortForOutPool, YACS::ENGINE::DynParaLoop::getInputPort(), NAME_OF_ALGO_INIT_PORT, and NAME_OF_OUT_POOL_INPUT.

◆ getLocalInputPorts()

std::list< InputPort * > OptimizerLoop::getLocalInputPorts ( ) const

virtual

redefined on derived class of ComposedNode. by default a ComposedNode has no port by itself

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 285 of file OptimizerLoop.cxx.

 {
   list<InputPort *> ret=DynParaLoop::getLocalInputPorts();
   ret.push_back((InputPort *)&_algoInitPort);
   ret.push_back((InputPort *)&_retPortForOutPool);
   return ret;
 }

References _algoInitPort, _retPortForOutPool, and YACS::ENGINE::DynParaLoop::getLocalInputPorts().

◆ getLocalOutputPorts()

std::list< OutputPort * > OptimizerLoop::getLocalOutputPorts ( ) const

virtual

redefined on derived class of ComposedNode. by default a ComposedNode has no port by itself

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 827 of file OptimizerLoop.cxx.

 {
   list<OutputPort *> ret = DynParaLoop::getLocalOutputPorts();
   ret.push_front((OutputPort *)&_algoResultPort);
   return ret;
 }

References _algoResultPort, and YACS::ENGINE::DynParaLoop::getLocalOutputPorts().

◆ getNumberOfInputPorts()

int OptimizerLoop::getNumberOfInputPorts ( ) const

virtual

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 262 of file OptimizerLoop.cxx.

 {
   return DynParaLoop::getNumberOfInputPorts()+2;
 }

References YACS::ENGINE::DynParaLoop::getNumberOfInputPorts().

◆ getNumberOfOutputPorts()

int OptimizerLoop::getNumberOfOutputPorts ( ) const

virtual

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 815 of file OptimizerLoop.cxx.

 {
   return DynParaLoop::getNumberOfOutputPorts() + 1;
 }

References YACS::ENGINE::DynParaLoop::getNumberOfOutputPorts().

◆ getOutPort()

OutPort * OptimizerLoop::getOutPort ( const std::string & name ) const

virtual

Note: : Contrary to getOutputPort method, this method returns the output port at highest level, possible. That is to say in some ComposedNode, like ForEachLoop or Switch, an outport inside 'this' is seen differently than the true outport.

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 834 of file OptimizerLoop.cxx.

 {
   return (name == NAME_OF_ALGO_RESULT_PORT) ? (OutPort *)&_algoResultPort :
                                               DynParaLoop::getOutPort(name);
 }

References _algoResultPort, YACS::ENGINE::DynParaLoop::getOutPort(), and NAME_OF_ALGO_RESULT_PORT.

Referenced by OptimizerLoop().

◆ getOutputPort()

OutputPort * OptimizerLoop::getOutputPort ( const std::string & name ) const

virtual

Get an output port given its name.

Contrary to YACS::ENGINE::ComposedNode::getInputPort, this method is recursive and go down hierarchy step by step to complete its work.

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 841 of file OptimizerLoop.cxx.

 {
   return (name == NAME_OF_ALGO_RESULT_PORT) ? (OutputPort *)&_algoResultPort :
                                               DynParaLoop::getOutputPort(name);
 }

References _algoResultPort, YACS::ENGINE::DynParaLoop::getOutputPort(), and NAME_OF_ALGO_RESULT_PORT.

Referenced by initInterceptors().

◆ getReadyTasks()

void OptimizerLoop::getReadyTasks ( std::vector< Task * > & tasks )

virtual

Implements YACS::ENGINE::Node.

Definition at line 297 of file OptimizerLoop.cxx.

 {
   if(!_node)
     return;
   if(_state==YACS::TOACTIVATE || _state==YACS::ACTIVATED)
     {
       if(_nodeForSpecialCases)
         {
           _nodeForSpecialCases->getReadyTasks(tasks);
           return ;
         }
       vector<Node *>::iterator iter;
       for (iter=_execNodes.begin() ; iter!=_execNodes.end() ; iter++)
         (*iter)->getReadyTasks(tasks);
       for (iter=_execInitNodes.begin() ; iter!=_execInitNodes.end() ; iter++)
         (*iter)->getReadyTasks(tasks);
       for (iter=_execFinalizeNodes.begin() ; iter!=_execFinalizeNodes.end() ; iter++)
         (*iter)->getReadyTasks(tasks);
     }
 }

References YACS::ENGINE::DynParaLoop::_execFinalizeNodes, YACS::ENGINE::DynParaLoop::_execInitNodes, YACS::ENGINE::DynParaLoop::_execNodes, YACS::ENGINE::DynParaLoop::_node, _nodeForSpecialCases, YACS::ENGINE::Node::_state, YACS::ACTIVATED, YACS::ENGINE::ElementaryNode::getReadyTasks(), and YACS::TOACTIVATE.

◆ getSetOfInputPort()

std::list< InputPort * > OptimizerLoop::getSetOfInputPort ( ) const

virtual

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 277 of file OptimizerLoop.cxx.

 {
   list<InputPort *> ret=DynParaLoop::getSetOfInputPort();
   ret.push_back((InputPort *)&_algoInitPort);
   ret.push_back((InputPort *)&_retPortForOutPool);
   return ret;
 }

References _algoInitPort, _retPortForOutPool, and YACS::ENGINE::DynParaLoop::getSetOfInputPort().

◆ getSetOfOutputPort()

std::list< OutputPort * > OptimizerLoop::getSetOfOutputPort ( ) const

virtual

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 820 of file OptimizerLoop.cxx.

 {
   list<OutputPort *> ret = DynParaLoop::getSetOfOutputPort();
   ret.push_back((OutputPort *)&_algoResultPort);
   return ret;
 }

References _algoResultPort, and YACS::ENGINE::DynParaLoop::getSetOfOutputPort().

◆ getSymbol()

virtual std::string YACS::ENGINE::OptimizerLoop::getSymbol ( ) const

inlinevirtual

Definition at line 96 of file OptimizerLoop.hxx.

96 { return _symbol; }

Referenced by YACS::HMI::EditionOptimizerLoop::onModifyEntry(), YACS::HMI::EditionOptimizerLoop::update(), and YACS::ENGINE::VisitorSaveSchema::visitOptimizerLoop().

◆ init()

void OptimizerLoop::init ( bool start = true )

virtual

initialisation of all input and output ports and gates, for execution

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 150 of file OptimizerLoop.cxx.

 {
   DynParaLoop::init(start);
   _algoInitPort.exInit(start);
   _retPortForOutPool.exInit(start);
   _algoResultPort.exInit();
   _convergenceReachedWithOtherCalc=false;
   cleanDynGraph();
   cleanInterceptors();
 }

References _algoInitPort, _algoResultPort, _convergenceReachedWithOtherCalc, _retPortForOutPool, YACS::ENGINE::DynParaLoop::cleanDynGraph(), cleanInterceptors(), YACS::ENGINE::OutputPort::exInit(), YACS::ENGINE::InputPort::exInit(), and YACS::ENGINE::DynParaLoop::init().

◆ initInterceptors()

void OptimizerLoop::initInterceptors ( unsigned nbOfBr )

protected

Perform initialization of interceptors. WARNING _execNodes have to be created before.

Definition at line 621 of file OptimizerLoop.cxx.

 {
   //For all classical outputports leaving 'this'
   set<OutPort *> portsToIntercept=getAllOutPortsLeavingCurrentScope();
   portsToIntercept.erase(&_algoResultPort);
   for(set<OutPort *>::iterator iter=portsToIntercept.begin();iter!=portsToIntercept.end();iter++)
     {
       OutputPort *portC=(OutputPort *)(*iter);//Warrantied by OptimizerLoop::buildDelegateOf
       const set<InputPort *>& links=portC->getSetOfPhyLinks();
       for(set<InputPort *>::const_iterator iter2=links.begin();iter2!=links.end();iter2++)
         {
 #ifdef NOCOVARIANT
           InputPort *reprCur=dynamic_cast<InputPort *>((*iter2)->getPublicRepresentant());
 #else
           InputPort *reprCur=(*iter2)->getPublicRepresentant();
 #endif
           if(!isInMyDescendance(reprCur->getNode()))
             {//here we've got an out of scope link : Let's intercept it
               if(_interceptors.find(reprCur)==_interceptors.end())
                 {
                   _interceptors[reprCur].resize(nbOfBr);
                   for(unsigned i=0;i<nbOfBr;i++)
                     {
                       OutputPort *portExecC=(OutputPort *)_execNodes[i]->getOutputPort(_node->getOutPortName(portC));
                       InputPort *clone=reprCur->clone(0);
                       _interceptors[reprCur][i]=clone;
                       portExecC->edAddInputPort(clone);
                     }
                 }
               else
                 {
                   for(unsigned i=0;i<nbOfBr;i++)
                     {
                       OutputPort *portExecC=(OutputPort *)_execNodes[i]->getOutputPort(_node->getOutPortName(portC));
                       portExecC->edAddInputPort(_interceptors[reprCur][i]);
                     }
                 }
             }
         }
     }
   // For out pool
   _interceptorsForOutPool.resize(nbOfBr);
   set< OutPort * > links=_retPortForOutPool.edSetOutPort();
   for(unsigned i=0;i<nbOfBr;i++)
     _interceptorsForOutPool[i]=(AnyInputPort *)_retPortForOutPool.clone(this);
   for(set<OutPort *>::iterator iter2=links.begin();iter2!=links.end();iter2++)
     for(unsigned j=0;j<nbOfBr;j++)
       {
         OutPort *portExec;
         Node *whatType=isInMyDescendance((*iter2)->getNode());
         if(whatType==_node)
           {
             portExec=_execNodes[j]->getOutPort(_node->getOutPortName(*iter2));
             portExec->addInPort(_interceptorsForOutPool[j]);
           }
         else if(whatType==_initNode && whatType!=0)//This case should never happend. Useless !
           {
             portExec=_execInitNodes[j]->getOutPort(_node->getOutPortName(*iter2));
             portExec->addInPort(_interceptorsForOutPool[j]);
           }
       }
 }

References _algoResultPort, YACS::ENGINE::DynParaLoop::_execInitNodes, YACS::ENGINE::DynParaLoop::_execNodes, YACS::ENGINE::DynParaLoop::_initNode, _interceptors, _interceptorsForOutPool, YACS::ENGINE::DynParaLoop::_node, _retPortForOutPool, YACS::ENGINE::OutPort::addInPort(), YACS::ENGINE::Node::clone(), YACS::ENGINE::AnyInputPort::clone(), YACS::ENGINE::InputPort::clone(), YACS::ENGINE::OutputPort::edAddInputPort(), YACS::ENGINE::InPort::edSetOutPort(), YACS::ENGINE::ComposedNode::getAllOutPortsLeavingCurrentScope(), YACS::ENGINE::Port::getNode(), YACS::ENGINE::Node::getOutPortName(), getOutputPort(), YACS::ENGINE::InputPort::getPublicRepresentant(), YACS::ENGINE::OutputPort::getSetOfPhyLinks(), yacsorb.CORBAEngineTest::i, and YACS::ENGINE::ComposedNode::isInMyDescendance().

Referenced by exUpdateState().

◆ isFullyBusy()

bool OptimizerLoop::isFullyBusy ( unsigned & branchId ) const

protected

Returns if a dynamic branch is available.

Parameters

branchId Out param. Only usable if returned value is equal to false.

Definition at line 607 of file OptimizerLoop.cxx.

 {
   bool isFinished=true;
   unsigned i;
   for(i=0;i<_execIds.size() && isFinished;i++)
     isFinished=(_execIds[i]!=NOT_RUNNING_BRANCH_ID && _execIds[i]!=NOT_INITIALIZED_BRANCH_ID);
   if(!isFinished)
     branchId=i-1;
   return isFinished;
 }

References YACS::ENGINE::DynParaLoop::_execIds, yacsorb.CORBAEngineTest::i, YACS::ENGINE::ComposedNode::isFinished(), NOT_INITIALIZED_BRANCH_ID, and NOT_RUNNING_BRANCH_ID.

Referenced by launchMaxOfSamples().

◆ isFullyLazy()

bool OptimizerLoop::isFullyLazy ( ) const

protected

Definition at line 595 of file OptimizerLoop.cxx.

 {
   bool isLazy=true;
   for(unsigned i=0;i<_execIds.size() && isLazy;i++)
     isLazy=(_execIds[i]==NOT_RUNNING_BRANCH_ID || _execIds[i]==NOT_INITIALIZED_BRANCH_ID);
   return isLazy;
 }

References YACS::ENGINE::DynParaLoop::_execIds, yacsorb.CORBAEngineTest::i, NOT_INITIALIZED_BRANCH_ID, and NOT_RUNNING_BRANCH_ID.

Referenced by updateStateOnFinishedEventFrom().

◆ launchMaxOfSamples()

void OptimizerLoop::launchMaxOfSamples ( bool first )

protected

Definition at line 561 of file OptimizerLoop.cxx.

 {
   int id;
   unsigned char priority;
   Any *val;
   unsigned i;
   for (val = _myPool.getNextSampleWithHighestPriority(id, priority);
        !isFullyBusy(i) && val;
        val = _myPool.getNextSampleWithHighestPriority(id, priority))
     {
       if(_execIds[i] == NOT_INITIALIZED_BRANCH_ID)
         first=true; // node is not initialized (first pass)
       else
         first=false; // node is initialized (second pass)
       _execIds[i]=id;
       _myPool.markIdAsInUse(id);
       if(_initNode && !_initNodeUpdated[i])
         {
           putValueOnBranch(val,i,first);
           _execInitNodes[i]->exUpdateState();
           _initNodeUpdated[i]=true;
           _initializingCounter++;
         }
       else
         {
           if(!first)
             _execNodes[i]->init(first);
           putValueOnBranch(val,i,first);
           _execNodes[i]->exUpdateState();
           _nbOfEltConsumed++;
         }
     }
 }

References YACS::ENGINE::DynParaLoop::_execIds, YACS::ENGINE::DynParaLoop::_execInitNodes, YACS::ENGINE::DynParaLoop::_execNodes, YACS::ENGINE::DynParaLoop::_initializingCounter, YACS::ENGINE::DynParaLoop::_initNode, _initNodeUpdated, _myPool, YACS::ENGINE::DynParaLoop::_nbOfEltConsumed, YACS::ENGINE::Pool::getNextSampleWithHighestPriority(), yacsorb.CORBAEngineTest::i, isFullyBusy(), YACS::ENGINE::Pool::markIdAsInUse(), NOT_INITIALIZED_BRANCH_ID, and YACS::ENGINE::DynParaLoop::putValueOnBranch().

Referenced by exUpdateState(), and updateStateOnFinishedEventFrom().

◆ loadAlgorithm()

void OptimizerLoop::loadAlgorithm ( )

protectedvirtual

Load the algorithm from the dynamic library.

Reimplemented in YACS::ENGINE::SalomeOptimizerLoop.

Definition at line 759 of file OptimizerLoop.cxx.

 {
   YASSERT(_alg == NULL)
  
   if (_loader != NULL) {
     delete _loader;
     _loader = NULL;
   }
   _loader = new YACS::BASES::DynLibLoader(_alglib);
   OptimizerAlgBaseFactory algFactory = NULL;
  
   if (_alglib != "" && _symbol != "")
     {
       try
         {
           _errorDetails = "";
           algFactory = (OptimizerAlgBaseFactory)_loader->getHandleOnSymbolWithName(_symbol);
         }
       catch (YACS::Exception& e)
         {
           _errorDetails = e.what();
           modified();
           throw;
         }
     }
  
   if (algFactory != NULL)
     _alg = algFactory(&_myPool);
 }

References _alg, _alglib, YACS::ENGINE::Node::_errorDetails, _loader, _myPool, _symbol, YACS::ENGINE::Node::modified(), YACS::Exception::what(), and YASSERT.

Referenced by YACS::ENGINE::SalomeOptimizerLoop::loadAlgorithm(), and setAlgorithm().

◆ pushValueOutOfScopeForCase()

void OptimizerLoop::pushValueOutOfScopeForCase ( unsigned branchId )

protected

Typically called when _alg has decided that convergence has been reached. In this case the links leaving the current scope are activated and filled with value of the branch specified by 'branchId' that is the branch in which the convergence has been reached.

Definition at line 688 of file OptimizerLoop.cxx.

 {
   map<InputPort *, std::vector<InputPort *> >::iterator iter;
   for(iter=_interceptors.begin();iter!=_interceptors.end();iter++)
     (*iter).first->put((*iter).second[branchId]->get());
 }

References _interceptors.

Referenced by updateStateOnFinishedEventFrom().

◆ selectRunnableTasks()

void OptimizerLoop::selectRunnableTasks ( std::vector< Task * > & tasks )

virtual

Implements YACS::ENGINE::Scheduler.

Definition at line 293 of file OptimizerLoop.cxx.

294 {

295 }

◆ setAlgorithm()

void OptimizerLoop::setAlgorithm	(	const std::string &	alglib,
		const std::string &	symbol,
		bool	checkLinks = `true`,
		Proc *	procForTypes = `NULL`
	)

virtual

Set the algorithm library name and factory name (symbol in library) to create the algorithm and change it if the node is not connected.

throw an exception if the node is connected

Definition at line 704 of file OptimizerLoop.cxx.

 {
   if(checkLinks)
     {
       if (_splittedPort.edGetNumberOfOutLinks() != 0 ||
           _retPortForOutPool.edGetNumberOfLinks() != 0 ||
           _algoInitPort.edGetNumberOfLinks() != 0 ||
           _algoResultPort.edGetNumberOfOutLinks() != 0)
         throw Exception("The OptimizerLoop node must be disconnected before setting the algorithm");
     }
  
   _symbol = symbol;
   _alglib = alglib;
  
   if (_alg) {
     _alg->decrRef();
     _alg = NULL;
   }
  
   loadAlgorithm();
  
   if(_alg)
     {
       _alg->setProc((procForTypes == NULL) ? getProc() : procForTypes);
  
       // Delete the values in the input ports if they were initialized
       _retPortForOutPool.put((Any *)NULL);
       _algoInitPort.put((Any *)NULL);
  
       // Change the type of the ports
       _splittedPort.edSetType(checkTypeCode(_alg->getTCForInProxy(), NAME_OF_SPLITTED_SEQ_OUT));
       _retPortForOutPool.edSetType(checkTypeCode(_alg->getTCForOutProxy(), NAME_OF_OUT_POOL_INPUT));
       _algoInitPort.edSetType(checkTypeCode(_alg->getTCForAlgoInitProxy(), NAME_OF_ALGO_INIT_PORT));
       _algoResultPort.edSetType(checkTypeCode(_alg->getTCForAlgoResultProxy(), NAME_OF_ALGO_RESULT_PORT));
     }
  
   modified();
 }

References _alg, _alglib, _algoInitPort, _algoResultPort, _retPortForOutPool, YACS::ENGINE::DynParaLoop::_splittedPort, _symbol, checkTypeCode(), YACS::ENGINE::RefCounter::decrRef(), YACS::ENGINE::InPort::edGetNumberOfLinks(), YACS::ENGINE::OutPort::edGetNumberOfOutLinks(), YACS::ENGINE::DataPort::edSetType(), YACS::ENGINE::Node::getProc(), YACS::ENGINE::OptimizerAlgBase::getTCForAlgoInitProxy(), YACS::ENGINE::OptimizerAlgBase::getTCForAlgoResultProxy(), YACS::ENGINE::OptimizerAlgBase::getTCForInProxy(), YACS::ENGINE::OptimizerAlgBase::getTCForOutProxy(), loadAlgorithm(), YACS::ENGINE::Node::modified(), NAME_OF_ALGO_INIT_PORT, NAME_OF_ALGO_RESULT_PORT, NAME_OF_OUT_POOL_INPUT, YACS::ENGINE::DynParaLoop::NAME_OF_SPLITTED_SEQ_OUT, YACS::ENGINE::AnyInputPort::put(), and YACS::ENGINE::OptimizerAlgBase::setProc().

Referenced by YACS::HMI::CommandSetAlgo::localExecute(), YACS::HMI::CommandSetAlgo::localReverse(), OptimizerLoop(), YACS::ENGINE::SalomeOptimizerLoop::SalomeOptimizerLoop(), YACS::ENGINE::SalomeOptimizerLoop::simpleClone(), and simpleClone().

◆ simpleClone()

Node * OptimizerLoop::simpleClone	(	ComposedNode *	father,
		bool	editionOnly = `true`
	)		const

protectedvirtual

Implements YACS::ENGINE::Node.

Reimplemented in YACS::ENGINE::SalomeOptimizerLoop.

Definition at line 137 of file OptimizerLoop.cxx.

 {
   OptimizerLoop* ol=new OptimizerLoop(*this,father,editionOnly);
   // TODO: Remove this const_cast (find a better design to get the type codes from the original node)
   Proc * procForTypes = ol->getProc();
   if (procForTypes == NULL) {
     const Proc * origProc = getProc();
     procForTypes = const_cast<Proc *>(origProc);
   }
   ol->setAlgorithm(_alglib, _symbol, false, procForTypes);
   return ol;
 }

References _alglib, _symbol, YACS::ENGINE::Node::getProc(), OptimizerLoop(), and setAlgorithm().

◆ typeName()

virtual std::string YACS::ENGINE::OptimizerLoop::typeName ( )

inlinevirtual

Reimplemented from YACS::ENGINE::ComposedNode.

Reimplemented in YACS::ENGINE::SalomeOptimizerLoop.

Definition at line 101 of file OptimizerLoop.hxx.

101 {return "YACS__ENGINE__OptimizerLoop";}

◆ updateStateOnFailedEventFrom()

YACS::Event OptimizerLoop::updateStateOnFailedEventFrom	(	Node *	node,
		const Executor *	execInst
	)

protectedvirtual

Method used to notify the node that a child node has failed.

Notify the slave thread of the error, update the current state and return the change state

Parameters

node	: the child node that has failed

Returns: the state change

Reimplemented from YACS::ENGINE::DynParaLoop.

Definition at line 460 of file OptimizerLoop.cxx.

 {
   DEBTRACE("OptimizerLoop::updateStateOnFailedEventFrom " << node->getName());
   _alg->setError(string("Error during the execution of YACS node ") + node->getName() +
                  ": " + node->getErrorReport());
   _alg->finishProxy();
   _myPool.destroyAll();
   DEBTRACE("OptimizerLoop::updateStateOnFailedEventFrom: returned from error notification.");
   return DynParaLoop::updateStateOnFailedEventFrom(node,execInst);
 }

References _alg, _myPool, DEBTRACE, YACS::ENGINE::Pool::destroyAll(), YACS::ENGINE::OptimizerAlgBase::finishProxy(), YACS::ENGINE::Node::getErrorReport(), YACS::ENGINE::Node::getName(), YACS::ENGINE::OptimizerAlgBase::setError(), and YACS::ENGINE::DynParaLoop::updateStateOnFailedEventFrom().

◆ updateStateOnFinishedEventFrom()

YACS::Event OptimizerLoop::updateStateOnFinishedEventFrom ( Node * node )

virtual

Implements YACS::ENGINE::ComposedNode.

Definition at line 318 of file OptimizerLoop.cxx.

 {
   if (getState() == YACS::FAILED)
     {
       // This happens when a valid computation on a branch finishes after an error on another branch.
       // In this case we just ignore the new result because the algorithm has already been terminated.
       return YACS::NOEVENT;
     }
   unsigned int id;
   switch(getIdentityOfNotifyerNode(node,id))
     {
     case INIT_NODE:
     {
       _execNodes[id]->exUpdateState();
       _nbOfEltConsumed++;
       _initializingCounter--;
       if (_initializingCounter == 0) _initNode->setState(DONE);
       break;
     }
     case WORK_NODE:
     {
       if(_convergenceReachedWithOtherCalc)
         { //This case happens when alg has reached its convergence whereas other calculations still compute
           _execIds[id]=NOT_RUNNING_BRANCH_ID;
           if(!isFullyLazy())
             return YACS::NOEVENT;
           else
             return finalize();
         }
       _myPool.putOutSampleAt(_execIds[id],_interceptorsForOutPool[id]->getValue());
       _myPool.setCurrentId(_execIds[id]);
       _alg->takeDecisionProxy();
       if (_alg->hasError()) {
         _errorDetails = string("An error happened in the control algorithm of optimizer loop: ") +
                         _alg->getError();
         _alg->finishProxy();
         setState(YACS::FAILED);
         return YACS::ABORT;
       }
  
       _myPool.destroyCurrentCase();
       if(_myPool.empty())
         {
           pushValueOutOfScopeForCase(id);
           _execIds[id]=NOT_RUNNING_BRANCH_ID;
           if(!isFullyLazy())
             {// This case happens when the hand is returned to continue, whereas some other are working in parallel for nothing.
               _convergenceReachedWithOtherCalc=true;
               return YACS::NOEVENT;
             }
           return finalize();
         }
       _execIds[id]=NOT_RUNNING_BRANCH_ID;
       int newId;
       unsigned char priority;
       Any *val=_myPool.getNextSampleWithHighestPriority(newId, priority);
       if(!val)
         {
           bool isFinished=true;
           for(int i=0;i<_execIds.size() && isFinished;i++)
             isFinished=(_execIds[i]==NOT_RUNNING_BRANCH_ID || _execIds[i]==NOT_INITIALIZED_BRANCH_ID);
           if(isFinished)
             {
               std::cerr <<"OptimizerLoop::updateStateOnFinishedEventFrom: Alg has not inserted more cases whereas last element has been calculated !" << std::endl;
               setState(YACS::ERROR);
               exForwardFailed();
               _alg->finishProxy();
               return YACS::FINISH;
             }
           return YACS::NOEVENT;
         }
       launchMaxOfSamples(false);
       break;
     }
     case FINALIZE_NODE:
     {
       _unfinishedCounter--;
       if (_unfinishedCounter == 0)
         {
           _finalizeNode->setState(YACS::DONE);
           setState(YACS::DONE);
           return YACS::FINISH;
         }
       else
         return YACS::NOEVENT;
       break;
     }
     default:
       YASSERT(false);
     }
   return YACS::NOEVENT;
 }

References _alg, _convergenceReachedWithOtherCalc, YACS::ENGINE::Node::_errorDetails, YACS::ENGINE::DynParaLoop::_execIds, YACS::ENGINE::DynParaLoop::_execNodes, YACS::ENGINE::DynParaLoop::_finalizeNode, YACS::ENGINE::DynParaLoop::_initializingCounter, YACS::ENGINE::DynParaLoop::_initNode, _interceptorsForOutPool, _myPool, YACS::ENGINE::DynParaLoop::_nbOfEltConsumed, YACS::ENGINE::DynParaLoop::_unfinishedCounter, YACS::ABORT, YACS::ENGINE::Pool::destroyCurrentCase(), YACS::DONE, YACS::ENGINE::Pool::empty(), YACS::ERROR, YACS::ENGINE::Node::exForwardFailed(), YACS::FAILED, finalize(), YACS::ENGINE::DynParaLoop::FINALIZE_NODE, YACS::FINISH, YACS::ENGINE::OptimizerAlgBase::finishProxy(), YACS::ENGINE::OptimizerAlgBase::getError(), YACS::ENGINE::DynParaLoop::getIdentityOfNotifyerNode(), YACS::ENGINE::Pool::getNextSampleWithHighestPriority(), YACS::ENGINE::Node::getState(), YACS::ENGINE::OptimizerAlgBase::hasError(), yacsorb.CORBAEngineTest::i, YACS::ENGINE::DynParaLoop::INIT_NODE, YACS::ENGINE::ComposedNode::isFinished(), isFullyLazy(), launchMaxOfSamples(), YACS::NOEVENT, NOT_INITIALIZED_BRANCH_ID, NOT_RUNNING_BRANCH_ID, pushValueOutOfScopeForCase(), YACS::ENGINE::Pool::putOutSampleAt(), YACS::ENGINE::Pool::setCurrentId(), YACS::ENGINE::Node::setState(), YACS::ENGINE::OptimizerAlgBase::takeDecisionProxy(), YACS::ENGINE::DynParaLoop::WORK_NODE, and YASSERT.

Friends And Related Function Documentation

◆ FakeNodeForOptimizerLoop

friend class FakeNodeForOptimizerLoop

friend

Definition at line 58 of file OptimizerLoop.hxx.

Referenced by exUpdateState().

Member Data Documentation

◆ _alg

OptimizerAlgBase* YACS::ENGINE::OptimizerLoop::_alg

protected

Definition at line 67 of file OptimizerLoop.hxx.

Referenced by checkBasicConsistency(), YACS::ENGINE::FakeNodeForOptimizerLoop::execute(), exUpdateState(), finalize(), loadAlgorithm(), YACS::ENGINE::SalomeOptimizerLoop::loadAlgorithm(), setAlgorithm(), updateStateOnFailedEventFrom(), updateStateOnFinishedEventFrom(), and ~OptimizerLoop().

◆ _algInitOnFile

bool YACS::ENGINE::OptimizerLoop::_algInitOnFile

protected

Definition at line 62 of file OptimizerLoop.hxx.

◆ _alglib

std::string YACS::ENGINE::OptimizerLoop::_alglib

protected

Definition at line 64 of file OptimizerLoop.hxx.

Referenced by checkBasicConsistency(), getAlgLib(), loadAlgorithm(), YACS::ENGINE::SalomeOptimizerLoop::loadAlgorithm(), setAlgorithm(), YACS::ENGINE::SalomeOptimizerLoop::simpleClone(), and simpleClone().

◆ _algoInitPort

AnyInputPort YACS::ENGINE::OptimizerLoop::_algoInitPort

protected

Definition at line 65 of file OptimizerLoop.hxx.

Referenced by checkLinkPossibility(), exUpdateState(), getInputPort(), getLocalInputPorts(), getSetOfInputPort(), init(), and setAlgorithm().

◆ _algoResultPort

AnyOutputPort YACS::ENGINE::OptimizerLoop::_algoResultPort

protected

Definition at line 75 of file OptimizerLoop.hxx.

Referenced by buildDelegateOf(), checkLinkPossibility(), YACS::ENGINE::FakeNodeForOptimizerLoop::execute(), exUpdateState(), finalize(), getLocalOutputPorts(), getOutPort(), getOutputPort(), getSetOfOutputPort(), init(), initInterceptors(), and setAlgorithm().

◆ _convergenceReachedWithOtherCalc

bool YACS::ENGINE::OptimizerLoop::_convergenceReachedWithOtherCalc

protected

Definition at line 70 of file OptimizerLoop.hxx.

Referenced by init(), and updateStateOnFinishedEventFrom().

◆ _initNodeUpdated

std::vector<bool> YACS::ENGINE::OptimizerLoop::_initNodeUpdated

protected

Definition at line 69 of file OptimizerLoop.hxx.

Referenced by exUpdateState(), and launchMaxOfSamples().

◆ _interceptors

std::map<InputPort *, std::vector<InputPort *> > YACS::ENGINE::OptimizerLoop::_interceptors

protected

outputports interceptors leaving current scope.

Definition at line 74 of file OptimizerLoop.hxx.

Referenced by cleanInterceptors(), initInterceptors(), and pushValueOutOfScopeForCase().

◆ _interceptorsForOutPool

std::vector<AnyInputPort *> YACS::ENGINE::OptimizerLoop::_interceptorsForOutPool

protected

Definition at line 72 of file OptimizerLoop.hxx.

Referenced by cleanInterceptors(), initInterceptors(), and updateStateOnFinishedEventFrom().

◆ _loader

::YACS::BASES::DynLibLoader* YACS::ENGINE::OptimizerLoop::_loader

protected

Definition at line 66 of file OptimizerLoop.hxx.

Referenced by loadAlgorithm(), and ~OptimizerLoop().

◆ _myPool

Pool YACS::ENGINE::OptimizerLoop::_myPool

protected

Definition at line 61 of file OptimizerLoop.hxx.

Referenced by exUpdateState(), launchMaxOfSamples(), loadAlgorithm(), YACS::ENGINE::SalomeOptimizerLoop::loadAlgorithm(), updateStateOnFailedEventFrom(), and updateStateOnFinishedEventFrom().

◆ _nodeForSpecialCases

FakeNodeForOptimizerLoop* YACS::ENGINE::OptimizerLoop::_nodeForSpecialCases

protected

Definition at line 71 of file OptimizerLoop.hxx.

Referenced by exUpdateState(), getReadyTasks(), and ~OptimizerLoop().

◆ _retPortForOutPool

AnyInputPort YACS::ENGINE::OptimizerLoop::_retPortForOutPool

protected

Definition at line 68 of file OptimizerLoop.hxx.

Referenced by buildDelegateOf(), checkCFLinks(), checkControlDependancy(), checkLinkPossibility(), getInputPort(), getLocalInputPorts(), getSetOfInputPort(), init(), initInterceptors(), OptimizerLoop(), and setAlgorithm().

◆ _symbol

std::string YACS::ENGINE::OptimizerLoop::_symbol

protected

Definition at line 63 of file OptimizerLoop.hxx.

Referenced by checkBasicConsistency(), loadAlgorithm(), YACS::ENGINE::SalomeOptimizerLoop::loadAlgorithm(), setAlgorithm(), YACS::ENGINE::SalomeOptimizerLoop::simpleClone(), and simpleClone().

◆ NAME_OF_ALGO_INIT_PORT

const char OptimizerLoop::NAME_OF_ALGO_INIT_PORT = "algoInit"

staticprotected

Definition at line 136 of file OptimizerLoop.hxx.

Referenced by getInputPort(), and setAlgorithm().

◆ NAME_OF_ALGO_RESULT_PORT

const char OptimizerLoop::NAME_OF_ALGO_RESULT_PORT = "algoResults"

staticprotected

Definition at line 138 of file OptimizerLoop.hxx.

Referenced by getOutPort(), getOutputPort(), and setAlgorithm().

◆ NAME_OF_OUT_POOL_INPUT

const char OptimizerLoop::NAME_OF_OUT_POOL_INPUT = "evalResults"

staticprotected

Definition at line 137 of file OptimizerLoop.hxx.

Referenced by getInputPort(), and setAlgorithm().

◆ NOT_INITIALIZED_BRANCH_ID

const int OptimizerLoop::NOT_INITIALIZED_BRANCH_ID =-1973

staticprotected

Definition at line 135 of file OptimizerLoop.hxx.

Referenced by exUpdateState(), finalize(), isFullyBusy(), isFullyLazy(), launchMaxOfSamples(), and updateStateOnFinishedEventFrom().

◆ NOT_RUNNING_BRANCH_ID

const int OptimizerLoop::NOT_RUNNING_BRANCH_ID =-1973012217

staticprotected

Definition at line 134 of file OptimizerLoop.hxx.

Referenced by finalize(), isFullyBusy(), isFullyLazy(), and updateStateOnFinishedEventFrom().

The documentation for this class was generated from the following files:

src/engine/OptimizerLoop.hxx
src/engine/OptimizerLoop.cxx

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ OptimizerLoop() [1/2]

◆ OptimizerLoop() [2/2]

◆ ~OptimizerLoop()

Member Function Documentation

◆ accept()

◆ buildDelegateOf() [1/2]

◆ buildDelegateOf() [2/2]

◆ checkBasicConsistency()

◆ checkCFLinks()

◆ checkControlDependancy()

◆ checkLinkPossibility()

◆ checkNoCyclePassingThrough()

◆ checkTypeCode()

◆ cleanInterceptors()

◆ edGetAlgoInitPort()

◆ edGetAlgoResultPort()

◆ edGetPortForOutPool()

◆ exUpdateState()

◆ finalize()

◆ getAlgLib()

◆ getInputPort()

◆ getLocalInputPorts()

◆ getLocalOutputPorts()

◆ getNumberOfInputPorts()

◆ getNumberOfOutputPorts()

◆ getOutPort()

◆ getOutputPort()

◆ getReadyTasks()

◆ getSetOfInputPort()

◆ getSetOfOutputPort()

◆ getSymbol()

◆ init()

◆ initInterceptors()

◆ isFullyBusy()

◆ isFullyLazy()

◆ launchMaxOfSamples()

◆ loadAlgorithm()

◆ pushValueOutOfScopeForCase()

◆ selectRunnableTasks()

◆ setAlgorithm()

◆ simpleClone()

◆ typeName()

◆ updateStateOnFailedEventFrom()

◆ updateStateOnFinishedEventFrom()

Friends And Related Function Documentation

◆ FakeNodeForOptimizerLoop

Member Data Documentation

◆ _alg

◆ _algInitOnFile

◆ _alglib

◆ _algoInitPort

◆ _algoResultPort

◆ _convergenceReachedWithOtherCalc

◆ _initNodeUpdated

◆ _interceptors

◆ _interceptorsForOutPool

◆ _loader

◆ _myPool

◆ _nodeForSpecialCases

◆ _retPortForOutPool

◆ _symbol

◆ NAME_OF_ALGO_INIT_PORT

◆ NAME_OF_ALGO_RESULT_PORT

◆ NAME_OF_OUT_POOL_INPUT

◆ NOT_INITIALIZED_BRANCH_ID

◆ NOT_RUNNING_BRANCH_ID