wns::scheduler::grouper::AllPossibleGroupsGrouper Class Reference

#include <scheduler/grouper/AllPossibleGroupsGrouper.hpp>

Inheritance diagram for wns::scheduler::grouper::AllPossibleGroupsGrouper:

Collaboration diagram for wns::scheduler::grouper::AllPossibleGroupsGrouper:

List of all members.

Public Member Functions

AllPossibleGroupsGrouper (const wns::pyconfig::View &config)

virtual Grouping getRxGrouping (const UserSet activeUsers, int maxBeams)

Calculates an optimal grouping from a set of users. Such a grouping is a partition of the set of activeUsers into groups (subsets) of users so that every active users is served in exactly one group. The grouping is optimal with respect to the metric introduced in my (Jan Ellenbeck) diploma thesis.

virtual Grouping getTxGrouping (const UserSet activeUsers, int maxBeams)

Calculates an optimal grouping from a set of users. Such a grouping is a partition of the set of activeUsers into groups (subsets) of users so that every active users is served in exactly one group. The grouping is optimal with respect to the metric introduced in my (Jan Ellenbeck) diploma thesis.

virtual void setColleagues (RegistryProxyInterface *_registry)

~AllPossibleGroupsGrouper ()

Protected Types

enum ModeType { rx = 0, tx }

Protected Member Functions

virtual std::vector< Beams > calculateAllPossibleGroups (std::vector< UserID > allUsers, unsigned int maxBeams, ModeType mode)

virtual Grouping convertPartitionToGrouping (Partition partition, ModeType mode, std::vector< UserID > allUsers)

virtual std::map< UserID,
wns::CandI > getCandIs (std::vector< UserID > users, std::bitset< MAX_STATIONS > bitset, ModeType mode)

virtual std::vector< UserID > getServableUserVectorFromSet (const UserSet userSet, ModeType mode)

Return a vector of users but only include those that could get an SINR that is suitable for transmission when served alone. If we can't even transmit when the users is grouped alone, there is no point in trying to group him with users.

virtual float getTPperGroupTrivialGrouping (int noOfStations)

virtual Partition makeGrouping (int maxBeams, unsigned int noOfStations)=0

Protected Attributes

std::vector< Beams > allPossibleGroups

Classes

struct Beams

struct Partition

Detailed Description

Definition at line 44 of file AllPossibleGroupsGrouper.hpp.

Member Enumeration Documentation

enum wns::scheduler::grouper::AllPossibleGroupsGrouper::ModeType [protected]

Enumerator:

rx
tx

Definition at line 59 of file AllPossibleGroupsGrouper.hpp.

Constructor & Destructor Documentation

wns::scheduler::grouper::AllPossibleGroupsGrouper::AllPossibleGroupsGrouper ( const wns::pyconfig::View & config ) [inline]

Definition at line 48 of file AllPossibleGroupsGrouper.hpp.

wns::scheduler::grouper::AllPossibleGroupsGrouper::~AllPossibleGroupsGrouper ( ) [inline]

Definition at line 51 of file AllPossibleGroupsGrouper.hpp.

Member Function Documentation

std::vector< AllPossibleGroupsGrouper::Beams > AllPossibleGroupsGrouper::calculateAllPossibleGroups	(	std::vector< UserID >	allUsers,
		unsigned int	maxBeams,
		ModeType	mode
	)			`[protected, virtual]`

Definition at line 145 of file AllPossibleGroupsGrouper.cpp.

Grouping AllPossibleGroupsGrouper::convertPartitionToGrouping	(	Partition	partition,
		ModeType	mode,
		std::vector< UserID >	allUsers
	)			`[protected, virtual]`

Definition at line 202 of file AllPossibleGroupsGrouper.cpp.

std::map< UserID, wns::CandI > AllPossibleGroupsGrouper::getCandIs	(	std::vector< UserID >	users,
		std::bitset< MAX_STATIONS >	bitset,
		ModeType	mode
	)			`[protected, virtual]`

Definition at line 45 of file AllPossibleGroupsGrouper.cpp.

