This class defines a coordinator for the multi-work subdivision framework. More...

#include <mwsubdiv.h>

Inheritance diagram for chomp::multiwork::mwSubCoordinator< dim, coord >:

Public Member Functions
	mwSubCoordinator ()
	The constructor of an uninitialized coordinator. More...

	mwSubCoordinator (const char filename, int _inilevel, int _maxlevel, bool _flushfile, const double _paramLeft, const double *_paramRight)
	The complete constructor of a coordinator object. More...

	~mwSubCoordinator ()
	The destructor. More...

Public Member Functions inherited from chomp::multiwork::mwCoordinator
	mwCoordinator ()
	The default constructor. More...

virtual	~mwCoordinator ()
	The virtual destructor. More...

void	KeepWorkers (bool keep=true)
	Makes workers keep running after the coordinator's completion. More...

int	SaveWorkers (const char *filename)
	Saves addresses of workers to the given file in the form of address:port. More...

void	Init (mwData &data)
	Defines a portion of initialization data which will be sent to every newly connected worker. More...

int	Coordinate (mwWorker *w=NULL)
	Run the coordinator until all the work has been completed. More...

Public Member Functions inherited from chomp::multiwork::mwTask
	mwTask ()
	The default constructor. More...

virtual	~mwTask ()
	The destructor. More...

void	Port (int number)
	Sets the port number for the communication or 0 to use none. More...

int	Port () const
	Returns the current port number. More...

void	ControlNumber (unsigned int number)
	Sets the control number for identification. More...

unsigned int	ControlNumber () const
	Returns the currently set identification control number. More...

void	TimeOut (int seconds)
	Sets the network connection time-out interval in seconds. More...

int	TimeOut () const
	Returns the currently set network connection time-out interval. More...

int	LogFile (const char *filename)
	Begins logging detailed communication debug information to the given file. More...

void	LogFile (const mwTask &other)
	Uses another task's log file to log this task's information. More...

void	LogClose ()
	Closes the log file and adds a line with the time information unless this log file was borrowed from another task. More...

int	Add (const char *name, int port=-1)
	Adds an address to the list of computers to connect to at the beginning of working or coordinating. More...

int	Load (const char *filename)
	Loads computer addresses from the given file. More...

int	QuitWorkers ()
	Quits all the workers whose addresses were added with the 'Add' and 'Load' functions. More...

Private Types
typedef tCubeFix< dim, coord >	ppCube
	The maximal feasible subdivision level. More...

typedef hashedset< ppCube >	ppCubes
	The type of a set of cubes in the parameter space. More...

typedef tRectangle< coord >	ppRect
	The kind of rectangle used to iterate ranges of cubes. More...

typedef mwSubDataPack< dim, coord >	ppPack
	The type of a sent data pack kept in an internal array. More...

Private Member Functions
int	Prepare (mwData &data)
	A function for preparing data by a coordinator. More...

int	Accept (mwData &data)
	A function for accepting results by a coordinator. More...

int	Reject (mwData &data)
	A function for taking rejected data by a coordinator. More...

bool	FindMinCube (const typename mwSubCoordinator< dim, coord >::ppCubes tab[], const typename mwSubCoordinator< dim, coord >::ppCubes sent[], int minlevel, int maxlevel, int &level, typename mwSubCoordinator< dim, coord >::ppCube &q)
	Finds a cube at the lowest level (>= min, < max) of the given set of cubes that was not sent, yet. More...

int	Contained (const typename mwSubCoordinator< dim, coord >::ppCube &q, int level, const typename mwSubCoordinator< dim, coord >::ppCubes tab[], int minlevel) const
	Verifies if the given box is contained in a box at any level greater than or equal to the given minimum in the given family of boxes. More...

void	NegativeProbe (const ppCube &q, int level)
	A function for acquiring a negative probe. More...

void	GoodProbe (const ppCube &q, int level)
	A function for acquiring a good probe. More...

void	FailedBox (const ppCube &q, int level)
	A function for acquiring a box for which the verification failed. More...

void	SuccessfulBox (const ppCube &q, int level)
	A function for acquiring a successful box. More...

int	ReadResults (std::istream &in)
	A procedure for reading the previously computed results. More...

Static Private Member Functions
static mwSubCoordinator< dim, coord >::ppCube	UpLevel (const typename mwSubCoordinator< dim, coord >::ppCube &q)
	Returns a probe with respect to a higher level grid, that is, multiplies all the coordinates by 2. More...

static mwSubCoordinator< dim, coord >::ppCube	UpLevel (const typename mwSubCoordinator< dim, coord >::ppCube &box, const typename mwSubCoordinator< dim, coord >::ppCube &corner)
	Returns a box with respect to a higher level grid which is contained in the given box and contains the given corner. More...

static mwSubCoordinator< dim, coord >::ppCube	DownLevel (const typename mwSubCoordinator< dim, coord >::ppCube &q)
	Returns a box with respect to a higher level grid which contains the given box, that is, divides all the coordinates by 2. More...

Private Attributes
ppCubes	Negative [ppMaxSubdiv]
	The set N: Probes for which the verification of the property was negative. More...

ppCubes	Good [ppMaxSubdiv]
	The set G: Good probes, that is, probes for which the property was verified successfully. More...

