InstructionQueue Class Reference

An InstructionQueue object gathers Mesquite Instructions and ensures that the instruction queue is coherent for mesh improvement and/or mesh quality assessment purposes. More...

#include <InstructionQueue.hpp>

Inheritance diagram for InstructionQueue:

Collaboration diagram for InstructionQueue:

Public Member Functions
	InstructionQueue ()
virtual	~InstructionQueue ()
void	add_target_calculator (TargetCalculator *tc, MsqError &err)
void	add_preconditioner (QualityImprover *instr, MsqError &err)
	adds a QualityImprover at the end of the instruction list More...
void	remove_preconditioner (size_t index, MsqError &err)
	removes a QualityImprover* from the instruction queue More...
void	insert_preconditioner (QualityImprover *instr, size_t index, MsqError &err)
	inserts a QualityImprover* into the instruction queue. More...
void	add_quality_assessor (QualityAssessor *instr, MsqError &err)
	adds a QualityAssessor to the instruction queue. More...
void	remove_quality_assessor (size_t index, MsqError &err)
	removes a QualityAssessor* from the instruction queue More...
void	insert_quality_assessor (QualityAssessor *instr, size_t index, MsqError &err)
	inserts a QualityAssessor* into the instruction queue. More...
void	set_master_quality_improver (QualityImprover *instr, MsqError &err)
void	disable_automatic_quality_assessment ()
void	enable_automatic_quality_assessment ()
void	disable_automatic_midnode_adjustment ()
void	enable_automatic_midnode_adjustment ()
virtual void	run_instructions (MeshSet &msc, MsqError &err)
	This function is virtual so that it may be redefined in the wraper classes. More...
void	clear ()
void	trap_floating_point_exception (bool enable)
	Generate SIGFPE whenever a floating point exception occurs. More...
bool	trap_floating_point_exception () const
	InstructionQueue ()
virtual	~InstructionQueue ()
void	add_target_calculator (TargetCalculator *tc, MsqError &err)
void	add_preconditioner (QualityImprover *instr, MsqError &err)
void	remove_preconditioner (size_t index, MsqError &err)
void	insert_preconditioner (QualityImprover *instr, size_t index, MsqError &err)
void	add_quality_assessor (QualityAssessor *instr, MsqError &err)
void	remove_quality_assessor (size_t index, MsqError &err)
void	insert_quality_assessor (QualityAssessor *instr, size_t index, MsqError &err)
void	set_master_quality_improver (QualityImprover *instr, MsqError &err)
void	disable_automatic_quality_assessment ()
void	enable_automatic_quality_assessment ()
void	disable_automatic_midnode_adjustment ()
void	enable_automatic_midnode_adjustment ()
virtual void	run_instructions (MeshSet &msc, MsqError &err)
	This function is virtual so that it may be redefined in the wraper classes. More...
void	clear ()
void	trap_floating_point_exception (bool enable)
	Generate SIGFPE whenever a floating point exception occurs. More...
bool	trap_floating_point_exception () const

Private Member Functions
msq_std::list< PatchDataUser * > ::iterator	clear_master (MsqError &err)
msq_std::list< PatchDataUser * > ::iterator	clear_master (MsqError &err)

Private Attributes
msq_std::list< PatchDataUser * >	instructions
bool	autoQualAssess
bool	autoAdjMidNodes
size_t	nbPreConditionners
bool	isMasterSet
size_t	masterInstrIndex
	0-based. More...
PatchData *	globalPatch
	Used to prevent reallocating a global patch for successive global algorithms. More...
bool	trapFPE

Detailed Description

An InstructionQueue object gathers Mesquite Instructions and ensures that the instruction queue is coherent for mesh improvement and/or mesh quality assessment purposes.

The user can instantiate several InstructionQueue objects to be used with various MeshSet objects.

The most commonly used functions are:

1. add_preconditioner(...)
2. add_quality_assessor(...)
3. set_master_quality_improver(...)
4. run_instructions(...)

Definition at line 73 of file includeLinks/InstructionQueue.hpp.