Grouping AllPossibleGroupsGrouper::getRxGrouping	(	const UserSet	activeUsers,
		int	maxBeams
	)			`[virtual]`

RX case

Implements wns::scheduler::grouper::GroupingProviderInterface.

Definition at line 394 of file AllPossibleGroupsGrouper.cpp.

std::vector< UserID > AllPossibleGroupsGrouper::getServableUserVectorFromSet	(	const UserSet	userSet,
		ModeType	mode
	)			`[protected, virtual]`

Definition at line 283 of file AllPossibleGroupsGrouper.cpp.

float AllPossibleGroupsGrouper::getTPperGroupTrivialGrouping ( int noOfStations ) [protected, virtual]

Definition at line 111 of file AllPossibleGroupsGrouper.cpp.

Grouping AllPossibleGroupsGrouper::getTxGrouping	(	const UserSet	activeUsers,
		int	maxBeams
	)			`[virtual]`

TX case

Implements wns::scheduler::grouper::GroupingProviderInterface.

Definition at line 360 of file AllPossibleGroupsGrouper.cpp.

virtual Partition wns::scheduler::grouper::AllPossibleGroupsGrouper::makeGrouping	(	int	maxBeams,
		unsigned int	noOfStations
	)			`[protected, pure virtual]`

Implemented in wns::scheduler::grouper::GreedyGrouper, and wns::scheduler::grouper::OptimalGrouper.

void AllPossibleGroupsGrouper::setColleagues ( RegistryProxyInterface * _registry ) [virtual]

Reimplemented from wns::scheduler::grouper::SpatialGrouper.

Definition at line 38 of file AllPossibleGroupsGrouper.cpp.

Member Data Documentation

std::vector<Beams> wns::scheduler::grouper::AllPossibleGroupsGrouper::allPossibleGroups [protected]

Definition at line 89 of file AllPossibleGroupsGrouper.hpp.

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

framework/library/src/scheduler/grouper/AllPossibleGroupsGrouper.hpp
framework/library/src/scheduler/grouper/AllPossibleGroupsGrouper.cpp


Public Member Functions
	AllPossibleGroupsGrouper (const wns::pyconfig::View &config)
virtual Grouping	getRxGrouping (const UserSet activeUsers, int maxBeams)
	Calculates an optimal grouping from a set of users. Such a grouping is a partition of the set of activeUsers into groups (subsets) of users so that every active users is served in exactly one group. The grouping is optimal with respect to the metric introduced in my (Jan Ellenbeck) diploma thesis.
virtual Grouping	getTxGrouping (const UserSet activeUsers, int maxBeams)
	Calculates an optimal grouping from a set of users. Such a grouping is a partition of the set of activeUsers into groups (subsets) of users so that every active users is served in exactly one group. The grouping is optimal with respect to the metric introduced in my (Jan Ellenbeck) diploma thesis.
virtual void	setColleagues (RegistryProxyInterface *_registry)
	~AllPossibleGroupsGrouper ()
Protected Types
enum	ModeType { rx = 0, tx }
Protected Member Functions
virtual std::vector< Beams >	calculateAllPossibleGroups (std::vector< UserID > allUsers, unsigned int maxBeams, ModeType mode)
virtual Grouping	convertPartitionToGrouping (Partition partition, ModeType mode, std::vector< UserID > allUsers)
virtual std::map< UserID, wns::CandI >	getCandIs (std::vector< UserID > users, std::bitset< MAX_STATIONS > bitset, ModeType mode)
virtual std::vector< UserID >	getServableUserVectorFromSet (const UserSet userSet, ModeType mode)
	Return a vector of users but only include those that could get an SINR that is suitable for transmission when served alone. If we can't even transmit when the users is grouped alone, there is no point in trying to group him with users.
virtual float	getTPperGroupTrivialGrouping (int noOfStations)
virtual Partition	makeGrouping (int maxBeams, unsigned int noOfStations)=0
Protected Attributes
std::vector< Beams >	allPossibleGroups
Classes
struct	Beams
struct	Partition