class Vector2D

{
double vx, vy;
public:
Vector2D(double vx = 0.0, double vy = 0.0);
double getXComponent(){return vx;}
double getYComponent(){return vy;}
~Vector2D();
};
Vector2D::Vector2D(double vx, double vy)
:vx(vx), vy(vy){
}
Vector2D::~Vector2D(){
}
class Point2D
{
double x, y;
public:
Point2D(double x = 0.0, double y = 0.0);
~Point2D();
bool operator==(Point2D& p);
bool operator!=(Point2D& p);
void setX(double x){this->x = x;}
void setY(double y){this->y = y;}
double getX(){return x;}
double getY(){return y;}
};

Point2D::Point2D(double x, double y)
:x(x), y(y){
}
bool Point2D::operator==(Point2D& p)
{
bool retval;
retval = ((p.getX() == this->getX()) && (p.getY() == this->getY()));
return retval;
}
bool Point2D::operator!=(Point2D& p)
{
bool retval;
retval = ((p.getX() == this->getX()) && (p.getY() == this->getY()));
retval = !retval;
return retval;
}
Point2D::~Point2D(){
}
class Point2DTester
{
public:
Point2DTester();
void test();
~Point2DTester();
};
Point2DTester::Point2DTester(){
}

void Point2DTester::test(){
Point2D p1(0.,-1.1);
Point2D p2(0.,-1.1);
Point2D p3(1.,2.5);
bool flag;
double x,y;
cout << "Starting test of the class Point2D..." << endl;
// getX
x = p1.getX();
if(x != 0.){
cerr << "ERROR in testing class Point2D: the member function getX does not work
properly." << endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
x = p2.getX();
if(x != 0.){
cerr << "ERROR in testing class Point2D: the member function getX does not work
properly." << endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
x = p3.getX();
if(x != 1.){
cerr << "ERROR in testing class Point2D: the member function getX does not work
properly." << endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
// getX
y = p1.getY();

if(y != -1.1){
cerr << "ERROR in testing class Point2D: the member function getY does not work
properly." << endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
y = p2.getY();
if(y != -1.1){
cerr << "ERROR in testing class Point2D: the member function getY does not work
properly." << endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
y = p3.getY();
if(y != 2.5){
cerr << "ERROR in testing class Point2D: the member function getY does not work
properly." << endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
// ==
flag = (p1 == p2);
if(flag != true){
cerr << "ERROR in testing class Point2D: the operator == does not work properly." <<
endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
flag = (p2 == p1);
if(flag != true){
cerr << "ERROR in testing class Point2D: the operator == does not work properly." <<
endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;

}
flag = (p3 == p2);
if(flag != false){
cerr << "ERROR in testing class Point2D: the operator == does not work properly." <<
endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
flag = (p2 == p3);
if(flag != false){
cerr << "ERROR in testing class Point2D: the operator == does not work properly." <<
endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
flag = (p3 == p1);
if(flag != false){
cerr << "ERROR in testing class Point2D: the operator == does not work properly." <<
endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
flag = (p1 == p3);
if(flag != false){
cerr << "ERROR in testing class Point2D: the operator == does not work properly." <<
endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
// !=
flag = (p1 != p2);
if(flag != false){
cerr << "ERROR in testing class Point2D: the operator != does not work properly." <<

endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
flag = (p2 != p1);
if(flag != false){
cerr << "ERROR in testing class Point2D: the operator != does not work properly." <<
endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
flag = (p3 != p2);
if(flag != true){
cerr << "ERROR in testing class Point2D: the operator != does not work properly." <<
endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
flag = (p2 != p3);
if(flag != true){
cerr << "ERROR in testing class Point2D: the operator != does not work properly." <<
endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
flag = (p3 != p1);
if(flag != true){
cerr << "ERROR in testing class Point2D: the operator != does not work properly." <<
endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
flag = (p1 != p3);
if(flag != true){

cerr << "ERROR in testing class Point2D: the operator != does not work properly." <<
endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
cout << "done." << endl;
}
Point2DTester::~Point2DTester(){
}
class Node
{
Point2D *point;
int nodeID;
//

map<int,Element*> *elements;

//

map<int,double*> *distances;

//

void addElement(Element* e);

public:
Node(Point2D *point, int nodeID);
bool operator==(Node &n);
double getX(){return point->getX();}
double getY(){return point->getY();}
Point2D* getPoint2D(){return point;}
int getNodeID(){return nodeID;}
~Node();
//

map<int,Element*>* getElements(){return elements;}

//

map<int,double*>* getDistances(){return distances;}

};
Node::Node(Point2D *point, int nodeID)

:point(point),nodeID(nodeID){
//

elements = new map<int,Element*>;

//

distances = new map<int,double*>;

}
bool Node::operator==(Node &n){
bool retval;
retval = ((*(n.getPoint2D()) == *(this->getPoint2D())));
return retval;
}
Node::~Node(){
delete point;
}
class NodeTester
{
public:
NodeTester();
void test();
~NodeTester();
};
NodeTester::NodeTester(){
}
void NodeTester::test(){
Point2D p1(7.3,-1.4);
Point2D p2(7.3,-1.4);
Point2D p3(100.,2.5);
Node n1(&p1, 1);
Node n2(&p2, 10);

Node n3(&p3, -2);

double x,y;
cout << "Starting test of the class Node ..." << endl;
// getX
x = n1.getX();
if(x != 7.3){
cerr << "ERROR in testing class Node: the member function getX does not work properly."
<< endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
x = n2.getX();
if(x != 7.3){
cerr << "ERROR in testing class Node: the member function getX does not work properly."
<< endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
x = n3.getX();
if(x != 100.){
cerr << "ERROR in testing class Node: the member function getX does not work properly."
<< endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
// getY
y = n1.getY();
if(y != -1.4){
cerr << "ERROR in testing class Node: the member function getY does not work properly."
<< endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}

y = n2.getY();
if(y != -1.4){
cerr << "ERROR in testing class Node: the member function getY does not work properly."
<< endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
y = n3.getY();
if(y != 2.5){
cerr << "ERROR in testing class Node: the member function getY does not work properly."
<< endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
cout << "done." << endl;
}
NodeTester::~NodeTester(){
}
class Edge
{
Node *n1;
Node *n2;
int edgeID;
double length;
bool boundary;
Element* e1;
Element* e2;
public:
Edge(Node *n1, Node *n2, int edgeID, bool boundary = true);
bool operator==(Edge &e);

double getLength(){return length;}

bool isBoundary(){return (((e1 == 0) && (e2 != 0)) || ((e2 == 0) && (e1 != 0)));}
void setBoundary(bool b){boundary = b;}
int getEdgeID(){return edgeID;}
void addAdjacentElement(Element *e);
Element* getElement1(){return e1;}
Element* getElement2(){return e2;}
Node* getNode1(){return n1;}
Node* getNode2(){return n2;}
~Edge();
};
Edge::Edge(Node *n1, Node *n2, int edgeID, bool boundary)
:n1(n1), n2(n2), edgeID(edgeID), boundary(boundary){
double x1, x2;
double y1, y2;
e1 = 0;
e2 = 0;
x1 = n1->getX();
x2 = n2->getX();
y1 = n1->getY();
y2 = n2->getY();
length = sqrt((x2 - x1)*(x2 - x1) + (y2 - y1)*(y2 - y1));
if(length == 0.0){
cerr << "FATAL ERROR: zero length for edge of ID " << getEdgeID() << ". The program will
be terminated." << endl;
exit(EXIT_FAILURE);
}

}
void Edge::addAdjacentElement(Element *e){
if(0 == e1){
e1 = e;
}else if(0 == e2){
e2 = e;
}else{
cerr << "FATAL ERROR: attempting of adding a third element on edge " << getEdgeID()
<< ". The program will be terminated." << endl;
exit(EXIT_FAILURE);
}
}
bool Edge::operator==(Edge &e){
bool retval;
retval = ((*(this->getNode1()) == *(e.getNode1())) && (*(this->getNode2()) ==
*(e.getNode2()))) || ((*(this->getNode1()) == *(e.getNode2())) && (*(this->getNode2()) ==
*(e.getNode1())));
return retval;
}
Edge::~Edge(){
}
class PhysicalProperties
{
string type;
double epsr;
double sigma;
double mur;
double sigma_m;

public:
PhysicalProperties(string type);
PhysicalProperties(double epsr, double sigma, double mur, double sigma_m);
void read(ifstream *ifs);
void setEpsr(double epsr){this->epsr = epsr;}
void setSigma(double sigma){this->sigma = sigma;}
void setMur(double mur){this->mur = mur;}
void setSigma_m(double sigma_m){this->sigma_m = sigma_m;}
string getType(){return type;}
double getEpsr(){return epsr;}
double getSigma(){return sigma;}
double getMur(){return mur;}
double getSigma_m(){return sigma_m;}
~PhysicalProperties();
};
PhysicalProperties::PhysicalProperties(string type)
:type(type){
}
void PhysicalProperties::read(ifstream *ifs){
if(type == "D"){
*ifs >> epsr >> sigma >> mur >> sigma_m;
}else{
cerr << "FATAL ERROR: unknown media type: " << type << ". The program will be
terminated." << endl;
exit(EXIT_FAILURE);
}
}

PhysicalProperties::~PhysicalProperties()
{
}
class Element
{
Node *node1;
Node *node2;
Node *node3;
Edge *edge1;
Edge *edge2;
Edge *edge3;
Vector2D* normal1;
Vector2D* normal2;
Vector2D* normal3;
Point2D barycenter;
double area;
int elementID;
PhysicalProperties *physicalProperties;
Vector2D* computeNormal(Node *n1, Node *n2, Node *n_opposite);
bool boundaryElement;
map<int,Element*> *elements_node_1;
map<int,Element*> *elements_node_2;
map<int,Element*> *elements_node_3;
double* distances_node_1;
double* distances_node_2;
double* distances_node_3;
// ***************************EM Fields***************************

double E_z_old, E_z_new, E_z_old_1;

double Flux_E_z;
double H_x_old, H_x_new, H_x_old_1;
double H_y_old, H_y_new, H_y_old_1;
double Flux_H_x, Flux_H_y;
double E_z_pred, H_x_pred, H_y_pred;
double E_z_y_new, E_z_y_old;
double Flux_E_z_y;
double K_x_r_old, K_x_r_new;
double Flux_K_x_r;
double J_z, M_x, M_y;
double eps, mu;
double Amplitude, frequency;
double td, taup;
string Type_of_source;
// *********************Computational Fields**********************
double E_z_h, E_z_j, E_z_k;
double H_x_h, H_x_j, H_x_k;
double H_y_h, H_y_j, H_y_k;
double E_z_node_1, E_z_node_2, E_z_node_3;
double H_x_node_1, H_x_node_2, H_x_node_3;
double H_y_node_1, H_y_node_2, H_y_node_3;
double Weight_node_1, Weight_node_2, Weight_node_3;
double E_z_middle_1, E_z_middle_2, E_z_middle_3;
double E_z_middle_h, E_z_middle_j, E_z_middle_k;
double H_x_middle_1, H_x_middle_2, H_x_middle_3;
double H_y_middle_1, H_y_middle_2, H_y_middle_3;

double H_x_middle_h, H_x_middle_j, H_x_middle_k;

double H_y_middle_h, H_y_middle_j, H_y_middle_k;
// **************************Coefficients*************************
double N_i_h_y, N_i_h_x, N_i_j_y, N_i_j_x, N_i_k_y, N_i_k_x;
double Z, Z_h, Z_j, Z_k;
double Y, Y_h, Y_j, Y_k;
double alphaE, alphaE_h, alphaE_j, alphaE_k;
double alphaH, alphaH_h, alphaH_j, alphaH_k;
double TE_i_h,

TE_i_j, TE_i_k, TE_h_i, TE_j_i, TE_k_i;

double TH_i_h,

TH_i_j, TH_i_k, TH_h_i,

TH_j_i, TH_k_i;

double CE1, CH1;

double distance_i_h, distance_i_j, distance_i_k;
double distance_face_h, distance_face_j, distance_face_k;
double dl_i_h_x, dl_h_i_x, dl_i_h_y, dl_h_i_y;
double dl_i_j_x, dl_j_i_x, dl_i_j_y, dl_j_i_y;
double dl_i_k_x, dl_k_i_x, dl_i_k_y, dl_k_i_y;
double dl_i_h, dl_i_j, dl_i_k;
double dl_h_i, dl_j_i, dl_k_i;
double CSPML1, CSPML2;
double CE_loss1;
double CH_loss1, CH_loss2, CH_loss3, CH_loss4, CH_loss5, CH_loss6;
double CK_x_r1, CK_x_r2;
// ***************************************************************
float security_factor;
double Zetha_x_r,Zetha_zero, phi;
int spatial_order;
string pml_type;

int pml;
int boundaryFlag;
public:
Element(Node *n1, Node *n2, Node *n3, Edge *e1, Edge *e2, Edge *e3, int elementID, bool
boundaryElement = false);
Point2D getBarycenter(){return barycenter;}
Node* getNode1(){return node1;}
Node* getNode2(){return node2;}
Node* getNode3(){return node3;}
Edge* getEdge1(){return edge1;}
Edge* getEdge2(){return edge2;}
Edge* getEdge3(){return edge3;}
Vector2D* getNormal1(){return normal1;}
Vector2D* getNormal2(){return normal2;}
Vector2D* getNormal3(){return normal3;}
double getSideLength1(){return edge1->getLength();}
double getSideLength2(){return edge2->getLength();}
double getSideLength3(){return edge3->getLength();}
void updateBoundary();
void setBoundaryFlag(int boundaryType);
double getArea(){return area;}
void setPhysicalProperties(PhysicalProperties *p){physicalProperties = p;}
PhysicalProperties* getPhysicalProperties(){return physicalProperties;}
void setBoundaryElement(bool boundary){boundaryElement = boundary;}
bool isBoundary(){return boundaryElement;}
int getElementID(){return elementID;}
double getE_z_old(){return E_z_old;}

double getH_x_old(){return H_x_old;}

double getH_y_old(){return H_y_old;}
double getE_z_old_1(){return E_z_old_1;}
double getH_x_old_1(){return H_x_old_1;}
double getH_y_old_1(){return H_y_old_1;}
double getE_z_pred(){return E_z_pred;}
double getH_x_pred(){return H_x_pred;}
double getH_y_pred(){return H_y_pred;}
double getE_z_h(){return E_z_h;}
double getE_z_j(){return E_z_j;}
double getE_z_k(){return E_z_k;}
double getJ_z(){return J_z;}
void computeCoefficients(int flag, string type, int order);
double computeTemporalStep();
void swapFields();
void swapFieldE();
void swapFieldH();
void setUpFieldE();
void setUpFieldH();
void setUpMiddles();
void updateFieldE(double delta_t, ostream& ofs, int instant);
void updateFieldH(double delta_t, ostream& ofs, int instant);
void updateSource(double t);
void updateHardSource(double t);
void setUpSource(string type, double first_parameter, double second_parameter, double
third_parameter, double fourth_parameter);
void setImpedence();

void predictFieldE(double delta_t);

void predictFieldH(double delta_t);
void correctFieldE(double delta_t);
void correctFieldH(double delta_t);
void swapPredictedFieldE();
void swapPredictedFieldH();
void setUpPredictedFieldE();
void setUpPredictedFieldH();
void setSecurityFactor(float f){security_factor = f;}
double getE_z_middle_1(){return E_z_middle_1;}
double getE_z_middle_2(){return E_z_middle_2;}
double getE_z_middle_3(){return E_z_middle_3;}
double getH_x_middle_1(){return H_x_middle_1;}
double getH_x_middle_2(){return H_x_middle_2;}
double getH_x_middle_3(){return H_x_middle_3;}
double getH_y_middle_1(){return H_y_middle_1;}
double getH_y_middle_2(){return H_y_middle_2;}
double getH_y_middle_3(){return H_y_middle_3;}
double getZ(){return Z;}
double getY(){return Y;}
double getAlphaE(){return alphaE;}
double getAlphaH(){return alphaH;}
void addElement_node_1(Element* e);
void addElement_node_2(Element* e);
void addElement_node_3(Element* e);
void setDistances_node_1(double dist, int i);
void setDistances_node_2(double dist, int i);

void setDistances_node_3(double dist, int i);

void computeMiddleFieldE();
void computeMiddleFieldH();
void computePredictedMiddleFieldE();
void computePredictedMiddleFieldH();
void computeE_node();
void computeH_node();
void computeE_nodePredicted();
void computeH_nodePredicted();
void computeWeights();
~Element();
};
Element::Element(Node *n1, Node *n2, Node *n3, Edge *e1, Edge *e2, Edge *e3, int
elementID, bool boundaryElement)
:node1(n1),node2(n2),node3(n3),edge1(e1),edge2(e2),edge3(e3),elementID(elementID),
boundaryElement(boundaryElement){
elements_node_1 = new map<int,Element*>;
elements_node_2 = new map<int,Element*>;
elements_node_3 = new map<int,Element*>;
distances_node_1 = new double [10];
distances_node_2 = new double [10];
distances_node_3 = new double [10];
// Barycenter computation
double x1, x2, x3;
double y1, y2, y3;
double x_barycenter, y_barycenter;
x1 = node1->getX();
x2 = node2->getX();

x3 = node3->getX();
y1 = node1->getY();
y2 = node2->getY();
y3 = node3->getY();
x_barycenter = (x1 + x2 + x3)/3.;
y_barycenter = (y1 + y2 + y3)/3.;
barycenter.setX(x_barycenter);
barycenter.setY(y_barycenter);
e1->addAdjacentElement(this);
e2->addAdjacentElement(this);
e3->addAdjacentElement(this);
// Area computation
double p = (edge1->getLength() + edge2->getLength() + edge3->getLength())/2.;
area = sqrt(p*(p - edge1->getLength())*(p - edge2->getLength())*(p - edge3>getLength())); // Erone
// Normals computation
normal1 = computeNormal(node2, node3, node1);
normal2 = computeNormal(node1, node3, node2);
normal3 = computeNormal(node1, node2, node3);
// Fields inizialization
E_z_new = 0;
H_x_new = 0;
H_y_new =0;
// PML Fields initialization
E_z_y_new = 0;
K_x_r_new = 0;
// Flux initialization

Flux_E_z = 0;
Flux_H_x = 0;
Flux_H_y = 0;
Flux_E_z_y = 0;
Flux_K_x_r = 0;
// Nodal Fields initialization
E_z_node_1 = 0;
E_z_node_2 = 0;
E_z_node_3 = 0;
H_x_node_1 = 0;
H_x_node_2 = 0;
H_x_node_3 = 0;
H_y_node_1 = 0;
H_y_node_2 = 0;
H_y_node_3 = 0;
// Source initialization
J_z = 0;
M_x = 0;
M_y = 0;
Amplitude = 0.;
frequency = 0.;
td = 0.;
taup = 0.;
E_z_h = 0.;
E_z_j = 0.;
E_z_k = 0.;
H_x_h = 0.;

H_x_j = 0.;
H_x_k = 0.;
H_y_h = 0.;
H_y_j = 0.;
H_y_k = 0.;
swapFieldE();
swapFieldH();
//Coefficients initialization
eps = 8.85e-12;
mu = 1.26e-6;
alphaE = 0.;
alphaE_h = 0.;
alphaE_j = 0.;
alphaE_k = 0.;
alphaH = 0.;
alphaH_h = 0.;
alphaH_j = 0.;
alphaH_k = 0.;
CE1 = 0.;
CH1 = 0.;
N_i_h_y = 0.;
N_i_h_x = 0.;
N_i_j_y = 0.;
N_i_j_x = 0.;
N_i_k_y = 0.;
N_i_k_x = 0.;
Z_h = 0.;

Z_j = 0.;
Z_k = 0.;
Y_h = 0.;
Y_j = 0.;
Y_k = 0.;
distance_i_h = 0.;
distance_i_j = 0.;
distance_i_k = 0.;
distance_face_h = 0.;
distance_face_j = 0.;
distance_face_k = 0.;
CSPML1 = 0.;
CSPML2 = 0.;
CE_loss1 = 0.;
CH_loss1 = 0.;
CH_loss2 = 0.;
CH_loss3 = 0.;
CH_loss4 = 0.;
CH_loss5 = 0.;
CH_loss6 = 0.;
CK_x_r1 = 0.;
CK_x_r2 = 0.;
security_factor = 1.;
Zetha_zero = 0.;
Zetha_x_r = 0.;
phi = 0.;
spatial_order = 2;

for (int i = 0; i < 10;i++){

distances_node_1[i] = 0;
distances_node_2[i] = 0;
distances_node_3[i] = 0;
}
Weight_node_1 = 0.;
Weight_node_2 = 0.;
Weight_node_3 = 0.;
dl_i_h_x = 0.;
dl_i_h_y = 0.;
dl_i_j_x = 0.;
dl_i_j_y = 0.;
dl_i_k_x = 0.;
dl_i_k_y = 0.;
boundaryFlag = 0;
}
Vector2D* Element::computeNormal(Node *n1, Node *n2, Node *n_opposite){
double x1, x2, x_opposite;
double y1, y2, y_opposite;
x1 = n1->getX();
x2 = n2->getX();
x_opposite = n_opposite->getX();
y1 = n1->getY();
y2 = n2->getY();
y_opposite = n_opposite->getY();
double vx = x2 - x1;
double vy = y2 - y1;

double sideLength = sqrt(vx*vx + vy*vy);

double nx, ny;
nx = vy/sideLength;
ny = -vx/sideLength;
double auxiliary_vector_x = x1 - x_opposite;
double auxiliary_vector_y = y1 - y_opposite;
double scalar_product = nx*auxiliary_vector_x + ny*auxiliary_vector_y;
if(scalar_product < 0){
nx = -nx;
ny = -ny;
}
Vector2D* retval = new Vector2D(nx, ny);
return retval;
}
void Element::updateBoundary(){
boundaryElement = (edge1->isBoundary() || edge2->isBoundary() || edge3>isBoundary());
}
void Element::setImpedence(){
Z = sqrt((this->getPhysicalProperties()->getMur()*mu)/(this->getPhysicalProperties()>getEpsr()*eps));
Y = 1./Z;
alphaE = this->getPhysicalProperties()->getEpsr()*eps;
alphaH = this->getPhysicalProperties()->getMur()*mu;
// cout<<"Elemento "<<this->getElementID()<<" "<<Z<<" "<<Y<<endl;
}
void Element::setBoundaryFlag(int boundaryType){
boundaryFlag = boundaryType;

}
void Element::computeCoefficients(int pml_flag, string type, int order){
spatial_order = order;
double x_bar = 0.;
double y_bar = 0.;
double x = 0.;
double y = 0.;
// Calcolo delle normali delle facce******************************************************
CE1 = 1./(this->getArea());
N_i_h_y = (normal1->getYComponent());
N_i_h_x = (normal1->getXComponent());
N_i_j_y = (normal2->getYComponent());
N_i_j_x = (normal2->getXComponent());
N_i_k_y = (normal3->getYComponent());
N_i_k_x = (normal3->getXComponent());
CH1 = 1./(this->getArea());
//****************************************************************************************
// Serve per prendere i valori di impedenza e ammettenza degli elementi vicini************
// in caso di elemento di bordo si assume un interfaccia PEC
if(this->getEdge1()->isBoundary() == true){
Z_h = 0.;
Y_h = 1.e20;
}else{
if(this->getEdge1()->getElement1()->getElementID()!=this->getElementID()){
Z_h = (this->getEdge1()->getElement1()->getZ());
Y_h = (this->getEdge1()->getElement1()->getY());
}else{

Z_h = (this->getEdge1()->getElement2()->getZ());
Y_h = (this->getEdge1()->getElement2()->getY());
}
}
if(this->getEdge2()->isBoundary() == true){
Z_j = 0.;
Y_j = 1.e20;
}else{
if(this->getEdge2()->getElement1()->getElementID()!=this->getElementID()){
Z_j = (this->getEdge2()->getElement1()->getZ());
Y_j = (this->getEdge2()->getElement1()->getY());
}else{
Z_j = (this->getEdge2()->getElement2()->getZ());
Y_j = (this->getEdge2()->getElement2()->getY());
}
}
if(this->getEdge3()->isBoundary() == true){
Z_k = 0.;
Y_k = 1.e20;
}else{
if(this->getEdge3()->getElement1()->getElementID()!=this->getElementID()){
Z_k = (this->getEdge3()->getElement1()->getZ());
Y_k = (this->getEdge3()->getElement1()->getY());
}else{
Z_k = (this->getEdge3()->getElement2()->getZ());
Y_k = (this->getEdge3()->getElement2()->getY());
}

}
//***************************************************************************************
// Calcolo dei coefficienti T************************************************************
// sul bordo si utilizzano le condizioni di Silver-Muller o PEC
if(this->getEdge1()->isBoundary() == true){
if(boundaryFlag == 1){
TE_i_h = 1.;
TE_h_i = 0.;
TH_i_h = 1.;
TH_h_i = 0.;
}else{
TE_i_h = 2.;
TE_h_i = 0.;
TH_i_h = 0.;
TH_h_i = 0.;
}
}else{
TE_i_h = 2.*Z/(Z+Z_h);
TE_h_i = 2.*Z_h/(Z+Z_h);
TH_i_h = 2.*Y/(Y+Y_h);
TH_h_i = 2.*Y_h/(Y+Y_h);
}
if(this->getEdge2()->isBoundary() == true){
if(boundaryFlag == 1){
TE_i_j = 1.;
TE_j_i = 0.;
TH_i_j = 1.;

TH_j_i = 0.;
}else{
TE_i_j = 2.;
TE_j_i = 0.;
TH_i_j = 0.;
TH_j_i = 0.;
}
}else{
TE_i_j = 2.*Z/(Z+Z_j);
TE_j_i = 2.*Z_j/(Z+Z_j);
TH_i_j = 2.*Y/(Y+Y_j);
TH_j_i = 2.*Y_j/(Y+Y_j);
}
if(this->getEdge3()->isBoundary() == true){
if(boundaryFlag == 1){
TE_i_k = 1.;
TE_k_i = 0.;
TH_i_k = 1.;
TH_k_i = 0.;
}else{
TE_i_k = 2.;
TE_k_i = 0.;
TH_i_k = 0.;
TH_k_i = 0.;
}
}else{
TE_i_k = 2.*Z/(Z+Z_k);

TE_k_i = 2.*Z_k/(Z+Z_k);
TH_i_k = 2.*Y/(Y+Y_k);
TH_k_i = 2.*Y_k/(Y+Y_k);
}
if (spatial_order == 2){
//
********************************************************************************************
****
//

Calcolo delle distanze del baricentro dell'elemento dai lati di bordo

x = this->getBarycenter().getX();
y = this->getBarycenter().getY();
double x_1, x_2, x_3, y_1, y_2, y_3;
if(this->getEdge1()->isBoundary() == true){
x_1=(this->getEdge1()->getNode1()->getX() + this->getEdge1()->getNode2()->getX())/2;
y_1=(this->getEdge1()->getNode1()->getY() + this->getEdge1()->getNode2()->getY())/2;
}
else{
if(this->getEdge1()->getElement1()->getElementID()!=this->getElementID()){
x_1 = this->getEdge1()->getElement1()->getBarycenter().getX();
y_1 = this->getEdge1()->getElement1()->getBarycenter().getY();
}
else{
x_1 = this->getEdge1()->getElement2()->getBarycenter().getX();
y_1 = this->getEdge1()->getElement2()->getBarycenter().getY();
}
}
if(this->getEdge2()->isBoundary() == true){
x_2=(this->getEdge2()->getNode1()->getX() + this->getEdge2()->getNode2()->getX())/2;

y_2=(this->getEdge2()->getNode1()->getY() + this->getEdge2()->getNode2()->getY())/2;
}
else{
if(this->getEdge2()->getElement1()->getElementID()!=this->getElementID()){
x_2 = this->getEdge2()->getElement1()->getBarycenter().getX();
y_2 = this->getEdge2()->getElement1()->getBarycenter().getY();
}
else{
x_2 = this->getEdge2()->getElement2()->getBarycenter().getX();
y_2 = this->getEdge2()->getElement2()->getBarycenter().getY();
}
}
if(this->getEdge3()->isBoundary() == true){
x_3=(this->getEdge3()->getNode1()->getX() + this->getEdge3()->getNode2()->getX())/2;
y_3=(this->getEdge3()->getNode1()->getY() + this->getEdge3()->getNode2()->getY())/2;
}
else{
if(this->getEdge3()->getElement1()->getElementID()!=this->getElementID()){
x_3 = this->getEdge3()->getElement1()->getBarycenter().getX();
y_3 = this->getEdge3()->getElement1()->getBarycenter().getY();
}
else{
x_3 = this->getEdge3()->getElement2()->getBarycenter().getX();
y_3 = this->getEdge3()->getElement2()->getBarycenter().getY();
}
}
dl_i_h_x = ((this->getEdge1()->getNode1()->getX() + this->getEdge1()->getNode2()-

>getX())/2.)- x;
dl_i_j_x = ((this->getEdge2()->getNode1()->getX() + this->getEdge2()->getNode2()>getX())/2.)- x;
dl_i_k_x = ((this->getEdge3()->getNode1()->getX() + this->getEdge3()->getNode2()>getX())/2.)- x;
dl_i_h_y = ((this->getEdge1()->getNode1()->getY() + this->getEdge1()->getNode2()>getY())/2.) - y;
dl_i_j_y = ((this->getEdge2()->getNode1()->getY() + this->getEdge2()->getNode2()>getY())/2.) - y;
dl_i_k_y = ((this->getEdge3()->getNode1()->getY() + this->getEdge3()->getNode2()>getY())/2.) - y;
dl_i_h = sqrt(dl_i_h_x*dl_i_h_x + dl_i_h_y*dl_i_h_y);
dl_i_j = sqrt(dl_i_j_x*dl_i_j_x + dl_i_j_y*dl_i_j_y);
dl_i_k = sqrt(dl_i_k_x*dl_i_k_x + dl_i_k_y*dl_i_k_y);
dl_h_i_x = ((this->getEdge1()->getNode1()->getX() + this->getEdge1()->getNode2()>getX())/2.)- x_1;
dl_j_i_x = ((this->getEdge2()->getNode1()->getX() + this->getEdge2()->getNode2()>getX())/2.)- x_2;
dl_k_i_x = ((this->getEdge3()->getNode1()->getX() + this->getEdge3()->getNode2()>getX())/2.)- x_3;
dl_h_i_y = ((this->getEdge1()->getNode1()->getY() + this->getEdge1()->getNode2()>getY())/2.) - y_1;
dl_j_i_y = ((this->getEdge2()->getNode1()->getY() + this->getEdge2()->getNode2()>getY())/2.) - y_2;
dl_k_i_y = ((this->getEdge3()->getNode1()->getY() + this->getEdge3()->getNode2()>getY())/2.) - y_3;
dl_h_i = sqrt(dl_h_i_x*dl_h_i_x + dl_h_i_y*dl_h_i_y);
dl_j_i = sqrt(dl_j_i_x*dl_j_i_x + dl_j_i_y*dl_j_i_y);
dl_k_i = sqrt(dl_k_i_x*dl_k_i_x + dl_k_i_y*dl_k_i_y);
double y_t = (this->getEdge1()->getNode1()->getY() + this->getEdge1()->getNode2()>getY())/2;
double x_t = (this->getEdge1()->getNode1()->getX() + this->getEdge1()->getNode2()-

>getX())/2;
distance_face_h = sqrt((x-x_t)*(x-x_t) + (y-y_t)*(y-y_t));
y_t = (this->getEdge2()->getNode1()->getY() + this->getEdge2()->getNode2()->getY())/2;
x_t = (this->getEdge2()->getNode1()->getX() + this->getEdge2()->getNode2()->getX())/2;
distance_face_j = sqrt((x-x_t)*(x-x_t) + (y-y_t)*(y-y_t));
y_t = (this->getEdge3()->getNode1()->getY() + this->getEdge3()->getNode2()->getY())/2;
x_t = (this->getEdge3()->getNode1()->getX() + this->getEdge3()->getNode2()->getX())/2;
distance_face_k = sqrt((x-x_t)*(x-x_t) + (y-y_t)*(y-y_t));
//
********************************************************************************************
****
//
********************************************************************************************
****
//
Calcolo delle distanze del baricentro dell'elemento dai baricentri degli elementi
adiacenti
if(this->getEdge1()->isBoundary() == true){
distance_i_h = distance_face_h;
}
else{
if(this->getEdge1()->getElement1()->getElementID()!=this->getElementID()){
x_bar = this->getEdge1()->getElement1()->getBarycenter().getX();
y_bar = this->getEdge1()->getElement1()->getBarycenter().getY();
y_t = (this->getEdge1()->getNode1()->getY() + this->getEdge1()->getNode2()->getY())/2;
x_t = (this->getEdge1()->getNode1()->getX() + this->getEdge1()->getNode2()->getX())/2;
distance_i_h = sqrt((x_t-x_bar)*(x_t-x_bar) + (y_t-y_bar)*(y_t-y_bar)) + distance_face_h;
}
else{

x_bar = this->getEdge1()->getElement2()->getBarycenter().getX();
y_bar = this->getEdge1()->getElement2()->getBarycenter().getY();
y_t = (this->getEdge1()->getNode1()->getY() + this->getEdge1()->getNode2()->getY())/2;
x_t = (this->getEdge1()->getNode1()->getX() + this->getEdge1()->getNode2()->getX())/2;
distance_i_h = sqrt((x_t-x_bar)*(x_t-x_bar) + (y_t-y_bar)*(y_t-y_bar)) + distance_face_h;
}
}
if(this->getEdge2()->isBoundary() == true){
distance_i_j = distance_face_j;
}
else{
if(this->getEdge2()->getElement1()->getElementID()!=this->getElementID()){
x_bar = this->getEdge2()->getElement1()->getBarycenter().getX();
y_bar = this->getEdge2()->getElement1()->getBarycenter().getY();
y_t = (this->getEdge2()->getNode1()->getY() + this->getEdge2()->getNode2()->getY())/2;
x_t = (this->getEdge2()->getNode1()->getX() + this->getEdge2()->getNode2()->getX())/2;
distance_i_j = sqrt((x_t-x_bar)*(x_t-x_bar) + (y_t-y_bar)*(y_t-y_bar)) + distance_face_j;
}
else{
x_bar = this->getEdge2()->getElement2()->getBarycenter().getX();
y_bar = this->getEdge2()->getElement2()->getBarycenter().getY();
y_t = (this->getEdge2()->getNode1()->getY() + this->getEdge2()->getNode2()->getY())/2;
x_t = (this->getEdge2()->getNode1()->getX() + this->getEdge2()->getNode2()->getX())/2;
distance_i_j = sqrt((x_t-x_bar)*(x_t-x_bar) + (y_t-y_bar)*(y_t-y_bar)) + distance_face_j;
}

}
if(this->getEdge3()->isBoundary() == true){
distance_i_k = distance_face_k;
}
else{
if(this->getEdge3()->getElement1()->getElementID()!=this->getElementID()){
x_bar = this->getEdge3()->getElement1()->getBarycenter().getX();
y_bar = this->getEdge3()->getElement1()->getBarycenter().getY();
y_t = (this->getEdge3()->getNode1()->getY() + this->getEdge3()->getNode2()->getY())/2;
x_t = (this->getEdge3()->getNode1()->getX() + this->getEdge3()->getNode2()->getX())/2;
distance_i_k = sqrt((x_t-x_bar)*(x_t-x_bar) + (y_t-y_bar)*(y_t-y_bar)) + distance_face_k;
}
else{
x_bar = this->getEdge3()->getElement2()->getBarycenter().getX();
y_bar = this->getEdge3()->getElement2()->getBarycenter().getY();
y_t = (this->getEdge3()->getNode1()->getY() + this->getEdge3()->getNode2()->getY())/2;
x_t = (this->getEdge3()->getNode1()->getX() + this->getEdge3()->getNode2()->getX())/2;
distance_i_k = sqrt((x_t-x_bar)*(x_t-x_bar) + (y_t-y_bar)*(y_t-y_bar)) + distance_face_k;
}
}
}
pml_type = type;
//

cout<<pml_flag<<endl;

//

cout<<pml_type<<endl;

if(pml_flag == 1){
pml = 1;

if (pml_type == "S"){
//
if (((this->getElementID()>=1)&&(this->getElementID()<=750))||((this>getElementID()>=10500)&&(this->getElementID()<=11250))){
//
//
//

CSPML1 =1;

//sigma x

//
CSPML2 = 1; /*=1*((0.1-this->getBarycenter().getY())/0.1)*((0.1-this>getBarycenter().getY())/0.1)*((0.1-this->getBarycenter().getY())/0.1);
//sigma y*/
//

//
//

for (int i = 0; i<11250;i+=150){

//
if(((this->getElementID()>=(1+i))&&(this->getElementID()<=(10+i)))||((this>getElementID()>=(140+i))&&(this->getElementID()<=(150+i)))){
//
CSPML1 = 1; /*=1*((0.1-this->getBarycenter().getX())/0.1)*((0.1-this>getBarycenter().getX())/0.1)*((0.1-this->getBarycenter().getX())/0.1);
//sigma x*/
//

CSPML2 = 1;

//
//

//
//

if ((this->getElementID()>=1)&&(this->getElementID()<=1200)){
CSPML1 =1;

//sigma x

CSPML2 =1.*((0.24-this->getBarycenter().getY())/0.24)*((0.24-this>getBarycenter().getY())/0.24)*((0.24-this->getBarycenter().getY())/0.24);
//sigma y
}
}
if (pml_type == "R"){
double x, y;

Zetha_zero = 8.*2.*3.14*3e8;
Zetha_x_r = Zetha_zero*((sqrt((this->getBarycenter().getX()-0.)*(this>getBarycenter().getX()-0.) + (this->getBarycenter().getY()-0.)*(this>getBarycenter().getY()-0.))-0.5)/0.5)
*((sqrt((this->getBarycenter().getX()-0.)*(this->getBarycenter().getX()-0.) + (this>getBarycenter().getY()-0.)*(this->getBarycenter().getY()-0.))-0.5)/0.5);
//
*((sqrt((this->getBarycenter().getX()-0.)*(this>getBarycenter().getX()-0.) + (this->getBarycenter().getY()-0.)*(this>getBarycenter().getY()-0.))-0.7)/0.3);
//
*((sqrt((this->getBarycenter().getX()-0.)*(this>getBarycenter().getX()-0.) + (this->getBarycenter().getY()-0.)*(this>getBarycenter().getY()-0.))-0.7)/0.3)
//
*((sqrt((this->getBarycenter().getX()-0.)*(this>getBarycenter().getX()-0.) + (this->getBarycenter().getY()-0.)*(this>getBarycenter().getY()-0.))-0.7)/0.3);
if ((((this->getBarycenter().getX()-0.)*(this->getBarycenter().getX()-0.) + (this>getBarycenter().getY()-0.)*(this->getBarycenter().getY()-0.))>=(0.5*0.5))&&(((this>getBarycenter().getX()-0.)*(this->getBarycenter().getX()-0.) + (this>getBarycenter().getY()-0.)*(this->getBarycenter().getY()-0.))<=(1.*1.))){
x= this->getBarycenter().getX()-0.;
y= this->getBarycenter().getY()-0.;
phi = atan(y/x);
CE_loss1 = Zetha_x_r;
CH_loss1 = cos(phi);
CH_loss2 = Zetha_x_r*(sin(phi)*sin(phi));
CH_loss3 = Zetha_x_r*(cos(phi)*sin(phi));
CH_loss4 = sin(phi);
CH_loss5 = Zetha_x_r*(cos(phi)*cos(phi));
CH_loss6 = Zetha_x_r*(cos(phi)*sin(phi));
//
CK_x_r1 = Zetha_x_r*sin(phi)/(this->getPhysicalProperties()>getMur()*mu*this->getArea());
//
CK_x_r2 = Zetha_x_r*cos(phi)/(this->getPhysicalProperties()>getMur()*mu*this->getArea());

CK_x_r1 = Zetha_x_r*sin(phi)/(this->getArea());
CK_x_r2 = Zetha_x_r*cos(phi)/(this->getArea());
}
}
}
}
double Element::computeTemporalStep(){
double step;
step =security_factor*2.* (sqrt(this->getPhysicalProperties()->getEpsr()*eps*this>getPhysicalProperties()->getMur()*mu))*this->getArea()/(this->edge1->getLength() +
this->edge2->getLength() + this->edge3->getLength());
//

step = 9.585e-12;

return step;
}
void Element::computeWeights(){
for (int i = 0; i<10; i++){
Weight_node_1 = Weight_node_1 + distances_node_1[i];
Weight_node_2 = Weight_node_2 + distances_node_2[i];
Weight_node_3 = Weight_node_3 + distances_node_3[i];
}
}
void Element::swapFields(){
E_z_old = E_z_new;
H_x_old = H_x_new;
H_y_old = H_y_new;
K_x_r_old = K_x_r_new;
}
void Element::swapFieldH(){

H_x_old = H_x_new;
H_y_old = H_y_new;
K_x_r_old = K_x_r_new;
}
void Element::swapFieldE(){
E_z_old = E_z_new;
E_z_y_old = E_z_y_new;
}
void Element::swapPredictedFieldH(){
H_x_old_1 = H_x_pred;
H_y_old_1 = H_y_pred;
}
void Element::swapPredictedFieldE(){
E_z_old_1 = E_z_pred;
}
void Element::setUpFieldH(){
if(spatial_order == 2){
double gradient;
if(this->getEdge1()->isBoundary() == true){
if(1 == boundaryFlag){
H_x_h = H_x_old;
H_y_h = H_y_old;
}else{
H_x_h = 0.;
H_y_h = 0.;
}
}else{

if(this->getEdge1()->getElement1()->getElementID()!=this->getElementID()){
H_x_h = (this->getEdge1()->getElement1()->getH_x_old());
H_y_h = (this->getEdge1()->getElement1()->getH_y_old());
}else{
H_x_h = (this->getEdge1()->getElement2()->getH_x_old());
H_y_h = (this->getEdge1()->getElement2()->getH_y_old());
}
}
if(this->getEdge2()->isBoundary() == true){
if(1 == boundaryFlag){
H_x_j = H_x_old;
H_y_j = H_y_old;
}else{
H_x_j = 0.;
H_y_j = 0.;
}
}else{
if(this->getEdge2()->getElement1()->getElementID()!=this->getElementID()){
H_x_j = (this->getEdge2()->getElement1()->getH_x_old());
H_y_j = (this->getEdge2()->getElement1()->getH_y_old());
}else{
H_x_j = (this->getEdge2()->getElement2()->getH_x_old());
H_y_j = (this->getEdge2()->getElement2()->getH_y_old());
}
}
if(this->getEdge3()->isBoundary() == true){
if(1 == boundaryFlag){

H_x_k = H_x_old;
H_y_k = H_y_old;
}else{
H_x_k = 0.;
H_y_k = 0.;
}
}else{
if(this->getEdge3()->getElement1()->getElementID()!=this->getElementID()){
H_x_k = (this->getEdge3()->getElement1()->getH_x_old());
H_y_k = (this->getEdge3()->getElement1()->getH_y_old());
}else{
H_x_k = (this->getEdge3()->getElement2()->getH_x_old());
H_y_k = (this->getEdge3()->getElement2()->getH_y_old());
}
}
H_x_middle_h = (H_x_old*dl_i_h + H_x_h*dl_h_i)/(dl_i_h + dl_h_i);
H_x_middle_j = (H_x_old*dl_i_j + H_x_j*dl_j_i)/(dl_i_j + dl_j_i);
H_x_middle_k = (H_x_old*dl_i_k + H_x_k*dl_k_i)/(dl_i_k + dl_k_i);
double gradient_dl_h =
H_x_middle_h*(N_i_h_x*dl_i_h_x + N_i_h_y*dl_i_h_y)*edge1->getLength() +
H_x_middle_j*(N_i_j_x*dl_i_h_x + N_i_j_y*dl_i_h_y)*edge2->getLength() +
H_x_middle_k*(N_i_k_x*dl_i_h_x + N_i_k_y*dl_i_h_y)*edge3->getLength();
gradient_dl_h = gradient_dl_h/getArea();
double gradient_dl_j =
H_x_middle_h*(N_i_h_x*dl_i_j_x + N_i_h_y*dl_i_j_y)*edge1->getLength() +
H_x_middle_j*(N_i_j_x*dl_i_j_x + N_i_j_y*dl_i_j_y)*edge2->getLength() +
H_x_middle_k*(N_i_k_x*dl_i_j_x + N_i_k_y*dl_i_j_y)*edge3->getLength();

gradient_dl_j = gradient_dl_j/getArea();
double gradient_dl_k =
H_x_middle_h*(N_i_h_x*dl_i_k_x + N_i_h_y*dl_i_k_y)*edge1->getLength() +
H_x_middle_j*(N_i_j_x*dl_i_k_x + N_i_j_y*dl_i_k_y)*edge2->getLength() +
H_x_middle_k*(N_i_k_x*dl_i_k_x + N_i_k_y*dl_i_k_y)*edge3->getLength();
gradient_dl_k = gradient_dl_k/getArea();
H_x_middle_1 = H_x_old + gradient_dl_h;
H_x_middle_2 = H_x_old + gradient_dl_j;
H_x_middle_3 = H_x_old + gradient_dl_k;
H_y_middle_h = (H_y_old*dl_i_h + H_y_h*dl_h_i)/(dl_i_h + dl_h_i);
H_y_middle_j = (H_y_old*dl_i_j + H_y_j*dl_j_i)/(dl_i_j + dl_j_i);
H_y_middle_k = (H_y_old*dl_i_k + H_y_k*dl_k_i)/(dl_i_k + dl_k_i);
gradient_dl_h =
H_y_middle_h*(N_i_h_x*dl_i_h_x + N_i_h_y*dl_i_h_y)*edge1->getLength() +
H_y_middle_j*(N_i_j_x*dl_i_h_x + N_i_j_y*dl_i_h_y)*edge2->getLength() +
H_y_middle_k*(N_i_k_x*dl_i_h_x + N_i_k_y*dl_i_h_y)*edge3->getLength();
gradient_dl_h = gradient_dl_h/getArea();
gradient_dl_j =
H_y_middle_h*(N_i_h_x*dl_i_j_x + N_i_h_y*dl_i_j_y)*edge1->getLength() +
H_y_middle_j*(N_i_j_x*dl_i_j_x + N_i_j_y*dl_i_j_y)*edge2->getLength() +
H_y_middle_k*(N_i_k_x*dl_i_j_x + N_i_k_y*dl_i_j_y)*edge3->getLength();
gradient_dl_j = gradient_dl_j/getArea();
gradient_dl_k =
H_y_middle_h*(N_i_h_x*dl_i_k_x + N_i_h_y*dl_i_k_y)*edge1->getLength() +
H_y_middle_j*(N_i_j_x*dl_i_k_x + N_i_j_y*dl_i_k_y)*edge2->getLength() +
H_y_middle_k*(N_i_k_x*dl_i_k_x + N_i_k_y*dl_i_k_y)*edge3->getLength();
gradient_dl_k = gradient_dl_k/getArea();

H_y_middle_1 = H_y_old + gradient_dl_h;

H_y_middle_2 = H_y_old + gradient_dl_j;
H_y_middle_3 = H_y_old + gradient_dl_k;
}
if(spatial_order == 1){
if(this->getEdge1()->isBoundary() == true){
H_x_h = 0.;
H_y_h = 0.;
}else{
if(this->getEdge1()->getElement1()->getElementID()!=this->getElementID()){
H_x_h = (this->getEdge1()->getElement1()->getH_x_old());
H_y_h = (this->getEdge1()->getElement1()->getH_y_old());
}
else{
H_x_h = (this->getEdge1()->getElement2()->getH_x_old());
H_y_h = (this->getEdge1()->getElement2()->getH_y_old());
}
}
if(this->getEdge2()->isBoundary() == true){
H_x_j = 0.;
H_y_j = 0.;
}
else{
if(this->getEdge2()->getElement1()->getElementID()!=this->getElementID()){
H_x_j = (this->getEdge2()->getElement1()->getH_x_old());
H_y_j = (this->getEdge2()->getElement1()->getH_y_old());
}

else{
H_x_j = (this->getEdge2()->getElement2()->getH_x_old());
H_y_j = (this->getEdge2()->getElement2()->getH_y_old());
}
}
if(this->getEdge3()->isBoundary() == true){
H_x_k = 0.;
H_y_k = 0.;
}
else{
if(this->getEdge3()->getElement1()->getElementID()!=this->getElementID()){
H_x_k = (this->getEdge3()->getElement1()->getH_x_old());
H_y_k = (this->getEdge3()->getElement1()->getH_y_old());
}
else{
H_x_k = (this->getEdge3()->getElement2()->getH_x_old());
H_y_k = (this->getEdge3()->getElement2()->getH_y_old());
}
}
}
//
cout<<"elemento "<<this->getElementID()<<" E_z_h = "<<E_z_h<<" E_z_j =
"<<E_z_j<<" E_z_k = "<<E_z_k<<endl;
if(spatial_order == 3){
if(this->getEdge1()->isBoundary() == true){
//
H_x_h = H_x_middle_1;
H_y_h = H_y_middle_1;

}
else{
if(this->getEdge1()->getElement1()->getElementID()!=this->getElementID()){
if(this->getEdge1()==this->getEdge1()->getElement1()->getEdge1()){
H_x_h = (this->getEdge1()->getElement1()->getH_x_middle_1());
H_y_h = (this->getEdge1()->getElement1()->getH_y_middle_1());
}
if(this->getEdge1()==this->getEdge1()->getElement1()->getEdge2()){
H_x_h = (this->getEdge1()->getElement1()->getH_x_middle_2());
H_y_h = (this->getEdge1()->getElement1()->getH_y_middle_2());
}
if(this->getEdge1()==this->getEdge1()->getElement1()->getEdge3()){
H_x_h = (this->getEdge1()->getElement1()->getH_x_middle_3());
H_y_h = (this->getEdge1()->getElement1()->getH_y_middle_3());
}
}
else{
if(this->getEdge1()==this->getEdge1()->getElement2()->getEdge1()){
H_x_h = (this->getEdge1()->getElement2()->getH_x_middle_1());
H_y_h = (this->getEdge1()->getElement2()->getH_y_middle_1());
}
if(this->getEdge1()==this->getEdge1()->getElement2()->getEdge2()){
H_x_h = (this->getEdge1()->getElement2()->getH_x_middle_2());
H_y_h = (this->getEdge1()->getElement2()->getH_y_middle_2());
}
if(this->getEdge1()==this->getEdge1()->getElement2()->getEdge3()){
H_x_h = (this->getEdge1()->getElement2()->getH_x_middle_3());

H_y_h = (this->getEdge1()->getElement2()->getH_y_middle_3());
}
}
}
if(this->getEdge2()->isBoundary() == true){
H_x_j = H_x_middle_2;
H_y_j = H_y_middle_2;
}
else{
if(this->getEdge2()->getElement1()->getElementID()!=this->getElementID()){
if(this->getEdge2()==this->getEdge2()->getElement1()->getEdge1()){
H_x_j = (this->getEdge2()->getElement1()->getH_x_middle_1());
H_y_j = (this->getEdge2()->getElement1()->getH_y_middle_1());
}
if(this->getEdge2()==this->getEdge2()->getElement1()->getEdge2()){
H_x_j = (this->getEdge2()->getElement1()->getH_x_middle_2());
H_y_j = (this->getEdge2()->getElement1()->getH_y_middle_2());
}
if(this->getEdge2()==this->getEdge2()->getElement1()->getEdge3()){
H_x_j = (this->getEdge2()->getElement1()->getH_x_middle_3());
H_y_j = (this->getEdge2()->getElement1()->getH_y_middle_3());
}
}
else{
if(this->getEdge2()==this->getEdge2()->getElement2()->getEdge1()){
H_x_j = (this->getEdge2()->getElement2()->getH_x_middle_1());
H_y_j = (this->getEdge2()->getElement2()->getH_y_middle_1());

}
if(this->getEdge2()==this->getEdge2()->getElement2()->getEdge2()){
H_x_j = (this->getEdge2()->getElement2()->getH_x_middle_2());
H_y_j = (this->getEdge2()->getElement2()->getH_y_middle_2());
}
if(this->getEdge2()==this->getEdge2()->getElement2()->getEdge3()){
H_x_j = (this->getEdge2()->getElement2()->getH_x_middle_3());
H_y_j = (this->getEdge2()->getElement2()->getH_y_middle_3());
}
}
}
if(this->getEdge3()->isBoundary() == true){
H_x_k = H_x_middle_3;
H_y_k = H_y_middle_3;
}
else{
if(this->getEdge3()->getElement1()->getElementID()!=this->getElementID()){
if(this->getEdge3()==this->getEdge3()->getElement1()->getEdge1()){
H_x_k = (this->getEdge3()->getElement1()->getH_x_middle_1());
H_y_k = (this->getEdge3()->getElement1()->getH_y_middle_1());
}
if(this->getEdge3()==this->getEdge3()->getElement1()->getEdge2()){
H_x_k = (this->getEdge3()->getElement1()->getH_x_middle_2());
H_y_k = (this->getEdge3()->getElement1()->getH_y_middle_2());
}
if(this->getEdge3()==this->getEdge3()->getElement1()->getEdge3()){
H_x_k = (this->getEdge3()->getElement1()->getH_x_middle_3());

H_y_k = (this->getEdge3()->getElement1()->getH_y_middle_3());
}
}
else{
if(this->getEdge3()==this->getEdge3()->getElement2()->getEdge1()){
H_x_k = (this->getEdge3()->getElement2()->getH_x_middle_1());
H_y_k = (this->getEdge3()->getElement2()->getH_y_middle_1());
}
if(this->getEdge3()==this->getEdge3()->getElement1()->getEdge2()){
H_x_k = (this->getEdge3()->getElement2()->getH_x_middle_2());
H_y_k = (this->getEdge3()->getElement2()->getH_y_middle_2());
}
if(this->getEdge3()==this->getEdge3()->getElement1()->getEdge3()){
H_x_k = (this->getEdge3()->getElement2()->getH_x_middle_3());
H_y_k = (this->getEdge3()->getElement2()->getH_y_middle_3());
}
}
}
}
}
void Element::setUpFieldE(){
if (spatial_order == 2){
if(this->getEdge1()->isBoundary() == true){
if(1 == boundaryFlag){
E_z_h = E_z_old;
}else{
E_z_h = 0.;

}
}else{
if(this->getEdge1()->getElement1()->getElementID()!=this->getElementID()){
E_z_h = (this->getEdge1()->getElement1()->getE_z_old());
}else{
E_z_h = (this->getEdge1()->getElement2()->getE_z_old());
}
}
if(this->getEdge2()->isBoundary() == true){
if(1 == boundaryFlag){
E_z_j = E_z_old;
}else{
E_z_j = 0.;
}
}else{
if(this->getEdge2()->getElement1()->getElementID()!=this->getElementID()){
E_z_j = (this->getEdge2()->getElement1()->getE_z_old());
}else{
E_z_j = (this->getEdge2()->getElement2()->getE_z_old());
}
}
if(this->getEdge3()->isBoundary() == true){
if(1 == boundaryFlag){
E_z_k = E_z_old;
}else{
E_z_k = 0.;
}

}else{
if(this->getEdge3()->getElement1()->getElementID()!=this->getElementID()){
E_z_k = (this->getEdge3()->getElement1()->getE_z_old());
}else{
E_z_k = (this->getEdge3()->getElement2()->getE_z_old());
}
}
E_z_middle_h = (E_z_old*dl_i_h + E_z_h*dl_h_i)/(dl_i_h + dl_h_i);
E_z_middle_j = (E_z_old*dl_i_j + E_z_j*dl_j_i)/(dl_i_j + dl_j_i);
E_z_middle_k = (E_z_old*dl_i_k + E_z_k*dl_k_i)/(dl_i_k + dl_k_i);
double gradient_dl_h =
E_z_middle_h*(N_i_h_x*dl_i_h_x + N_i_h_y*dl_i_h_y)*edge1->getLength() +
E_z_middle_j*(N_i_j_x*dl_i_h_x + N_i_j_y*dl_i_h_y)*edge2->getLength() +
E_z_middle_k*(N_i_k_x*dl_i_h_x + N_i_k_y*dl_i_h_y)*edge3->getLength();
gradient_dl_h = gradient_dl_h/getArea();
double gradient_dl_j =
E_z_middle_h*(N_i_h_x*dl_i_j_x + N_i_h_y*dl_i_j_y)*edge1->getLength() +
E_z_middle_j*(N_i_j_x*dl_i_j_x + N_i_j_y*dl_i_j_y)*edge2->getLength() +
E_z_middle_k*(N_i_k_x*dl_i_j_x + N_i_k_y*dl_i_j_y)*edge3->getLength();
gradient_dl_j = gradient_dl_j/getArea();
double gradient_dl_k =
E_z_middle_h*(N_i_h_x*dl_i_k_x + N_i_h_y*dl_i_k_y)*edge1->getLength() +
E_z_middle_j*(N_i_j_x*dl_i_k_x + N_i_j_y*dl_i_k_y)*edge2->getLength() +
E_z_middle_k*(N_i_k_x*dl_i_k_x + N_i_k_y*dl_i_k_y)*edge3->getLength();
gradient_dl_k = gradient_dl_k/getArea();
E_z_middle_1 = E_z_old + gradient_dl_h;
E_z_middle_2 = E_z_old + gradient_dl_j;

E_z_middle_3 = E_z_old + gradient_dl_k;

}
if(spatial_order == 1){
if(this->getEdge1()->isBoundary() == true){
if(spatial_order == 1){
E_z_h = 0.;
}else{
E_z_old = 0.;
}
}
else{
if(this->getEdge1()->getElement1()->getElementID()!=this->getElementID()){
E_z_h = (this->getEdge1()->getElement1()->getE_z_old());
}
else{
E_z_h = (this->getEdge1()->getElement2()->getE_z_old());
}
}
if(this->getEdge2()->isBoundary() == true){
if(spatial_order == 1){
E_z_j = 0.;
}else{
E_z_old = 0.;
}
}
else{
if(this->getEdge2()->getElement1()->getElementID()!=this->getElementID()){

E_z_j = (this->getEdge2()->getElement1()->getE_z_old());
}
else{
E_z_j = (this->getEdge2()->getElement2()->getE_z_old());
}
}
if(this->getEdge3()->isBoundary() == true){
if(spatial_order == 1){
E_z_k = 0.;
}else{
E_z_old = 0.;
}
}
else{
if(this->getEdge3()->getElement1()->getElementID()!=this->getElementID()){
E_z_k = (this->getEdge3()->getElement1()->getE_z_old());
}
else{
E_z_k = (this->getEdge3()->getElement2()->getE_z_old());
}
if(spatial_order == 3){
if(this->getEdge1()->isBoundary() == true){
E_z_h = -E_z_middle_1;
}
else{
if(this->getEdge1()->getElement1()->getElementID()!=this->getElementID()){
if(this->getEdge1()==this->getEdge1()->getElement1()->getEdge1()){

E_z_h = (this->getEdge1()->getElement1()->getE_z_middle_1());
}
if(this->getEdge1()==this->getEdge1()->getElement1()->getEdge2()){
E_z_h = (this->getEdge1()->getElement1()->getE_z_middle_2());
}
if(this->getEdge1()==this->getEdge1()->getElement1()->getEdge3()){
E_z_h = (this->getEdge1()->getElement1()->getE_z_middle_3());
}
}
else{
if(this->getEdge1()==this->getEdge1()->getElement2()->getEdge1()){
E_z_h = (this->getEdge1()->getElement2()->getE_z_middle_1());
}
if(this->getEdge1()==this->getEdge1()->getElement2()->getEdge2()){
E_z_h = (this->getEdge1()->getElement2()->getE_z_middle_2());
}
if(this->getEdge1()==this->getEdge1()->getElement2()->getEdge3()){
E_z_h = (this->getEdge1()->getElement2()->getE_z_middle_3());
}
}
}
if(this->getEdge2()->isBoundary() == true){
E_z_j = -E_z_middle_2;
}
else{
if(this->getEdge2()->getElement1()->getElementID()!=this->getElementID()){
if(this->getEdge2()==this->getEdge2()->getElement1()->getEdge1()){

E_z_j = (this->getEdge2()->getElement1()->getE_z_middle_1());
}
if(this->getEdge2()==this->getEdge2()->getElement1()->getEdge2()){
E_z_j = (this->getEdge2()->getElement1()->getE_z_middle_2());
}
if(this->getEdge2()==this->getEdge2()->getElement1()->getEdge3()){
E_z_j = (this->getEdge2()->getElement1()->getE_z_middle_3());
}
}
else{
if(this->getEdge2()==this->getEdge2()->getElement2()->getEdge1()){
E_z_j = (this->getEdge2()->getElement2()->getE_z_middle_1());
}
if(this->getEdge2()==this->getEdge2()->getElement2()->getEdge2()){
E_z_j = (this->getEdge2()->getElement2()->getE_z_middle_2());
}
if(this->getEdge2()==this->getEdge2()->getElement2()->getEdge3()){
E_z_j = (this->getEdge2()->getElement2()->getE_z_middle_3());
}
}
}
if(this->getEdge3()->isBoundary() == true){
E_z_k = -E_z_middle_3;
}
else{
if(this->getEdge3()->getElement1()->getElementID()!=this->getElementID()){
if(this->getEdge3()==this->getEdge3()->getElement1()->getEdge1()){

E_z_k = (this->getEdge3()->getElement1()->getE_z_middle_1());
}
if(this->getEdge3()==this->getEdge3()->getElement1()->getEdge2()){
E_z_k = (this->getEdge3()->getElement1()->getE_z_middle_2());
}
if(this->getEdge3()==this->getEdge3()->getElement1()->getEdge3()){
E_z_k = (this->getEdge3()->getElement1()->getE_z_middle_3());
}
}
else{
if(this->getEdge3()==this->getEdge3()->getElement2()->getEdge1()){
E_z_k = (this->getEdge3()->getElement2()->getE_z_middle_1());
}
if(this->getEdge3()==this->getEdge3()->getElement2()->getEdge2()){
E_z_k = (this->getEdge3()->getElement2()->getE_z_middle_2());
}
if(this->getEdge3()==this->getEdge3()->getElement2()->getEdge3()){
E_z_k = (this->getEdge3()->getElement2()->getE_z_middle_3());
}
}
}
}
//
cout<<"elemento "<<this->getElementID()<<" E_z_h = "<<E_z_h<<" E_z_j =
"<<E_z_j<<" E_z_k = "<<E_z_k<<endl;
}
void Element::computeE_node(){
E_z_node_1 = 0;

E_z_node_2 = 0;
E_z_node_3 = 0;
map<int,Element*>::iterator it_elements;
int i= 0;
for(it_elements = elements_node_1->begin(); it_elements != elements_node_1->end();
it_elements++){
E_z_node_1 = E_z_node_1 + it_elements->second->getE_z_old()*distances_node_1[i];
i++;
}
E_z_node_1 = E_z_node_1/Weight_node_1;
i = 0;
for(it_elements = elements_node_2->begin(); it_elements != elements_node_2->end();
it_elements++){
E_z_node_2 = E_z_node_2 + it_elements->second->getE_z_old()*distances_node_2[i];
i++;
}
E_z_node_2 = E_z_node_2/Weight_node_2;
i = 0;
for(it_elements = elements_node_3->begin(); it_elements != elements_node_3->end();
it_elements++){
E_z_node_3 = E_z_node_3 + it_elements->second->getE_z_old()*distances_node_3[i];
i++;
}
E_z_node_3 = E_z_node_3/Weight_node_3;
}
void Element::computeH_node(){
H_x_node_1 = 0;
H_y_node_1 = 0;

H_x_node_2 = 0;
H_y_node_2 = 0;
H_x_node_3 = 0;
H_y_node_3 = 0;
map<int,Element*>::iterator it_elements;
int i= 0;
for(it_elements = elements_node_1->begin(); it_elements != elements_node_1->end();
it_elements++){
H_x_node_1 = H_x_node_1 + it_elements->second->getH_x_old()*distances_node_1[i];
H_y_node_1 = H_y_node_1 + it_elements->second->getH_y_old()*distances_node_1[i];
Weight_node_1 = Weight_node_1 + distances_node_1[i];
i++;
}
H_x_node_1 = H_x_node_1/Weight_node_1;
H_y_node_1 = H_y_node_1/Weight_node_1;
i = 0;
for(it_elements = elements_node_2->begin(); it_elements != elements_node_2->end();
it_elements++){
H_x_node_2 = H_x_node_2 + it_elements->second->getH_x_old()*distances_node_2[i];
H_y_node_2 = H_y_node_2 + it_elements->second->getH_y_old()*distances_node_2[i];
Weight_node_2 = Weight_node_2 + distances_node_2[i];
i++;
}
H_x_node_2 = H_x_node_2/Weight_node_2;
H_y_node_2 = H_y_node_2/Weight_node_2;
i = 0;
for(it_elements = elements_node_3->begin(); it_elements != elements_node_3->end();
it_elements++){

H_x_node_3 = H_x_node_3 + it_elements->second->getH_x_old()*distances_node_3[i];

H_y_node_3 = H_y_node_3 + it_elements->second->getH_y_old()*distances_node_3[i];
Weight_node_3 = Weight_node_3 + distances_node_3[i];
i++;
}
H_x_node_3 = H_x_node_3/Weight_node_3;
H_y_node_3 = H_y_node_3/Weight_node_3;
}
void Element::computeE_nodePredicted(){
E_z_node_1 = 0;
E_z_node_2 = 0;
E_z_node_3 = 0;
map<int,Element*>::iterator it_elements;
int i= 0;
for(it_elements = elements_node_1->begin(); it_elements != elements_node_1->end();
it_elements++){
E_z_node_1 = E_z_node_1 + it_elements->second->getE_z_old_1()*distances_node_1[i];
//

Weight_node_1 = Weight_node_1 + distances_node_1[i];

i++;
}
E_z_node_1 = E_z_node_1/Weight_node_1;
i = 0;
for(it_elements = elements_node_2->begin(); it_elements != elements_node_2->end();
it_elements++){
E_z_node_2 = E_z_node_2 + it_elements->second->getE_z_old_1()*distances_node_2[i];
//
i++;
}

Weight_node_2 = Weight_node_2 + distances_node_2[i];

E_z_node_2 = E_z_node_2/Weight_node_2;
i = 0;
for(it_elements = elements_node_3->begin(); it_elements != elements_node_3->end();
it_elements++){
E_z_node_3 = E_z_node_3 + it_elements->second->getE_z_old_1()*distances_node_3[i];
//

Weight_node_3 = Weight_node_3 + distances_node_3[i];

i++;
}
E_z_node_3 = E_z_node_3/Weight_node_3;
}
void Element::computeH_nodePredicted(){
H_x_node_1 = 0;
H_y_node_1 = 0;
H_x_node_2 = 0;
H_y_node_2 = 0;
H_x_node_3 = 0;
H_y_node_3 = 0;
map<int,Element*>::iterator it_elements;
int i= 0;
for(it_elements = elements_node_1->begin(); it_elements != elements_node_1->end();
it_elements++){
H_x_node_1 = H_x_node_1 + it_elements->second->getH_x_old_1()*distances_node_1[i];
H_y_node_1 = H_y_node_1 + it_elements->second->getH_y_old_1()*distances_node_1[i];
Weight_node_1 = Weight_node_1 + distances_node_1[i];
i++;
}
H_x_node_1 = H_x_node_1/Weight_node_1;
H_y_node_1 = H_y_node_1/Weight_node_1;

i = 0;
for(it_elements = elements_node_2->begin(); it_elements != elements_node_2->end();
it_elements++){
H_x_node_2 = H_x_node_2 + it_elements->second->getH_x_old_1()*distances_node_2[i];
H_y_node_2 = H_y_node_2 + it_elements->second->getH_y_old_1()*distances_node_2[i];
Weight_node_2 = Weight_node_2 + distances_node_2[i];
i++;
}
H_x_node_2 = H_x_node_2/Weight_node_2;
H_y_node_2 = H_y_node_2/Weight_node_2;
i = 0;
for(it_elements = elements_node_3->begin(); it_elements != elements_node_3->end();
it_elements++){
H_x_node_3 = H_x_node_3 + it_elements->second->getH_x_old_1()*distances_node_3[i];
H_y_node_3 = H_y_node_3 + it_elements->second->getH_y_old_1()*distances_node_3[i];
Weight_node_3 = Weight_node_3 + distances_node_3[i];
i++;
}
H_x_node_3 = H_x_node_3/Weight_node_3;
H_y_node_3 = H_y_node_3/Weight_node_3;
}
void Element::computeMiddleFieldE(){
if((this->getNode1()!=this->getEdge1()->getNode1())||(this->getNode1()!=this>getEdge1()->getNode2())){
E_z_middle_1 = E_z_old-(E_z_node_1-E_z_old)/2;
E_z_middle_1 = E_z_old + 1/3*(1/2*(E_z_node_2+E_z_node_3)-E_z_node_1);
}
if((this->getNode1()!=this->getEdge2()->getNode1())||(this->getNode1()!=this>getEdge2()->getNode2())){

E_z_middle_2 = E_z_old-(E_z_node_1-E_z_old)/2;
E_z_middle_2 = E_z_old + 1/3*(1/2*(E_z_node_2+E_z_node_3)-E_z_node_1);
}
if((this->getNode1()!=this->getEdge3()->getNode1())||(this->getNode1()!=this>getEdge3()->getNode2())){
E_z_middle_3 = E_z_old-(E_z_node_1-E_z_old)/2;
E_z_middle_3 = E_z_old + 1/3*(1/2*(E_z_node_2+E_z_node_3)-E_z_node_1);
}
if((this->getNode2()!=this->getEdge1()->getNode1())||(this->getNode2()!=this>getEdge1()->getNode2())){
E_z_middle_1 = E_z_old-(E_z_node_2-E_z_old)/2;
E_z_middle_1 = E_z_old + 1/3*(1/2*(E_z_node_1+E_z_node_3)-E_z_node_2);
}
if((this->getNode2()!=this->getEdge2()->getNode1())||(this->getNode2()!=this>getEdge2()->getNode2())){
E_z_middle_2 = E_z_old-(E_z_node_2-E_z_old)/2;
E_z_middle_2 = E_z_old + 1/3*(1/2*(E_z_node_1+E_z_node_3)-E_z_node_2);
}
if((this->getNode2()!=this->getEdge3()->getNode1())||(this->getNode2()!=this>getEdge3()->getNode2())){
E_z_middle_3 = E_z_old-(E_z_node_2-E_z_old)/2;
E_z_middle_3 = E_z_old + 1/3*(1/2*(E_z_node_1+E_z_node_3)-E_z_node_2);
}
if((this->getNode3()!=this->getEdge1()->getNode1())||(this->getNode3()!=this>getEdge1()->getNode2())){
E_z_middle_1 = E_z_old-(E_z_node_3-E_z_old)/2;
E_z_middle_1 = E_z_old + 1/3*(1/2*(E_z_node_1+E_z_node_2)-E_z_node_3);
}
if((this->getNode3()!=this->getEdge2()->getNode1())||(this->getNode3()!=this-

>getEdge2()->getNode2())){
E_z_middle_2 = E_z_old-(E_z_node_3-E_z_old)/2;
E_z_middle_2 = E_z_old + 1/3*(1/2*(E_z_node_1+E_z_node_2)-E_z_node_3);
}
if((this->getNode3()!=this->getEdge3()->getNode1())||(this->getNode3()!=this>getEdge3()->getNode2())){
E_z_middle_3 = E_z_old-(E_z_node_3-E_z_old)/2;
E_z_middle_3 = E_z_old + 1/3*(1/2*(E_z_node_1+E_z_node_2)-E_z_node_3);
}
}
void Element::computeMiddleFieldH(){
if((this->getNode1()!=this->getEdge1()->getNode1())||(this->getNode1()!=this>getEdge1()->getNode2())){
H_x_middle_1 = H_x_old-(H_x_node_1-H_x_old)/2;
H_y_middle_1 = H_y_old-(H_y_node_1-H_y_old)/2;
H_x_middle_1 = H_x_old + 1/3*(1/2*(H_x_node_2+H_x_node_3)-H_x_node_1);
H_y_middle_1 = H_y_old + 1/3*(1/2*(H_y_node_2+H_y_node_3)-H_y_node_1);
}
if((this->getNode1()!=this->getEdge2()->getNode1())||(this->getNode1()!=this>getEdge2()->getNode2())){
H_x_middle_2 = H_x_old-(H_x_node_1-H_x_old)/2;
H_y_middle_2 = H_y_old-(H_y_node_1-H_y_old)/2;
H_x_middle_2 = H_x_old + 1/3*(1/2*(H_x_node_2+H_x_node_3)-H_x_node_1);
H_y_middle_2 = H_y_old + 1/3*(1/2*(H_y_node_2+H_y_node_3)-H_y_node_1);
}
if((this->getNode1()!=this->getEdge3()->getNode1())||(this->getNode1()!=this>getEdge3()->getNode2())){
H_x_middle_3 = H_x_old-(H_x_node_1-H_x_old)/2;
H_y_middle_3 = H_y_old-(H_y_node_1-H_y_old)/2;

H_x_middle_3 = H_x_old + 1/3*(1/2*(H_x_node_2+H_x_node_3)-H_x_node_1);

H_y_middle_3 = H_y_old + 1/3*(1/2*(H_y_node_2+H_y_node_3)-H_y_node_1);
}
if((this->getNode2()!=this->getEdge1()->getNode1())||(this->getNode2()!=this>getEdge1()->getNode2())){
H_x_middle_1 = H_x_old-(H_x_node_2-H_x_old)/2;
H_y_middle_1 = H_y_old-(H_y_node_2-H_y_old)/2;
H_x_middle_1 = H_x_old + 1/3*(1/2*(H_x_node_1+H_x_node_3)-H_x_node_2);
H_y_middle_1 = H_y_old + 1/3*(1/2*(H_y_node_1+H_y_node_3)-H_y_node_2);
}
if((this->getNode2()!=this->getEdge2()->getNode1())||(this->getNode2()!=this>getEdge2()->getNode2())){
H_x_middle_2 = H_x_old-(H_x_node_2-H_x_old)/2.;
H_y_middle_2 = H_y_old-(H_y_node_2-H_y_old)/2.;
H_x_middle_2 = H_x_old + 1./3.*(1./2.*(H_x_node_1+H_x_node_3)-H_x_node_2);
H_y_middle_2 = H_y_old + 1./3.*(1./2.*(H_y_node_1+H_y_node_3)-H_y_node_2);
}
if((this->getNode2()!=this->getEdge3()->getNode1())||(this->getNode2()!=this>getEdge3()->getNode2())){
H_x_middle_3 = H_x_old-(H_x_node_2-H_x_old)/2.;
H_y_middle_3 = H_y_old-(H_y_node_2-H_y_old)/2.;
H_x_middle_3 = H_x_old + 1./3.*(1./2.*(H_x_node_1+H_x_node_3)-H_x_node_2);
H_y_middle_3 = H_y_old + 1./3.*(1./2.*(H_y_node_1+H_y_node_3)-H_y_node_2);
}
if((this->getNode3()!=this->getEdge1()->getNode1())||(this->getNode3()!=this>getEdge1()->getNode2())){
H_x_middle_1 = H_x_old-(H_x_node_3-H_x_old)/2.;
H_y_middle_1 = H_y_old-(H_y_node_3-H_y_old)/2.;
H_x_middle_1 = H_x_old + 1./3.*(1./2.*(H_x_node_1+H_x_node_2)-H_x_node_3);

H_y_middle_1 = H_y_old + 1./3.*(1./2.*(H_y_node_1+H_y_node_2)-H_y_node_3);

}
if((this->getNode3()!=this->getEdge2()->getNode1())||(this->getNode3()!=this>getEdge2()->getNode2())){
H_x_middle_2 = H_x_old-(H_x_node_3-H_x_old)/2.;
H_y_middle_2 = H_y_old-(H_y_node_3-H_y_old)/2.;
H_x_middle_2 = H_x_old + 1./3.*(1./2.*(H_x_node_1+H_x_node_2)-H_x_node_3);
H_y_middle_2 = H_y_old + 1./3.*(1./2.*(H_y_node_1+H_y_node_2)-H_y_node_3);
}
if((this->getNode3()!=this->getEdge3()->getNode1())||(this->getNode3()!=this>getEdge3()->getNode2())){
H_x_middle_3 = H_x_old-(H_x_node_3-H_x_old)/2.;
H_y_middle_3 = H_y_old-(H_y_node_3-H_y_old)/2.;
H_x_middle_3 = H_x_old + 1./3.*(1./2.*(H_x_node_1+H_x_node_2)-H_x_node_3);
H_y_middle_3 = H_y_old + 1./3.*(1./2.*(H_y_node_1+H_y_node_2)-H_y_node_3);
}
}
void Element::computePredictedMiddleFieldE(){
if((this->getNode1()!=this->getEdge1()->getNode1())||(this->getNode1()!=this>getEdge1()->getNode2())){
E_z_middle_1 = E_z_old_1 + 1./3.*(1./2.*(E_z_node_2+E_z_node_3)-E_z_node_1);
}
if((this->getNode1()!=this->getEdge2()->getNode1())||(this->getNode1()!=this>getEdge2()->getNode2())){
E_z_middle_2 = E_z_old_1 + 1./3.*(1./2.*(E_z_node_2+E_z_node_3)-E_z_node_1);
}
if((this->getNode1()!=this->getEdge3()->getNode1())||(this->getNode1()!=this>getEdge3()->getNode2())){
E_z_middle_3 = E_z_old_1 + 1./3.*(1./2.*(E_z_node_2+E_z_node_3)-E_z_node_1);

}
if((this->getNode2()!=this->getEdge1()->getNode1())||(this->getNode2()!=this>getEdge1()->getNode2())){
E_z_middle_1 = E_z_old_1 + 1./3.*(1./2.*(E_z_node_1+E_z_node_3)-E_z_node_2);
}
if((this->getNode2()!=this->getEdge2()->getNode1())||(this->getNode2()!=this>getEdge2()->getNode2())){
E_z_middle_2 = E_z_old_1 + 1./3.*(1./2.*(E_z_node_1+E_z_node_3)-E_z_node_2);
}
if((this->getNode2()!=this->getEdge3()->getNode1())||(this->getNode2()!=this>getEdge3()->getNode2())){
E_z_middle_3 = E_z_old_1 + 1./3.*(1./2.*(E_z_node_1+E_z_node_3)-E_z_node_2);
}
if((this->getNode3()!=this->getEdge1()->getNode1())||(this->getNode3()!=this>getEdge1()->getNode2())){
E_z_middle_1 = E_z_old_1 + 1./3.*(1./2.*(E_z_node_1+E_z_node_2)-E_z_node_3);
}
if((this->getNode3()!=this->getEdge2()->getNode1())||(this->getNode3()!=this>getEdge2()->getNode2())){
E_z_middle_2 = E_z_old_1 + 1./3.*(1./2.*(E_z_node_1+E_z_node_2)-E_z_node_3);
}
if((this->getNode3()!=this->getEdge3()->getNode1())||(this->getNode3()!=this>getEdge3()->getNode2())){
E_z_middle_3 = E_z_old_1 + 1./3.*(1./2.*(E_z_node_1+E_z_node_2)-E_z_node_3);
}
}
void Element::computePredictedMiddleFieldH(){
if((this->getNode1()!=this->getEdge1()->getNode1())||(this->getNode1()!=this>getEdge1()->getNode2())){
H_x_middle_1 = H_x_old_1 + 1./3.*(1./2.*(H_x_node_2+H_x_node_3)-H_x_node_1);

H_y_middle_1 = H_y_old_1 + 1./3.*(1./2.*(H_y_node_2+H_y_node_3)-H_y_node_1);

}
if((this->getNode1()!=this->getEdge2()->getNode1())||(this->getNode1()!=this>getEdge2()->getNode2())){
H_x_middle_2 = H_x_old_1 + 1./3.*(1./2.*(H_x_node_2+H_x_node_3)-H_x_node_1);
H_y_middle_2 = H_y_old_1 + 1./3.*(1./2.*(H_y_node_2+H_y_node_3)-H_y_node_1);
}
if((this->getNode1()!=this->getEdge3()->getNode1())||(this->getNode1()!=this>getEdge3()->getNode2())){
H_x_middle_3 = H_x_old_1 + 1./3.*(1./2.*(H_x_node_2+H_x_node_3)-H_x_node_1);
H_y_middle_3 = H_y_old_1 + 1./3.*(1./2.*(H_y_node_2+H_y_node_3)-H_y_node_1);
}
if((this->getNode2()!=this->getEdge1()->getNode1())||(this->getNode2()!=this>getEdge1()->getNode2())){
H_x_middle_1 = H_x_old_1 + 1./3.*(1./2.*(H_x_node_1+H_x_node_3)-H_x_node_2);
H_y_middle_1 = H_y_old_1 + 1./3.*(1./2.*(H_y_node_1+H_y_node_3)-H_y_node_2);
}
if((this->getNode2()!=this->getEdge2()->getNode1())||(this->getNode2()!=this>getEdge2()->getNode2())){
H_x_middle_2 = H_x_old_1 + 1./3.*(1./2.*(H_x_node_1+H_x_node_3)-H_x_node_2);
H_y_middle_2 = H_y_old_1 + 1./3.*(1./2.*(H_y_node_1+H_y_node_3)-H_y_node_2);
}
if((this->getNode2()!=this->getEdge3()->getNode1())||(this->getNode2()!=this>getEdge3()->getNode2())){
H_x_middle_3 = H_x_old_1 + 1./3.*(1./2.*(H_x_node_1+H_x_node_3)-H_x_node_2);
H_y_middle_3 = H_y_old_1 + 1./3.*(1./2.*(H_y_node_1+H_y_node_3)-H_y_node_2);
}
if((this->getNode3()!=this->getEdge1()->getNode1())||(this->getNode3()!=this>getEdge1()->getNode2())){

H_x_middle_1 = H_x_old_1 + 1./3.*(1./2.*(H_x_node_1+H_x_node_2)-H_x_node_3);

H_y_middle_1 = H_y_old_1 + 1./3.*(1./2.*(H_y_node_1+H_y_node_2)-H_y_node_3);
}
if((this->getNode3()!=this->getEdge2()->getNode1())||(this->getNode3()!=this>getEdge2()->getNode2())){
H_x_middle_2 = H_x_old_1 + 1/3*(1/2*(H_x_node_1+H_x_node_2)-H_x_node_3);
H_y_middle_2 = H_y_old_1 + 1/3*(1/2*(H_y_node_1+H_y_node_2)-H_y_node_3);
}
if((this->getNode3()!=this->getEdge3()->getNode1())||(this->getNode3()!=this>getEdge3()->getNode2())){
H_x_middle_3 = H_x_old_1 + 1/3*(1/2*(H_x_node_1+H_x_node_2)-H_x_node_3);
H_y_middle_3 = H_y_old_1 + 1/3*(1/2*(H_y_node_1+H_y_node_2)-H_y_node_3);
}
}
void Element::setUpPredictedFieldH(){
if(spatial_order == 2){
double gradient;
if(this->getEdge1()->isBoundary() == true){
if(1 == boundaryFlag){
H_x_h = H_x_old_1;
H_y_h = H_y_old_1;
}else{
H_x_h = 0.;
H_y_h = 0.;
}
}else{
if(this->getEdge1()->getElement1()->getElementID()!=this->getElementID()){
H_x_h = (this->getEdge1()->getElement1()->getH_x_pred());

H_y_h = (this->getEdge1()->getElement1()->getH_y_pred());
}else{
H_x_h = (this->getEdge1()->getElement2()->getH_x_pred());
H_y_h = (this->getEdge1()->getElement2()->getH_y_pred());
}
}
if(this->getEdge2()->isBoundary() == true){
if(1 == boundaryFlag){
H_x_j = H_x_old_1;
H_y_j = H_y_old_1;
}else{
H_x_j = 0.;
H_y_j = 0.;
}
}else{
if(this->getEdge2()->getElement1()->getElementID()!=this->getElementID()){
H_x_j = (this->getEdge2()->getElement1()->getH_x_pred());
H_y_j = (this->getEdge2()->getElement1()->getH_y_pred());
}else{
H_x_j = (this->getEdge2()->getElement2()->getH_x_pred());
H_y_j = (this->getEdge2()->getElement2()->getH_y_pred());
}
}
if(this->getEdge3()->isBoundary() == true){
if(1 == boundaryFlag){
H_x_k = H_x_old_1;

H_y_k = H_y_old_1;
}else{
H_x_k = 0.;
H_y_k = 0.;
}
}else{
if(this->getEdge3()->getElement1()->getElementID()!=this->getElementID()){
H_x_k = (this->getEdge3()->getElement1()->getH_x_pred());
H_y_k = (this->getEdge3()->getElement1()->getH_y_pred());
}else{
H_x_k = (this->getEdge3()->getElement2()->getH_x_pred());
H_y_k = (this->getEdge3()->getElement2()->getH_y_pred());
}
}
H_x_middle_h = (H_x_old_1*dl_i_h + H_x_h*dl_h_i)/(dl_i_h + dl_h_i);
H_x_middle_j = (H_x_old_1*dl_i_j + H_x_j*dl_j_i)/(dl_i_j + dl_j_i);
H_x_middle_k = (H_x_old_1*dl_i_k + H_x_k*dl_k_i)/(dl_i_k + dl_k_i);
double gradient_dl_h =
H_x_middle_h*(N_i_h_x*dl_i_h_x + N_i_h_y*dl_i_h_y)*edge1->getLength() +
H_x_middle_j*(N_i_j_x*dl_i_h_x + N_i_j_y*dl_i_h_y)*edge2->getLength() +
H_x_middle_k*(N_i_k_x*dl_i_h_x + N_i_k_y*dl_i_h_y)*edge3->getLength();
gradient_dl_h = gradient_dl_h/getArea();
double gradient_dl_j =
H_x_middle_h*(N_i_h_x*dl_i_j_x + N_i_h_y*dl_i_j_y)*edge1->getLength() +
H_x_middle_j*(N_i_j_x*dl_i_j_x + N_i_j_y*dl_i_j_y)*edge2->getLength() +
H_x_middle_k*(N_i_k_x*dl_i_j_x + N_i_k_y*dl_i_j_y)*edge3->getLength();

gradient_dl_j = gradient_dl_j/getArea();
double gradient_dl_k =
H_x_middle_h*(N_i_h_x*dl_i_k_x + N_i_h_y*dl_i_k_y)*edge1->getLength() +
H_x_middle_j*(N_i_j_x*dl_i_k_x + N_i_j_y*dl_i_k_y)*edge2->getLength() +
H_x_middle_k*(N_i_k_x*dl_i_k_x + N_i_k_y*dl_i_k_y)*edge3->getLength();
gradient_dl_k = gradient_dl_k/getArea();
H_x_middle_1 = H_x_old_1 + gradient_dl_h;
H_x_middle_2 = H_x_old_1 + gradient_dl_j;
H_x_middle_3 = H_x_old_1 + gradient_dl_k;
// Hy
H_y_middle_h = (H_y_old_1*dl_i_h + H_y_h*dl_h_i)/(dl_i_h + dl_h_i);
H_y_middle_j = (H_y_old_1*dl_i_j + H_y_j*dl_j_i)/(dl_i_j + dl_j_i);
H_y_middle_k = (H_y_old_1*dl_i_k + H_y_k*dl_k_i)/(dl_i_k + dl_k_i);
gradient_dl_h =
H_y_middle_h*(N_i_h_x*dl_i_h_x + N_i_h_y*dl_i_h_y)*edge1->getLength() +
H_y_middle_j*(N_i_j_x*dl_i_h_x + N_i_j_y*dl_i_h_y)*edge2->getLength() +
H_y_middle_k*(N_i_k_x*dl_i_h_x + N_i_k_y*dl_i_h_y)*edge3->getLength();
gradient_dl_h = gradient_dl_h/getArea();
gradient_dl_j =
H_y_middle_h*(N_i_h_x*dl_i_j_x + N_i_h_y*dl_i_j_y)*edge1->getLength() +
H_y_middle_j*(N_i_j_x*dl_i_j_x + N_i_j_y*dl_i_j_y)*edge2->getLength() +
H_y_middle_k*(N_i_k_x*dl_i_j_x + N_i_k_y*dl_i_j_y)*edge3->getLength();
gradient_dl_j = gradient_dl_j/getArea();
gradient_dl_k =
H_y_middle_h*(N_i_h_x*dl_i_k_x + N_i_h_y*dl_i_k_y)*edge1->getLength() +
H_y_middle_j*(N_i_j_x*dl_i_k_x + N_i_j_y*dl_i_k_y)*edge2->getLength() +
H_y_middle_k*(N_i_k_x*dl_i_k_x + N_i_k_y*dl_i_k_y)*edge3->getLength();

gradient_dl_k = gradient_dl_k/getArea();
H_y_middle_1 = H_y_old_1 + gradient_dl_h;
H_y_middle_2 = H_y_old_1 + gradient_dl_j;
H_y_middle_3 = H_y_old_1 + gradient_dl_k;
}
if (spatial_order == 1){
if(this->getEdge1()->isBoundary() == true){
H_x_h = 0.;
H_y_h = 0.;
}else{
if(this->getEdge1()->getElement1()->getElementID()!=this->getElementID()){
H_x_h = (this->getEdge1()->getElement1()->getH_x_pred());
H_y_h = (this->getEdge1()->getElement1()->getH_y_pred());
}
else{
H_x_h = (this->getEdge1()->getElement2()->getH_x_pred());
H_y_h = (this->getEdge1()->getElement2()->getH_y_pred());
}
}
if(this->getEdge2()->isBoundary() == true){
H_x_j = 0.;
H_y_j = 0.;
}else{
if(this->getEdge2()->getElement1()->getElementID()!=this->getElementID()){
H_x_j = (this->getEdge2()->getElement1()->getH_x_pred());
H_y_j = (this->getEdge2()->getElement1()->getH_y_pred());
}else{

H_x_j = (this->getEdge2()->getElement2()->getH_x_pred());
H_y_j = (this->getEdge2()->getElement2()->getH_y_pred());
}
}
if(this->getEdge3()->isBoundary() == true){
H_x_k = 0.;
H_y_k = 0.;
}else{
if(this->getEdge3()->getElement1()->getElementID()!=this->getElementID()){
H_x_k = (this->getEdge3()->getElement1()->getH_x_pred());
H_y_k = (this->getEdge3()->getElement1()->getH_y_pred());
}else{
H_x_k = (this->getEdge3()->getElement2()->getH_x_pred());
H_y_k = (this->getEdge3()->getElement2()->getH_y_pred());
}
}
}
if(spatial_order == 3){
if(this->getEdge1()->isBoundary() == true){
H_x_h = H_x_middle_1;
H_y_h = H_y_middle_1;
}else{
if(this->getEdge1()->getElement1()->getElementID()!=this->getElementID()){
if(this->getEdge1()==this->getEdge1()->getElement1()->getEdge1()){
H_x_h = (this->getEdge1()->getElement1()->getH_x_middle_1());
H_y_h = (this->getEdge1()->getElement1()->getH_y_middle_1());
}

if(this->getEdge1()==this->getEdge1()->getElement1()->getEdge2()){
H_x_h = (this->getEdge1()->getElement1()->getH_x_middle_2());
H_y_h = (this->getEdge1()->getElement1()->getH_y_middle_2());
}
if(this->getEdge1()==this->getEdge1()->getElement1()->getEdge3()){
H_x_h = (this->getEdge1()->getElement1()->getH_x_middle_3());
H_y_h = (this->getEdge1()->getElement1()->getH_y_middle_3());
}
}else{
if(this->getEdge1()==this->getEdge1()->getElement2()->getEdge1()){
H_x_h = (this->getEdge1()->getElement2()->getH_x_middle_1());
H_y_h = (this->getEdge1()->getElement2()->getH_y_middle_1());
}
if(this->getEdge1()==this->getEdge1()->getElement2()->getEdge2()){
H_x_h = (this->getEdge1()->getElement2()->getH_x_middle_2());
H_y_h = (this->getEdge1()->getElement2()->getH_y_middle_2());
}
if(this->getEdge1()==this->getEdge1()->getElement2()->getEdge3()){
H_x_h = (this->getEdge1()->getElement2()->getH_x_middle_3());
H_y_h = (this->getEdge1()->getElement2()->getH_y_middle_3());
}
}
}
if(this->getEdge2()->isBoundary() == true){
H_x_j = H_x_middle_2;
H_y_j = H_y_middle_2;
}else{

if(this->getEdge2()->getElement1()->getElementID()!=this->getElementID()){
if(this->getEdge2()==this->getEdge2()->getElement1()->getEdge1()){
H_x_j = (this->getEdge2()->getElement1()->getH_x_middle_1());
H_y_j = (this->getEdge2()->getElement1()->getH_y_middle_1());
}
if(this->getEdge2()==this->getEdge2()->getElement1()->getEdge2()){
H_x_j = (this->getEdge2()->getElement1()->getH_x_middle_2());
H_y_j = (this->getEdge2()->getElement1()->getH_y_middle_2());
}
if(this->getEdge2()==this->getEdge2()->getElement1()->getEdge3()){
H_x_j = (this->getEdge2()->getElement1()->getH_x_middle_3());
H_y_j = (this->getEdge2()->getElement1()->getH_y_middle_3());
}
}else{
if(this->getEdge2()==this->getEdge2()->getElement2()->getEdge1()){
H_x_j = (this->getEdge2()->getElement2()->getH_x_middle_1());
H_y_j = (this->getEdge2()->getElement2()->getH_y_middle_1());
}
if(this->getEdge2()==this->getEdge2()->getElement2()->getEdge2()){
H_x_j = (this->getEdge2()->getElement2()->getH_x_middle_2());
H_y_j = (this->getEdge2()->getElement2()->getH_y_middle_2());
}
if(this->getEdge2()==this->getEdge2()->getElement2()->getEdge3()){
H_x_j = (this->getEdge2()->getElement2()->getH_x_middle_3());
H_y_j = (this->getEdge2()->getElement2()->getH_y_middle_3());
}
}

}
if(this->getEdge3()->isBoundary() == true){
H_x_k = H_x_middle_3;
H_y_k = H_y_middle_3;
}else{
if(this->getEdge3()->getElement1()->getElementID()!=this->getElementID()){
if(this->getEdge3()==this->getEdge3()->getElement1()->getEdge1()){
H_x_k = (this->getEdge3()->getElement1()->getH_x_middle_1());
H_y_k = (this->getEdge3()->getElement1()->getH_y_middle_1());
}
if(this->getEdge3()==this->getEdge3()->getElement1()->getEdge2()){
H_x_k = (this->getEdge3()->getElement1()->getH_x_middle_2());
H_y_k = (this->getEdge3()->getElement1()->getH_y_middle_2());
}
if(this->getEdge3()==this->getEdge3()->getElement1()->getEdge3()){
H_x_k = (this->getEdge3()->getElement1()->getH_x_middle_3());
H_y_k = (this->getEdge3()->getElement1()->getH_y_middle_3());
}
}
else{
if(this->getEdge3()==this->getEdge3()->getElement2()->getEdge1()){
H_x_k = (this->getEdge3()->getElement2()->getH_x_middle_1());
H_y_k = (this->getEdge3()->getElement2()->getH_y_middle_1());
}
if(this->getEdge3()==this->getEdge3()->getElement1()->getEdge2()){
H_x_k = (this->getEdge3()->getElement2()->getH_x_middle_2());
H_y_k = (this->getEdge3()->getElement2()->getH_y_middle_2());

}
if(this->getEdge3()==this->getEdge3()->getElement1()->getEdge3()){
H_x_k = (this->getEdge3()->getElement2()->getH_x_middle_3());
H_y_k = (this->getEdge3()->getElement2()->getH_y_middle_3());
}
}
}
}
//
cout<<"elemento "<<this->getElementID()<<" E_z_h = "<<E_z_h<<" E_z_j =
"<<E_z_j<<" E_z_k = "<<E_z_k<<endl;
}
void Element::setUpPredictedFieldE(){
if (spatial_order == 2){
double gradient;
if(this->getEdge1()->isBoundary() == true){
if(1 == boundaryFlag){
E_z_h = E_z_old_1;
}else{
E_z_h = 0.;
}
}else{
if(this->getEdge1()->getElement1()->getElementID()!=this->getElementID()){
E_z_h = (this->getEdge1()->getElement1()->getE_z_pred());
}else{
E_z_h = (this->getEdge1()->getElement2()->getE_z_pred());
}
}

if(this->getEdge2()->isBoundary() == true){
if(1 == boundaryFlag){
E_z_j = E_z_old_1;
}else{
E_z_j = 0.;
}
}else{
if(this->getEdge2()->getElement1()->getElementID()!=this->getElementID()){
E_z_j = (this->getEdge2()->getElement1()->getE_z_pred());
}else{
E_z_j = (this->getEdge2()->getElement2()->getE_z_pred());
}
}
if(this->getEdge3()->isBoundary() == true){
if(1 == boundaryFlag){
E_z_k = E_z_old_1;
}else{
E_z_k = 0.;
}
}else{
if(this->getEdge3()->getElement1()->getElementID()!=this->getElementID()){
E_z_k = (this->getEdge3()->getElement1()->getE_z_pred());
}else{
E_z_k = (this->getEdge3()->getElement2()->getE_z_pred());
}
}
E_z_middle_h = (E_z_old_1*dl_i_h + E_z_h*dl_h_i)/(dl_i_h + dl_h_i);

E_z_middle_j = (E_z_old_1*dl_i_j + E_z_j*dl_j_i)/(dl_i_j + dl_j_i);

E_z_middle_k = (E_z_old_1*dl_i_k + E_z_k*dl_k_i)/(dl_i_k + dl_k_i);
double gradient_dl_h =
E_z_middle_h*(N_i_h_x*dl_i_h_x + N_i_h_y*dl_i_h_y)*edge1->getLength() +
E_z_middle_j*(N_i_j_x*dl_i_h_x + N_i_j_y*dl_i_h_y)*edge2->getLength() +
E_z_middle_k*(N_i_k_x*dl_i_h_x + N_i_k_y*dl_i_h_y)*edge3->getLength();
gradient_dl_h = gradient_dl_h/getArea();
double gradient_dl_j =
E_z_middle_h*(N_i_h_x*dl_i_j_x + N_i_h_y*dl_i_j_y)*edge1->getLength() +
E_z_middle_j*(N_i_j_x*dl_i_j_x + N_i_j_y*dl_i_j_y)*edge2->getLength() +
E_z_middle_k*(N_i_k_x*dl_i_j_x + N_i_k_y*dl_i_j_y)*edge3->getLength();
gradient_dl_j = gradient_dl_j/getArea();
double gradient_dl_k =
E_z_middle_h*(N_i_h_x*dl_i_k_x + N_i_h_y*dl_i_k_y)*edge1->getLength() +
E_z_middle_j*(N_i_j_x*dl_i_k_x + N_i_j_y*dl_i_k_y)*edge2->getLength() +
E_z_middle_k*(N_i_k_x*dl_i_k_x + N_i_k_y*dl_i_k_y)*edge3->getLength();
gradient_dl_k = gradient_dl_k/getArea();
E_z_middle_1 = E_z_old_1 + gradient_dl_h;
E_z_middle_2 = E_z_old_1 + gradient_dl_j;
E_z_middle_3 = E_z_old_1 + gradient_dl_k;
}
if (spatial_order == 1){
if(this->getEdge1()->isBoundary() == true){
if(spatial_order == 1){
E_z_h = 0.0;
}else{
E_z_pred = 0.0;

}
}
else{
if(this->getEdge1()->getElement1()->getElementID()!=this->getElementID()){
E_z_h = (this->getEdge1()->getElement1()->getE_z_pred());
}
else{
E_z_h = (this->getEdge1()->getElement2()->getE_z_pred());
}
}
if(this->getEdge2()->isBoundary() == true){
if(spatial_order == 1){
E_z_j = 0.0;
}else{
E_z_pred = 0.0;
}
}
else{
if(this->getEdge2()->getElement1()->getElementID()!=this->getElementID()){
E_z_j = (this->getEdge2()->getElement1()->getE_z_pred());
}
else{
E_z_j = (this->getEdge2()->getElement2()->getE_z_pred());
}
}
if(this->getEdge3()->isBoundary() == true){
if(spatial_order == 1){

E_z_k = 0.;
}else{
E_z_pred = 0.;
}
}
else{
if(this->getEdge3()->getElement1()->getElementID()!=this->getElementID()){
E_z_k = (this->getEdge3()->getElement1()->getE_z_pred());
}
else{
E_z_k = (this->getEdge3()->getElement2()->getE_z_pred());
}
}
}
if(spatial_order == 3){
if(this->getEdge1()->isBoundary() == true){
E_z_h = 0.0;
}
else{
if(this->getEdge1()->getElement1()->getElementID()!=this->getElementID()){
if(this->getEdge1()==this->getEdge1()->getElement1()->getEdge1()){
E_z_h = (this->getEdge1()->getElement1()->getE_z_middle_1());
}
if(this->getEdge1()==this->getEdge1()->getElement1()->getEdge2()){
E_z_h = (this->getEdge1()->getElement1()->getE_z_middle_2());
}
if(this->getEdge1()==this->getEdge1()->getElement1()->getEdge3()){

E_z_h = (this->getEdge1()->getElement1()->getE_z_middle_3());
}
}
else{
if(this->getEdge1()==this->getEdge1()->getElement2()->getEdge1()){
E_z_h = (this->getEdge1()->getElement2()->getE_z_middle_1());
}
if(this->getEdge1()==this->getEdge1()->getElement2()->getEdge2()){
E_z_h = (this->getEdge1()->getElement2()->getE_z_middle_2());
}
if(this->getEdge1()==this->getEdge1()->getElement2()->getEdge3()){
E_z_h = (this->getEdge1()->getElement2()->getE_z_middle_3());
}
}
}
if(this->getEdge2()->isBoundary() == true){
E_z_j = 0.0;
}
else{
if(this->getEdge2()->getElement1()->getElementID()!=this->getElementID()){
if(this->getEdge2()==this->getEdge2()->getElement1()->getEdge1()){
E_z_j = (this->getEdge2()->getElement1()->getE_z_middle_1());
}
if(this->getEdge2()==this->getEdge2()->getElement1()->getEdge2()){
E_z_j = (this->getEdge2()->getElement1()->getE_z_middle_2());
}
if(this->getEdge2()==this->getEdge2()->getElement1()->getEdge3()){

E_z_j = (this->getEdge2()->getElement1()->getE_z_middle_3());
}
}
else{
if(this->getEdge2()==this->getEdge2()->getElement2()->getEdge1()){
E_z_j = (this->getEdge2()->getElement2()->getE_z_middle_1());
}
if(this->getEdge2()==this->getEdge2()->getElement2()->getEdge2()){
E_z_j = (this->getEdge2()->getElement2()->getE_z_middle_2());
}
if(this->getEdge2()==this->getEdge2()->getElement2()->getEdge3()){
E_z_j = (this->getEdge2()->getElement2()->getE_z_middle_3());
}
}
}
if(this->getEdge3()->isBoundary() == true){
E_z_k = 0.0;
}
else{
if(this->getEdge3()->getElement1()->getElementID()!=this->getElementID()){
if(this->getEdge3()==this->getEdge3()->getElement1()->getEdge1()){
E_z_k = (this->getEdge3()->getElement1()->getE_z_middle_1());
}
if(this->getEdge3()==this->getEdge3()->getElement1()->getEdge2()){
E_z_k = (this->getEdge3()->getElement1()->getE_z_middle_2());
}
if(this->getEdge3()==this->getEdge3()->getElement1()->getEdge3()){

E_z_k = (this->getEdge3()->getElement1()->getE_z_middle_3());
}
}
else{
if(this->getEdge3()==this->getEdge3()->getElement2()->getEdge1()){
E_z_k = (this->getEdge3()->getElement2()->getE_z_middle_1());
}
if(this->getEdge3()==this->getEdge3()->getElement2()->getEdge2()){
E_z_k = (this->getEdge3()->getElement2()->getE_z_middle_2());
}
if(this->getEdge3()==this->getEdge3()->getElement2()->getEdge3()){
E_z_k = (this->getEdge3()->getElement2()->getE_z_middle_3());
}
}
}
}
//
cout<<"elemento "<<this->getElementID()<<" E_z_h = "<<E_z_h<<" E_z_j =
"<<E_z_j<<" E_z_k = "<<E_z_k<<endl;
}
void Element::setUpMiddles(){
Element *elem;
int myID;
if(this->getEdge1()->isBoundary() == true){
E_z_middle_h = 0.;
H_x_middle_h = 0.;
H_y_middle_h = 0.;
}else{

myID = this->getEdge1()->getEdgeID();
if(this->getEdge1()->getElement1()->getElementID() != this->getElementID()){
elem = this->getEdge1()->getElement1();
}else{
elem = this->getEdge1()->getElement2();
}
if(myID == elem->getEdge1()->getEdgeID()){
E_z_middle_h = elem->getE_z_middle_1();
H_x_middle_h = elem->getH_x_middle_1();
H_y_middle_h = elem->getH_y_middle_1();
}else if(myID == elem->getEdge2()->getEdgeID()){
E_z_middle_h = elem->getE_z_middle_2();
H_x_middle_h = elem->getH_x_middle_2();
H_y_middle_h = elem->getH_y_middle_2();
}else if(myID == elem->getEdge3()->getEdgeID()){
E_z_middle_h = elem->getE_z_middle_3();
H_x_middle_h = elem->getH_x_middle_3();
H_y_middle_h = elem->getH_y_middle_3();
}
}
if(this->getEdge2()->isBoundary() == true){
E_z_middle_j = 0.;
H_x_middle_j = 0.;
H_y_middle_j = 0.;
}else{
myID = this->getEdge2()->getEdgeID();
if(this->getEdge2()->getElement1()->getElementID() != this->getElementID()){

elem = this->getEdge2()->getElement1();
}else{
elem = this->getEdge2()->getElement2();
}
if(myID == elem->getEdge1()->getEdgeID()){
E_z_middle_j = elem->getE_z_middle_1();
H_x_middle_j = elem->getH_x_middle_1();
H_y_middle_j = elem->getH_y_middle_1();
}else if(myID == elem->getEdge2()->getEdgeID()){
E_z_middle_j = elem->getE_z_middle_2();
H_x_middle_j = elem->getH_x_middle_2();
H_y_middle_j = elem->getH_y_middle_2();
}else if(myID == elem->getEdge3()->getEdgeID()){
E_z_middle_j = elem->getE_z_middle_3();
H_x_middle_j = elem->getH_x_middle_3();
H_y_middle_j = elem->getH_y_middle_3();
}
}
if(this->getEdge3()->isBoundary() == true){
E_z_middle_k = 0.;
H_x_middle_k = 0.;
H_y_middle_k = 0.;
}else{
myID = this->getEdge3()->getEdgeID();
if(this->getEdge3()->getElement1()->getElementID() != this->getElementID()){
elem = this->getEdge3()->getElement1();
}else{

elem = this->getEdge3()->getElement2();
}
if(myID == elem->getEdge1()->getEdgeID()){
E_z_middle_k = elem->getE_z_middle_1();
H_x_middle_k = elem->getH_x_middle_1();
H_y_middle_k = elem->getH_y_middle_1();
}else if(myID == elem->getEdge2()->getEdgeID()){
E_z_middle_k = elem->getE_z_middle_2();
H_x_middle_k = elem->getH_x_middle_2();
H_y_middle_k = elem->getH_y_middle_2();
}else if(myID == elem->getEdge3()->getEdgeID()){
E_z_middle_k = elem->getE_z_middle_3();
H_x_middle_k = elem->getH_x_middle_3();
H_y_middle_k = elem->getH_y_middle_3();
}
}
}
void Element::predictFieldE(double delta_t){
if (spatial_order == 1){
double ai_Phi_plus, ai_Phi_minus, ai_Phi, Phi;
ai_Phi_plus =
TE_i_h*(Y*E_z_old + N_i_h_y*H_x_old - N_i_h_x*H_y_old)*edge1->getLength() +
TE_i_j*(Y*E_z_old + N_i_j_y*H_x_old - N_i_j_x*H_y_old)*edge2->getLength() +
TE_i_k*(Y*E_z_old + N_i_k_y*H_x_old - N_i_k_x*H_y_old)*edge3->getLength();
ai_Phi_plus = 0.5*ai_Phi_plus;
ai_Phi_minus =
TE_h_i*(-Y_h*E_z_h + N_i_h_y*H_x_h - N_i_h_x*H_y_h)*edge1->getLength() +

TE_j_i*(-Y_j*E_z_j + N_i_j_y*H_x_j - N_i_j_x*H_y_j)*edge2->getLength() +

TE_k_i*(-Y_k*E_z_k + N_i_k_y*H_x_k - N_i_k_x*H_y_k)*edge3->getLength();
ai_Phi_minus = 0.5*ai_Phi_minus;
ai_Phi = ai_Phi_plus + ai_Phi_minus;
Phi = ai_Phi/alphaE;
Flux_E_z = Phi;
}
if (spatial_order == 2) {
double ai_Phi_plus, ai_Phi_minus, ai_Phi, Phi;
ai_Phi_plus =
TE_i_h*(Y*E_z_middle_1 + N_i_h_y*H_x_middle_1 - N_i_h_x*H_y_middle_1)*edge1>getLength() +
TE_i_j*(Y*E_z_middle_2 + N_i_j_y*H_x_middle_2 - N_i_j_x*H_y_middle_2)*edge2>getLength() +
TE_i_k*(Y*E_z_middle_3 + N_i_k_y*H_x_middle_3 - N_i_k_x*H_y_middle_3)*edge3>getLength();
ai_Phi_plus = 0.5*ai_Phi_plus;
ai_Phi_minus =
TE_h_i*(-Y_h*E_z_middle_h + N_i_h_y*H_x_middle_h - N_i_h_x*H_y_middle_h)*edge1>getLength() +
TE_j_i*(-Y_j*E_z_middle_j + N_i_j_y*H_x_middle_j - N_i_j_x*H_y_middle_j)*edge2>getLength() +
TE_k_i*(-Y_k*E_z_middle_k + N_i_k_y*H_x_middle_k - N_i_k_x*H_y_middle_k)*edge3>getLength();
ai_Phi_minus = 0.5*ai_Phi_minus;
ai_Phi = ai_Phi_plus + ai_Phi_minus;
Phi = ai_Phi/alphaE;
Flux_E_z = Phi;
}

if (spatial_order == 3){
Flux_E_z = (N_i_h_y*(H_x_middle_1 + H_x_h)/2 - N_i_h_x*(H_y_middle_1 + H_y_h)/2 +
N_i_j_y*(H_x_middle_2 + H_x_j)/2 - N_i_j_x*(H_y_middle_2 + H_y_j)/2 +
N_i_k_y*(H_x_middle_3 + H_x_k)/2 - N_i_k_x*(H_y_middle_3 + H_y_k)/2);
}
/*
E_z_pred = E_z_old - CE1*Flux_E_z*delta_t - ((this->getPhysicalProperties()>getSigma()/(this->getPhysicalProperties()->getEpsr()*eps))*E_z_old + J_z/(this>getPhysicalProperties()->getEpsr()*eps))*delta_t;*/
E_z_pred = E_z_old - CE1*Flux_E_z*delta_t - J_z/(this->getPhysicalProperties()>getEpsr()*eps)*delta_t;
if (pml ==1) {
if (pml_type == "S"){
E_z_pred = E_z_pred - (CSPML1*E_z_old + (CSPML2 - CSPML1)*E_z_y_old)/(this>getPhysicalProperties()->getEpsr()*eps)*delta_t;
}
if (pml_type == "R"){
E_z_pred = E_z_pred - (CE_loss1*E_z_old)*delta_t;
}
}
void Element::correctFieldE(double delta_t){
if(spatial_order == 1){
double ai_Phi_plus, ai_Phi_minus, ai_Phi, Phi;
ai_Phi_plus =
TE_i_h*(Y*E_z_old_1 + N_i_h_y*H_x_old_1 - N_i_h_x*H_y_old_1)*edge1->getLength() +
TE_i_j*(Y*E_z_old_1 + N_i_j_y*H_x_old_1 - N_i_j_x*H_y_old_1)*edge2->getLength() +
TE_i_k*(Y*E_z_old_1 + N_i_k_y*H_x_old_1 - N_i_k_x*H_y_old_1)*edge3->getLength();
ai_Phi_plus = 0.5*ai_Phi_plus;
ai_Phi_minus =
TE_h_i*(-Y_h*E_z_h + N_i_h_y*H_x_h - N_i_h_x*H_y_h)*edge1->getLength() +

TE_j_i*(-Y_j*E_z_j + N_i_j_y*H_x_j - N_i_j_x*H_y_j)*edge2->getLength() +

TE_k_i*(-Y_k*E_z_k + N_i_k_y*H_x_k - N_i_k_x*H_y_k)*edge3->getLength();
ai_Phi_minus = 0.5*ai_Phi_minus;
ai_Phi = ai_Phi_plus + ai_Phi_minus;
Phi = ai_Phi/alphaE;
Flux_E_z = Phi;
if (pml ==1) {
if (pml_type == "S"){
Flux_E_z_y =
(N_i_h_y*(TE_i_h*H_x_old_1 + TE_h_i*H_x_h) + (Y*TE_i_h*E_z_old_1 - Y_h*TE_h_i*E_z_h))*
edge1->getLength()+
(N_i_j_y*(TE_i_j*H_x_old_1 + TE_j_i*H_x_j) + (Y*TE_i_j*E_z_old_1 - Y_j*TE_j_i*E_z_j))* edge2>getLength() +
(N_i_k_y*(TE_i_k*H_x_old_1 + TE_k_i*H_x_k) + (Y*TE_i_k*E_z_old_1 - Y_k*TE_k_i*E_z_k))*
edge3->getLength();
Flux_E_z_y = (1./alphaE)*Flux_E_z_y*0.5;
}
}
}
if(spatial_order == 2) {
//
double ai_Phi_plus, ai_Phi_minus, ai_Phi, Phi;
ai_Phi_plus =
TE_i_h*(Y*E_z_middle_1 + N_i_h_y*H_x_middle_1 - N_i_h_x*H_y_middle_1)*edge1>getLength() +
TE_i_j*(Y*E_z_middle_2 + N_i_j_y*H_x_middle_2 - N_i_j_x*H_y_middle_2)*edge2>getLength() +
TE_i_k*(Y*E_z_middle_3 + N_i_k_y*H_x_middle_3 - N_i_k_x*H_y_middle_3)*edge3>getLength();

ai_Phi_plus = 0.5*ai_Phi_plus;
ai_Phi_minus =
TE_h_i*(-Y_h*E_z_middle_h + N_i_h_y*H_x_middle_h - N_i_h_x*H_y_middle_h)*edge1>getLength() +
TE_j_i*(-Y_j*E_z_middle_j + N_i_j_y*H_x_middle_j - N_i_j_x*H_y_middle_j)*edge2>getLength() +
TE_k_i*(-Y_k*E_z_middle_k + N_i_k_y*H_x_middle_k - N_i_k_x*H_y_middle_k)*edge3>getLength();
ai_Phi_minus = 0.5*ai_Phi_minus;
ai_Phi = ai_Phi_plus + ai_Phi_minus;
Phi = ai_Phi/alphaE;
Flux_E_z = Phi;
if (pml ==1) {
if (pml_type == "S"){
Flux_E_z_y = (N_i_h_y*((distance_face_h/distance_i_h)*H_x_old_1 + (1distance_face_h/distance_i_h)*H_x_h) + N_i_j_y*((distance_face_j/distance_i_j)*H_x_old_1 +
(1-distance_face_j/distance_i_j)*H_x_j) + N_i_k_y*((distance_face_k/distance_i_k)*H_x_old_1
+ (1-distance_face_k/distance_i_k)*H_x_k));
}
}
}
if(spatial_order == 3){
Flux_E_z = (N_i_h_y*(H_x_middle_1 + H_x_h)/2 - N_i_h_x*(H_y_middle_1 + H_y_h)/2 +
N_i_j_y*(H_x_middle_1 + H_x_j)/2 - N_i_j_x*(H_y_middle_1 + H_y_j)/2 +
N_i_k_y*(H_x_middle_1 + H_x_k)/2 - N_i_k_x*(H_y_middle_1 + H_y_k)/2);
if (pml ==1) {
if (pml_type == "S"){
Flux_E_z_y = (N_i_h_y*(H_x_middle_1 + H_x_h)/2 + N_i_j_y*(H_x_middle_1 + H_x_j)/2 +
N_i_k_y*(H_x_middle_1 + H_x_k)/2);
}
}

}
/*
E_z_new = E_z_old - CE1*Flux_E_z*delta_t - ((this->getPhysicalProperties()>getSigma()/(this->getPhysicalProperties()->getEpsr()*eps))*E_z_old +J_z/(this>getPhysicalProperties()->getEpsr()*eps))*delta_t;*/
E_z_new = E_z_old - CE1*Flux_E_z*delta_t - J_z/(this->getPhysicalProperties()>getEpsr()*eps)*delta_t;
E_z_new = E_z_new *exp(-(getPhysicalProperties()->getSigma()/
(eps*getPhysicalProperties()->getEpsr()))*delta_t);
if (pml ==1) {
if (pml_type == "S"){
E_z_y_new = E_z_y_old - CE1*Flux_E_z_y*delta_t - CSPML2*E_z_y_old/(this>getPhysicalProperties()->getEpsr()*eps)*delta_t;
E_z_new = E_z_new - (CSPML1*E_z_old + (CSPML2 - CSPML1)*E_z_y_old)/(this>getPhysicalProperties()->getEpsr()*eps)*delta_t;
}
if (pml_type == "R"){
E_z_new = E_z_new - (CE_loss1*E_z_old)*delta_t;
}
}
/*
if(delta_t !=0)
ofs<<"Istante "<<instant<<endl;
ofs<<"Elemento "<<this->getElementID()<<"\n\nE_z_h = "<<E_z_h<<"\nE_z_j =
"<<E_z_j<<"\nE_z_k = "<<E_z_k<<"\n\n"<<"E_z_old = "<<E_z_old<<"\nE_z_new =
"<<E_z_new<<"\nJ_z = "<<J_z<<"\n\nH_x_h = "<<H_x_h<<"\nH_x_j =
"<<H_x_j<<"\nH_x_k = "<<H_x_k<<"\n"<<"H_x_old = "<<H_x_old<<"\nH_x_new =
"<<H_x_new<<"\n\nH_y_h = "<<H_y_h<<"\nH_y_j = "<<H_y_j<<"\nH_y_k =
"<<H_y_k<<"\n"<<"H_y_old = "<<H_y_old<<"\nH_y_new = "<<H_y_new<<"\n\ndelta_t
= "<<delta_t<<"\n--------------------------\n\n"<<endl;
ofs<<"CE1 = "<<CE1<<endl;
ofs<<"N_i_h_y = "<<N_i_h_y<<endl;
ofs<<"N_i_h_x = "<<N_i_h_x<<endl;

ofs<<"N_i_j_y = "<<N_i_j_y<<endl;
ofs<<"N_i_j_x = "<<N_i_j_x<<endl;
ofs<<"N_i_k_y = "<<N_i_k_y<<endl;
ofs<<"N_i_k_x = "<<N_i_k_x<<endl;
ofs<<"CH1 = "<<CH1<<endl;
ofs<<"N_i_h_y = "<<N_i_h_y<<endl;
ofs<<"N_i_j_y = "<<N_i_j_y<<endl;
ofs<<"N_i_k_y = "<<N_i_k_y<<endl;
ofs<<"N_i_h_x = "<<N_i_h_x<<endl;
ofs<<"N_i_j_x = "<<N_i_j_x<<endl;
ofs<<"N_i_k_x = "<<N_i_k_x<<endl;
ofs<<"\n--------------------------\n\n"<<endl;*/
}
void Element::updateFieldE(double delta_t, ostream& ofs, int instant){
//
formula del tipo: U_new = U_old +/- Flusso * delta_t +/- Perdite * delta_t +/- Sorgenti
* delta_t
//

double F;

// *************************************Aggiornamento di
E**********************************************
if(spatial_order == 1){
Flux_E_z = (N_i_h_y*(H_x_old + H_x_h)/2 - N_i_h_x*(H_y_old + H_y_h)/2 + N_i_j_y*(H_x_old
+ H_x_j)/2 - N_i_j_x*(H_y_old + H_y_j)/2 + N_i_k_y*(H_x_old + H_x_k)/2 - N_i_k_x*(H_y_old +
H_y_k)/2);
if (pml ==1) {
if (pml_type == "S"){
Flux_E_z_y = (N_i_h_y*(H_x_old + H_x_h)/2 + N_i_j_y*(H_x_old + H_x_j)/2 +
N_i_k_y*(H_x_old + H_x_k)/2);
}
}

}
if(spatial_order == 2) {
Flux_E_z = (N_i_h_y*((distance_face_h/distance_i_h)*H_x_old + (1distance_face_h/distance_i_h)*H_x_h) - N_i_h_x*((distance_face_h/distance_i_h)*H_y_old +
(1-distance_face_h/distance_i_h)*H_y_h) + N_i_j_y*((distance_face_j/distance_i_j)*H_x_old +
(1-distance_face_j/distance_i_j)*H_x_j) - N_i_j_x*((distance_face_j/distance_i_j)*H_y_old + (1distance_face_j/distance_i_j)*H_y_j) + N_i_k_y*((distance_face_k/distance_i_k)*H_x_old + (1distance_face_k/distance_i_k)*H_x_k) - N_i_k_x*((distance_face_k/distance_i_k)*H_y_old +
(1-distance_face_k/distance_i_k)*H_y_k));
if (pml ==1) {
if (pml_type == "S"){
Flux_E_z_y = (N_i_h_y*((distance_face_h/distance_i_h)*H_x_old + (1distance_face_h/distance_i_h)*H_x_h) + N_i_j_y*((distance_face_j/distance_i_j)*H_x_old +
(1-distance_face_j/distance_i_j)*H_x_j) + N_i_k_y*((distance_face_k/distance_i_k)*H_x_old +
(1-distance_face_k/distance_i_k)*H_x_k));
}
}
}
if(spatial_order == 3){
Flux_E_z = (N_i_h_y*(H_x_middle_1 + H_x_h)/2 - N_i_h_x*(H_y_middle_1 + H_y_h)/2 +
N_i_j_y*(H_x_middle_2 + H_x_j)/2 - N_i_j_x*(H_y_middle_2 + H_y_j)/2 +
N_i_k_y*(H_x_middle_3 + H_x_k)/2 - N_i_k_x*(H_y_middle_3 + H_y_k)/2);
if (pml ==1) {
if (pml_type == "S"){
Flux_E_z_y = (N_i_h_y*(H_x_middle_1 + H_x_h)/2 + N_i_j_y*(H_x_middle_2 + H_x_j)/2 +
N_i_k_y*(H_x_middle_3 + H_x_k)/2);
}
}
}
E_z_new = E_z_old - CE1*Flux_E_z*delta_t - ((this->getPhysicalProperties()->getSigma()/
(this->getPhysicalProperties()->getEpsr()*eps))*E_z_old +J_z/(this->getPhysicalProperties()>getEpsr()*eps))*delta_t;
if (pml ==1) {

if (pml_type == "S"){
E_z_y_new = E_z_y_old - CE1*Flux_E_z_y*delta_t - CSPML2*E_z_y_old/(this>getPhysicalProperties()->getEpsr()*eps)*delta_t;
E_z_new = E_z_new - (CSPML1*E_z_old + (CSPML2 - CSPML1)*E_z_y_old)/(this>getPhysicalProperties()->getEpsr()*eps)*delta_t;
}
if (pml_type == "R"){
E_z_new = E_z_new - (CE_loss1*E_z_old)*delta_t;
}
}
/*
if(delta_t !=0)
ofs<<"Istante "<<instant<<endl;
ofs<<"Elemento "<<this->getElementID()<<"\n\nE_z_h = "<<E_z_h<<"\nE_z_j =
"<<E_z_j<<"\nE_z_k = "<<E_z_k<<"\n\n"<<"E_z_old = "<<E_z_old<<"\nE_z_new =
"<<E_z_new<<"\nJ_z = "<<J_z<<"\n\nH_x_h = "<<H_x_h<<"\nH_x_j =
"<<H_x_j<<"\nH_x_k = "<<H_x_k<<"\n"<<"H_x_old = "<<H_x_old<<"\nH_x_new =
"<<H_x_new<<"\n\nH_y_h = "<<H_y_h<<"\nH_y_j = "<<H_y_j<<"\nH_y_k =
"<<H_y_k<<"\n"<<"H_y_old = "<<H_y_old<<"\nH_y_new = "<<H_y_new<<"\n\ndelta_t
= "<<delta_t<<"\n--------------------------\n\n"<<endl;
ofs<<"CE1 = "<<CE1<<endl;
ofs<<"N_i_h_y = "<<N_i_h_y<<endl;
ofs<<"N_i_h_x = "<<N_i_h_x<<endl;
ofs<<"N_i_j_y = "<<N_i_j_y<<endl;
ofs<<"N_i_j_x = "<<N_i_j_x<<endl;
ofs<<"N_i_k_y = "<<N_i_k_y<<endl;
ofs<<"N_i_k_x = "<<N_i_k_x<<endl;
ofs<<"CH1 = "<<CH1<<endl;
ofs<<"N_i_h_y = "<<N_i_h_y<<endl;
ofs<<"N_i_j_y = "<<N_i_j_y<<endl;

ofs<<"N_i_k_y = "<<N_i_k_y<<endl;
ofs<<"N_i_h_x = "<<N_i_h_x<<endl;
ofs<<"N_i_j_x = "<<N_i_j_x<<endl;
ofs<<"N_i_k_x = "<<N_i_k_x<<endl;
ofs<<"\n--------------------------\n\n"<<endl;*/
}
void Element::predictFieldH(double delta_t){
if (spatial_order == 1){
double ai_Phi_plus, ai_Phi_minus, ai_Phi, Phi;
ai_Phi_plus =
TH_i_h*(N_i_h_y*E_z_old + Z*N_i_h_y*(N_i_h_y*H_x_old - N_i_h_x*H_y_old))*edge1>getLength() +
TH_i_j*(N_i_j_y*E_z_old + Z*N_i_j_y*(N_i_j_y*H_x_old - N_i_j_x*H_y_old))*edge2>getLength() +
TH_i_k*(N_i_k_y*E_z_old + Z*N_i_k_y*(N_i_k_y*H_x_old - N_i_k_x*H_y_old))*edge3>getLength();
ai_Phi_plus = 0.5*ai_Phi_plus;
ai_Phi_minus =
TH_h_i*(N_i_h_y*E_z_h + Z_h*N_i_h_y*(-N_i_h_y*H_x_h + N_i_h_x*H_y_h))*edge1>getLength() +
TH_j_i*(N_i_j_y*E_z_j + Z_j*N_i_j_y*(-N_i_j_y*H_x_j + N_i_j_x*H_y_j))*edge2->getLength() +
TH_k_i*(N_i_k_y*E_z_k + Z_k*N_i_k_y*(-N_i_k_y*H_x_k + N_i_k_x*H_y_k))*edge3>getLength();
ai_Phi_minus = 0.5*ai_Phi_minus;
ai_Phi = ai_Phi_plus + ai_Phi_minus;
Phi = ai_Phi/alphaH;
Flux_H_x = Phi;
ai_Phi_plus =
TH_i_h*(-N_i_h_x*E_z_old + Z*N_i_h_x*(-N_i_h_y*H_x_old + N_i_h_x*H_y_old))*edge1-

>getLength() +
TH_i_j*(-N_i_j_x*E_z_old + Z*N_i_j_x*(-N_i_j_y*H_x_old + N_i_j_x*H_y_old))*edge2>getLength() +
TH_i_k*(-N_i_k_x*E_z_old + Z*N_i_k_x*(-N_i_k_y*H_x_old + N_i_k_x*H_y_old))*edge3>getLength();
ai_Phi_plus = 0.5*ai_Phi_plus;
ai_Phi_minus =
TH_h_i*(-N_i_h_x*E_z_h + Z_h*N_i_h_x*(N_i_h_y*H_x_h - N_i_h_x*H_y_h))*edge1>getLength() +
TH_j_i*(-N_i_j_x*E_z_j + Z_j*N_i_j_x*(N_i_j_y*H_x_j - N_i_j_x*H_y_j))*edge2->getLength() +
TH_k_i*(-N_i_k_x*E_z_k + Z_k*N_i_k_x*(N_i_k_y*H_x_k - N_i_k_x*H_y_k))*edge3>getLength();
ai_Phi_minus = 0.5*ai_Phi_minus;
ai_Phi = ai_Phi_plus + ai_Phi_minus;
Phi = ai_Phi/alphaH;
Flux_H_y = Phi;
}
if (spatial_order == 2) {
double ai_Phi_plus, ai_Phi_minus, ai_Phi, Phi;
ai_Phi_plus =
TH_i_h*(N_i_h_y*E_z_middle_1 + Z*N_i_h_y*(N_i_h_y*H_x_middle_1 N_i_h_x*H_y_middle_1))*edge1->getLength() +
TH_i_j*(N_i_j_y*E_z_middle_2 + Z*N_i_j_y*(N_i_j_y*H_x_middle_2 N_i_j_x*H_y_middle_2))*edge2->getLength() +
TH_i_k*(N_i_k_y*E_z_middle_3 + Z*N_i_k_y*(N_i_k_y*H_x_middle_3 N_i_k_x*H_y_middle_3))*edge3->getLength();
ai_Phi_plus = 0.5*ai_Phi_plus;
ai_Phi_minus =
TH_h_i*(N_i_h_y*E_z_middle_h + Z_h*N_i_h_y*(-N_i_h_y*H_x_middle_h +
N_i_h_x*H_y_middle_h))*edge1->getLength() +

TH_j_i*(N_i_j_y*E_z_middle_j + Z_j*N_i_j_y*(-N_i_j_y*H_x_middle_j +
N_i_j_x*H_y_middle_j))*edge2->getLength() +
TH_k_i*(N_i_k_y*E_z_middle_k + Z_k*N_i_k_y*(-N_i_k_y*H_x_middle_k +
N_i_k_x*H_y_middle_k))*edge3->getLength();
ai_Phi_minus = 0.5*ai_Phi_minus;
ai_Phi = ai_Phi_plus + ai_Phi_minus;
Phi = ai_Phi/alphaH;
Flux_H_x = Phi;
ai_Phi_plus =
TH_i_h*(-N_i_h_x*E_z_middle_1 + Z*N_i_h_x*(-N_i_h_y*H_x_middle_1 +
N_i_h_x*H_y_middle_1))*edge1->getLength() +
TH_i_j*(-N_i_j_x*E_z_middle_2 + Z*N_i_j_x*(-N_i_j_y*H_x_middle_2 +
N_i_j_x*H_y_middle_2))*edge2->getLength() +
TH_i_k*(-N_i_k_x*E_z_middle_3 + Z*N_i_k_x*(-N_i_k_y*H_x_middle_3 +
N_i_k_x*H_y_middle_3))*edge3->getLength();
ai_Phi_plus = 0.5*ai_Phi_plus;
ai_Phi_minus =
TH_h_i*(-N_i_h_x*E_z_middle_h + Z_h*N_i_h_x*(N_i_h_y*H_x_middle_h N_i_h_x*H_y_middle_h))*edge1->getLength() +
TH_j_i*(-N_i_j_x*E_z_middle_j + Z_j*N_i_j_x*(N_i_j_y*H_x_middle_j N_i_j_x*H_y_middle_j))*edge2->getLength() +
TH_k_i*(-N_i_k_x*E_z_middle_k + Z_k*N_i_k_x*(N_i_k_y*H_x_middle_k N_i_k_x*H_y_middle_k))*edge3->getLength();
ai_Phi_minus = 0.5*ai_Phi_minus;
ai_Phi = ai_Phi_plus + ai_Phi_minus;
Phi = ai_Phi/alphaH;
Flux_H_y = Phi;
}
if (spatial_order == 3){
Flux_H_x = (N_i_h_y*(E_z_middle_1 + E_z_h)/2 + N_i_j_y*(E_z_middle_2 + E_z_j)/2 +
N_i_k_y*(E_z_middle_3 + E_z_k)/2);

Flux_H_y = (N_i_h_x*(E_z_middle_1 + E_z_h)/2 + N_i_j_x*(E_z_middle_2 + E_z_j)/2 +

N_i_k_x*(E_z_middle_3 + E_z_k)/2);
}
/*
H_x_pred = H_x_old - CH1*Flux_H_x*delta_t + ((this->getPhysicalProperties()>getSigma_m()/(this->getPhysicalProperties()->getMur()*mu))*H_x_old + M_x/(this>getPhysicalProperties()->getMur()*mu))*delta_t;
H_y_pred = H_y_old - CH1*Flux_H_y*delta_t + ((this->getPhysicalProperties()>getSigma_m()/(this->getPhysicalProperties()->getMur()*mu))*H_y_old + M_y/(this>getPhysicalProperties()->getMur()*mu))*delta_t;*/
H_x_pred = H_x_old - CH1*Flux_H_x*delta_t;
H_y_pred = H_y_old - CH1*Flux_H_y*delta_t;
if (pml ==1) {
if (pml_type == "S"){
H_x_pred = H_x_pred - (CSPML2*H_x_old)/(this->getPhysicalProperties()>getMur()*mu)*delta_t;
H_y_pred = H_y_pred - (CSPML1*H_y_old)/(this->getPhysicalProperties()>getMur()*mu)*delta_t;
}
if (pml_type == "R"){
Flux_K_x_r = (CK_x_r1*Flux_H_y + CK_x_r2*Flux_H_x);
K_x_r_new = K_x_r_old + Flux_K_x_r*delta_t;
H_x_pred = H_x_pred - (CH_loss1*K_x_r_new + CH_loss2*H_x_old CH_loss3*H_y_old)*delta_t;
H_y_pred = H_y_pred - (CH_loss4*K_x_r_old + CH_loss5*H_y_old CH_loss6*H_x_old)*delta_t;
}
}
}
void Element::correctFieldH(double delta_t){
double ai_Phi_plus, ai_Phi_minus, ai_Phi, Phi;
if(spatial_order == 1){

ai_Phi_plus =
TH_i_h*(N_i_h_y*E_z_old_1 + Z*N_i_h_y*(N_i_h_y*H_x_old_1 - N_i_h_x*H_y_old_1))*edge1>getLength() +
TH_i_j*(N_i_j_y*E_z_old_1 + Z*N_i_j_y*(N_i_j_y*H_x_old_1 - N_i_j_x*H_y_old_1))*edge2>getLength() +
TH_i_k*(N_i_k_y*E_z_old_1 + Z*N_i_k_y*(N_i_k_y*H_x_old_1 - N_i_k_x*H_y_old_1))*edge3>getLength();
ai_Phi_plus = 0.5*ai_Phi_plus;
ai_Phi_minus =
TH_h_i*(N_i_h_y*E_z_h + Z_h*N_i_h_y*(-N_i_h_y*H_x_h + N_i_h_x*H_y_h))*edge1>getLength() +
TH_j_i*(N_i_j_y*E_z_j + Z_j*N_i_j_y*(-N_i_j_y*H_x_j + N_i_j_x*H_y_j))*edge2->getLength() +
TH_k_i*(N_i_k_y*E_z_k + Z_k*N_i_k_y*(-N_i_k_y*H_x_k + N_i_k_x*H_y_k))*edge3>getLength();
ai_Phi_minus = 0.5*ai_Phi_minus;
ai_Phi = ai_Phi_plus + ai_Phi_minus;
Phi = ai_Phi/alphaH;
Flux_H_x = Phi;
ai_Phi_plus =
TH_i_h*(-N_i_h_x*E_z_old_1 + Z*N_i_h_x*(-N_i_h_y*H_x_old_1 + N_i_h_x*H_y_old_1))*edge1>getLength() +
TH_i_j*(-N_i_j_x*E_z_old_1 + Z*N_i_j_x*(-N_i_j_y*H_x_old_1 + N_i_j_x*H_y_old_1))*edge2>getLength() +
TH_i_k*(-N_i_k_x*E_z_old_1 + Z*N_i_k_x*(-N_i_k_y*H_x_old_1 + N_i_k_x*H_y_old_1))*edge3>getLength();
ai_Phi_plus = 0.5*ai_Phi_plus;
ai_Phi_minus =
TH_h_i*(-N_i_h_x*E_z_h + Z_h*N_i_h_x*(N_i_h_y*H_x_h - N_i_h_x*H_y_h))*edge1>getLength() +
TH_j_i*(-N_i_j_x*E_z_j + Z_j*N_i_j_x*(N_i_j_y*H_x_j - N_i_j_x*H_y_j))*edge2->getLength() +
TH_k_i*(-N_i_k_x*E_z_k + Z_k*N_i_k_x*(N_i_k_y*H_x_k - N_i_k_x*H_y_k))*edge3-

>getLength();
ai_Phi_minus = 0.5*ai_Phi_minus;
ai_Phi = ai_Phi_plus + ai_Phi_minus;
Phi = ai_Phi/alphaH;
Flux_H_y = Phi;
}
if(spatial_order == 2) {
ai_Phi_plus =
TH_i_h*(N_i_h_y*E_z_middle_1 + Z*N_i_h_y*(N_i_h_y*H_x_middle_1 N_i_h_x*H_y_middle_1))*edge1->getLength() +
TH_i_j*(N_i_j_y*E_z_middle_2 + Z*N_i_j_y*(N_i_j_y*H_x_middle_2 N_i_j_x*H_y_middle_2))*edge2->getLength() +
TH_i_k*(N_i_k_y*E_z_middle_3 + Z*N_i_k_y*(N_i_k_y*H_x_middle_3 N_i_k_x*H_y_middle_3))*edge3->getLength();
ai_Phi_plus = 0.5*ai_Phi_plus;
ai_Phi_minus =
TH_h_i*(N_i_h_y*E_z_middle_h + Z_h*N_i_h_y*(-N_i_h_y*H_x_middle_h +
N_i_h_x*H_y_middle_h))*edge1->getLength() +
TH_j_i*(N_i_j_y*E_z_middle_j + Z_j*N_i_j_y*(-N_i_j_y*H_x_middle_j +
N_i_j_x*H_y_middle_j))*edge2->getLength() +
TH_k_i*(N_i_k_y*E_z_middle_k + Z_k*N_i_k_y*(-N_i_k_y*H_x_middle_k +
N_i_k_x*H_y_middle_k))*edge3->getLength();
ai_Phi_minus = 0.5*ai_Phi_minus;
ai_Phi = ai_Phi_plus + ai_Phi_minus;
Phi = ai_Phi/alphaH;
Flux_H_x = Phi;
ai_Phi_plus =
TH_i_h*(-N_i_h_x*E_z_middle_1 + Z*N_i_h_x*(-N_i_h_y*H_x_middle_1 +
N_i_h_x*H_y_middle_1))*edge1->getLength() +
TH_i_j*(-N_i_j_x*E_z_middle_2 + Z*N_i_j_x*(-N_i_j_y*H_x_middle_2 +

N_i_j_x*H_y_middle_2))*edge2->getLength() +
TH_i_k*(-N_i_k_x*E_z_middle_3 + Z*N_i_k_x*(-N_i_k_y*H_x_middle_3 +
N_i_k_x*H_y_middle_3))*edge3->getLength();
ai_Phi_plus = 0.5*ai_Phi_plus;
ai_Phi_minus =
TH_h_i*(-N_i_h_x*E_z_middle_h + Z_h*N_i_h_x*(N_i_h_y*H_x_middle_h N_i_h_x*H_y_middle_h))*edge1->getLength() +
TH_j_i*(-N_i_j_x*E_z_middle_j + Z_j*N_i_j_x*(N_i_j_y*H_x_middle_j N_i_j_x*H_y_middle_j))*edge2->getLength() +
TH_k_i*(-N_i_k_x*E_z_middle_k + Z_k*N_i_k_x*(N_i_k_y*H_x_middle_k N_i_k_x*H_y_middle_k))*edge3->getLength();
ai_Phi_minus = 0.5*ai_Phi_minus;
ai_Phi = ai_Phi_plus + ai_Phi_minus;
Phi = ai_Phi/alphaH;
Flux_H_y = Phi;
}
//

if (spatial_order == 3){

//
//
Flux_H_x = (N_i_h_y*(E_z_middle_1 + E_z_h)/2 + N_i_j_y*(E_z_middle_2 + E_z_j)/2 +
N_i_k_y*(E_z_middle_3 + E_z_k)/2);
//
//
Flux_H_y = (N_i_h_x*(E_z_middle_1 + E_z_h)/2 + N_i_j_x*(E_z_middle_2 + E_z_j)/2 +
N_i_k_x*(E_z_middle_3 + E_z_k)/2);
//
//
//

if (pml ==1) {
if (pml_type == "R"){

//
//
Flux_K_x_r = (-CK_x_r1*(N_i_h_x*(E_z_middle_1 + E_z_h)/2 +
N_i_j_x*(E_z_middle_1 + E_z_j)/2 + N_i_k_x*(E_z_middle_1 + E_z_k)/2) +
CK_x_r2*(N_i_h_y*(E_z_middle_1 + E_z_h)/2 + N_i_j_y*(E_z_middle_1 + E_z_j)/2 +
N_i_k_y*(E_z_middle_1 + E_z_k)/2));

//
//

//
//

//
//

/*
H_x_new = H_x_old - CH1*Flux_H_x*delta_t + ((this->getPhysicalProperties()>getSigma_m()/(this->getPhysicalProperties()->getMur()*mu))*H_x_old + M_x/(this>getPhysicalProperties()->getMur()*mu))*delta_t;
H_y_new = H_y_old - CH1*Flux_H_y*delta_t + ((this->getPhysicalProperties()>getSigma_m()/(this->getPhysicalProperties()->getMur()*mu))*H_y_old + M_y/(this>getPhysicalProperties()->getMur()*mu))*delta_t;*/
H_x_new = H_x_old - CH1*Flux_H_x*delta_t;
H_y_new = H_y_old - CH1*Flux_H_y*delta_t;
if (pml ==1) {
if (pml_type == "S"){
H_x_new = H_x_new - (CSPML2*H_x_old)/(this->getPhysicalProperties()>getMur()*mu)*delta_t;
H_y_new = H_y_new - (CSPML1*H_y_old)/(this->getPhysicalProperties()>getMur()*mu)*delta_t;
}
if (pml_type == "R"){
Flux_K_x_r = (CK_x_r1*Flux_H_y + CK_x_r2*Flux_H_x);
K_x_r_new = K_x_r_old + Flux_K_x_r*delta_t;
H_x_new = H_x_new - (CH_loss1*K_x_r_old + CH_loss2*H_x_old CH_loss3*H_y_old)*delta_t;
H_y_new = H_y_new - (CH_loss4*K_x_r_old + CH_loss5*H_y_old CH_loss6*H_x_old)*delta_t;
}
}

}
void Element::updateFieldH(double delta_t, ostream& ofs, int instant){
//
formula del tipo: U_new = U_old +/- Flusso * delta_t +/- Perdite * delta_t +/- Sorgenti
* delta_t
//

double G_x, G_y;

// **************************************Aggiornamento di
H*********************************************
if(spatial_order == 1){
Flux_H_x = (N_i_h_y*(E_z_old + E_z_h)/2 + N_i_j_y*(E_z_old + E_z_j)/2 + N_i_k_y*(E_z_old +
E_z_k)/2);
Flux_H_y = (N_i_h_x*(E_z_old + E_z_h)/2 + N_i_j_x*(E_z_old + E_z_j)/2 + N_i_k_x*(E_z_old +
E_z_k)/2);
if (pml ==1) {
if (pml_type == "R"){
Flux_K_x_r = (-CK_x_r1*(N_i_h_x*(E_z_old + E_z_h)/2 + N_i_j_x*(E_z_old + E_z_j)/2 +
N_i_k_x*(E_z_old + E_z_k)/2) + CK_x_r2*(N_i_h_y*(E_z_old + E_z_h)/2 + N_i_j_y*(E_z_old +
E_z_j)/2 + N_i_k_y*(E_z_old + E_z_k)/2));
}
}
}
if(spatial_order == 2) {
Flux_H_x = (N_i_h_y*((distance_face_h/distance_i_h)*E_z_old + (1distance_face_h/distance_i_h)*E_z_h) + N_i_j_y*((distance_face_j/distance_i_j)*E_z_old + (1distance_face_j/distance_i_j)*E_z_j) + N_i_k_y*((distance_face_k/distance_i_k)*E_z_old + (1distance_face_k/distance_i_k)*E_z_k));
Flux_H_y = (N_i_h_x*((distance_face_h/distance_i_h)*E_z_old + (1distance_face_h/distance_i_h)*E_z_h) + N_i_j_x*((distance_face_j/distance_i_j)*E_z_old + (1distance_face_j/distance_i_j)*E_z_j) + N_i_k_x*((distance_face_k/distance_i_k)*E_z_old + (1distance_face_k/distance_i_k)*E_z_k));
if (pml ==1) {
if (pml_type == "R"){
Flux_K_x_r = (-CK_x_r1*(N_i_h_x*((distance_face_h/distance_i_h)*E_z_old + (1-

distance_face_h/distance_i_h)*E_z_h) + N_i_j_x*((distance_face_j/distance_i_j)*E_z_old + (1distance_face_j/distance_i_j)*E_z_j) + N_i_k_x*((distance_face_k/distance_i_k)*E_z_old + (1distance_face_k/distance_i_k)*E_z_k)) +

CK_x_r2*(N_i_h_y*((distance_face_h/distance_i_h)*E_z_old + (1distance_face_h/distance_i_h)*E_z_h) + N_i_j_y*((distance_face_j/distance_i_j)*E_z_old + (1distance_face_j/distance_i_j)*E_z_j) + N_i_k_y*((distance_face_k/distance_i_k)*E_z_old + (1distance_face_k/distance_i_k)*E_z_k)));
}
}
}
if(spatial_order == 3){
Flux_H_x = (N_i_h_y*(E_z_middle_1 + E_z_h)/2 + N_i_j_y*(E_z_middle_2 + E_z_j)/2 +
N_i_k_y*(E_z_middle_3 + E_z_k)/2);
Flux_H_y = (N_i_h_x*(E_z_middle_1 + E_z_h)/2 + N_i_j_x*(E_z_middle_2 + E_z_j)/2 +
N_i_k_x*(E_z_middle_3 + E_z_k)/2);
if (pml ==1) {
if (pml_type == "R"){
Flux_K_x_r = (-CK_x_r1*(N_i_h_x*(E_z_middle_1 + E_z_h)/2 + N_i_j_x*(E_z_middle_2 +
E_z_j)/2 + N_i_k_x*(E_z_middle_3 + E_z_k)/2) + CK_x_r2*(N_i_h_y*(E_z_middle_1 + E_z_h)/2
+ N_i_j_y*(E_z_middle_2 + E_z_j)/2 + N_i_k_y*(E_z_middle_3 + E_z_k)/2));
}
}
}
H_x_new = H_x_old - CH1*Flux_H_x*delta_t + ((this->getPhysicalProperties()>getSigma_m()/(this->getPhysicalProperties()->getMur()*mu))*H_x_old + M_x/(this>getPhysicalProperties()->getMur()*mu))*delta_t;
H_y_new = H_y_old + CH1*Flux_H_y*delta_t + ((this->getPhysicalProperties()>getSigma_m()/(this->getPhysicalProperties()->getMur()*mu))*H_y_old + M_y/(this>getPhysicalProperties()->getMur()*mu))*delta_t;
if (pml ==1) {
if (pml_type == "S"){
H_x_new = H_x_new - (CSPML2*H_x_old)/(this->getPhysicalProperties()>getMur()*mu)*delta_t;

H_y_new = H_y_new - (CSPML1*H_y_old)/(this->getPhysicalProperties()>getMur()*mu)*delta_t;

}
if (pml_type == "R"){
K_x_r_new = K_x_r_old + Flux_K_x_r*delta_t;
H_x_new = H_x_new - (CH_loss1*K_x_r_old + CH_loss2*H_x_old CH_loss3*H_y_old)*delta_t;
H_y_new = H_y_new - (CH_loss4*K_x_r_old + CH_loss5*H_y_old CH_loss6*H_x_old)*delta_t;
}
}
}
void Element::setUpSource(string type, double first_parameter, double second_parameter,
double third_parameter, double fourth_parameter){
Type_of_source = type;
if (Type_of_source == "S"){
Amplitude = first_parameter;
frequency = second_parameter;
}else if(Type_of_source == "G"){
Amplitude = first_parameter;
taup = second_parameter;
td = third_parameter;
}else if(Type_of_source == "P"){
Amplitude = first_parameter;
taup = second_parameter;
td = third_parameter;
frequency = fourth_parameter;
}
}

void Element::updateSource(double t){

if(Type_of_source == "S"){
J_z = Amplitude*sin(2.*3.14*frequency*t);
}else if (Type_of_source == "G"){
J_z = Amplitude*exp(-((t-td)/taup)*((t-td)/taup)*0.5);
}else if(Type_of_source == "P"){
J_z = Amplitude*(exp(-((t-td)/taup)*((t-td)/taup)*0.5))*sin(2.*3.14*frequency*t);
}
}
void Element::updateHardSource(double t){
//

double taup = (1./(6.*3.14))*1.e-8;

//

double expected_value = 4.*taup;

//

if ((t>0) &&((this->getElementID()==2550)))

// //

E_z_old= -sin(6.28*3e7*t);

//
//
//
//
E_z_old = Amplitude*exp(-((t-expected_value)/taup)*((texpected_value)/taup)*0.5);
}
void Element::addElement_node_1(Element* e){
if(elements_node_1->count(e->getElementID()) != 0){
cerr << "FATAL ERROR: Attempt of inserting an element, which already exists. The
program will be terminated." << endl;
exit(EXIT_FAILURE);
}
(*elements_node_1)[e->getElementID()] = e;
}

void Element::addElement_node_2(Element* e){

if(elements_node_2->count(e->getElementID()) != 0){
cerr << "FATAL ERROR: Attempt of inserting an element, which already exists. The
program will be terminated." << endl;
exit(EXIT_FAILURE);
}
(*elements_node_2)[e->getElementID()] = e;
}
void Element::addElement_node_3(Element* e){
if(elements_node_3->count(e->getElementID()) != 0){
cerr << "FATAL ERROR: Attempt of inserting an element, which already exists. The
program will be terminated." << endl;
exit(EXIT_FAILURE);
}
(*elements_node_3)[e->getElementID()] = e;
}
void Element::setDistances_node_1(double dist, int i){
distances_node_1[i]=dist;
}
void Element::setDistances_node_2(double dist, int i){
distances_node_2[i]=dist;
}
void Element::setDistances_node_3(double dist, int i){
distances_node_3[i]=dist;
}
Element::~Element(){
map<int,Element*>::iterator it_element;
for(it_element = elements_node_1->begin(); it_element != elements_node_1->end();

it_element++){
delete it_element->second;
}
for(it_element = elements_node_2->begin(); it_element != elements_node_2->end();
it_element++){
delete it_element->second;
}
for(it_element = elements_node_3->begin(); it_element != elements_node_3->end();
it_element++){
delete it_element->second;
}
delete elements_node_1;
delete elements_node_2;
delete elements_node_3;
delete normal1;
delete normal2;
delete normal3;
delete [] distances_node_1;
delete [] distances_node_2;
delete [] distances_node_3;
}
class ElementTester{
double tol;
public:
ElementTester();
void test();
~ElementTester();
};

ElementTester::ElementTester(){
tol = 1e-6;
}
void ElementTester::test(){
cout << "Starting test of the class Element ..." << endl;
{
// First test
Point2D p1(0.,0.);
Point2D p2(1.,0.);
Point2D p3(0.,1.);
Node n1(&p1, 1);
Node n2(&p2, 2);
Node n3(&p3, 3);
Edge e1(&n2, &n3, 1);
Edge e2(&n1, &n3, 2);
Edge e3(&n1, &n2, 31);
Element element(&n1, &n2, &n3, &e1, &e2, &e3, 1);
// barycenter
double x_barycenter, y_barycenter;
Point2D barycenter = element.getBarycenter();
x_barycenter = barycenter.getX();
y_barycenter = barycenter.getY();
cout << "x_BC = " << x_barycenter << endl;
cout << "y_BC = " << y_barycenter << endl;
if(abs(x_barycenter - 0.333333) >= tol || abs(y_barycenter - 0.333333) >= tol){
cerr << "ERROR in testing class Element: the barycenter computation does not work
properly." << endl;

cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
// lengths
double l1 = element.getSideLength1();
double l2 = element.getSideLength2();
double l3 = element.getSideLength3();
cout << "l1 = " << l1 << endl;
cout << "l2 = " << l2 << endl;
cout << "l3 = " << l3 << endl;
if(abs(l1 - sqrt(2.0)) >= tol || abs(l2 - 1.0) >= tol || abs(l3 - 1.0) >= tol){
cerr << "ERROR in testing class Element: the side lengths computation does not work
properly." << endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
// area
double area = element.getArea();
cout << "Area = " << area << endl;
if(abs(area - 0.5) >= tol){
cerr << "ERROR in testing class Element: the area computation does not work properly."
<< endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
// normals
Vector2D* normal1 = element.getNormal1();
Vector2D* normal2 = element.getNormal2();
Vector2D* normal3 = element.getNormal3();
if(abs(normal1->getXComponent() - sqrt(0.5)) >= tol || abs(normal1->getYComponent() sqrt(0.5)) >= tol){

cerr << "ERROR in testing class Element: the normal computation does not work properly."
<< endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
if(abs(normal2->getXComponent() - (-1.0)) >= tol || abs(normal2->getYComponent() - 0.0)
>= tol){
cerr << "ERROR in testing class Element: the normal computation does not work properly."
<< endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
if(abs(normal3->getXComponent() - (0.0)) >= tol || abs(normal3->getYComponent() - (1.0)) >= tol){
cerr << "ERROR in testing class Element: the normal computation does not work properly."
<< endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
}
{
// Second test
Point2D p1(-1.,0.);
Point2D p2(1.,0.);
Point2D p3(0.,1.);
Node n1(&p1, 1);
Node n2(&p2, 2);
Node n3(&p3, 3);
Edge e1(&n2, &n3, 1);
Edge e2(&n1, &n3, 2);
Edge e3(&n1, &n2, 31);
Element element(&n1, &n2, &n3, &e1, &e2, &e3, 1);

// barycenter
double x_barycenter, y_barycenter;
Point2D barycenter = element.getBarycenter();
x_barycenter = barycenter.getX();
y_barycenter = barycenter.getY();
cout << "x_BC = " << x_barycenter << endl;
cout << "y_BC = " << y_barycenter << endl;
if(abs(x_barycenter - 0.) >= tol || abs(y_barycenter - 0.333333) >= tol){
cerr << "ERROR in testing class Element: the barycenter computation does not work
properly." << endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
// lengths
double l1 = element.getSideLength1();
double l2 = element.getSideLength2();
double l3 = element.getSideLength3();
cout << "l1 = " << l1 << endl;
cout << "l2 = " << l2 << endl;
cout << "l3 = " << l3 << endl;
if(abs(l1 - sqrt(2.0)) >= tol || abs(l2 - sqrt(2.0)) >= tol || abs(l3 - 2.0) >= tol){
cerr << "ERROR in testing class Element: the side lengths computation does not work
properly." << endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
// area
double area = element.getArea();
cout << "Area = " << area << endl;
if(abs(area - 1.0) >= tol){

cerr << "ERROR in testing class Element: the area computation does not work properly."
<< endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
// normals
Vector2D* normal1 = element.getNormal1();
Vector2D* normal2 = element.getNormal2();
Vector2D* normal3 = element.getNormal3();
if(abs(normal1->getXComponent() - sqrt(0.5)) >= tol || abs(normal1->getYComponent() sqrt(0.5)) >= tol){
cerr << "ERROR in testing class Element: the normal computation does not work properly."
<< endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
if(abs(normal2->getXComponent() - (-sqrt(0.5))) >= tol || abs(normal2->getYComponent() sqrt(0.5)) >= tol){
cerr << "ERROR in testing class Element: the normal computation does not work properly."
<< endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
if(abs(normal3->getXComponent() - (0.0)) >= tol || abs(normal3->getYComponent() - (1.0)) >= tol){
cerr << "ERROR in testing class Element: the normal computation does not work properly."
<< endl;
cerr << "See file " << __FILE__ << " at line " << __LINE__ << "." << endl;
}
}
cout << "done." << endl;
}
ElementTester::~ElementTester(){

}
class Mesh{
map<int,Node*> *nodes;
map<int,Element*> *elements;
map<int,Edge*> *edges;
void addElement(Element* e);
void addNode(Node* n);
Edge* addEdge(Edge* e);
public:
Mesh(string nodesFilename, string elementsFilename, string mediaFilename);
Edge* getEdge(int edgeID);
Node* getNode(int nodeID);
Element* getElement(int elementID);
int getElementsNumber(){return elements->size();}
void printBoundaryNodes(string filename);
map<int,Node*>* getNodes(){return nodes;}
map<int,Element*>* getElements(){return elements;}
map<int,Edge*>* getEdges(){return edges;}
~Mesh();
};
Mesh::Mesh(string nodesFilename, string elementsFilename, string mediaFilename){
nodes = new map<int,Node*>;
elements = new map<int,Element*>;
edges = new map<int,Edge*>;
ifstream nodeInput, elementInput, mediaInput;
nodeInput.open(nodesFilename.c_str());
if(!nodeInput){

cerr << "Impossibile to open file " << nodesFilename << ". The program will be
terminated." << endl;
exit(EXIT_FAILURE);
}
int nodesNumber, dummy1, dummy2, dummy3, dummy5;
double x, y, dummy4;
int nodeID;
Point2D *point;
Node *node;
Element *element;
nodeInput >> nodesNumber >> dummy1 >> dummy2 >> dummy3;
for(int n = 0; n < nodesNumber; n++){
nodeInput >> nodeID >> x >> y >> dummy4;
point = new Point2D(x,y);
node = new Node(point, nodeID);
addNode(node);
}
nodeInput.close();
elementInput.open(elementsFilename.c_str());
if(!elementInput){
cerr << "Impossibile to open file " << elementsFilename << ". The program will be
terminated." << endl;
exit(EXIT_FAILURE);
}
int elementsNumber;
int nodesPerElement;
int elementID;
elementInput >> elementsNumber >> nodesPerElement >> dummy1;

if(nodesPerElement != 3){
cerr << "FATAL ERROR: the program is unable to handle elements with a number of nodes
different from 3. The progrm will be terminated.";
exit(EXIT_FAILURE);
}
int nodeID_vector[3];
Node* node_vector[3];
Edge* edge_vector[3];
int edgeID = 0;
for(int e = 0; e < elementsNumber; e++){
elementInput >> elementID;
for(int n = 0; n < nodesPerElement; n++){
elementInput >> nodeID_vector[n];
}
for(int n = 0; n < nodesPerElement; n++){
node_vector[n] = getNode(nodeID_vector[n]);
}
edge_vector[0] = new Edge(node_vector[1], node_vector[2], edgeID);
edgeID++;
edge_vector[1] = new Edge(node_vector[0], node_vector[2], edgeID);
edgeID++;
edge_vector[2] = new Edge(node_vector[0], node_vector[1], edgeID);
edgeID++;
for(int n = 0; n < nodesPerElement; n++){
edge_vector[n] = addEdge(edge_vector[n]);
}
element = new Element(node_vector[0], node_vector[1], node_vector[2], edge_vector[0],
edge_vector[1], edge_vector[2], elementID);

addElement(element);
}
elementInput.close();
map<int,Element*>::iterator it_elements;
for(it_elements = getElements()->begin(); it_elements != getElements()->end();
it_elements++){
it_elements->second->updateBoundary();
}
string mediaType;
PhysicalProperties *physicalProperties;
mediaInput.open(mediaFilename.c_str());
for(int e = 0; e < getElementsNumber(); e++){
mediaInput >> elementID >> mediaType;
physicalProperties = new PhysicalProperties(mediaType);
physicalProperties->read(&mediaInput);
element = getElement(elementID);
element->setPhysicalProperties(physicalProperties);
}
mediaInput.close();
}
void Mesh::printBoundaryNodes(string filename){
ofstream output;
output.open(filename.c_str());
map<int,Edge*>::iterator it;
for(it = getEdges()->begin(); it != getEdges()->end(); it++){
if(it->second->isBoundary() == true){
output << it->second->getNode1()->getX() << "\t" << it->second->getNode1()->getY()
<< endl;

output << it->second->getNode2()->getX() << "\t" << it->second->getNode2()->getY()

<< endl;
}
}
output.close();
}
void Mesh::addNode(Node* n){
if(nodes->count(n->getNodeID()) != 0){
cerr << "FATAL ERROR: Attempt of inserting a node, which already exists. The program will
be terminated." << endl;
cerr << "The critical node has ID " << n->getNodeID() << "." << endl;
cerr << "x = " << n->getX() << ", y = " << n->getY() << "." << endl;
exit(EXIT_FAILURE);
}
(*nodes)[n->getNodeID()] = n;
}
Node* Mesh::getNode(int nodeID){
if(nodes->count(nodeID) == 0){
return 0;
}else{
return (*nodes)[nodeID];
}
}
void Mesh::addElement(Element* e){
if(elements->count(e->getElementID()) != 0){
cerr << "FATAL ERROR: Attempt of inserting an element, which already exists. The
program will be terminated." << endl;
exit(EXIT_FAILURE);

}
(*elements)[e->getElementID()] = e;
}
Element* Mesh::getElement(int elementID){
if(elements->count(elementID) == 0){
return 0;
}else{
return (*elements)[elementID];
}
}
Edge* Mesh::addEdge(Edge* e){
Edge* retval = e;
if(edges->count(e->getEdgeID()) != 0){
cerr << "FATAL ERROR: Attempt of inserting an edge, which already exists. The programa
will be terminated." << endl;
exit(EXIT_FAILURE);
}
map<int,Edge*>::iterator it;
Edge* edge;
bool found = false;
for(it = edges->begin(); it != edges->end(); it++){
edge = it->second;
if(*edge == *e){
retval = edge;
//edge->setBoundary(false);
delete e;
found = true;

break;
}
}
if(found == false){
(*edges)[e->getEdgeID()] = e;
}
return retval;
}
Edge* Mesh::getEdge(int edgeID){
if(edges->count(edgeID) == 0){
return 0;
}else{
return (*edges)[edgeID];
}
}
Mesh::~Mesh(){
map<int,Node*>::iterator it_node;
map<int,Edge*>::iterator it_edge;
map<int,Element*>::iterator it_element;
for(it_node = getNodes()->begin(); it_node != getNodes()->end(); it_node++){
delete it_node->second;
}
for(it_edge = getEdges()->begin(); it_edge != getEdges()->end(); it_edge++){
delete it_edge->second;
}
for(it_element = getElements()->begin(); it_element != getElements()->end(); it_element+
+){

delete it_element->second->getPhysicalProperties();
delete it_element->second;
}
delete nodes;
delete elements;
delete edges;
}
class MeshGen{
public:
MeshGen(string nodesFilename, string elementsFilename, string mediaFilename, int row,
int col, double x_step, double y_step, double x_start, double y_start);
~MeshGen();
};
MeshGen::MeshGen(string nodesFilename, string elementsFilename, string mediaFilename,
int col, int row, double x_step, double y_step, double x_start, double y_start){
int N = col+1;

//N e M contano i nodi mentre row e col contano gli elementi

int M = row+1;
int dummy1 = 1;
int dummy2 = 1;
int dummy3 = 1;
int dummy4 = 1;
int dummy5 = 1;
int nodesPerElement = 3;
int offset;
int ID = 1;
double noise = 0;
double noise2 = 0;
double epsr = 1;

double sigma = 0;
double mur = 1;
double sigma_m = 0;
string type = "D";
ofstream outputNodes;
outputNodes.open(nodesFilename.c_str());
if(!outputNodes){
cerr << "Impossibile to open the output nodes file. The program will be terminated."<<
endl;
exit(EXIT_FAILURE);
}
outputNodes<<N*M<<"\t"<<dummy1<<"\t"<<dummy2<<"\t"<<dummy3<<endl;
for(int m=0; m<M; m++){
offset = (m)*N;
for(int n=0; n<N; n++){
if((offset !=0) && (offset != (M-1)*N)){
//

noise = rand()%100*x_step/100*0.2;

//

noise2 = rand()%100*y_step/100*0.2;

cout <<x_step<<"\n"<<noise<<"\n"<<noise2<<endl;
}
outputNodes << (n)+offset << "\t" << (n*x_step) + x_start + noise << "\t" << (m*y_step)
+ y_start + noise2 << "\t" << dummy4 << endl;
}
}
ofstream outputElements;
outputElements.open(elementsFilename.c_str());
if(!outputElements){
cerr << "Impossibile to open the output elements file. The program will be terminated."<<

endl;
exit(EXIT_FAILURE);
}
outputElements<<2*(N-1)*(M-1)<<"\t"<<nodesPerElement<<"\t"<<dummy1<<endl;
for(int m=1; m<M; m++){
offset = (m -1)*N;
for(int n=1; n<N; n++){
outputElements<<ID<<"\t"<<(n-1)+offset<<"\t"<<(n)+offset<<"\t"<<(N+n1)+offset<<endl;
outputElements<<ID+1<<"\t"<<(n)+offset<<"\t"<<(n-1+N)+offset<<"\t"<<(n+N)
+offset<<endl;
ID+= 2;;
}
}
ofstream outputMedia;
outputMedia.open(mediaFilename.c_str());
if(!outputMedia){
cerr << "Impossibile to open the output parameters file. The program will be
terminated."<< endl;
exit(EXIT_FAILURE);
}
ID = 1;
for(int m =1; m < M; m++){
offset = (m -1)*N;
for(int n=1; n<N; n++){
if(((ID>(3500+41)) && (ID<(3500+61)))||((ID>(3600+41)) && (ID<(3600+61)))||
((ID>(3700+41)) && (ID<(3700+61)))||((ID>(3800+41)) && (ID<(3800+61)))||
((ID>(3900+41)) && (ID<(3900+61)))){
outputMedia << ID << "\t" << type << "\t" << epsr

<<"\t"<<0.<<"\t"<<mur<<"\t"<<sigma_m<<endl;
outputMedia << ID + 1 << "\t" <<type << "\t" << epsr << "\t" << 0.
<<"\t"<<mur<<"\t"<<sigma_m<<endl;
ID+=2;
}else{
outputMedia<<ID<<"\t"<<type<<"\t"<<epsr<<"\t"<<0.<<"\t"<<mur<<"\t"<<sigma_m
<<endl;
outputMedia<<ID+1<<"\t"<<type<<"\t"<<epsr<<"\t"<<0.<<"\t"<<mur<<"\t"<<sigma
_m<<endl;
ID+=2;
}
}
}
//
********************************************************************************************
**********************
outputNodes.close();
outputElements.close();
outputMedia.close();
}
MeshGen::~MeshGen(){
}
////
ostream& operator<<(ostream& ofs, Point2D* p);
ostream& operator<<(ostream& ofs, Node* n);
ostream& operator<<(ostream& ofs, Edge* e);
ostream& operator<<(ostream& ofs, PhysicalProperties* p);
ostream& operator<<(ostream& ofs, Element* e);
ostream& operator<<(ostream& ofs, Vector2D* v);

ostream& operator<<(ostream& ofs, Mesh *m);

ostream& operator<<(ostream& ofs, Point2D *p){
ofs << "x = " << p->getX() << ", y = " << p->getY();
return ofs;
}
ostream& operator<<(ostream& ofs, Node *n){
ofs << "Node ID = " << n->getNodeID() << ", " << n->getPoint2D();
return ofs;
}
ostream& operator<<(ostream& ofs, Edge *e){
ofs << "Edge ID = " << e->getEdgeID() << ".\n" << e->getNode1() << ".\n" << e>getNode2() << ".\n L = " << e->getLength() << ".\n ";
ofs << "Is boundary: " << e->isBoundary() << endl;
if(e->getElement1() != 0){
ofs << " " << e->getElement1()->getElementID() << endl;
}else{
ofs << " -- " << endl;
}
if(e->getElement2() != 0){
ofs << " " << e->getElement2()->getElementID() << endl;
}else{
ofs << " -- " << endl;
}
return ofs;
}
ostream& operator<<(ostream& ofs, Vector2D *v){
ofs << "x-component = " << v->getXComponent() << ", y-component = " << v>getYComponent();

return ofs;
}
ostream& operator<<(ostream& ofs, PhysicalProperties* p){
ofs << "Type: " << p->getType() << endl;
if(p->getType() == "D"){
ofs << p->getEpsr() << " " << p->getSigma() << " " << p->getMur() << " " << p>getSigma_m() << endl;
}
return ofs;
}
ostream& operator<<(ostream& ofs, Element *e){
Edge* e1 = e->getEdge1();
Edge* e2 = e->getEdge2();
Edge* e3 = e->getEdge3();
Vector2D* normal1 = e->getNormal1();
Vector2D* normal2 = e->getNormal2();
Vector2D* normal3 = e->getNormal3();
ofs << "Element ID = " << e->getElementID() << endl;
ofs << "Is boundary: " << e->isBoundary() << endl;
ofs << "Edge 1" << endl;
ofs << e1 << endl;
ofs << "Edge 2" << endl;
ofs << e2 << endl;
ofs << "Edge 3" << endl;
ofs << e3 << endl;
ofs << "Normal 1" << endl;
ofs << normal1 << endl;

ofs << "Normal 2" << endl;

ofs << normal2 << endl;
ofs << "Normal 3" << endl;
ofs << normal3 << endl;
ofs << "Physical Properties" << endl;
ofs << e->getPhysicalProperties() << endl;
return ofs;
}
ostream& operator<<(ostream& ofs, Mesh *m){
map<int,Element*>::iterator it_elements;
map<int,Node*>::iterator it_nodes;
cout << "ELEMENTS" << endl;
for(it_elements = m->getElements()->begin(); it_elements != m->getElements()->end();
it_elements++){
cout << "-----------------------------" << endl;
cout << it_elements->second << endl;
}
return ofs;
}
class fvtd2dSolver{
double t_start, t_end, delta_t;
float security_coefficient;
int order, spatial_order;
int boundaryType;
int pml_flag;
int print_step;
//

int grid_flag;

Element** grid;
Element** test_elements;
double* test_points;
int test_points_number;
ofstream outfile1, outfile2, outfile3, outfile4;
//

double* distancev;

int row;
int col;
double x_end, x_start;
double y_end, y_start;
double x_step;
double y_step;
double x_dimension;
double y_dimension;
Mesh *mesh;
map<int,Element*> *elements;
public:
fvtd2dSolver();
~fvtd2dSolver();
void inizialize();
void readDomain();
void solve();
void createMesh();
void createBoundary();
void createSource();
void setOutput();
Element* nearestElement(double x, double y);

map<int,Element*>* getElements(){return elements;}

void setDeltaT(double t){delta_t = t;}
};
fvtd2dSolver::fvtd2dSolver(){
//

cout<<"Chiamata al costruttore di fvtd2dSolver"<<endl;

t_start = 0.;
t_end = 0.;
pml_flag = 0.;
security_coefficient = 0.;
inizialize();
}
fvtd2dSolver::~fvtd2dSolver(){
delete[] grid;
//

delete[] test_elements;

//

delete test_points;

}
void fvtd2dSolver::readDomain(){
ifstream infile("Domain.dat");
if(!infile){
cerr << "Impossibile to open the domain file. The program will be terminated."<< endl;
exit(EXIT_FAILURE);
}
infile >> x_start >> x_end >> row;
infile >> y_start >> y_end >> col;
infile >> t_start >> t_end >> security_coefficient;
infile >> order >> spatial_order;
infile >> boundaryType;

cout << "Coefficiente di sicurezza settato al " << security_coefficient*100 << " %" <<
endl;
cout << "Precisione spaziale di ordine: " << spatial_order << endl;
}
void fvtd2dSolver::inizialize(){
cout << "Inizializzazione in corso..." << endl;
readDomain();
int number_of_elements_x, number_of_elements_y;
double element_dimension_x, element_dimension_y;
ifstream infile("Mesh.dat");
if(!infile){
cerr << "Impossibile to open the mesh parameters file. The program will be
terminated."<< endl;
exit(EXIT_FAILURE);
}
infile >> number_of_elements_x >> number_of_elements_y;
element_dimension_x = (x_end - x_start)/number_of_elements_x;
element_dimension_y = (y_end - y_start)/number_of_elements_y;
MeshGen generator("test_data/test.0.node", "test_data/test.0.ele",
"test_data/parametri.dat", number_of_elements_x, number_of_elements_y,
element_dimension_x, element_dimension_y, x_start, y_start);
createMesh();
createSource();
createBoundary();
delta_t = t_end-t_start;
double min_step = delta_t;
double step=0.;
map<int,Element*>::iterator it_elements;
double bar_x, bar_y;

int id;
cout<<"Calcolo del passo temporale..."<<endl;
for(it_elements = mesh->getElements()->begin(); it_elements != mesh->getElements()>end(); it_elements++){
it_elements->second->setSecurityFactor(security_coefficient);
step = it_elements->second->computeTemporalStep();
if(step<=min_step)
{
min_step=step;
bar_x = it_elements->second->getBarycenter().getX();
bar_y = it_elements->second->getBarycenter().getY();
id = it_elements->second->getElementID();
}
}
delta_t=min_step;
cout << "Passo temporale: " << delta_t << " sec" << endl;
cout << bar_x << " " << bar_y << " " << id << endl;
setOutput();
}
void fvtd2dSolver::createMesh(){
cout<<"Costruzione della mesh in corso..."<<endl;
mesh = new Mesh("test_data/test.0.node", "test_data/test.0.ele",
"test_data/parametri.dat");
//
mesh = new Mesh("test_data/reticolo.2.node", "test_data/reticolo.2.ele",
"test_data/parametri.dat");
mesh->printBoundaryNodes("boundary.dat");
map<int,Element*>::iterator it_elements;
//

double leftValue = -0.125;

//

double rightValue = 0.125;

//

double bottomValue = 0.063;

//

double upperValue = 0.188;

double leftValue = -0.188;

double rightValue = 0.;
double bottomValue = 0.063;
double upperValue = 0.188;
double leftValue2 = 0.063;
double rightValue2 = 0.188;
double bottomValue2 = -0.063;
double upperValue2 = 0.188;
for(it_elements = mesh->getElements()->begin(); it_elements != mesh->getElements()>end(); it_elements++){
//
Modifica temporanea per creare oggetti
dielettrici**************************************
if ((it_elements->second->getBarycenter().getX()>leftValue)&&(it_elements->second>getBarycenter().getX()<rightValue)&&(it_elements->second>getBarycenter().getY()>bottomValue)&&(it_elements->second>getBarycenter().getY()<upperValue)){
it_elements->second->getPhysicalProperties()->setSigma(0.);
it_elements->second->getPhysicalProperties()->setEpsr(2.);
}
if ((it_elements->second->getBarycenter().getX()>leftValue2)&&(it_elements->second>getBarycenter().getX()<rightValue2)&&(it_elements->second>getBarycenter().getY()>bottomValue2)&&(it_elements->second>getBarycenter().getY()<upperValue2)){
it_elements->second->getPhysicalProperties()->setSigma(0.2);
it_elements->second->getPhysicalProperties()->setEpsr(3.);
}
//*****************************************************************************************

it_elements->second->setSecurityFactor(security_coefficient);
it_elements->second->setImpedence();
}
}
void fvtd2dSolver::createBoundary(){
string type;
cout << "Impostazione parametri di contorno..." << endl;
ifstream boundary("PML.dat");
if(!boundary){
cerr << "Impossibile to open the PML parameter file. The program will be terminated." <<
endl;
exit(EXIT_FAILURE);
}
boundary >> pml_flag;
if (pml_flag != 0){
boundary >> type;
cout << "PML di tipo " << type << endl;
}else{
cout << "PML non presenti" << endl;
}
map<int,Element*>::iterator it_elements;
for(it_elements = mesh->getElements()->begin(); it_elements != mesh->getElements()>end(); it_elements++){
it_elements->second->setBoundaryFlag(boundaryType);
it_elements->second->computeCoefficients(pml_flag, type, spatial_order);
}
/*
if(spatial_order == 3){

//Solo nel caso in cui si utilizza il Truly Upwind

Scheme***********************************************************
map<int,Element*>::iterator it_elements_2;
int i, j, k;
double dist = 0;
double x_barycenter, y_barycenter;
double x_node, y_node;
for(it_elements = mesh->getElements()->begin(); it_elements != mesh->getElements()>end(); it_elements++){
i = 0;
j = 0;
k = 0;
for(it_elements_2 = mesh->getElements()->begin(); it_elements_2 != mesh>getElements()->end(); it_elements_2++){
if((it_elements_2->second->getNode1()==it_elements->second->getNode1())||
(it_elements_2->second->getNode2()==it_elements->second->getNode1())||
(it_elements_2->second->getNode3()==it_elements->second->getNode1())){
it_elements->second->addElement_node_1(it_elements_2->second);
x_node = it_elements->second->getNode1()->getX();
y_node = it_elements->second->getNode1()->getY();
x_barycenter = it_elements_2->second->getBarycenter().getX();
y_barycenter = it_elements_2->second->getBarycenter().getX();
dist = sqrt((x_node-x_barycenter)*(x_node-x_barycenter)+(y_node-y_barycenter)*(y_nodey_barycenter));
it_elements->second->setDistances_node_1(dist, i);
i++;
}
if((it_elements_2->second->getNode1()==it_elements->second->getNode2())||
(it_elements_2->second->getNode2()==it_elements->second->getNode2())||
(it_elements_2->second->getNode3()==it_elements->second->getNode2())){

it_elements->second->addElement_node_2(it_elements_2->second);
x_node = it_elements->second->getNode2()->getX();
y_node = it_elements->second->getNode2()->getY();
x_barycenter = it_elements_2->second->getBarycenter().getX();
y_barycenter = it_elements_2->second->getBarycenter().getX();
dist = sqrt((x_node-x_barycenter)*(x_node-x_barycenter)+(y_node-y_barycenter)*(y_nodey_barycenter));
it_elements->second->setDistances_node_2(dist, j);
j++;
}
if((it_elements_2->second->getNode1()==it_elements->second->getNode3())||
(it_elements_2->second->getNode2()==it_elements->second->getNode3())||
(it_elements_2->second->getNode3()==it_elements->second->getNode3())){
it_elements->second->addElement_node_3(it_elements_2->second);
x_node = it_elements->second->getNode3()->getX();
y_node = it_elements->second->getNode3()->getY();
x_barycenter = it_elements_2->second->getBarycenter().getX();
y_barycenter = it_elements_2->second->getBarycenter().getX();
dist = sqrt((x_node-x_barycenter)*(x_node-x_barycenter)+(y_node-y_barycenter)*(y_nodey_barycenter));
it_elements->second->setDistances_node_3(dist, k);
k++;
}
}
}
for(it_elements = mesh->getElements()->begin(); it_elements != mesh->getElements()>end(); it_elements++){
it_elements->second->computeWeights();
}

//*******************************************************************************************
*************************+
}*/
}
void fvtd2dSolver::createSource(){
cout << "Creazione delle sorgenti in corso..." << endl;
map<int,Element*>::iterator it_elements;
double x_start, y_start, x_end, y_end, x_step, y_step;
string type;
double first_parameter, second_parameter, third_parameter, fourth_parameter;
int nearestElementID;
ifstream infile;
infile.open("Source.dat");
if(!infile){
cerr << "Impossibile to open the source parameter file. The program will be terminated."
<< endl;
exit(EXIT_FAILURE);
}
while(!infile.eof()){
infile >> x_start >> y_start >> type >> first_parameter >> second_parameter >>
third_parameter >> fourth_parameter;
x_step = (x_end - x_start)/6.;
y_step = (y_end - y_start)/6.;
cout << x_step << " " << y_step << endl;
//
//

for (double x = x_start; x <= x_end ; x+=x_step){

for (double y = y_start; y <= y_end ; y+=y_step){

//

nearestElementID = nearestElement(x, y)->getElementID();

//

cout << nearestElementID << endl;

//
for(it_elements = mesh->getElements()->begin(); it_elements !=
mesh->getElements()->end(); it_elements++){
//
{

if (it_elements->second->getElementID() == nearestElementID)

//
it_elements->second->setUpSource(type, first_parameter,
second_parameter, third_parameter, fourth_parameter);
//
y << endl;

cout << "Sorgente impressa nel punto " << x << " " <<

//

//

//
//

}
}

nearestElementID = nearestElement(x_start, y_start)->getElementID();

cout << "Sorgente impressa nel punto " << x_start << " " << y_start << endl;
for(it_elements = mesh->getElements()->begin(); it_elements != mesh->getElements()>end(); it_elements++){
if (it_elements->second->getElementID() == nearestElementID){
it_elements->second->setUpSource(type, first_parameter, second_parameter,
third_parameter, fourth_parameter);
}
}
}
infile.close();
}
Element* fvtd2dSolver::nearestElement(double x, double y){
double x_barycenter, y_barycenter;
double distance = 0.;
double min_distance = 1.e5;
Element* nearestElement;

map<int,Element*>::iterator it_elements;
for(it_elements = mesh->getElements()->begin(); it_elements != mesh->getElements()>end(); it_elements++){
x_barycenter= it_elements->second->getBarycenter().getX();
y_barycenter= it_elements->second->getBarycenter().getY();
distance = sqrt((x - x_barycenter)*(x - x_barycenter) + (y - y_barycenter)*(y y_barycenter));
if (distance <= min_distance){
min_distance = distance;
nearestElement = it_elements->second;
}
}
return nearestElement;
}
void fvtd2dSolver::setOutput(){
double x, y;
ifstream infile("Output.dat");
ofstream outfile("outpoints.dat");
if(!infile){
cerr << "Impossibile to open the output parameter file. The program will be terminated."
<< endl;
exit(EXIT_FAILURE);
}
infile >> print_step;
infile >> test_points_number;
if(test_points_number != 0){
//

test_points = new double[test_points_number*2 +1];

test_elements = new Element*[test_points_number];

}
test_elements[0] = nearestElement(-2.894e-06, -3.8e-06);
outfile << "sorgente " << test_elements[0]->getBarycenter().getX() << "\t" <<
test_elements[0]->getBarycenter().getY() << " elemento " << test_elements[0]>getElementID() << endl;
for(int i=1; i<=test_points_number; i++){
infile >> x >> y;
cout << x << " " << y << endl;
//

test_points [i] = x;

//

test_points [i+1] = y;

test_elements[i] = nearestElement(x, y);

outfile << "punto " << i << "\t" << test_elements[i]->getBarycenter().getX() << "\t" <<
test_elements[i]->getBarycenter().getY() << " elemento " << test_elements[i]>getElementID() << endl;
}
infile.close();
outfile.close();
cout<<"Impostazione della griglia di uscita..."<<endl;
x_dimension = x_end - x_start;
y_dimension = y_end - y_start;
x_step = x_dimension/row;
y_step = y_dimension/col;
grid = new Element*[row*col];
for (int i = 0; i<row; i++){
for (int j = 0; j<col; j++){
grid[i*col + j] = NULL;
grid[i*col + j] = nearestElement(x_start + i*x_step, y_start + j*y_step);
}
}

cout << "Dimensione della griglia = " << row*col << endl;
cout << "Righe = " << row << " Colonne = " << col << " x_step = " << x_step << "
y_step = " << y_step << endl;
cout << "Stampa ogni " << print_step << " passi temporali" << endl;
return;
}
void fvtd2dSolver::solve(){
cout << "Simulazione in corso..." << endl;
int step = 0;
map<int,Element*>::iterator it_elements;
std::stringstream script;
script<<"grafici.plt";
ofstream scriptfile(script.str().c_str());
if(!scriptfile){
cerr << "Impossibile to open the script file. The program will be terminated."<< endl;
exit(EXIT_FAILURE);
}
outfile1.open("electric1.dat");
//

outfile2.open("electric2.dat");

//

outfile3.open("electric3.dat");

//

outfile4.open("electric4.dat");

//

ofstream sourcefile ("outsource.dat");

for (double t= t_start; t<=t_end; t+=delta_t){

for(it_elements = mesh->getElements()->begin(); it_elements != mesh->getElements()>end(); it_elements++){
it_elements->second->updateSource(t);
}
//

if ((order == 1)&&(spatial_order == 3)) {

//
//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//

it_elements->second->computeH_node();

//
//

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//

it_elements->second->computeMiddleFieldH();

//
//

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//

it_elements->second->setUpFieldH();

//
//

//
//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//
//

it_elements->second->updateFieldE(delta_t, fields, step);

}

//
//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//
//

it_elements->second->swapFieldE();
}

//
//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){

//

it_elements->second->updateHardSource(t);

//

//
// //update H
//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//

it_elements->second->computeE_node();

//
//

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//

it_elements->second->computeMiddleFieldE();

//
//

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//

//

it_elements->second->updateSource(t, sourceTester, index);

//

it_elements->second->setUpFieldE();

//
//

//
//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//
//

it_elements->second->updateFieldH(delta_t, fields, step);

}

//
//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//

it_elements->second->swapFieldH();

//

//
//
//

if ((order == 2)&&(spatial_order != 3)){

//**************Lax
Wendroff********************************************************************
for(it_elements = mesh->getElements()->begin(); it_elements != mesh->getElements()>end(); it_elements++){
//

it_elements->second->updateSource(t, sourceTester, index);

it_elements->second->setUpFieldE();
it_elements->second->setUpFieldH();
}
for(it_elements = mesh->getElements()->begin(); it_elements != mesh->getElements()>end(); it_elements++){
it_elements->second->setUpMiddles();
}
for(it_elements = mesh->getElements()->begin(); it_elements != mesh->getElements()>end(); it_elements++){
it_elements->second->predictFieldH(delta_t/2.);
it_elements->second->predictFieldE(delta_t/2.);
}
for(it_elements = mesh->getElements()->begin(); it_elements != mesh->getElements()>end(); it_elements++){
it_elements->second->swapPredictedFieldH();
it_elements->second->swapPredictedFieldE();
}
for(it_elements = mesh->getElements()->begin(); it_elements != mesh->getElements()>end(); it_elements++){

it_elements->second->setUpPredictedFieldE();
it_elements->second->setUpPredictedFieldH();
}
for(it_elements = mesh->getElements()->begin(); it_elements != mesh->getElements()>end(); it_elements++){
it_elements->second->setUpMiddles();
}
for(it_elements = mesh->getElements()->begin(); it_elements != mesh->getElements()>end(); it_elements++){
it_elements->second->correctFieldH(delta_t);
it_elements->second->correctFieldE(delta_t);
}
for(it_elements = mesh->getElements()->begin(); it_elements != mesh->getElements()>end(); it_elements++){
it_elements->second->swapFieldH();
it_elements->second->swapFieldE();
}
for(it_elements = mesh->getElements()->begin(); it_elements != mesh->getElements()>end(); it_elements++){
it_elements->second->updateHardSource(t);
}
//Predictor Corrector con LeapFrog*********************************************************************************
//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//
index);

//

//

it_elements->second->setUpFieldE();

//
//

it_elements->second->updateSource(t, sourceTester,

//
//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//
index);

//

//
step);

it_elements->second->updateSource(t, sourceTester,
it_elements->second->predictFieldH(delta_t/2, fields,

//
//

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//
index);

//

//

it_elements->second->updateSource(t, sourceTester,
it_elements->second->swapPredictedFieldH();

//
//

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//
index);

//

//

it_elements->second->updateSource(t, sourceTester,
it_elements->second->setUpPredictedFieldH();

//
//

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//
index);

//

//
step);

it_elements->second->predictFieldE(delta_t/2, fields,

//
//

it_elements->second->updateSource(t, sourceTester,

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//
//

it_elements->second->swapPredictedFieldE();
}

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//
//

it_elements->second->setUpPredictedFieldE();
}

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//
//

it_elements->second->correctFieldH(delta_t, fields, step);

}

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//
//

it_elements->second->swapFieldH();
}

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//
//

it_elements->second->setUpFieldH();
}

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//
//

it_elements->second->correctFieldE(delta_t, fields, step);

}

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//
//

it_elements->second->swapFieldE();
}

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){

//

it_elements->second->updateHardSource(t);

//

//
}
//

if ((order == 2)&&(spatial_order == 3)){

//
//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//

it_elements->second->computeE_node();

//
//

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//

it_elements->second->computeMiddleFieldE();

//
//

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//

it_elements->second->setUpFieldE();

//
//

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//
index);

//

it_elements->second->updateSource(t, sourceTester,

//
step);

it_elements->second->predictFieldH(delta_t/2, fields,

//
//

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//
index);

//

//

it_elements->second->updateSource(t, sourceTester,
it_elements->second->swapPredictedFieldH();

//
//

// //Prediciamo E
//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//

it_elements->second->computeH_nodePredicted();

//
//

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//

it_elements->second->computePredictedMiddleFieldH();

//
//

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//

it_elements->second->setUpPredictedFieldH();

//
//

//
//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//
index);
//
step);

//

it_elements->second->updateSource(t, sourceTester,
it_elements->second->predictFieldE(delta_t/2, fields,

//

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//
index);

//

it_elements->second->updateSource(t, sourceTester,

//

it_elements->second->swapPredictedFieldE();

//
//

//
// //Correggiamo il valore di H
//
//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//

it_elements->second->computeE_nodePredicted();

//
//

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//

it_elements->second->computePredictedMiddleFieldE();

//
//

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//
//

it_elements->second->setUpPredictedFieldE();
}

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//
//

it_elements->second->correctFieldH(delta_t, fields, step);

}

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//
//

it_elements->second->swapFieldH();
}

//
// //Correggiamo il valore di E
//
//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//

it_elements->second->computeH_node();

//
//

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//

it_elements->second->computeMiddleFieldH();

//
//

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//
//

it_elements->second->setUpFieldH();
}

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//
//

it_elements->second->correctFieldE(delta_t, fields, step);

}

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//
//

it_elements->second->swapFieldE();
}

//
for(it_elements = mesh->getElements()->begin(); it_elements != mesh>getElements()->end(); it_elements++){
//

it_elements->second->updateHardSource(t);

//

//
//
//

//BISOGNA CREARE I FILE DI USCITA PER GRAFICARE I PUNTI DI MISURA

//

cout << "test" << endl;

//

cout << out_files[i] << " " << *out_files[i] << endl;

outfile1 << t << "\t" << test_elements[0]->getJ_z();

for (int i = 1; i <= test_points_number; i++){
outfile1 << "\t" << test_elements[i]->getE_z_old() << "\t";
}
outfile1 << endl;
//

outfile2 << t << "\t" << test_elements[1]->getE_z_old() << endl;

//

outfile3 << t << "\t" << test_elements[2]->getE_z_old() << endl;

//

outfile4 << t << "\t" << test_elements[3]->getE_z_old() << endl;

//

sourcefile << t << "\t" << test_elements[4]->getJ_z() << endl;

//
if ((step%print_step)==0){
std::stringstream temp;
temp<<"Risultati/fvtd2D_time_"<<t<<".dat";
ofstream outfile(temp.str().c_str());
if(!outfile){
cerr << "Impossibile to open the output file. The program will be terminated."<< endl;
exit(EXIT_FAILURE);

}
int riga = 0;
int off = 0;
for (int i=0; i<row; i++){
for (int j=0; j<col; j++){
if((grid[i*col + j]->getBarycenter().getX()*grid[i*col + j]->getBarycenter().getX() +
grid[i*col + j]->getBarycenter().getY()*grid[i*col + j]->getBarycenter().getY())>2){
outfile << i << "\t" << j << "\t" << 0. << endl;
}else{
outfile << i << "\t" << j << "\t" << grid[i*col + j]->getE_z_old() << "\t" << grid[i*col + j]>getAlphaE() << "\t" << log (abs(grid[i*col + j]->getE_z_old()) + 1.e-20) << "\t" << endl;
}
}
outfile << endl;
}
outfile.close();
scriptfile << "set pm3d map" << "\n" << "set size ratio -1" << "\n" << "set cbrange [:]\n"
<< "splot '" << temp.str().c_str() << "' using (($1/"<< row << "*" << x_dimension << ")
+" << x_start << "):(($2/" << col << "*" << y_dimension << ")+" << y_start << "):($3/2)
" << "title 'T = " << t/1.e-9 << " ns'" << endl;
scriptfile << "set xlabel 'x [m]'" << endl;
scriptfile << "set ylabel 'y [m]'" << endl;
scriptfile << "set cblabel 'E [V/m]'" << endl;
scriptfile << "set terminal png " << "\n" << "set output " << "'image_time_" <<
int(round(t/delta_t)) << ".png'" << "\n" << "repl" << endl;
}
step++;
}
scriptfile.close();

outfile1.close();
//

outfile2.close();

//

outfile3.close();

//

outfile4.close();

cout << "Terminato." << endl;

}
using namespace std;
int main(int argc, char *argv[])
{
#ifdef DEBUG
Point2DTester point2DTester;
point2DTester.test();
NodeTester nodeTester;
nodeTester.test();
ElementTester elementTester;
elementTester.test();
#endif
/*

Mesh mesh("prova.2.node", "prova.2.ele", "prova.2.node");*/

//

Mesh mesh("test_data/nodes.dat", "test_data/elements.dat", "test_data/media.dat");

//

cout << &mesh << endl;

//
//

mesh.printBoundaryNodes("boundary.dat");

//

*///cout << "PIPPO" << endl;

//
MeshGen generator("test_data/test.0.node", "test_data/test.0.ele",
"test_data/parametri.dat", 50, 50, 0.02, 0.02, 0., 0.);
fvtd2dSolver solver;
//

solver.inizialize();

solver.solve();
return EXIT_SUCCESS;
}