ppCubes	Test [ppMaxSubdiv]
	The set T: Probes which have to be sent for testing. More...

ppCubes	CurProbes [ppMaxSubdiv]
	Part of the set C2: Currently processed probes. More...

ppCubes	Failed [ppMaxSubdiv]
	The set F: Boxes for which the verification failed. More...

ppCubes	Successful [ppMaxSubdiv]
	The set A: Boxes which are successfully verified to satisfy the given property and thus are contained in the set A. More...

ppCubes	Waiting [ppMaxSubdiv]
	The set W: Boxes waiting for verification. More...

ppCubes	CurBoxes [ppMaxSubdiv]
	Part of the set C: Currently processed boxes. More...

double	paramLeft [dim]
	The left (minimal) vertices of the parameter cube. More...

double	paramRight [dim]
	The right (maximal) vertices of the parameter cube. More...

int	inilevel
	The level of subdivisions in the parameter space at which the actual computations begin. More...

int	maxlevel
	The maximal allowed level of subdivision in the parameter space. More...

mwIniProbes< dim, coord >	iniProbes
	An iterator of initial probes. More...

ppCubes	iniProcessed
	A set of previously processed initial probes (used only if continuing the computations). More...

std::ofstream	f
	A file to append the results to. More...

bool	flushfile
	Should the results file be flushed after every write? More...

int	current
	The counter of data packs prepared by a coordinator. More...

multitable< ppPack >	sent
	The data packs sent for processing. More...

int	sentlen
	The number of data packs sent for processing. More...

int	countNegative
	The number of processed probes with negative result. More...

int	countGood
	The number of processed probes which turn out to be good. More...

int	countFailed
	The number of processed boxes for which the verification failed. More...

int	countSuccessful
	The number of processed boxes for which the verification was successful. More...

Static Private Attributes
static const int	ppMaxSubdiv = 8 * sizeof (coord) - 2
	The maximal feasible subdivision level. More...

static const int	ppMaxDim = ppCube::MaxDim
	The maximal dimension of cubes. More...

Additional Inherited Members
Static Protected Member Functions inherited from chomp::multiwork::mwTask
static int	SendMessage (int fd, unsigned int ctrl, unsigned int code, const mwData &x)
	Sends a message with data to the given socket. More...

static int	RecvMessage (int fd, unsigned int &ctrl, unsigned int &code, mwData &x)
	Receives a message with data from the given socket. More...

Protected Attributes inherited from chomp::multiwork::mwTask
std::ofstream *	logFile
	The debug log file stream. More...

std::vector< std::string >	computers
	A list of workers or coordinators to connect to at start-up. More...

std::vector< int >	ports
	A list of port numbers of workers to connect to at start-up. More...

Detailed Description

template<int dim, class coord>
class chomp::multiwork::mwSubCoordinator< dim, coord >

This class defines a coordinator for the multi-work subdivision framework.

Definition at line 554 of file mwsubdiv.h.

Member Typedef Documentation

◆ ppCube

template<int dim, class coord >

typedef tCubeFix<dim,coord> chomp::multiwork::mwSubCoordinator< dim, coord >::ppCube

private

The maximal feasible subdivision level.

The type of a cube of parameters.

Definition at line 563 of file mwsubdiv.h.

◆ ppCubes

template<int dim, class coord >

typedef hashedset<ppCube> chomp::multiwork::mwSubCoordinator< dim, coord >::ppCubes

private

The type of a set of cubes in the parameter space.

Definition at line 569 of file mwsubdiv.h.

◆ ppPack

template<int dim, class coord >

typedef mwSubDataPack<dim,coord> chomp::multiwork::mwSubCoordinator< dim, coord >::ppPack

private

The type of a sent data pack kept in an internal array.

Definition at line 575 of file mwsubdiv.h.

◆ ppRect

template<int dim, class coord >

typedef tRectangle<coord> chomp::multiwork::mwSubCoordinator< dim, coord >::ppRect

private

The kind of rectangle used to iterate ranges of cubes.

Definition at line 572 of file mwsubdiv.h.

Constructor & Destructor Documentation

◆ mwSubCoordinator() [1/2]

template<int dim, class coord >

chomp::multiwork::mwSubCoordinator< dim, coord >::mwSubCoordinator

inline

The constructor of an uninitialized coordinator.

Definition at line 750 of file mwsubdiv.h.

{
        return;
} /* mwSubCoordinator<dim,coord>::mwSubCoordinator */

◆ mwSubCoordinator() [2/2]

template<int dim, class coord >

chomp::multiwork::mwSubCoordinator< dim, coord >::mwSubCoordinator	(	const char *	filename,
		int	_inilevel,
		int	_maxlevel,
		bool	_flushfile,
		const double *	_paramLeft,
		const double *	_paramRight
	)

The complete constructor of a coordinator object.

