HopFunc2< A1, A2 > Class Template Reference

#include <HopFunc.h>

Inheritance diagram for HopFunc2< A1, A2 >:

Collaboration diagram for HopFunc2< A1, A2 >:

Public Member Functions
	HopFunc2 (HopIndex hopIndex)
void	op (const Eref &e, A1 arg1, A2 arg2) const
void	opVec (const Eref &e, const vector< A1 > &arg1, const vector< A1 > &arg2, const OpFunc2Base< A1, A2 > *op) const
Public Member Functions inherited from OpFunc2Base< A1, A2 >
bool	checkFinfo (const Finfo *s) const
const OpFunc *	makeHopFunc (HopIndex hopIndex) const
void	opBuffer (const Eref &e, double *buf) const
	Executes the OpFunc by converting args. More...
virtual void	opVec (const Eref &e, const vector< A1 > &arg1, const vector< A2 > &arg2, const OpFunc2Base< A1, A2 > *op) const
void	opVecBuffer (const Eref &e, double *buf) const
	Executes the OpFunc for all data by converting a vector of args. More...
string	rttiType () const
Public Member Functions inherited from OpFunc
	OpFunc ()
unsigned int	opIndex () const
bool	setIndex (unsigned int i)
	Used when rebuilding the Fid->OpFunc mapping. More...
virtual	~OpFunc ()

Private Attributes
HopIndex	hopIndex_

Additional Inherited Members
Static Public Member Functions inherited from OpFunc
static const OpFunc *	lookop (unsigned int opIndex)
static unsigned int	rebuildOpIndex ()
	cleans out the entire Ops vector. Returns size of orig vector. More...

Detailed Description

template<class A1, class A2>
class HopFunc2< A1, A2 >

Definition at line 189 of file HopFunc.h.

Constructor & Destructor Documentation

template<class A1, class A2>

HopFunc2< A1, A2 >::HopFunc2 ( HopIndex  hopIndex )

inline

Definition at line 194 of file HopFunc.h.

                : hopIndex_( hopIndex )
        {;}

Member Function Documentation

template<class A1, class A2>

void HopFunc2< A1, A2 >::op ( const Eref &  e, A1  arg1, A2  arg2  ) const

inlinevirtual

Implements OpFunc2Base< A1, A2 >.

Definition at line 197 of file HopFunc.h.

References addToBuf(), dispatchBuffers(), HopFunc2< A1, A2 >::hopIndex_, and Conv< T >::val2buf().

Referenced by testHopFunc().

        {
            double* buf = addToBuf( e, hopIndex_,
                Conv< A1 >::size( arg1 ) + Conv< A2 >::size( arg2 ) );
            /*
            Conv< A1 >::val2buf( arg1, buf );
            Conv< A2 >::val2buf( arg2, buf + Conv< A1 >.size( arg1 ) );
            or
            buf = Conv< A1 >.val2buf( arg1, buf );
            Conv< A2 >::val2buf( arg2, buf );
            or
            */
            Conv< A1 >::val2buf( arg1, &buf );
            Conv< A2 >::val2buf( arg2, &buf );
            dispatchBuffers( e, hopIndex_ );
        }

Here is the call graph for this function:

Here is the caller graph for this function:

template<class A1, class A2>

void HopFunc2< A1, A2 >::opVec ( const Eref &  e, const vector< A1 > &  arg1, const vector< A1 > &  arg2, const OpFunc2Base< A1, A2 > *  op  ) const

inline

Definition at line 214 of file HopFunc.h.

References addToBuf(), dataIndex, dispatchBuffers(), Eref::element(), Element::getNumOnNode(), HopFunc2< A1, A2 >::hopIndex_, Element::isGlobal(), mooseMyNode(), mooseNumNodes(), Element::numField(), Element::numLocalData(), and OpFunc2Base< A1, A2 >::op().

        {
            Element* elm = e.element();
            unsigned int k = 0; // counter for index to arg vector.
            if ( elm->isGlobal() ) {
                // Need to ensure that all nodes get the same args,
                // as opposed to below, where they are serial.
            }
            for ( unsigned int i = 0; i < mooseNumNodes(); ++i ) {
                if ( i == mooseMyNode() ) {
                    unsigned int numData = elm->numLocalData();
                    for ( unsigned int p = 0; p < numData; ++p ) {
                        unsigned int numField = elm->numField( p );
                        for ( unsigned int q = 0; q < numField; ++q ) {
                            Eref er( elm, p, q );
                            unsigned int x = k % arg1.size();
                            unsigned int y = k % arg2.size();
                            op->op( er, arg1[x], arg2[y] );
                            k++;
                        }
                    }
                } else {
                    unsigned int dataIndex = k;
                    // nn includes dataIndices and if present fieldIndices
                    // too. It may involve a query to the remote node.
                    unsigned int nn = elm->getNumOnNode( i );
                    vector< A1 > temp1( nn );
                    vector< A2 > temp2( nn );
                    // Have to do the insertion entry by entry because the
                    // argument vectors may wrap around.
                    for ( unsigned int j = 0; j < nn; ++j ) {
                        unsigned int x = k % arg1.size();
                        unsigned int y = k % arg2.size();
                        temp1[j] = arg1[x];
                        temp2[j] = arg2[y];
                        k++;
                    }
                    double* buf = addToBuf( e, hopIndex_,
                            Conv< vector< A1 > >::size( temp1 ) +
                           Conv< vector< A2 > >::size( temp2 ) );
                    Conv< vector< A1 > >::val2buf( temp1, &buf );
                    Conv< vector< A2 > >::val2buf( temp2, &buf );
                    dispatchBuffers( Eref( elm, dataIndex ), hopIndex_ );
                    // HopIndex says that it is a SetVec call.
                }
            }
        }

Here is the call graph for this function:

Member Data Documentation

template<class A1, class A2>

HopIndex HopFunc2< A1, A2 >::hopIndex_

private

Definition at line 265 of file HopFunc.h.

Referenced by HopFunc2< A1, A2 >::op(), and HopFunc2< A1, A2 >::opVec().

---

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

• moose-core/basecode/HopFunc.h