# Tutorial:Creating the Element

As we wrote in the previous section, the files describing our element will be placed in the folder /custom_elements , with names: poisson_2D.h and poissonn_2D.cpp. The names of the subroutines are self-explanatory so their use is easy to underestand. However, if you need more information on the implementation of elements you can read How to Create New Element

Note that since we have no source terms involving that involve the area of the elements (we have only puntual loads), no righthandside term is calculated in the the suboutines. The Rigidity matrix is calculated in CalculateLocalSystem

### What you need to underestand of these lines

When the buider and solver is called in your strategy, it will loop through all the nodes and condition asking for their contribution to the system. This means that we need the following information:

- First of all, we need to know the contribution to the global system. In our case the 3x3 LHS matrix and the 3x1 RHS vector. Given the strategy we chose, to do we'll program this contribution in the CalculateLocalSystem. In this file we will perform all the necesary computations. We will return the rLeftHandSideMatrix (our LHS matrix) and the rRightHandSideVector (our RHS vector) . The rCurrentProcessInfo is an input used to gather general information, for example the delta_time in transcient problems. In this particular problem we are not using it due to its simplicity.

- Besides returning the 3x3 matrix and the RHS vector, we must tell the builder to which degrees of freedom each of the lines of this matrix must add its contribution. In our case it is pretty simple, the first line corresponds to the TEMPERATURE DoF of the first node, the seccond node to the TEMPERATURE dof of the second node and so on. This information is given to the builder and solver using both EquationIdVector and GetDofList.

In our case we will not use the CalculateRightHandSide, but the idea is basically the same as the CalculateLocalSystem

```//
//   Project Name:        Kratos
//   Date:                \$Date: 2008-08-08 23:58:38 \$
//   Revision:            \$Revision: 1.0 \$
//
//

#if !defined(KRATOS_POISSON_2D_ELEM_H_INCLUDED)
#define  KRATOS_POISSON_2D_ELEM_H_INCLUDED

// System includes

// External includes
#include "boost/smart_ptr.hpp"

// Project includes
#include "includes/define.h"
#include "includes/element.h"
#include "includes/ublas_interface.h"
#include "includes/variables.h"

namespace Kratos
{

class Poisson2D
: public Element
{
public:

/// Counted pointer of Poisson2D
KRATOS_CLASS_POINTER_DEFINITION(Poisson2D);

/// Default constructor.
Poisson2D(IndexType NewId, GeometryType::Pointer pGeometry);
Poisson2D(IndexType NewId, GeometryType::Pointer pGeometry,  PropertiesType::Pointer pProperties);

/// Destructor.
virtual ~ Poisson2D();

Element::Pointer Create(IndexType NewId, NodesArrayType const& ThisNodes,  PropertiesType::Pointer pProperties) const;

void CalculateLocalSystem(MatrixType& rLeftHandSideMatrix, VectorType& rRightHandSideVector, ProcessInfo& rCurrentProcessInfo);

void CalculateRightHandSide(VectorType& rRightHandSideVector, ProcessInfo& rCurrentProcessInfo);

void EquationIdVector(EquationIdVectorType& rResult, ProcessInfo& rCurrentProcessInfo);

void GetDofList(DofsVectorType& ElementalDofList,ProcessInfo& CurrentProcessInfo);

void InitializeSolutionStep(ProcessInfo& CurrentProcessInfo);

protected:

private:
friend class Serializer;

Poisson2D() : Element()
{
}

}; // Class Poisson2D
}  // namespace Kratos.

#endif // KRATOS_POISSON_2D_ELEM_H_INCLUDED  defined
```

### cpp file: poisson_2d.cpp