Definition at line 756 of file mwsubdiv.h.

                                                            :
        inilevel ((_inilevel < 2) ? 2 : _inilevel),
        maxlevel ((_maxlevel <= inilevel) ? (inilevel + 1) : _maxlevel),
        iniProbes (inilevel),
        flushfile (_flushfile),
        current (0), sentlen (0),
        countNegative (0), countGood (0),
        countFailed (0), countSuccessful (0)
{
        // display a warning if no file name is provided
        if (!filename || !*filename)
                sout << "WARNING: No results file name given. "
                        "Computation results will not be saved.\n";
 
        // initialize the subdivision levels
        if (maxlevel > ppMaxSubdiv)
        {
                sout << "WARNING: Max subdivision level decreased from " <<
                        maxlevel << " to " << ppMaxSubdiv << ".\n";
                maxlevel = ppMaxSubdiv;
                if (inilevel >= maxlevel)
                        inilevel = maxlevel - 1;
        }
 
        // read the previously computed results of the computations
        if (filename && *filename)
        {
                std::ifstream in (filename);
                if (!in)
                        sout << "Note: Could not open the results file. "
                        "Any previous results will be ignored.\n";
                else
                {
                        this -> ReadResults (in);
                        in. close ();
                }
        }
 
        // open the results file for appending
        if (filename && *filename)
        {
                f. open (filename, std::ios::out | std::ios::app);
                f << "; Started on " << currenttime ();
                if (flushfile)
                        f << std::flush;
        }
 
        // copy the left and right ends of the intervals
        for (int i = 0; i < dim; ++ i)
        {
                paramLeft [i] = _paramLeft [i];
                paramRight [i] = _paramRight [i];
        }
 
        return;
} /* mwSubCoordinator<dim,coord>::mwSubCoordinator */

◆ ~mwSubCoordinator()

template<int dim, class coord >

chomp::multiwork::mwSubCoordinator< dim, coord >::~mwSubCoordinator

inline

The destructor.

Definition at line 816 of file mwsubdiv.h.

{
        f << "; A total of " << (countNegative + countGood) <<
                " probes and " << (countFailed + countSuccessful) <<
                " boxes have been processed.\n";
        f << "; The verification was negative for " << countNegative <<
                " probes, and " << countGood << " probes were good.\n";
        f << "; The verification failed for " << countFailed <<
                " boxes, and was successful for " << countSuccessful <<
                " boxes.\n";
        f << "; Finished on " << currenttime ();
        f << "; ---------------------------------------------------\n";
        f. close ();
        return;
} /* mwSubCoordinator<dim,coord>::~mwSubCoordinator */

References chomp::homology::currenttime().

Member Function Documentation

◆ Accept()

template<int dim, class coord >

int chomp::multiwork::mwSubCoordinator< dim, coord >::Accept ( mwData & data )

privatevirtual

A function for accepting results by a coordinator.

Reimplemented from chomp::multiwork::mwCoordinator.

Definition at line 1286 of file mwsubdiv.h.

{
        // decode the data pack number
        int n = 0;
        data >> n;
 
        // decode the result
        int result = 0;
        data >> result;
 
        // say what has been received
        sout << "* " << n << " " << result << ".\n";
 
        // find this data among the data packs that were sent for processing
        int pos = 0;
        while ((pos < sentlen) && (sent [pos]. num != n))
                ++ pos;
        if (pos >= sentlen)
        {
                sout << "ERROR: Wrong data pack number received "
                        "from a worker.\n";
                return mwError;
        }
        const ppPack &pack = sent [pos];
 
        // save the data to the output file
        f << (pack. full ? "* " : "@ ") << n << " " << result <<
                " " << pack. level << " " << pack. q << ".\n";
        if (flushfile)
                f << std::flush;
        
        // extract the data from the data pack
        const ppCube &q = pack. q;
        int level = pack. level;
        bool full = pack. full;
 
        // remove the cube from appropriate sets and process it
        if (full)
        {
                CurBoxes [level]. remove (q);
                Waiting [level]. remove (q);
                if (result)
                {
                        ++ countSuccessful;
                        SuccessfulBox (q, level);
                }
                else
                {
                        ++ countFailed;
                        FailedBox (q, level);
                }
        }
        else
        {
                CurProbes [level]. remove (q);
                Test [level]. remove (q);
                if (result)
                {
                        ++ countGood;
                        GoodProbe (q, level);
                }
                else
                {
                        ++ countNegative;
                        NegativeProbe (q, level);
                }
        }
 
        // remove the data pack from the table containing the data packs
        -- sentlen;
        if (pos != sentlen)
                sent [pos] = sent [sentlen];
 
        return mwOk;
} /* mwSubCoordinator<dim,coord>::Accept */

References chomp::multiwork::mwError, chomp::multiwork::mwOk, and chomp::homology::sout.

◆ Contained()

template<int dim, class coord >

int chomp::multiwork::mwSubCoordinator< dim, coord >::Contained	(	const typename mwSubCoordinator< dim, coord >::ppCube &	q,
		int	level,
		const typename mwSubCoordinator< dim, coord >::ppCubes	tab[],
		int	minlevel
	)		const

private

Verifies if the given box is contained in a box at any level greater than or equal to the given minimum in the given family of boxes.

Returns the level of a box which is found or 0 if none.

Definition at line 1054 of file mwsubdiv.h.

{
        // verify if the box itself is contained in any set of boxes
        if (tab [level]. check (q))
                return level;
 
        // subdivide the box and verify at a higher level
        if (minlevel < inilevel)
                minlevel = inilevel;
        ppCube box = q;
        while (-- level > minlevel)
        {
                box = DownLevel (box);
                if (tab [level]. check (box))
                        return level;
        }
 
        return 0;
} /* mwSubCoordinator::Contained */