Constructor & Destructor Documentation

InstructionQueue

(

)

Definition at line 66 of file Control/InstructionQueue.cpp.

                                   :
  autoQualAssess(true),
  autoAdjMidNodes(true),
  nbPreConditionners(0),
  isMasterSet(false),
  masterInstrIndex(0),
  globalPatch(0),
  trapFPE(IQ_TRAP_FPE_DEFAULT)
{
}

virtual ~InstructionQueue ( )

inlinevirtual

Definition at line 79 of file includeLinks/InstructionQueue.hpp.

{};

InstructionQueue

(

)

virtual ~InstructionQueue ( )

inlinevirtual

Definition at line 79 of file src/Control/InstructionQueue.hpp.

{};

Member Function Documentation

void add_preconditioner	(	QualityImprover *	instr,
		MsqError &	err
	)

adds a QualityImprover at the end of the instruction list

This function cannot be used once the set_master_quality_improver() function has been used.

See also insert_preconditioner().

Definition at line 91 of file Control/InstructionQueue.cpp.

References InstructionQueue::instructions, MsqError::INVALID_STATE, InstructionQueue::isMasterSet, MSQ_SETERR, and InstructionQueue::nbPreConditionners.

{
  if (isMasterSet) {
    MSQ_SETERR(err)("Cannot add preconditionners once the master "
                    "QualityImprover has been set.", MsqError::INVALID_STATE);
    return;
  }
  
  instructions.push_back(instr);
  nbPreConditionners++;
}

void add_preconditioner	(	QualityImprover *	instr,
		MsqError &	err
	)

void add_quality_assessor	(	QualityAssessor *	instr,
		MsqError &	err
	)

adds a QualityAssessor to the instruction queue.

QualityAssessor pointers can be added at any time to the instruction queue.

Definition at line 177 of file Control/InstructionQueue.cpp.

References InstructionQueue::instructions.

Referenced by LaplacianIQ::LaplacianIQ().

{
  instructions.push_back(instr);
}

Here is the caller graph for this function:

void add_quality_assessor	(	QualityAssessor *	instr,
		MsqError &	err
	)

void add_target_calculator	(	TargetCalculator *	tc,
		MsqError &	err
	)

void add_target_calculator	(	TargetCalculator *	tc,
		MsqError &	err
	)

Definition at line 78 of file Control/InstructionQueue.cpp.

References InstructionQueue::instructions.

{
  instructions.push_back( tc );
}

void clear

(

)

Definition at line 327 of file Control/InstructionQueue.cpp.

References InstructionQueue::autoAdjMidNodes, InstructionQueue::autoQualAssess, InstructionQueue::instructions, InstructionQueue::isMasterSet, and InstructionQueue::masterInstrIndex.

{
  instructions.clear();
  autoQualAssess = true;
  autoAdjMidNodes = false;
  isMasterSet = false;
  masterInstrIndex = 0;
}

void clear

(

)

msq_std::list<PatchDataUser*>::iterator clear_master ( MsqError &  err )

private

list< PatchDataUser * >::iterator clear_master ( MsqError &  err )

private

Definition at line 337 of file Control/InstructionQueue.cpp.

References InstructionQueue::instructions, MsqError::INVALID_STATE, InstructionQueue::isMasterSet, InstructionQueue::masterInstrIndex, and MSQ_SETERR.

Referenced by InstructionQueue::set_master_quality_improver().

{
  msq_std::list<PatchDataUser*>::iterator instr_iter;
  msq_std::list<PatchDataUser*>::iterator master_pos;
  
  if (!isMasterSet) {
    MSQ_SETERR(err)("No master quality improver to clear.", MsqError::INVALID_STATE);
    return instr_iter;
  }
  
    // position the instruction iterator over the master quality improver
  master_pos = instructions.begin();
  advance(master_pos, masterInstrIndex);
  
    // erases the master quality improver
  instr_iter = instructions.erase(master_pos);
  isMasterSet = false;
  
    // returns the position where the Master was
  return instr_iter;
}

Here is the caller graph for this function:

void disable_automatic_midnode_adjustment ( )

inline

Definition at line 98 of file includeLinks/InstructionQueue.hpp.

References InstructionQueue::autoAdjMidNodes.

       { autoAdjMidNodes = false; }

void disable_automatic_midnode_adjustment ( )

inline

Definition at line 98 of file src/Control/InstructionQueue.hpp.

References InstructionQueue::autoAdjMidNodes.

       { autoAdjMidNodes = false; }

void disable_automatic_quality_assessment ( )

inline

Definition at line 93 of file includeLinks/InstructionQueue.hpp.

References InstructionQueue::autoQualAssess.

       { autoQualAssess = false; }

void disable_automatic_quality_assessment ( )

inline

Definition at line 93 of file src/Control/InstructionQueue.hpp.

References InstructionQueue::autoQualAssess.

       { autoQualAssess = false; }

void enable_automatic_midnode_adjustment ( )

inline

Definition at line 100 of file includeLinks/InstructionQueue.hpp.

References InstructionQueue::autoAdjMidNodes.

       { autoAdjMidNodes = true; }

void enable_automatic_midnode_adjustment ( )

inline

Definition at line 100 of file src/Control/InstructionQueue.hpp.

References InstructionQueue::autoAdjMidNodes.

       { autoAdjMidNodes = true; }

void enable_automatic_quality_assessment ( )

inline

Definition at line 95 of file includeLinks/InstructionQueue.hpp.

References InstructionQueue::autoQualAssess.

       { autoQualAssess = true; }

void enable_automatic_quality_assessment ( )

inline

Definition at line 95 of file src/Control/InstructionQueue.hpp.

References InstructionQueue::autoQualAssess.

       { autoQualAssess = true; }

void insert_preconditioner	(	QualityImprover *	instr,
		size_t	index,
		MsqError &	err
	)

inserts a QualityImprover* into the instruction queue.

Pre-conditionners can only be inserted before the master QualityImprover.

Parameters

index

is 0-based. An error is set if the index does not correspond to a valid position in the queue.

Definition at line 148 of file Control/InstructionQueue.cpp.

References InstructionQueue::instructions, MsqError::INVALID_ARG, MsqError::INVALID_STATE, InstructionQueue::isMasterSet, InstructionQueue::masterInstrIndex, MSQ_SETERR, and InstructionQueue::nbPreConditionners.

{
  // checks index is valid
  if (isMasterSet==true && index > masterInstrIndex) {
    MSQ_SETERR(err)("Cannot add a preconditionner after the master "
                    "QualityImprover.", MsqError::INVALID_STATE);
    return;
  }
  if (index >= instructions.size() ) {
    MSQ_SETERR(err)("index", MsqError::INVALID_ARG);
    return;
  }

  // position the instruction iterator
  list<PatchDataUser*>::iterator pos;
  pos = instructions.begin();
  advance(pos, index);
  // adds the preconditioner
  instructions.insert(pos,instr);
  nbPreConditionners++;
}

void insert_preconditioner	(	QualityImprover *	instr,
		size_t	index,
		MsqError &	err
	)

void insert_quality_assessor	(	QualityAssessor *	instr,
		size_t	index,
		MsqError &	err
	)

inserts a QualityAssessor* into the instruction queue.

QualityAssessors can be inserted at any position in the instruction queue.

Parameters

index

is 0-based. An error is set if the index is past the end of the queue.

Definition at line 222 of file Control/InstructionQueue.cpp.

References InstructionQueue::instructions, MsqError::INVALID_ARG, and MSQ_SETERR.

{
  // checks index is valid
  if (index > instructions.size()) {
    MSQ_SETERR(err)("index points two positions beyond end of list.",
                    MsqError::INVALID_ARG);
    return;
  }

  // position the instruction iterator
  list<PatchDataUser*>::iterator pos;
  pos = instructions.begin();
  advance(pos, index);
  // adds the QualityAssessor
  instructions.insert(pos,instr);
}

void insert_quality_assessor	(	QualityAssessor *	instr,
		size_t	index,
		MsqError &	err
	)

