diff --git a/config.pri b/config.pri
index 3585baa5ad96c0f2d357e008912b9fa157001511..99d1f938d68578c597b918b5af92aa13d401da9f 100644
--- a/config.pri
+++ b/config.pri
@@ -29,7 +29,7 @@ unix:VTK_LIBPATH = -L/usr/local/lib
# Pathes
# -Home Directory
-HOME_DIR = /home/rzlin/er96apow/git/
+HOME_DIR = /home/pflaum/UGBlocks
#HOME_DIR = ../../
# -UGBlocks Directory
diff --git a/program/main.cc b/program/main.cc
index 2ac9d1fe4d07efe6cd06eb055b8cf94f7eb2a969..26f216581971eceb1329a49ffe038b6312817770 100644
--- a/program/main.cc
+++ b/program/main.cc
@@ -6,6 +6,108 @@
#include "source/ugblock.h"
+
+/** Kern_matrix
+*** 6 x 6 matrix for rigid body modes
+**/
+Kern_matrix::Kern_matrix() {
+ matrix = new double*[6];
+ for(int i=0;i<6;++i)
+ matrix[i] = new double[6];
+
+ aux_matrix = new double*[6];
+ for(int i=0;i<6;++i)
+ aux_matrix[i] = new double[6];
+ perm = new int[6];
+ b = new double[6];
+ x = new double[6];
+}
+
+Kern_matrix::~Kern_matrix() {
+ for(int i=0;i<6;++i) {
+ delete[](matrix[i]);
+ delete[](aux_matrix[i]);
+ }
+ delete[](matrix);
+ delete[](aux_matrix);
+ delete[](perm);
+ delete[](b);
+ delete[](x);
+}
+
+
+void Calc_weights(Variable<double>& One,
+ Variable<double>& Xcoord, Variable<double>& Ycoord, Variable<double>& Zcoord,
+ Kern_matrix& M) {
+ double weight_const;
+ One = 1.0;
+ weight_const = sqrt(product(One,One));
+ One = One / weight_const;
+
+ // erste Zeile
+ M.matrix[0][0] = 1.0;
+ M.matrix[0][1] = 0.0;
+ M.matrix[0][2] = 0.0;
+
+ M.matrix[0][3] = 0.0;
+ M.matrix[0][4] = product(One,Zcoord);
+ M.matrix[0][5] = - product(One,Ycoord);
+
+ // zweite Zeile
+ M.matrix[1][0] = 0.0;
+ M.matrix[1][1] = 1.0;
+ M.matrix[1][2] = 0.0;
+
+ M.matrix[1][3] = - product(One,Zcoord);
+ M.matrix[1][4] = 0.0;
+ M.matrix[1][5] = product(One,Xcoord);
+
+ // dritte Zeile
+
+
+ M.matrix[2][0] = 0.0;
+ M.matrix[2][1] = 0.0;
+ M.matrix[2][2] = 1.0;
+
+ M.matrix[2][3] = product(One,Ycoord);
+ M.matrix[2][4] = - product(One,Xcoord);
+ M.matrix[2][5] = 0.0;
+
+ // vierte Zeile
+ M.matrix[3][0] = 0.0;
+ M.matrix[3][1] = - product(One,Zcoord);
+ M.matrix[3][2] = product(One,Ycoord);
+
+ M.matrix[3][3] = product(Zcoord,Zcoord) + product(Ycoord,Ycoord);
+ M.matrix[3][4] = - product(Ycoord,Xcoord);
+ M.matrix[3][5] = - product(Xcoord,Zcoord);
+
+ // fuenfte Zeile
+ M.matrix[4][0] = product(One,Zcoord);
+ M.matrix[4][1] = 0.0;
+ M.matrix[4][2] = - product(One,Xcoord);
+
+ M.matrix[4][3] = - product(Xcoord,Ycoord);
+ M.matrix[4][4] = product(Zcoord,Zcoord) + product(Xcoord,Xcoord);
+ M.matrix[4][5] = - product(Ycoord,Zcoord);
+
+ // sechste Zeile
+ M.matrix[5][0] = - product(One,Ycoord);
+ M.matrix[5][1] = product(One,Xcoord);
+ M.matrix[5][2] = 0.0;
+
+ M.matrix[5][3] = - product(Xcoord,Zcoord);
+ M.matrix[5][4] = - product(Ycoord,Zcoord);
+ M.matrix[5][5] = product(Ycoord,Ycoord) + product(Xcoord,Xcoord);
+
+ // Calc LR-decomposition
+ int result;
+ result = gauss(1,6,M.matrix,M.aux_matrix,M.perm,M.b,M.x,&(M.signd));
+ if(result!=0)std::cout << " error in gauss: " << result <<std::endl;
+}
+
+
+
double sinus (double x){
return sin(x);
}
diff --git a/program/source/grid/examples_ug.cc b/program/source/grid/examples_ug.cc
index df5070071671b397be50c845aa2a595d5c63ec2a..029ee5ca717061abf5aaefa9f20876b80a08d7c8 100644
--- a/program/source/grid/examples_ug.cc
+++ b/program/source/grid/examples_ug.cc
@@ -109,6 +109,74 @@ Hexahedron::Hexahedron(double lx, double ly, double lz,
construction_done();
}
+HexahedronRotY::HexahedronRotY(double lx, double ly, double lz, double rx, double ry, double rz, double sa)
+ : UG_WithZdirection(hexahedronUgTyp,2){
+ constructionParameters.resize(7);
+ constructionParameters[0] = lx;
+ constructionParameters[1] = ly;
+ constructionParameters[2] = lz;
+ constructionParameters[3] = rx;
+ constructionParameters[4] = ry;
+ constructionParameters[5] = rz;
+ constructionParameters[6] = sa;
+
+ Lz.at(0) = lz;
+ Lz.at(1) = rz;
+ Set_number_points ( 8 ); // 8 an den Ecken
+
+ assert(sa*sa <=1.0);
+ double ca = sqrt(1.0 - sa*sa);
+
+ double sx = 0.5*(rx-lx);
+ double sz = 0.5*(rz-lz);
+
+ double ETz = ca * sz - sa * sx;
+ double ETx = sa * sz + ca * sx;
+
+ double WTz = ca * sz + sa * sx;
+ double WTx = sa * sz - ca * sx;
+
+ double EDz = -ca * sz - sa * sx;
+ double EDx = -sa * sz + ca * sx;
+
+ double WDz = -ca * sz + sa * sx;
+ double WDx = -sa * sz - ca * sx;
+
+ double centerX = 0.5*(rx+lx);
+ double centerZ = 0.5*(rz+lz);
+
+
+ Set_coordinate_point ( WSDdir3D, D3vector ( centerX + WDx,ly, centerZ + WDz ) );
+ Set_coordinate_point ( ESDdir3D, D3vector ( centerX + EDx,ly, centerZ + EDz ) );
+ Set_coordinate_point ( WNDdir3D, D3vector ( centerX + WDx,ry, centerZ + WDz ) );
+ Set_coordinate_point ( ENDdir3D, D3vector ( centerX + EDx,ry, centerZ + EDz ) );
+
+ Set_coordinate_point ( WSTdir3D, D3vector ( centerX + WTx,ly, centerZ + WTz ) );
+ Set_coordinate_point ( ESTdir3D, D3vector ( centerX + ETx,ly, centerZ + ETz ) );
+ Set_coordinate_point ( WNTdir3D, D3vector ( centerX + WTx,ry, centerZ + WTz ) );
+ Set_coordinate_point ( ENTdir3D, D3vector ( centerX + ETx,ry, centerZ + ETz ) );
+
+ Set_number_hexahedra ( 1 );
+ Set_hexahedron ( 0, WSDdir3D, ESDdir3D, WNDdir3D, ENDdir3D, WSTdir3D, ESTdir3D, WNTdir3D, ENTdir3D );
+
+ construction_hexahedron_points_done();
+ // set all directions constant
+ Give_not_constant_directions()->Mark_x_as_not_constant_at ( 0,false );
+ Give_not_constant_directions()->Mark_y_as_not_constant_at ( 0,false );
+ Give_not_constant_directions()->Mark_z_as_not_constant_at ( 0,false );
+
+ // no transformations of the edges and faces
+ construction_done();
+}
+
+void HexahedronBasis::PrintLengthEdgesHere(std::vector<D3vector> pointsHere) {
+ cout << " Print Hexaeder info of UGBlocks. " << endl;
+ cout << " -------------------------------- " << endl;
+ cout << " L1: " << D3VectorNorm(pointsHere.at(WSDdir3D) - pointsHere.at(ESDdir3D)) << endl;
+ cout << " L1: " << D3VectorNorm(pointsHere.at(WSDdir3D) - pointsHere.at(WNDdir3D)) << endl;
+ cout << " L1: " << D3VectorNorm(pointsHere.at(WSDdir3D) - pointsHere.at(WSTdir3D)) << endl;
+}
+
Hexahedron::Hexahedron ( double l_x, double l_y, double l_z ) : UG_WithZdirection(hexahedronUgTyp,2) {
Lz.at(0) = 0.0;
Lz.at(1) = l_z;
diff --git a/program/source/grid/examples_ug.h b/program/source/grid/examples_ug.h
index fc9da5d139e068099caaf607bfa494d49719fe63..885502577f490cafca50c01f3202566501bbf32c 100644
--- a/program/source/grid/examples_ug.h
+++ b/program/source/grid/examples_ug.h
@@ -20,13 +20,18 @@
#define EXAMPLES_UG_H
#include <vector>
+class HexahedronBasis {
+protected:
+ void PrintLengthEdgesHere(std::vector<D3vector> pointsHere);
+};
+
/** \addtogroup GridGeneration **/
/* @{ */
/**
* Normaler Hexaeder
*
* **/
-class Hexahedron : public UG_WithZdirection {
+class Hexahedron : public HexahedronBasis , public UG_WithZdirection{
public:
/**
* [0,lx] x [0,ly] x [0,lz]
@@ -37,7 +42,28 @@ class Hexahedron : public UG_WithZdirection {
*/
Hexahedron(double lx, double ly, double lz,
double rx, double ry, double rz);
+
+ void PrintLengthEdges() { PrintLengthEdgesHere(getVectorOfPoints()); }
+
~Hexahedron(){};
+
+};
+
+/**
+ * Hexaeder rotated Y
+ *
+ * **/
+class HexahedronRotY : public HexahedronBasis, public UG_WithZdirection {
+ public:
+ /**
+ * [lx,rx] x [ly,ry] x [lz,rz] und rotiert um das Zentrum ((lx+rx)/2, (ly+ry)/2, (lz+rz)/2)
+ */
+ HexahedronRotY(double lx, double ly, double lz,
+ double rx, double ry, double rz, double sinRotY);
+
+ void PrintLengthEdges() { PrintLengthEdgesHere(getVectorOfPoints()); }
+
+ ~HexahedronRotY(){};
};
/**
diff --git a/program/source/grid/examples_ug_optics.h b/program/source/grid/examples_ug_optics.h
index a9cb3af86ced3858420060392f6b8398db983ca6..9c2e3284dca707d753bcb8615f6b5156623c79b1 100644
--- a/program/source/grid/examples_ug_optics.h
+++ b/program/source/grid/examples_ug_optics.h
@@ -3,11 +3,17 @@
#include <vector>
+class GeometryWithBoundaryPoints {
+public:
+ std::vector<D3vector> getBoundaryPoints(){return boundaryPoints;}
+protected:
+ std::vector<D3vector> boundaryPoints;
+};
/** \addtogroup GridGeneration **/
/* @{ */
-class Lens_Geometry : public Unstructured_grid {
+class Lens_Geometry : public Unstructured_grid {
public:
Lens_Geometry(double Radius, double thickness, double curvatureLeft, double curvatureRight, double offsetX, double offsetY, double offsetZ, bool inner_grid_arched = false, double radius = 0.0);
~Lens_Geometry(){};
@@ -20,7 +26,7 @@ class Lens_Geometry : public Unstructured_grid {
};
-class Lens_Geometry_Quad : public Unstructured_grid {
+class Lens_Geometry_Quad : public GeometryWithBoundaryPoints, public Unstructured_grid {
public:
Lens_Geometry_Quad(double Radius, double thickness, double curvatureLeft, double curvatureRight, double offsetX, double offsetY, double offsetZ, bool inner_grid_arched = false, double radius = 0.0, double cut_edge_from_left = 0, double cut_edge_from_right = 0);
~Lens_Geometry_Quad(){};
@@ -31,8 +37,7 @@ class Lens_Geometry_Quad : public Unstructured_grid {
double getOffsetY(){return offsetY_;};
double getOffsetZ(){return offsetZ_;};
double getFocalLength(){return focalLength_;};
- private:
-
+ private:
double Radius_;
double radius_;
double thickness_;
@@ -42,7 +47,7 @@ class Lens_Geometry_Quad : public Unstructured_grid {
double focalLength_;
};
-class Lens_Geometry_cutted_edges : public Unstructured_grid {
+class Lens_Geometry_cutted_edges : public GeometryWithBoundaryPoints, public Unstructured_grid {
public:
Lens_Geometry_cutted_edges(double RadiusLeft, double RadiusRight, double MechanicalRadiusLeft,double MechanicalRadiusRight, double thickness, double curvatureLeft, double curvatureRight, double offsetX, double offsetY, double offsetZ, bool inner_grid_arched = false, double radius = 0.0);
~Lens_Geometry_cutted_edges(){};
diff --git a/program/source/grid/ug.cc b/program/source/grid/ug.cc
index 48a82a1d78c9b957da4288c861de267c0836c2ca..18b5329d6dda885035271a357cb8b5f55f25c36f 100644
--- a/program/source/grid/ug.cc
+++ b/program/source/grid/ug.cc
@@ -209,6 +209,15 @@ void Unstructured_grid::Set_coordinate_point(int id, D3vector coord) {
points[id].Set_coordinate(coord);
}
+std::vector<D3vector> Unstructured_grid::getVectorOfPoints() {
+ std::vector<D3vector> pointsReturn;
+ pointsReturn.resize(num_points);
+ for(int i=0;i<num_points;++i) {
+ pointsReturn.at(i) = points[i].Give_coordinate();
+ }
+ return pointsReturn;
+}
+
void Unstructured_grid::Set_number_hexahedra(int num_hexahedra_) {
// Set informations of hexahedra
num_hexahedra = num_hexahedra_;
diff --git a/program/source/grid/ug.h b/program/source/grid/ug.h
index 19c03db5c240717c7f1ab02a26212f9193704c9e..a08c48b5677e33cc1e57bd5d9ab4b7169dfa7efd 100644
--- a/program/source/grid/ug.h
+++ b/program/source/grid/ug.h
@@ -121,7 +121,8 @@ class Zordering {
// main class describing an unstructured grid
//////////////////////////////////////////////////////////////////
-enum TypeOfUG { noWithZTyp = 0, hexahedronUgTyp = 1, cylinderUgTyp = 2, cylinderListUgTyp = 3, hexahedronAdaptiveUgTyp = 4, hexahedronListUgTyp = 5,hexahedronListTestUgTyp = 6, lensUgTyp = 7 };
+enum TypeOfUG { noWithZTyp = 0, hexahedronUgTyp = 1, cylinderUgTyp = 2, cylinderListUgTyp = 3, hexahedronAdaptiveUgTyp = 4, hexahedronListUgTyp = 5,hexahedronListTestUgTyp = 6,
+ lensUgTyp = 7 };
// This is base class of every object which needs data from ug Unstructured_grid
class Object_based_on_ug {
@@ -294,12 +295,14 @@ class Unstructured_grid : public Partitioning {
Zordering* Give_Zordering() { return zordering; }
double* Get_pointer_global_data() { return pointer_global_data; }
- std::vector<D3vector> getBoundaryPoints(){return boundaryPoints;}
+
+ std::vector<D3vector> getVectorOfPoints();
+
int sizeGlobalPointerData() { return size_pointer_global_data; }
protected:
// pointer for global objects used in coordinate transformations
double* pointer_global_data;
- std::vector<D3vector> boundaryPoints;
+
int size_pointer_global_data;
TypeOfUG typFuerSlice;
diff --git a/program/source/interpol/interpol.cc b/program/source/interpol/interpol.cc
index 15722aa4fa473b0da1deb5d39723542a40181481..b95dec6463eb0e1f7094cfda5e739a01506e467b 100644
--- a/program/source/interpol/interpol.cc
+++ b/program/source/interpol/interpol.cc
@@ -5163,3 +5163,150 @@ void Interpolate_on_block_grid_from_pointinterpolator::interpolate(Variable<doub
}
+void Interpolate_fromOneXZhexaeder::Copy(Variable<double> &toData, Variable<double> &fromData) {
+// toData = fromData;
+// return;
+
+ init(fromData);
+ fromData.UpdateHexahedra();
+
+ Blockgrid* bg = toData.Give_blockgrid();
+
+ X_coordinate X(*bg);
+ Y_coordinate Y(*bg);
+ Z_coordinate Z(*bg);
+
+ Functor3<double,double,Interpolate_fromOneXZhexaeder> interpolRotated(this);
+
+ toData = interpolRotated(X,Y,Z);
+}
+
+
+void Interpolate_fromOneXZhexaeder::Add( Variable<double> &toData, Variable<double> &addData) {
+ init(addData);
+ addData.UpdateHexahedra();
+
+ Blockgrid* bg = toData.Give_blockgrid();
+
+ X_coordinate X(*bg);
+ Y_coordinate Y(*bg);
+ Z_coordinate Z(*bg);
+
+ Functor3<double,double,Interpolate_fromOneXZhexaeder> interpolRotated(this);
+
+//TEST NOW
+ toData = toData + interpolRotated(X,Y,Z);
+}
+
+
+
+double Interpolate_fromOneXZhexaeder::evaluate(double px, double py, double pz) {
+ double xP = px - xOrg;
+ double yP = py - yOrg;
+ double zP = pz - zOrg;
+
+ xP = xP * 1.0000001;
+ yP = yP * 1.0000001;
+ zP = zP * 1.0000001;
+
+ double zRot = zP * cosA + xP * sinA;
+ double xRot = - zP * sinA + xP * cosA;
+
+// if((zP<=0.0) || (yP<=0.0) || (xP<=0.0)) return defaultVal;
+// if((zP>=LZ ) || (yP>=LY ) || (xP>=LX )) return defaultVal;
+
+ int k = int(zRot / hZ);
+ int j = int(yP / hY);
+ int i = int(xRot / hX);
+
+ if(k<0) { if(k>-0.00001) k=0; else return defaultVal; }
+ if(j<0) { if(j>-0.00001) j=0; else return defaultVal; }
+ if(i<0) { if(i>-0.00001) i=0; else return defaultVal; }
+
+ if(k>=Nz) { if(k<=Nz+0.00001) k=Nz-1; else return defaultVal; }
+ if(j>=Ny) { if(j<=Ny+0.00001) j=Ny-1; else return defaultVal; }
+ if(i>=Nx) { if(i<=Nx+0.00001) i=Nx-1; else return defaultVal; }
+
+//cout << " i: " << i << " j: " << j << " k: " << k
+// << " xRot/hX: " << xRot/hX << " yP/hY: " << yP/hY << " zRot / hZ: " << zRot/hZ << endl;
+
+ double uWSD = hexFrom[((Ny+1)*k+j)*(Nx+1)+i];
+ double uESD = hexFrom[((Ny+1)*k+j)*(Nx+1)+i+1];
+ double uWND = hexFrom[((Ny+1)*k+j+1)*(Nx+1)+i];
+ double uEND = hexFrom[((Ny+1)*k+j+1)*(Nx+1)+i+1];
+ double uWST = hexFrom[((Ny+1)*(k+1)+j)*(Nx+1)+i];
+ double uEST = hexFrom[((Ny+1)*(k+1)+j)*(Nx+1)+i+1];
+ double uWNT = hexFrom[((Ny+1)*(k+1)+j+1)*(Nx+1)+i];
+ double uENT = hexFrom[((Ny+1)*(k+1)+j+1)*(Nx+1)+i+1];
+
+// assert(((Ny+1)*(k+1)+j+1)*(Nx+1)+i+1 < (Nx+1)*(Ny+1)*(Nz+1));
+
+ double fz = zRot/hZ - k;
+ double fy = yP/hY - j;
+ double fx = xRot/hX - i;
+
+ return ((uWSD * (1.0-fx) + uESD * fx) * (1.0-fy) +
+ (uWND * (1.0-fx) + uEND * fx) * fy ) * (1.0-fz) +
+ ((uWST * (1.0-fx) + uEST * fx) * (1.0-fy) +
+ (uWNT * (1.0-fx) + uENT * fx) * fy ) * fz;
+
+ return hexFrom[((Ny+1)*k+j)*(Nx+1)+i];
+}
+
+void Interpolate_fromOneXZhexaeder::init(Variable<double> &fromData) {
+ Blockgrid* bg = fromData.Give_blockgrid();
+ hexFrom = fromData.Give_pointer_data_hexahedra()[0];
+
+ Unstructured_grid* ug = bg->Give_unstructured_grid();
+ Hexahedron_el* hex = ug->Give_hexahedron(0);
+
+// enum dir3D_sons { WSDdir3D, ESDdir3D, WNDdir3D, ENDdir3D, WSTdir3D, ESTdir3D, WNTdir3D, ENTdir3D };
+ D3vector pWSD = hex->Give_coord(WSDdir3D);
+ D3vector pWST = hex->Give_coord(WSTdir3D);
+ D3vector pESD = hex->Give_coord(ESDdir3D);
+ D3vector pWND = hex->Give_coord(WNDdir3D);
+
+ xOrg = pWSD.x;
+ yOrg = pWSD.y;
+ zOrg = pWSD.z;
+
+ double xZ = pWST.x - xOrg;
+ double zZ = pWST.z - zOrg;
+
+ double xX = pESD.x - xOrg;
+ double zX = pESD.z - zOrg;
+
+ LY = pWND.y - yOrg;
+
+ LZ = sqrt(xZ*xZ+zZ*zZ);
+ LX = sqrt(xX*xX+zX*zX);
+
+ cosA = zZ / LZ;
+ sinA = xZ / LZ;
+
+ Nx = bg->Give_Nx_hexahedron(0);
+ Ny = bg->Give_Ny_hexahedron(0);
+ Nz = bg->Give_Nz_hexahedron(0);
+
+ hX = LX / Nx;
+ hY = LY / Ny;
+ hZ = LZ / Nz;
+
+/*
+cout << " hX: " << hX << " hY: " << hY << " hZ: " << hZ
+ << " Nx: " << Nx << " Ny: " << Ny << " Nz: " << Nz
+ << " LX: " << LX << " LY: " << LY << " LZ: " << LZ << endl
+ << " cosA: " << cosA << " sinA: " << sinA
+ << endl;
+ */
+
+}
+
+/*
+ private:
+ double xOrg;
+ double zOrg;
+
+ double cosA;
+ double sinA;
+*/
diff --git a/program/source/interpol/interpol.h b/program/source/interpol/interpol.h
index 5a8271155bdddb7e451ae6ff6abda21f7a179367..77b33cc16eac90f26f907d6b55d7f41b6f8a164a 100644
--- a/program/source/interpol/interpol.h
+++ b/program/source/interpol/interpol.h
@@ -30,6 +30,7 @@
// 2. Interpolate from blockgrid to blockgrid
// 3. Interpolate from Variable on a blockgrid to any point using structured intermediate grid
// 4. Interpolate from blockgrid direct to any point
+// 5. Interpolate from xz-rotated Hexaeder Block
/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////
@@ -622,7 +623,50 @@ DTyp Interpolate_direct::evaluateSurface(Variable<DTyp> &u)
}
+/////////////////////////////////////////////////////////////
+// 5. Interpolate from xz-rotated Hexaeder Block
+/////////////////////////////////////////////////////////////
+/** \addtogroup InterpolationOperators **/
+/* @{ */
+/**
+ * Interpolate from a single xz-rotated Hexaeder Block
+***/
+class Interpolate_fromOneXZhexaeder {
+ public:
+ Interpolate_fromOneXZhexaeder(double defaultValue) { defaultVal = defaultValue; };
+
+ void Copy(Variable<double> &toData, Variable<double> &fromData);
+ void Add( Variable<double> &toData, Variable<double> &addData);
+
+ double evaluate(double px, double py, double pz);
+
+ private:
+ void init(Variable<double> &fromData);
+
+ double defaultVal;
+
+ double xOrg;
+ double yOrg;
+ double zOrg;
+
+ double LZ;
+ double LY;
+ double LX;
+
+ int Nz;
+ int Ny;
+ int Nx;
+
+
+ double hZ;
+ double hY;
+ double hX;
+ double *hexFrom;
+
+ double cosA;
+ double sinA;
+};
#endif // INTERPOL_H
diff --git a/program2D/source/extemp/interpolateFrom3D.cc b/program2D/source/extemp/interpolateFrom3D.cc
index b66dd60a9485d5b80adf42c5952d3ad0684cbf8b..239aa81208f073e3d78f0bf2649ae4a486901761 100644
--- a/program2D/source/extemp/interpolateFrom3D.cc
+++ b/program2D/source/extemp/interpolateFrom3D.cc
@@ -168,6 +168,11 @@ void IteratorZDirection::endBlock(int numBlock) {
else z_Wert = zRight - hz;
}
+bool IteratorZDirection::nextDirection(bool right) {
+ if(right) return next();
+ return previous();
+}
+
bool IteratorZDirection::next() {
if(k==Nz) {
if(nummernBloecke == nummerBlock+1) return false;
@@ -202,6 +207,11 @@ bool IteratorZDirection::previous() {
return true;
}
+void IteratorZDirection::gotoStartDirection(bool right) {
+ if(right) gotoFront();
+ else gotoEnd();
+}
+
void IteratorZDirection::gotoFront() {
index = 0;
//Start-Werte setzen:
diff --git a/program2D/source/extemp/interpolateFrom3D.h b/program2D/source/extemp/interpolateFrom3D.h
index 84e4bb54221a1a589d32fb15e4c2df13d18aeea1..69556bd5aec6cd44c5b1ff9fd0d980576e64e9b7 100644
--- a/program2D/source/extemp/interpolateFrom3D.h
+++ b/program2D/source/extemp/interpolateFrom3D.h
@@ -66,8 +66,10 @@ public:
bool next(); ///> nächster slice in z-Richtung
bool has_next(); ///> true falls es nächsten slice in z-Richtung gibt
bool previous(); ///> vorheriger slice in z-Richtung
+ bool nextDirection(bool right); ///> nächster oder vorheriger slice in z-Richtung, nächster falls right==true
void gotoFront(); ///> geh zum ersten slice in z-Richtung, dies ist default beim constructor
void gotoEnd(); ///> geh zum letzten slice in z-Richtung
+ void gotoStartDirection(bool right); ///> geh zum start slice in z-Richtung in Richtung right
int get_k() { return index; } ///> globaler NummerierungsIndex: 0, ... , getSize()-1
int getSize() { return totalNumberSlices; } ///> maximale Anzahl der indizes