◆ DownLevel()

template<int dim, class coord >

mwSubCoordinator< dim, coord >::ppCube chomp::multiwork::mwSubCoordinator< dim, coord >::DownLevel ( const typename mwSubCoordinator< dim, coord >::ppCube & q )

staticprivate

Returns a box with respect to a higher level grid which contains the given box, that is, divides all the coordinates by 2.

Definition at line 1043 of file mwsubdiv.h.

{
        coord c [dim];
        q. coord (c);
        for (int i = 0; i < dim; ++ i)
                c [i] >>= 1;
        return ppCube (c, dim);
} /* mwSubCoordinator::DownLevel */

◆ FailedBox()

template<int dim, class coord >

void chomp::multiwork::mwSubCoordinator< dim, coord >::FailedBox	(	const ppCube &	q,
		int	level
	)

private

A function for acquiring a box for which the verification failed.

Definition at line 1150 of file mwsubdiv.h.

{
        // add the box to the list of boxes which failed
        Failed [level]. add (q);
        sbug << "@ FailedBox [" << level << "]: " << q << "\n";
 
        // if no further subdivisions are to be considered then quit here
        if (level + 1 == maxlevel)
                return;
 
        // consider all the corners of the box
        mwCorners<dim,coord> corners (q);
        while (corners. available ())
        {
                // take the next corner of the box
                ppCube c = corners. get ();
 
                // if this is a negative probe then skip it
                if (Negative [level]. check (c))
                        continue;
 
                // if this probe has not yet been checked
                // then add it to the list of probes to test
                if (!Good [level]. check (c))
                {
                        Test [level]. add (c);
                        sbug << "+ Test [" << level << "]: " << c << "\n";
                        continue;
                }
 
                // add a twice smaller box located at the given corner
                // to the list of boxes which wait for being verified,
                // unless the result for this box is already known
                ppCube box = UpLevel (q, c);
                if (!Successful [level + 1]. check (box) &&
                        !Failed [level + 1]. check (box))
                {
                        Waiting [level + 1]. add (box);
                        sbug << "+ Waiting [" << (level + 1) << "]: " <<
                                box << "\n";
                }
 
                // mark the probe as good at the higher subdivision level
                ppCube probe = UpLevel (c);
                Good [level + 1]. add (probe);
                sbug << "+ Good [" << (level + 1) << "]: " << probe << "\n";
        }
 
        return;
} /* mwSubCoordinator::FailedBox */

References chomp::homology::sbug.

◆ FindMinCube()

template<int dim, class coord >

bool chomp::multiwork::mwSubCoordinator< dim, coord >::FindMinCube	(	const typename mwSubCoordinator< dim, coord >::ppCubes	tab[],
		const typename mwSubCoordinator< dim, coord >::ppCubes	sent[],
		int	minlevel,
		int	maxlevel,
		int &	level,
		typename mwSubCoordinator< dim, coord >::ppCube &	q
	)

inlineprivate

Finds a cube at the lowest level (>= min, < max) of the given set of cubes that was not sent, yet.

Modifies 'level' and 'q'. Returns true if found, false if not found.

Definition at line 835 of file mwsubdiv.h.

{
        for (int l = minlevel; l < maxlevel; ++ l)
        {
                const ppCubes &theSet = tab [l];
                const ppCubes &sentSet = sent [l];
                int number = theSet. size ();
                for (int i = number - 1; i >= 0; -- i)
                {
                        const ppCube &c = theSet [i];
                        if (!sentSet. check (c))
                        {
                                level = l;
                                q = c;
                                return true;
                        }
                }
        }
        return false;
} /* mwSubCoordinator::FindMinCube */

◆ GoodProbe()

template<int dim, class coord >

void chomp::multiwork::mwSubCoordinator< dim, coord >::GoodProbe	(	const ppCube &	q,
		int	level
	)

private

A function for acquiring a good probe.

Definition at line 1108 of file mwsubdiv.h.

{
        // if it is already known that this probe is good then skip it
        if (Good [level]. check (q))
        {
                sbug << "@ GoodKnown [" << level << "]: " << q << "\n";
                return;
        }
 
        // add the probe to the set of good probes at its level
        Good [level]. add (q);
        sbug << "@ GoodProbe [" << level << "]: " << q << "\n";
 
        // if the next level is beyond the scope then quit here
        if (level + 1 == maxlevel)
                return;
 
        // transfer the probe to the next level and remember that it is good
        ppCube probe = UpLevel (q);
        Good [level + 1]. add (probe);
        sbug << "+ GoodProbe [" << (level + 1) << "]: " << probe << "\n";
 
        // consider all the boxes which contain this probe
        mwBoxes<dim,coord> boxes (probe);
        while (boxes. available ())
        {
                // if the box is not contained in any larger successful box
                // then add it to the waiting list
                ppCube box = boxes. get ();
                if (!Contained (box, level + 1, Successful, 0))
                {
                        
                        Waiting [level + 1]. add (box);
                        sbug << "+ Waiting [" << (level + 1) << "]: " <<
                                box << "\n";
                }
        }
 
        return;
} /* mwSubCoordinator::GoodProbe */

References chomp::homology::sbug.

◆ NegativeProbe()