```//
//   Project Name:        Kratos
//   Date:                \$Date: 2008-08-08 23:58:38 \$
//   Revision:            \$Revision: 1.0 \$
//
//

// Project includes
#include "includes/define.h"
#include "custom_elements/poisson_2d.h"
#include "purediffusion_application.h"
#include "utilities/math_utils.h"
#include "utilities/geometry_utilities.h"

namespace Kratos
{

//************************************************************************************
//************************************************************************************
Poisson2D::Poisson2D(IndexType NewId, GeometryType::Pointer pGeometry)
: Element(NewId, pGeometry)
{
}

//************************************************************************************
//************************************************************************************
Poisson2D::Poisson2D(IndexType NewId, GeometryType::Pointer pGeometry,  PropertiesType::Pointer pProperties)
: Element(NewId, pGeometry, pProperties)
{

}

Element::Pointer Poisson2D::Create(IndexType NewId, NodesArrayType const& ThisNodes,  PropertiesType::Pointer pProperties) const
{
return Element::Pointer(new Poisson2D(NewId, GetGeometry().Create(ThisNodes), pProperties));
}

Poisson2D::~Poisson2D()
{
}

//************************************************************************************
//************************************************************************************
void Poisson2D::CalculateLocalSystem(MatrixType& rLeftHandSideMatrix, VectorType& rRightHandSideVector, ProcessInfo& rCurrentProcessInfo)
{
KRATOS_TRY

boost::numeric::ublas::bounded_matrix<double,2,2> msD;  //conductivity matrix
msD = ZeroMatrix(2,2); //initializing the matrix as zero
array_1d<double,3> msN; //dimension = number of nodes . Position of the gauss point
array_1d<double,3> ms_temp; //dimension = number of nodes . . since we are using a residualbased approach

const unsigned int number_of_points = GetGeometry().size();

if(rLeftHandSideMatrix.size1() != number_of_points)
rLeftHandSideMatrix.resize(number_of_points,number_of_points,false); //resizing the system in case it does not have the right size

if(rRightHandSideVector.size() != number_of_points)
rRightHandSideVector.resize(number_of_points,false);

//getting data for the given geometry
double Area;

double permittivity = GetProperties()[CONDUCTIVITY];
msD(0,0)=permittivity;
msD(1,1)=permittivity;

// main loop
//const GeometryType::IntegrationPointsArrayType& integration_points = GetGeometry().IntegrationPoints();

noalias(rLeftHandSideMatrix) = prod(msDN_DX,Matrix(prod(msD,trans(msDN_DX))));  // Bt D B

rLeftHandSideMatrix *= Area;

//subtracting the dirichlet term
// RHS -= LHS*DUMMY_UNKNOWNs
for(unsigned int iii = 0; iii<number_of_points; iii++)
ms_temp[iii] = GetGeometry()[iii].FastGetSolutionStepValue(TEMPERATURE);
noalias(rRightHandSideVector) = -prod(rLeftHandSideMatrix,ms_temp);

KRATOS_CATCH("");
}

//************************************************************************************
//************************************************************************************
void Poisson2D::CalculateRightHandSide(VectorType& rRightHandSideVector, ProcessInfo& rCurrentProcessInfo)
{
KRATOS_THROW_ERROR(std::logic_error,  "method not implemented" , "");
}

//************************************************************************************
//************************************************************************************
// this subroutine calculates the nodal contributions for the explicit steps of the
// fractional step procedure
void Poisson2D::InitializeSolutionStep(ProcessInfo& CurrentProcessInfo)
{
KRATOS_TRY

KRATOS_CATCH("");
}

//************************************************************************************
//************************************************************************************
void Poisson2D::EquationIdVector(EquationIdVectorType& rResult, ProcessInfo& CurrentProcessInfo)
{
unsigned int number_of_nodes = GetGeometry().PointsNumber();
if(rResult.size() != number_of_nodes)
rResult.resize(number_of_nodes,false);

for (unsigned int i=0;i<number_of_nodes;i++)
rResult[i] = GetGeometry()[i].GetDof(TEMPERATURE).EquationId();
}

//************************************************************************************
//************************************************************************************
void Poisson2D::GetDofList(DofsVectorType& ElementalDofList,ProcessInfo& CurrentProcessInfo)
{
unsigned int number_of_nodes = GetGeometry().PointsNumber();
if(ElementalDofList.size() != number_of_nodes)
ElementalDofList.resize(number_of_nodes);

for (unsigned int i=0;i<number_of_nodes;i++)
ElementalDofList[i] = GetGeometry()[i].pGetDof(TEMPERATURE);

}

} // Namespace Kratos
```

back to Kratos For Dummies