#include <ForkBlocPoint.hxx>

Inheritance diagram for YACS::ENGINE::ForkBlocPoint:

Collaboration diagram for YACS::ENGINE::ForkBlocPoint:

[legend]

Public Member Functions
	ForkBlocPoint ()=default

	ForkBlocPoint (const std::list< AbstractPoint * > &nodes, AbstractPoint *father)

AbstractPoint *	deepCopy (AbstractPoint *father) const override

Node *	getFirstNode () override

Node *	getLastNode () override

int	getMaxLevelOfParallelism () const

void	getWeightRegardingDPL (ComplexWeight *weight)

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

std::string	getRepr () const

void	accept (PointVisitor *pv) override

AbstractPoint *	expandNonSimpleCaseOn (NotSimpleCasePoint pathologicalPt, const std::set< Node > &uncatchedNodes) override

virtual	~ForkBlocPoint ()

Public Member Functions inherited from YACS::ENGINE::BlocPoint
	BlocPoint ()=default

	BlocPoint (const std::list< AbstractPoint * > &nodes, AbstractPoint *father)

void	deepCopyFrom (const BlocPoint &other)

AbstractPoint *	findPointWithNode (Node *node)

AbstractPoint *	getNodeAfter (Node *node)

AbstractPoint *	getNodeB4 (Node *node)

bool	contains (Node *node) const override

bool	anyOf (const std::set< Node * > &nodes) const override

int	getNumberOfNodes () const

const std::list< AbstractPoint * > &	getListOfPoints () const

virtual	~BlocPoint ()

bool	internalContinueForSimplify () const

bool	presenceOfNonSimpleCase () const

AbstractPoint *	getUnique ()

const AbstractPoint *	getUnique () const

AbstractPoint *	getUniqueAndReleaseIt ()

Public Member Functions inherited from YACS::ENGINE::AbstractPoint
	AbstractPoint ()=default

	AbstractPoint (AbstractPoint *father)

AbstractPoint *	getFather () const

AbstractPoint *	getGodFather ()

bool	amIGod ()

void	setFather (AbstractPoint *father)

bool	isBegin ()

bool	isLast ()

bool	isSimplyLinkedBeforeAfter (BlocPoint *sop)

bool	isSimplyLinkedAfterNullBefore (BlocPoint *sop)

bool	isSimplyLinkedBeforeNullAfter (BlocPoint *sop)

bool	isNullBeforeNullAfter (BlocPoint *sop)

LinkedBlocPoint *	tryAsLink (BlocPoint *sop)

ForkBlocPoint *	tryAsFork (BlocPoint *sop)

ForkBlocPoint *	tryAsForkBis (BlocPoint *sop)

ForkBlocPoint *	tryAsForkTer (BlocPoint *sop)

ForkBlocPoint *	tryAsForkQuatro (BlocPoint *sop)

virtual	~AbstractPoint ()

bool	isSimplyLinkedAfter (BlocPoint sop, Node node)

bool	isSimplyLinkedBefore (BlocPoint sop, Node node)

Additional Inherited Members
Static Public Member Functions inherited from YACS::ENGINE::AbstractPoint
static void	TryAsNotSimpleCase (AbstractPoint father, const std::vector< AbstractPoint > &ptsToKill, std::list< AbstractPoint * > &nodes, bool &somethingDone)

static bool	IsGatherB4Ext (Node *node)

static bool	IsSimplyLinkedAfterExt (Node *node)

static bool	IsScatterAfterExt (Node *node)

static bool	IsSimplyLinkedBeforeExt (Node *node)

static bool	IsNoLinksBefore (Node *node)

static bool	IsNoLinksAfter (Node *node)

static Node *	GetNodeB4 (Node *node)

static Node *	GetNodeAfter (Node *node)

static AbstractPoint *	GetDirectSonOf (AbstractPoint refFather, AbstractPoint sonOrLittleSon)

static bool	IsCommonDirectSonOf (AbstractPoint refFather, const std::list< OutGate > &outgs, AbstractPoint *&ret)

static bool	IsCommonDirectSonOf (AbstractPoint refFather, const std::list< InGate > &ings, AbstractPoint *&ret)

static void	FeedData (AbstractPoint ptToBeRewired, std::map< std::string, std::tuple< ElementaryPoint , Node , std::shared_ptr< Bloc > > > m)