template<int dim, class coord >

void chomp::multiwork::mwSubCoordinator< dim, coord >::NegativeProbe	(	const ppCube &	q,
		int	level
	)

private

A function for acquiring a negative probe.

Definition at line 1078 of file mwsubdiv.h.

{
        // add the probe to the set of negative probes
        Negative [level]. add (q);
        sbug << "@ NegProbe [" << level << "]: " << q << "\n";
 
        // boxes around this probe automatically fail, so remove them
        // from the queue and interpret them as failed boxes
        mwBoxes<dim,coord> boxes (q);
        while (boxes. available ())
        {
                // take a box which has this probe in its corner
                ppCube box = boxes. get ();
 
                // if it is waiting for processing but was not sent yet
                // then pretend it has just returned as a failed box
                if (Waiting [level]. check (box) &&
                        !CurBoxes [level]. check (box))
                {
                        sbug << "# FailedBox [" << level << "]: " <<
                                box << "\n";
                        Waiting [level]. remove (box);
                        FailedBox (box, level);
                }
        }
 
        return;
} /* mwSubCoordinator::NegativeProbe */

References chomp::homology::sbug.

◆ Prepare()

template<int dim, class coord >

int chomp::multiwork::mwSubCoordinator< dim, coord >::Prepare ( mwData & data )

privatevirtual

A function for preparing data by a coordinator.

Reimplemented from chomp::multiwork::mwCoordinator.

Definition at line 861 of file mwsubdiv.h.

{
        // prepare a data pack to send
        ppPack &pack = sent [sentlen];
 
        // if there is any initial probe that has not yet been processed
        // then take this probe
        bool iniProbe = false;
        while (iniProbes. available ())
        {
                pack = ppPack (current, iniProbes. get (), inilevel, false);
                if (iniProcessed. check (pack. q))
                {
                        iniProcessed. remove (pack. q);
                        continue;
                }
                else
                {
                        iniProbe = true;
                        break;
                }
        }
 
        // otherwise send a probe or a box which is waiting to be verified
        if (!iniProbe)
        {
                // find a probe for testing at the lowest level available
                int levelT = 0;
                ppCube cubeT;
                bool foundT = this -> FindMinCube (Test, CurProbes,
                        inilevel, maxlevel, levelT, cubeT);
 
                // find a box that is waiting at the lowest level available
                int levelW = 0;
                ppCube cubeW;
                bool foundW = this -> FindMinCube (Waiting, CurBoxes,
                        inilevel, maxlevel, levelW, cubeW);
 
                // if no cube for processing can be found, then interrupt
                if (!foundT && !foundW)
                        return mwNoData;
 
                // send the probe found if this is the right thing to do
                if (foundT && (!foundW || (levelT <= levelW)))
                {
                        pack = ppPack (current, cubeT, levelT, false);
                        CurProbes [levelT]. add (cubeT);
                }
                // otherwise send the box found
                else
                {
                        pack = ppPack (current, cubeW, levelW, true);
                        CurBoxes [levelW]. add (cubeW);
                }
        }
 
        // prepare the intervals of parameters corresponding to the cube
        coord c [ppMaxDim];
        pack. q. coord (c);
        int fullSize = 1 << pack. level;
        double left [ppMaxDim];
        double right [ppMaxDim];
        for (int i = 0; i < dim; ++ i)
        {
                // prepare the probe or the left corner of the box
                left [i] = mwSubdivPoint (paramLeft [i], paramRight [i],
                        c [i], fullSize);
 
                // if this is a full box then compute the right corner, too
                if (pack. full)
                {
                        // prepare the right corner of the box
                        right [i] =  mwSubdivPoint (paramLeft [i],
                                paramRight [i], c [i] + 1, fullSize);
 
                        // if the resolution of the representable numbers
                        // has been reached then set this level to be
                        // the strict upper bound for the subdivision level
                        if (left [i] == right [i])
                        {
                                // leave a note of this situation in the file
                                f << "; The resolution of representable "
                                        "numbers exceeded.\n; Decreasing "
                                        "max level from " << maxlevel <<
                                        " to " << pack. level << ".\n";
                                if (flushfile)
                                        f << std::flush;
 
                                // notify the user about this situation
                                sout << "WARNING: The resolution of "
                                        "representable numbers exceeded.\n"
                                        "Decreasing max level from " <<
                                        maxlevel << " to " << pack. level <<
                                        ".\n";
 
                                // decrease the max level limit
                                maxlevel = pack. level;
                                return mwNoData;
                        }
                }
        }
 
        // write th information on the prepared cube to the results file
        f << "+ " << pack. num;
        for (int i = 0; i < dim; ++ i)
        {
                f << (i ? "x[" : " [") << left [i];
                if (pack. full)
                        f << "," << right [i];
                f << "]";
        }
        f << ".\n";
        if (flushfile)
                f << std::flush;
 
        // send the data pack number
        data << pack. num;
        
        // send the subdivision level
        data << pack. level;
 
        // send the information on whether this is a full box or a probe
        data << pack. full;
 
        // send the intervals (left and right ends where applicable)
        for (int i = 0; i < dim; ++ i)
        {
                data << left [i];
                if (pack. full)
                        data << right [i];
        }
 
        // append the data end marker for extra verification
        const int dataEndMarker = 13;
        data << dataEndMarker;
 
        // show a message on which data pack has been prepared
        sout << "+ " << pack. num << ".\n";
 
        // increase the counters
        ++ current;
        ++ sentlen;
 
        return mwOk;
} /* mwSubCoordinator<dim,coord>::Prepare */

