#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 *	deepCopy (AbstractPoint *father) const =0

virtual Node *	getFirstNode ()=0

virtual Node *	getLastNode ()=0

virtual AbstractPoint *	findPointWithNode (Node *node)=0

virtual bool	contains (Node *node) const =0

virtual bool	anyOf (const std::set< Node * > &nodes) const =0

virtual int	getNumberOfNodes () const =0

virtual int	getMaxLevelOfParallelism () const =0

virtual void	getWeightRegardingDPL (ComplexWeight *weight)=0

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

virtual std::string	getRepr () const =0

virtual void	accept (PointVisitor *pv)=0

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

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()