void remove_preconditioner	(	size_t	index,
		MsqError &	err
	)

void remove_preconditioner	(	size_t	index,
		MsqError &	err
	)

removes a QualityImprover* from the instruction queue

Parameters

index

is 0-based. An error is set if the index does not correspond to a valid element in the queue.

Definition at line 111 of file Control/InstructionQueue.cpp.

References InstructionQueue::instructions, MsqError::INVALID_ARG, InstructionQueue::isMasterSet, InstructionQueue::masterInstrIndex, MSQ_SETERR, InstructionQueue::nbPreConditionners, and PatchDataUser::QUALITY_IMPROVER.

{
  // checks index is valid
  if ( isMasterSet && index == masterInstrIndex ) {
    MSQ_SETERR(err)("cannot remove master QualityImprover.", MsqError::INVALID_ARG);
    return;
  } else if (index >= instructions.size() ) {
    MSQ_SETERR(err)("Index points beyond end of list.",MsqError::INVALID_ARG);
    return;
  }
  
  // position the instruction iterator over the preconditionner to delete
  msq_std::list<PatchDataUser*>::iterator pos;
  pos = instructions.begin();
  advance(pos, index);

  if ( (*pos)->get_algorithm_type() != PatchDataUser::QUALITY_IMPROVER ) 
  {
    MSQ_SETERR(err)("Index does not point to a QualityImprover.",
                    MsqError::INVALID_ARG);
    return;
  }
  
  string name = (*pos)->get_name();
  instructions.erase(pos);
  nbPreConditionners--;
}  

void remove_quality_assessor	(	size_t	index,
		MsqError &	err
	)

void remove_quality_assessor	(	size_t	index,
		MsqError &	err
	)

removes a QualityAssessor* from the instruction queue

Parameters

index

is 0-based. An error is set if the index does not correspond to a valid element in the queue.

Definition at line 190 of file Control/InstructionQueue.cpp.

References InstructionQueue::instructions, MsqError::INVALID_ARG, MSQ_SETERR, and PatchDataUser::QUALITY_ASSESSOR.

{
  // checks index is valid
  if (index >= instructions.size() ) {
    MSQ_SETERR(err)("index", MsqError::INVALID_ARG);
    return;
  }
  
  // position the instruction iterator over the QualityAssessor to delete
  list<PatchDataUser*>::iterator pos;
  pos = instructions.begin();
  advance(pos, index);

  if ( (*pos)->get_algorithm_type() != PatchDataUser::QUALITY_ASSESSOR ) 
  {
    MSQ_SETERR(err)("Index does not point to a QualityImprover.",
                    MsqError::INVALID_ARG);
    return;
  }
  
  string name = (*pos)->get_name();
  instructions.erase(pos);
}  

virtual void run_instructions ( MeshSet &  msc, MsqError &  err  )

virtual

This function is virtual so that it may be redefined in the wraper classes.

Reimplemented in ShapeImprovementWrapper, and ShapeImprovementWrapper.

void run_instructions ( MeshSet &  msc, MsqError &  err  )

virtual

This function is virtual so that it may be redefined in the wraper classes.

Reimplemented in ShapeImprovementWrapper, and ShapeImprovementWrapper.

Definition at line 260 of file Control/InstructionQueue.cpp.

References InstructionQueue::autoAdjMidNodes, MeshSet::get_next_patch(), PatchData::GLOBAL_PATCH, InstructionQueue::globalPatch, InstructionQueue::instructions, MsqError::INVALID_STATE, InstructionQueue::isMasterSet, MSQ_DBGOUT, MSQ_ERRRTN, MSQ_SETERR, InstructionQueue::nbPreConditionners, InstructionQueue::trapFPE, and Mesquite::version_string().