References chomp::multiwork::mwNoData, chomp::multiwork::mwOk, chomp::multiwork::mwSubdivPoint(), and chomp::homology::sout.

◆ ReadResults()

template<int dim, class coord >

int chomp::multiwork::mwSubCoordinator< dim, coord >::ReadResults ( std::istream & in )

private

A procedure for reading the previously computed results.

Definition at line 1378 of file mwsubdiv.h.

{
        ignorecomments (in);
        while (!in. eof ())
        {
                // read the first char and interprete the line
                int ch = in. get ();
 
                // ignore the line if it contains no useful information
                if ((ch != '*') && (ch != '@'))
                {
                        ignoreline (in);
                        ignorecomments (in);
                        continue;
                }
        
                // read the data number if relevant
                if ((ch == '*') || (ch == '@'))
                {
                        int n = -1;
                        in >> n;
                        if (n < 0)
                                break;
                }
 
                // read the result if any
                int result = -1;
                if ((ch == '*') || (ch == '@'))
                {
                        in >> result;
                        if (result < 0)
                                break;
                }
 
                // read the subdivision level of the cube
                int level = -1;
                in >> level;
                if (level < 0)
                        break;
 
                // read the cube itself
                ppCube q;
                in >> q;
 
                // make sure that there is the dot which ends the line
                if (in. peek () != '.')
                        break;
 
                // ignore the remaining part of the line
                ignoreline (in);
                ignorecomments (in);
 
                // process the data as necessary
                if (ch == '*')
                {
                        Waiting [level]. remove (q);
                        if (result)
                                SuccessfulBox (q, level);
                        else
                                FailedBox (q, level);
                }
                else if (ch == '@')
                {
                        if (level == inilevel)
                                iniProcessed. add (q);
                        else
                                Test [level]. remove (q);
                        if (result)
                                GoodProbe (q, level);
                        else
                                NegativeProbe (q, level);
                }
        }
 
        return 0;
} /* mwSubCoordinator<dim,coord>::ReadResults */

References chomp::homology::ignorecomments(), and chomp::homology::ignoreline().

Referenced by chomp::multiwork::mwSubCoordinator< dim, coord >::mwSubCoordinator().

◆ Reject()

template<int dim, class coord >

int chomp::multiwork::mwSubCoordinator< dim, coord >::Reject ( mwData & data )

privatevirtual

A function for taking rejected data by a coordinator.

Reimplemented from chomp::multiwork::mwCoordinator.

Definition at line 1363 of file mwsubdiv.h.

{
        // decode the number
        int n = 0;
        data >> n;
 
        // say that data has been rejected
        sout << "!!! Data no. " << n << " rejected.\n";
 
        return mwError;
} /* mwSubCoordinator<dim,coord>::Reject */

References chomp::multiwork::mwError, and chomp::homology::sout.

◆ SuccessfulBox()

template<int dim, class coord >

void chomp::multiwork::mwSubCoordinator< dim, coord >::SuccessfulBox	(	const ppCube &	q,
		int	level
	)

private

A function for acquiring a successful box.

Definition at line 1202 of file mwsubdiv.h.

{
        // if the box has already been added then skip it
        if (Successful [level]. check (q))
        {
                sbug << "@ SuccessKnown [" << level << "]: " << q << "\n";
                return;
        }
 
        // if this box is already contained in a larger successful box
        // then ignore it
        if (Contained (q, level, Successful, 0))
        {
                sbug << "@ SuccessSubset [" << level << "]: " << q << "\n";
                return;
        }
 
        // add the box to the set of successful boxes which form the set A
        Successful [level]. add (q);
        sbug << "@ SuccessBox [" << level << "]: " << q << "\n";
 
        // consider all the vertices of this box
        mwCorners<dim,coord> corners (q);
        while (corners. available ())
        {
                // take the next corner of the box
                ppCube c = corners. get ();
 
                // remove the corner probe from a list of probes to test
                if (Test [level]. check (c))
                {
                        Test [level]. remove (c);
                        sbug << "- Test [" << level << "]: " << c << "\n";
                }
 
                // remove the corner box from a list of boxes to test
                ppCube cornerBox = UpLevel (q, c);
                if (Waiting [level + 1]. check (cornerBox))
                {
                        Waiting [level + 1]. remove (cornerBox);
                        sbug << "- Waiting [" << (level + 1) << "]: " <<
                                cornerBox << "\n";
                        // note: there might be some boxes contained in q
                        // waiting at deeper levels, but determining them
                        // might be quite inefficient,
                        // so they are not cleaned in this implementation
                        // of the algorithm
                }
 
                // if the probe is already known to be good then skip it
                if (Good [level]. check (c))
                        continue;
 
                // add the probe to the list of good ones
                Good [level]. add (c);
                sbug << "+ Good [" << level << "]: " << c << "\n";
 
                // propagate the probe one level deeper and mark it as good
                ppCube probe = UpLevel (c);
                Good [level + 1]. add (probe);
                sbug << "+ Good [" << (level + 1) << "]: " << probe << "\n";
 
                // consider all the boxes which contain this probe
                mwBoxes<dim,coord> boxes (probe);
                while (boxes. available ())
                {
                        // take the next box
                        ppCube box = boxes. get ();
 
                        // if this box is not contained in any successful
                        // larger box then add it to the waiting list
                        if (!Contained (box, level + 1, Successful, 0))
                        {
                                Waiting [level + 1]. add (box);
                                sbug << "+ Waiting [" << (level + 1) <<
                                        "]: " << box << "\n";
                        }
                }
        }
 
        return;
} /* mwSubCoordinator::SuccessfulBox */