static void	FeedData (const std::list< AbstractPoint * > &ptsToBeRewired, std::map< std::string, std::tuple< ElementaryPoint , Node , std::shared_ptr< Bloc > > > *m)

static void	Rewire (const std::vector< AbstractPoint * > &ptsToKill, std::map< std::string, std::tuple< ElementaryPoint , Node , std::shared_ptr< Bloc > > > *m)

static void	UnRewire (std::map< std::string, std::tuple< ElementaryPoint , Node , std::shared_ptr< Bloc > > > &m)

static void	Display (std::map< std::string, std::tuple< ElementaryPoint , Node , std::shared_ptr< Bloc > > > *m)

Protected Member Functions inherited from YACS::ENGINE::BlocPoint
void	getOutPoint (AbstractPoint *node)

Protected Attributes inherited from YACS::ENGINE::BlocPoint
std::list< AbstractPoint * >	_nodes

Protected Attributes inherited from YACS::ENGINE::AbstractPoint
AbstractPoint *	_father = nullptr

Detailed Description

Definition at line 30 of file ForkBlocPoint.hxx.

Constructor & Destructor Documentation

◆ ForkBlocPoint() [1/2]

YACS::ENGINE::ForkBlocPoint::ForkBlocPoint ( )

default

◆ ForkBlocPoint() [2/2]

ForkBlocPoint::ForkBlocPoint	(	const std::list< AbstractPoint * > &	nodes,
		AbstractPoint *	father
	)

Definition at line 28 of file ForkBlocPoint.cxx.

                                                                                         :BlocPoint(nodes,father)
 {
 }

◆ ~ForkBlocPoint()

ForkBlocPoint::~ForkBlocPoint ( )

virtual

Definition at line 40 of file ForkBlocPoint.cxx.

41 {

42 }

Member Function Documentation

◆ accept()

void ForkBlocPoint::accept ( PointVisitor * pv )

overridevirtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 122 of file ForkBlocPoint.cxx.

 {
   pv->beginForkBlocPoint(this);
   for(auto it:_nodes)
     it->accept(pv);
   pv->endForkBlocPoint(this);
 }

References YACS::ENGINE::BlocPoint::_nodes, YACS::ENGINE::PointVisitor::beginForkBlocPoint(), and YACS::ENGINE::PointVisitor::endForkBlocPoint().

◆ deepCopy()

AbstractPoint * ForkBlocPoint::deepCopy ( AbstractPoint * father ) const

overridevirtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 32 of file ForkBlocPoint.cxx.

 {
   ForkBlocPoint *ret(new ForkBlocPoint);
   ret->deepCopyFrom(*this);
   ret->setFather(father);
   return ret;
 }

References YACS::ENGINE::BlocPoint::deepCopyFrom(), and YACS::ENGINE::AbstractPoint::setFather().

◆ expandNonSimpleCaseOn()

AbstractPoint * ForkBlocPoint::expandNonSimpleCaseOn	(	NotSimpleCasePoint *	pathologicalPt,
		const std::set< Node * > &	uncatchedNodes
	)

overridevirtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 130 of file ForkBlocPoint.cxx.

 {
   for(auto& it : _nodes)
     {
       AbstractPoint *ret(it->expandNonSimpleCaseOn(pathologicalPt,uncatchedNodes));
       if(ret!=it)
         {
           ret->setFather(this);
           auto oldIt(it);
           it = ret;
           delete oldIt;
         }
     }
   return this;
 }

References YACS::ENGINE::BlocPoint::_nodes, and YACS::ENGINE::AbstractPoint::setFather().

◆ getFirstNode()

Node * ForkBlocPoint::getFirstNode ( )

overridevirtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 44 of file ForkBlocPoint.cxx.

 {
   if(_nodes.empty())
     throw Exception("ForkBlocPoint::getFirstNode : error no branches !");
   return _nodes.front()->getFirstNode();
 }

References YACS::ENGINE::BlocPoint::_nodes.

◆ getLastNode()

Node * ForkBlocPoint::getLastNode ( )

overridevirtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 51 of file ForkBlocPoint.cxx.

 {
   if(_nodes.empty())
     throw Exception("ForkBlocPoint::getLastNode : error no branches !");
   return _nodes.front()->getLastNode();//not a bug - seen from the outside only first branch exists !
 }

References YACS::ENGINE::BlocPoint::_nodes.