{ 
  MSQ_DBGOUT(1) << version_string(false) << "\n";

  if (nbPreConditionners != 0 && isMasterSet == false ) {
    MSQ_SETERR(err)("no pre-conditionners allowed if master QualityImprover "
                    "is not set.", MsqError::INVALID_STATE);
    return;
  }
  
#ifdef ENABLE_INTERRUPT
   // Register SIGINT handler
  MsqInterrupt msq_interrupt;
#endif

    // Generate SIGFPE on floating point errors
  MsqFPE( this->trapFPE );
  
  msq_std::list<PatchDataUser*>::const_iterator instr_iter;
  
  if (autoAdjMidNodes)
    instructions.push_back( new MeanMidNodeMover );
  
  // For each instruction in the list
  for (instr_iter = instructions.begin();
       !(instr_iter == instructions.end()); ++instr_iter) {
    
    // If instruction uses a global patch, creates one or reuse the existing one.
    if ((*instr_iter)->get_patch_type() == PatchData::GLOBAL_PATCH) {
      if (globalPatch == 0) {
        globalPatch = new PatchData;
        ms.get_next_patch(*globalPatch, (*instr_iter)->get_all_parameters(), err);
        MSQ_ERRRTN(err);
      } 
        
               
      (*instr_iter)->set_global_patch(globalPatch, err); MSQ_ERRRTN(err);
    }
    // If instruction does not use a Global Patch, make sure we discard any existing patch.
    else {
      delete globalPatch;
      globalPatch = 0;
      (*instr_iter)->no_global_patch();
    }
    
    // applies the QualityImprover/QualityAssessor to the MeshSet
      (*instr_iter)->loop_over_mesh(ms, err); MSQ_ERRRTN(err);

    // If this same instruction is reused in this queue, we can't assume the
    // global patch will still be valid. 
    (*instr_iter)->no_global_patch();
  }
  
  if (autoAdjMidNodes)
  {
    delete *instructions.rbegin();
    instructions.pop_back( );
  }  
 
  if (globalPatch != 0)
  {
    delete globalPatch; // clean up once all instructions are executed.
    globalPatch = 0;
  }
}

Here is the call graph for this function:

void set_master_quality_improver	(	QualityImprover *	instr,
		MsqError &	err
	)

Definition at line 241 of file Control/InstructionQueue.cpp.

References InstructionQueue::clear_master(), InstructionQueue::instructions, InstructionQueue::isMasterSet, InstructionQueue::masterInstrIndex, MSQ_DBGOUT, and MSQ_ERRRTN.

Referenced by LaplacianIQ::LaplacianIQ().