References chomp::homology::sbug.

◆ UpLevel() [1/2]

template<int dim, class coord >

mwSubCoordinator< dim, coord >::ppCube chomp::multiwork::mwSubCoordinator< dim, coord >::UpLevel	(	const typename mwSubCoordinator< dim, coord >::ppCube &	box,
		const typename mwSubCoordinator< dim, coord >::ppCube &	corner
	)

staticprivate

Returns a box with respect to a higher level grid which is contained in the given box and contains the given corner.

Definition at line 1023 of file mwsubdiv.h.

{
        coord cBox [dim];
        box. coord (cBox);
        coord cCorner [dim];
        corner. coord (cCorner);
        for (int i = 0; i < dim; ++ i)
        {
                if (cBox [i] == cCorner [i])
                        cBox [i] <<= 1;
                else
                        cBox [i] = (cBox [i] << 1) + 1;
        }
        return ppCube (cBox, dim);
} /* mwSubCoordinator::UpLevel */

◆ UpLevel() [2/2]

template<int dim, class coord >

mwSubCoordinator< dim, coord >::ppCube chomp::multiwork::mwSubCoordinator< dim, coord >::UpLevel ( const typename mwSubCoordinator< dim, coord >::ppCube & q )

staticprivate

Returns a probe with respect to a higher level grid, that is, multiplies all the coordinates by 2.

Definition at line 1011 of file mwsubdiv.h.

{
        coord c [dim];
        q. coord (c);
        for (int i = 0; i < dim; ++ i)
                c [i] <<= 1;
        return ppCube (c, dim);
} /* mwSubCoordinator::UpLevel */

Member Data Documentation

◆ countFailed

template<int dim, class coord >

int chomp::multiwork::mwSubCoordinator< dim, coord >::countFailed

private

The number of processed boxes for which the verification failed.

Definition at line 734 of file mwsubdiv.h.

◆ countGood

template<int dim, class coord >

int chomp::multiwork::mwSubCoordinator< dim, coord >::countGood

private

The number of processed probes which turn out to be good.

Definition at line 731 of file mwsubdiv.h.

◆ countNegative

template<int dim, class coord >

int chomp::multiwork::mwSubCoordinator< dim, coord >::countNegative

private

The number of processed probes with negative result.

Definition at line 728 of file mwsubdiv.h.

◆ countSuccessful

template<int dim, class coord >

int chomp::multiwork::mwSubCoordinator< dim, coord >::countSuccessful

private

The number of processed boxes for which the verification was successful.

Definition at line 738 of file mwsubdiv.h.

◆ CurBoxes

template<int dim, class coord >

ppCubes chomp::multiwork::mwSubCoordinator< dim, coord >::CurBoxes[ppMaxSubdiv]

private

Part of the set C: Currently processed boxes.

Definition at line 628 of file mwsubdiv.h.

◆ CurProbes

template<int dim, class coord >

ppCubes chomp::multiwork::mwSubCoordinator< dim, coord >::CurProbes[ppMaxSubdiv]

private

Part of the set C2: Currently processed probes.

Definition at line 615 of file mwsubdiv.h.

◆ current

template<int dim, class coord >

int chomp::multiwork::mwSubCoordinator< dim, coord >::current

private

The counter of data packs prepared by a coordinator.

Definition at line 717 of file mwsubdiv.h.

◆ f

template<int dim, class coord >

std::ofstream chomp::multiwork::mwSubCoordinator< dim, coord >::f

private

A file to append the results to.

Definition at line 706 of file mwsubdiv.h.

Referenced by chomp::multiwork::mwSubCoordinator< dim, coord >::mwSubCoordinator().

◆ Failed

template<int dim, class coord >

ppCubes chomp::multiwork::mwSubCoordinator< dim, coord >::Failed[ppMaxSubdiv]

private

The set F: Boxes for which the verification failed.

Definition at line 618 of file mwsubdiv.h.

◆ flushfile

template<int dim, class coord >

bool chomp::multiwork::mwSubCoordinator< dim, coord >::flushfile

private

Should the results file be flushed after every write?

Definition at line 709 of file mwsubdiv.h.

Referenced by chomp::multiwork::mwSubCoordinator< dim, coord >::mwSubCoordinator().

◆ Good

template<int dim, class coord >

ppCubes chomp::multiwork::mwSubCoordinator< dim, coord >::Good[ppMaxSubdiv]

private

The set G: Good probes, that is, probes for which the property was verified successfully.

Definition at line 609 of file mwsubdiv.h.

◆ inilevel

template<int dim, class coord >

int chomp::multiwork::mwSubCoordinator< dim, coord >::inilevel

