Pscf::BlockTmpl< TP > Class Template Reference

Class template for a block in a block copolymer. More...

#include <BlockTmpl.h>

Inheritance diagram for Pscf::BlockTmpl< TP >:

Public Member Functions
	BlockTmpl ()
	Constructor.
virtual	~BlockTmpl ()
	Destructor.
virtual void	setKuhn (double kuhn)
	Set monomer statistical segment length.
TP &	propagator (int directionId)
	Get a Propagator for a specified direction.
TP const &	propagator (int directionId) const
	Get a const Propagator for a specified direction.
TP::CField &	cField ()
	Get the associated monomer concentration field.
TP::CField const &	cField () const
	Get the associated const monomer concentration field.
double	kuhn () const
	Get monomer statistical segment length.
Public Member Functions inherited from Pscf::BlockDescriptor
	BlockDescriptor ()
	Constructor.
virtual	~BlockDescriptor ()
	Destructor.
template<class Archive >
void	serialize (Archive &ar, unsigned int versionId)
	Serialize to/from archive.
void	setId (int id)
	Set the id for this block.
void	setVertexIds (int vertexAId, int vertexBId)
	Set indices of associated vertices.
void	setMonomerId (int monomerId)
	Set the monomer type id.
virtual void	setLength (double length)
	Set the length of this block.
void	setPolymerType (PolymerType::Enum type)
	Set the polymer type (branched or linear).
int	id () const
	Get the id of this block.
int	monomerId () const
	Get the monomer type id.
const Pair< int > &	vertexIds () const
	Get the pair of associated vertex ids.
int	vertexId (int i) const
	Get id of an associated vertex.
double	length () const
	Get the length (number of monomers) in this block.
PolymerType::Enum	polymerType () const
	Get the type of the parent polymer (branched or linear).

Detailed Description

template<class TP>
class Pscf::BlockTmpl< TP >

Class template for a block in a block copolymer.

Class TP is a concrete propagator class. A BlockTmpl<TP> object has:

• two TP propagator objects, one per direction
• a single monomer concentration field
• a single kuhn length

Each implementation of self-consistent field theory (SCFT) is defined in a different sub-namespace of Pscf. Each such implementation defines a concrete propagator class and a concrete Block class that are named Propagator and Block by convention. The Block class in each implementation is derived from BlockTmpl<Propagator>, using the following syntax:

class Block : public BlockTmpl<Propagator>
{
  ....
}

Design notes:

The Block class of a polymer field theory implementation has member variables that specify all the data that is needed to describe the block. This includes but is not limited to the monomer type and Kuhn length that are defined in this base class template. In addition, subclasses may define a variety of member variables that define the numerical discretization of the block and any related parameters need by the algorithm that solves the modified diffusion equation.

The Block class will normally define one or more public functions that can be called repeatedly by the Propagator::solve() function in order to implement individual steps of the stepping algorithm used to solve the MDE.

The Block class also normally provides a void function named computeConcentration() that integrates the product of the two associated propagators with respect to contour length in order to compute the monomer concentration field associated with the block. This is normally called within the implementation of solve() function of the associated Polymer class, within a loop over all blocks of the molecule that is called after solution of the modified diffusion equation for all propagators.

Here is an example of a simple interface of the Block class for an implementation that is designed for self-consistent field theory:

// -------------------------------------------------------------
// One step of integration of the modified diffusion equation.
//
// \param in   input q-field from previous step
// \param out  output q-field at next step
// -------------------------------------------------------------
void step(Propagator::QField const & in, Propagator::QField& out);
 
// -------------------------------------------------------------
// Compute monomer concentration field for this block.
// 
// \param prefactor  numerical prefactor of phi/(Q*length)
// -------------------------------------------------------------
void computeConcentration(double prefactor);

The step and computeConcentration functions both use private variables that depend on the monomer type and contour length of a particular block, and that apply to both of the two associated propagators. Parameters that depend upon the step size used to discretize the MDE for a particular block generally cannot, however, be re-used by other blocks, because the MDE solver algorithm may use slightly different step sizes in different blocks in order to divide each block into an integer number of steps of equal length.

Definition at line 105 of file BlockTmpl.h.

Constructor & Destructor Documentation

BlockTmpl()

template<class TP >

Pscf::BlockTmpl< TP >::BlockTmpl

(

)

Constructor.

Definition at line 231 of file BlockTmpl.h.

References Pscf::BlockTmpl< TP >::propagator().

~BlockTmpl()

template<class TP >

Pscf::BlockTmpl< TP >::~BlockTmpl ( )

virtual

Destructor.

Definition at line 246 of file BlockTmpl.h.

Member Function Documentation

setKuhn()

template<class TP >

void Pscf::BlockTmpl< TP >::setKuhn ( double kuhn )

virtual

Set monomer statistical segment length.

Parameters

kuhn	monomer statistical segment length

Reimplemented in Pscf::Rpc::Block< D >, and Pscf::Rpg::Block< D >.

Definition at line 253 of file BlockTmpl.h.

propagator() [1/2]

template<class TP >

TP & Pscf::BlockTmpl< TP >::propagator ( int directionId )

inline

Get a Propagator for a specified direction.

For a block with v0 = vertexId(0) and v1 = vertexId(1), propagator(0) propagates from vertex v0 to v1, while propagator(1) propagates from vertex v1 to v0.

Parameters

directionId

integer index for direction (0 or 1)

Definition at line 191 of file BlockTmpl.h.

Referenced by Pscf::BlockTmpl< TP >::BlockTmpl().

propagator() [2/2]

template<class TP >

TP const & Pscf::BlockTmpl< TP >::propagator ( int directionId ) const

inline

Get a const Propagator for a specified direction.

See above for number conventions.

Parameters

directionId

integer index for direction (0 or 1)

Definition at line 199 of file BlockTmpl.h.

cField() [1/2]

template<class TP >

TP::CField & Pscf::BlockTmpl< TP >::cField ( )

inline

Get the associated monomer concentration field.

Definition at line 207 of file BlockTmpl.h.

cField() [2/2]

template<class TP >

TP::CField const & Pscf::BlockTmpl< TP >::cField ( ) const

inline

Get the associated const monomer concentration field.

Definition at line 215 of file BlockTmpl.h.

kuhn()

template<class TP >

double Pscf::BlockTmpl< TP >::kuhn ( ) const

inline

Get monomer statistical segment length.

Definition at line 222 of file BlockTmpl.h.

---

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

• BlockTmpl.h