{
  if (isMasterSet) {
    MSQ_DBGOUT(1) << "InstructionQueue::set_master_quality_improver():\n"
        << "\tOverwriting previously specified master quality improver.\n";
    // if master is already set, clears it and insert the new one at the same position.
    list<PatchDataUser*>::iterator master_pos;
    master_pos = this->clear_master(err); MSQ_ERRRTN(err);
    instructions.insert(master_pos, instr);
    isMasterSet = true;
  } else {
    // if master is not set, add it at the end of the queue.
    instructions.push_back(instr);
    isMasterSet = true;
    masterInstrIndex = instructions.size()-1;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void set_master_quality_improver	(	QualityImprover *	instr,
		MsqError &	err
	)

void trap_floating_point_exception ( bool  enable )

inline

Generate SIGFPE whenever a floating point exception occurs.

Generate a FPE signal when overflow, divbyzero, etc. occur during floating-point arithmatic. This is intended for debugging purposes only, as enabling this will typically result in a crash when such arithmatic errors occur.

If this option is enabled, Mesquite will attempt to set platform-specific flags such that a SIGFPE is generated for floating point errors while the instruction queue is running. If this option ins disabled, Mesquite will not change the flags. There is no option to explicitly disable such flags because that is the default behavior on most platforms, and presumably if the application has enabled such flags it makes little sense to disable them while Mesquite is running.

This functionality may not be supported on all platforms. If it is not supported, this option has no effect.

Definition at line 127 of file includeLinks/InstructionQueue.hpp.

References InstructionQueue::trapFPE.

      { trapFPE = enable; }

void trap_floating_point_exception ( bool  enable )

inline

Generate SIGFPE whenever a floating point exception occurs.

Generate a FPE signal when overflow, divbyzero, etc. occur during floating-point arithmatic. This is intended for debugging purposes only, as enabling this will typically result in a crash when such arithmatic errors occur.

If this option is enabled, Mesquite will attempt to set platform-specific flags such that a SIGFPE is generated for floating point errors while the instruction queue is running. If this option ins disabled, Mesquite will not change the flags. There is no option to explicitly disable such flags because that is the default behavior on most platforms, and presumably if the application has enabled such flags it makes little sense to disable them while Mesquite is running.

This functionality may not be supported on all platforms. If it is not supported, this option has no effect.

Definition at line 127 of file src/Control/InstructionQueue.hpp.

References InstructionQueue::trapFPE.

      { trapFPE = enable; }

bool trap_floating_point_exception ( ) const

inline

Definition at line 129 of file src/Control/InstructionQueue.hpp.

References InstructionQueue::trapFPE.

      { return trapFPE; }

bool trap_floating_point_exception ( ) const

inline

Definition at line 129 of file includeLinks/InstructionQueue.hpp.

References InstructionQueue::trapFPE.

      { return trapFPE; }

Member Data Documentation

bool autoAdjMidNodes

private

Definition at line 141 of file includeLinks/InstructionQueue.hpp.

Referenced by InstructionQueue::clear(), InstructionQueue::disable_automatic_midnode_adjustment(), InstructionQueue::enable_automatic_midnode_adjustment(), and InstructionQueue::run_instructions().

bool autoQualAssess

private

Definition at line 140 of file includeLinks/InstructionQueue.hpp.

Referenced by InstructionQueue::clear(), InstructionQueue::disable_automatic_quality_assessment(), and InstructionQueue::enable_automatic_quality_assessment().

PatchData * globalPatch

private

Used to prevent reallocating a global patch for successive global algorithms.

Definition at line 148 of file includeLinks/InstructionQueue.hpp.

Referenced by InstructionQueue::run_instructions().

msq_std::list< PatchDataUser * > instructions

private

Definition at line 138 of file includeLinks/InstructionQueue.hpp.

Referenced by InstructionQueue::add_preconditioner(), InstructionQueue::add_quality_assessor(), InstructionQueue::add_target_calculator(), InstructionQueue::clear(), InstructionQueue::clear_master(), InstructionQueue::insert_preconditioner(), InstructionQueue::insert_quality_assessor(), InstructionQueue::remove_preconditioner(), InstructionQueue::remove_quality_assessor(), InstructionQueue::run_instructions(), and InstructionQueue::set_master_quality_improver().

bool isMasterSet

private

Definition at line 144 of file includeLinks/InstructionQueue.hpp.

Referenced by InstructionQueue::add_preconditioner(), InstructionQueue::clear(), InstructionQueue::clear_master(), InstructionQueue::insert_preconditioner(), InstructionQueue::remove_preconditioner(), InstructionQueue::run_instructions(), and InstructionQueue::set_master_quality_improver().

size_t masterInstrIndex

private

0-based.

Keeping an index instead of an iterator in case list is reallocated

Definition at line 145 of file includeLinks/InstructionQueue.hpp.

Referenced by InstructionQueue::clear(), InstructionQueue::clear_master(), InstructionQueue::insert_preconditioner(), InstructionQueue::remove_preconditioner(), and InstructionQueue::set_master_quality_improver().

size_t nbPreConditionners

private

Definition at line 143 of file includeLinks/InstructionQueue.hpp.

Referenced by InstructionQueue::add_preconditioner(), InstructionQueue::insert_preconditioner(), InstructionQueue::remove_preconditioner(), and InstructionQueue::run_instructions().

bool trapFPE

private

Definition at line 151 of file includeLinks/InstructionQueue.hpp.

Referenced by InstructionQueue::run_instructions(), and InstructionQueue::trap_floating_point_exception().

---

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

• includeLinks/InstructionQueue.hpp
• src/Control/InstructionQueue.hpp
• Control/InstructionQueue.cpp
• inks/InstructionQueue.cpp