AGroup Class Reference

#include <FreeEnergyGroup.h>

Public Member Functions
	AGroup ()
	~AGroup ()
void	Clear ()
void	Add (int AnInt)
AGroup &	operator= (AGroup &Group)
int	operator[] (int Index)
int	GetNumInGroup ()
void	List (int NumToList=-1)

Detailed Description

Definition at line 18 of file FreeEnergyGroup.h.

Constructor & Destructor Documentation

AGroup()

AGroup::AGroup

(

)

Definition at line 18 of file FreeEnergyGroup.C.

References kGroupNumToStart.

               {
//------------------------------------------------------------------------
// make room for some ints.
//------------------------------------------------------------------------
  m_NumInts = 0;
  m_pInts = new int[kGroupNumToStart];
  m_MaxNum = kGroupNumToStart;
}

~AGroup()

AGroup::~AGroup

(

)

Definition at line 28 of file FreeEnergyGroup.C.

                {
//------------------------------------------------------------------------
// return borrowed memory to the free store.
//------------------------------------------------------------------------
  delete []m_pInts;
}

Member Function Documentation

Add()

void AGroup::Add

(

int

AnInt

)

Definition at line 44 of file FreeEnergyGroup.C.

References kGroupMultiplier.

Referenced by AddAtom(), and AddResidues().

                          {
//------------------------------------------------------------------------
// add an int to the list.  if there's not enough room, make room.
//------------------------------------------------------------------------
  int*  pInts;

  // if there's no room for a new int
  if (m_NumInts == m_MaxNum) {
    // create an array with more space
    m_MaxNum *= kGroupMultiplier;
    pInts = new int[m_MaxNum];
    // fast copy from the full array to the new one (memcpy(dest, src, bytes))
    memcpy(pInts, m_pInts, sizeof(int)*m_NumInts);
    // return the space used for the full array
    delete []m_pInts;
    // point to the bigger array
    m_pInts = pInts;
  }

  // add the int to the int array
  m_pInts[m_NumInts] = AnInt;
  m_NumInts++;
}

Clear()

void AGroup::Clear

(

)

Definition at line 36 of file FreeEnergyGroup.C.

                   {
//------------------------------------------------------------------------
// leave memory allocation alone.
//------------------------------------------------------------------------
  m_NumInts = 0;
}

GetNumInGroup()

int AGroup::GetNumInGroup ( )

inline

Definition at line 32 of file FreeEnergyGroup.h.

Referenced by ARestraint::DistributeForce(), and ARestraint::UpdateCOMs().

{ return(m_NumInts); }

List()

void AGroup::List

(

int

NumToList = -1

)

Definition at line 97 of file FreeEnergyGroup.C.

                               {
//------------------------------------------------------------------------
// list NumToList integers in the group to standard out.
// if NumToList is negative, list them all.
//------------------------------------------------------------------------
  int  i;

  if (NumToList < 0) {
    NumToList = m_NumInts;
  }
  for (i=0; i<NumToList; i++) {
//    cout << setw(10) << i << "   " << setw(10) << (*this)[i] << std::endl;
    CkPrintf("%10d   %10d\n", i, (*this)[i]);
  }
}

operator=()

AGroup & AGroup::operator=

(

AGroup &

Group

)

Definition at line 80 of file FreeEnergyGroup.C.

                                        {
//------------------------------------------------------------------------
// make this object identical to the passed one.
//------------------------------------------------------------------------
  // if there's not enough room here for Group's array
  if (m_MaxNum < Group.m_MaxNum) {
    // free this array and allocate space for the bigger one
    delete []m_pInts;
    m_MaxNum =  Group.m_MaxNum;
    m_pInts = new int[m_MaxNum];
  }
  // fast copy from the passed array to this one (memcpy(dest, src, bytes))
  m_NumInts = Group.m_NumInts;
  memcpy(m_pInts, Group.m_pInts, sizeof(int)*m_NumInts);
  return(*this);
}

operator[]()

int AGroup::operator[]

(

int

Index

)

Definition at line 69 of file FreeEnergyGroup.C.

References ASSERT.

                                 {
//------------------------------------------------------------------------
// return an int from this group of ints.
// note, by returning int, rather than int&, this function only allows
// retrieval of an int, not setting an int.  to set, use add.
//------------------------------------------------------------------------
  ASSERT((Index>=0) && (Index<m_NumInts));
  return(m_pInts[Index]);
}

---

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

• FreeEnergyGroup.h
• FreeEnergyGroup.C