private

The level of subdivisions in the parameter space at which the actual computations begin.

Definition at line 691 of file mwsubdiv.h.

Referenced by chomp::multiwork::mwSubCoordinator< dim, coord >::mwSubCoordinator().

◆ iniProbes

template<int dim, class coord >

mwIniProbes<dim,coord> chomp::multiwork::mwSubCoordinator< dim, coord >::iniProbes

private

An iterator of initial probes.

Definition at line 697 of file mwsubdiv.h.

◆ iniProcessed

template<int dim, class coord >

ppCubes chomp::multiwork::mwSubCoordinator< dim, coord >::iniProcessed

private

A set of previously processed initial probes (used only if continuing the computations).

Definition at line 701 of file mwsubdiv.h.

◆ maxlevel

template<int dim, class coord >

int chomp::multiwork::mwSubCoordinator< dim, coord >::maxlevel

private

The maximal allowed level of subdivision in the parameter space.

Definition at line 694 of file mwsubdiv.h.

Referenced by chomp::multiwork::mwSubCoordinator< dim, coord >::mwSubCoordinator().

◆ Negative

template<int dim, class coord >

ppCubes chomp::multiwork::mwSubCoordinator< dim, coord >::Negative[ppMaxSubdiv]

private

The set N: Probes for which the verification of the property was negative.

Definition at line 605 of file mwsubdiv.h.

◆ paramLeft

template<int dim, class coord >

double chomp::multiwork::mwSubCoordinator< dim, coord >::paramLeft[dim]

private

The left (minimal) vertices of the parameter cube.

Definition at line 684 of file mwsubdiv.h.

Referenced by chomp::multiwork::mwSubCoordinator< dim, coord >::mwSubCoordinator().

◆ paramRight

template<int dim, class coord >

double chomp::multiwork::mwSubCoordinator< dim, coord >::paramRight[dim]

private

The right (maximal) vertices of the parameter cube.

Definition at line 687 of file mwsubdiv.h.

Referenced by chomp::multiwork::mwSubCoordinator< dim, coord >::mwSubCoordinator().

◆ ppMaxDim

template<int dim, class coord >

const int chomp::multiwork::mwSubCoordinator< dim, coord >::ppMaxDim = ppCube::MaxDim

staticprivate

The maximal dimension of cubes.

Definition at line 566 of file mwsubdiv.h.

◆ ppMaxSubdiv

template<int dim, class coord >

const int chomp::multiwork::mwSubCoordinator< dim, coord >::ppMaxSubdiv = 8 * sizeof (coord) - 2

staticprivate

The maximal feasible subdivision level.

Definition at line 557 of file mwsubdiv.h.

Referenced by chomp::multiwork::mwSubCoordinator< dim, coord >::mwSubCoordinator().

◆ sent

template<int dim, class coord >

multitable<ppPack> chomp::multiwork::mwSubCoordinator< dim, coord >::sent

private

The data packs sent for processing.

Definition at line 720 of file mwsubdiv.h.

◆ sentlen

template<int dim, class coord >

int chomp::multiwork::mwSubCoordinator< dim, coord >::sentlen

private

The number of data packs sent for processing.

Definition at line 723 of file mwsubdiv.h.

◆ Successful

template<int dim, class coord >

ppCubes chomp::multiwork::mwSubCoordinator< dim, coord >::Successful[ppMaxSubdiv]

private

The set A: Boxes which are successfully verified to satisfy the given property and thus are contained in the set A.

Definition at line 622 of file mwsubdiv.h.

◆ Test

template<int dim, class coord >

ppCubes chomp::multiwork::mwSubCoordinator< dim, coord >::Test[ppMaxSubdiv]

private

The set T: Probes which have to be sent for testing.

Definition at line 612 of file mwsubdiv.h.

◆ Waiting

template<int dim, class coord >

ppCubes chomp::multiwork::mwSubCoordinator< dim, coord >::Waiting[ppMaxSubdiv]

private

The set W: Boxes waiting for verification.

Definition at line 625 of file mwsubdiv.h.

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

chomp/multiwork/mwsubdiv.h

Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ ppCube

◆ ppCubes

◆ ppPack

◆ ppRect

Constructor & Destructor Documentation

◆ mwSubCoordinator() [1/2]

◆ mwSubCoordinator() [2/2]

◆ ~mwSubCoordinator()

Member Function Documentation

◆ Accept()

◆ Contained()

◆ DownLevel()

◆ FailedBox()

◆ FindMinCube()

◆ GoodProbe()

◆ NegativeProbe()

◆ Prepare()

◆ ReadResults()

◆ Reject()

◆ SuccessfulBox()

◆ UpLevel() [1/2]

◆ UpLevel() [2/2]

Member Data Documentation

◆ countFailed

◆ countGood

◆ countNegative

◆ countSuccessful

◆ CurBoxes

◆ CurProbes

◆ current

◆ f

◆ Failed

◆ flushfile

◆ Good

◆ inilevel

◆ iniProbes

◆ iniProcessed

◆ maxlevel

◆ Negative

◆ paramLeft

◆ paramRight

◆ ppMaxDim

◆ ppMaxSubdiv

◆ sent

◆ sentlen

◆ Successful

◆ Test

◆ Waiting