◆ getMaxLevelOfParallelism()

int ForkBlocPoint::getMaxLevelOfParallelism ( ) const

virtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 58 of file ForkBlocPoint.cxx.

 {
   int ret(0);
   for(std::list<AbstractPoint *>::const_iterator it=_nodes.begin();it!=_nodes.end();it++)
     ret+=(*it)->getMaxLevelOfParallelism();
   return ret;
 }

References YACS::ENGINE::BlocPoint::_nodes.

Referenced by YACS::ENGINE::Bloc::getMaxLevelOfParallelism().

◆ getRepr()

std::string ForkBlocPoint::getRepr ( ) const

virtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 103 of file ForkBlocPoint.cxx.

 {
   std::size_t sz(_nodes.size()),ii(0);
   std::string ret("[");
   std::vector<std::string> elts(sz);
   for(std::list<AbstractPoint *>::const_iterator it=_nodes.begin();it!=_nodes.end();it++,ii++)
     elts[ii]=(*it)->getRepr();
   std::sort(elts.begin(),elts.end());
   ii=0;
   for(std::list<AbstractPoint *>::const_iterator it=_nodes.begin();it!=_nodes.end();it++,ii++)
     {
       ret+=elts[ii];
       if(ii!=sz-1)
         ret+="*";
     }
   ret+="]";
   return ret;
 }

References YACS::ENGINE::BlocPoint::_nodes.

◆ getWeightRegardingDPL()

void ForkBlocPoint::getWeightRegardingDPL ( ComplexWeight * weight )

virtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 66 of file ForkBlocPoint.cxx.

 {
   ComplexWeight localWeight;
   for(std::list<AbstractPoint *>::const_iterator it=_nodes.begin();it!=_nodes.end();it++)
   {
     (*it)->getWeightRegardingDPL(&localWeight);
     weight->addWeight(&localWeight);
     localWeight.setToZero();
   }
 }

References YACS::ENGINE::BlocPoint::_nodes, YACS::ENGINE::ComplexWeight::addWeight(), and YACS::ENGINE::ComplexWeight::setToZero().

Referenced by YACS::ENGINE::Bloc::getWeightRegardingDPL().

◆ partitionRegardingDPL()

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

virtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 77 of file ForkBlocPoint.cxx.

 {
   std::vector< std::pair<const PartDefinition *, const ComplexWeight *> > parts;
   std::vector< int> nbCoresPerShot;
   std::vector<std::size_t> v;
   std::vector<ComplexWeight> nodesWeight(_nodes.size());
   std::size_t ii(0);
   for(std::list<AbstractPoint *>::const_iterator it=_nodes.begin();it!=_nodes.end();it++,ii++)
     {
       ComplexWeight *w=&nodesWeight[ii];
       (*it)->getWeightRegardingDPL(w);
       parts.push_back(std::pair<const PartDefinition *, const ComplexWeight *>(pd,w));
       nbCoresPerShot.push_back((*it)->getMaxLevelOfParallelism());
       v.push_back(ii);
     }
   std::vector<AbstractPoint *> nodes2(_nodes.begin(),_nodes.end());
   if(!parts.empty())
     {
       const PlayGround *pg(pd->getPlayGround());
       std::vector< YACS::BASES::AutoRefCnt<PartDefinition> > pds(pg->partition(parts,nbCoresPerShot));
       ii=0;
       for(std::vector<std::size_t>::const_iterator iter=v.begin();iter!=v.end();iter++,ii++)
         nodes2[*iter]->partitionRegardingDPL(pds[ii],zeMap);
     }
 }

References YACS::ENGINE::BlocPoint::_nodes, YACS::ENGINE::PartDefinition::getPlayGround(), YACS::ENGINE::PlayGround::partition(), and gui.logview::w.

Referenced by YACS::ENGINE::Bloc::partitionRegardingDPL().

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

src/engine/ForkBlocPoint.hxx
src/engine/ForkBlocPoint.cxx

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ForkBlocPoint() [1/2]

◆ ForkBlocPoint() [2/2]

◆ ~ForkBlocPoint()

Member Function Documentation

◆ accept()

◆ deepCopy()

◆ expandNonSimpleCaseOn()

◆ getFirstNode()

◆ getLastNode()

◆ getMaxLevelOfParallelism()

◆ getRepr()

◆ getWeightRegardingDPL()

◆ partitionRegardingDPL()