function varargout = AnaSoft(varargin)
% AnaSoft M-file for AnaSoft.fig
%      AnaSoft, by itself, creates a new AnaSoft or raises the existing
%      singleton*.
%
%      H = AnaSoft returns the handle to a new AnaSoft or the handle to
%      the existing singleton*.
%
%      AnaSoft('CALLBACK',hObject,eventData,handles,...) calls the local
%      function named CALLBACK in AnaSoft.M with the given input arguments.
%
%      AnaSoft('Property','Value',...) creates a new AnaSoft or raises the
%      existing singleton*.  Starting from the left, property value pairs are
%      applied to the GUI before AnaSoft_OpeningFcn gets called.  An
%      unrecognized property name or invalid value makes property application
%      stop.  All inputs are passed to AnaSoft_OpeningFcn via varargin.
%
%      *See GUI Options on GUIDE's Tools menu.  Choose "GUI allows only one
%      instance to run (singleton)".
%
% See also: GUIDE, GUIDATA, GUIHANDLES

% Edit the above text to modify the response to help AnaSoft

% Last Modified by GUIDE v2.5 25-Oct-2010 16:19:52

% Begin initialization code - DO NOT EDIT
gui_Singleton = 1;
gui_State = struct('gui_Name',       mfilename, ...
                   'gui_Singleton',  gui_Singleton, ...
                   'gui_OpeningFcn', @AnaSoft_OpeningFcn, ...
                   'gui_OutputFcn',  @AnaSoft_OutputFcn, ...
                   'gui_LayoutFcn',  [] , ...
                   'gui_Callback',   []);
if nargin && ischar(varargin{1})
    gui_State.gui_Callback = str2func(varargin{1});
end

if nargout
    [varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
else
    gui_mainfcn(gui_State, varargin{:});
end
% End initialization code - DO NOT EDIT


% --- Executes just before AnaSoft is made visible.
function AnaSoft_OpeningFcn(hObject, eventdata, handles, varargin)
% This function has no output args, see OutputFcn.
% hObject    handle to figure
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
% varargin   command line arguments to AnaSoft (see VARARGIN)


% Choose default command line output for AnaSoft
handles.output = hObject;

% Update handles structure
guidata(hObject, handles);

% UIWAIT makes AnaSoft wait for user response (see UIRESUME)
% uiwait(handles.figure1);


% --- Outputs from this function are returned to the command line.
function varargout = AnaSoft_OutputFcn(hObject, eventdata, handles) 
% varargout  cell array for returning output args (see VARARGOUT);
% hObject    handle to figure
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

% Get default command line output from handles structure
varargout{1} = handles.output;


% --- Executes on button press in Oeffnenvor.                              % Entspricht Einlesen
function Oeffnenvor_Callback(hObject, eventdata, handles)
% hObject    handle to Oeffnenvor (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

% Einlesen vom Wafer

[txtfile,path2txt] = uigetfile('*.txt','Bitte Datei auswählen');           %Datei kann vom Nutzer selbst gewählt werden
fid = fopen(fullfile(path2txt,txtfile),'r');
    rawdata1 = textscan(fid,'%f %f %f','headerlines',8);                   %Überschrift entfernen
    data1 = rawdata1{3};                                                   %nur die dritte Spalte einlesen
    dataz = reshape(data1,10000,1);                                        %Z-Vektor als Spaltenvektor von 1-10000 erzeugen
    data1 = reshape(data1,100,100);                                        %100x100 Matrix aus Vektor data erzeugen
    %rawdata2 =  textscan(fid,'%f %f %f','headerlines',5);                  %Einlesen der Zeile 6 und 7 (XRange, YRange) 
    %messbereichx = rawdata2{7};                                            %Extraktion der Ziffern 
    %XRange = messbereichx;
fclose(fid);


%Aufteilung von 100 Messwerten auf jeweiliger Achse
%Beginn bei x=0 und y=0

XRange=0.106977 * 10^9;                                                    %Länge der Messstrecke in x Richtung (in mm)
betragx = XRange/99;                                                       %gleichmäßige Aufteilung der Messpunkte auf x
wertx = 0;                                                                 %Startwert x=0
vektorx = wertx + (0:99)*betragx;                                          %gleichmäßige aufteilung der Messstrecken (x-Richtung)
vektorx = vektorx';                                                        %Transponieren des Vektors
X = repmat(vektorx(:), 1, 100);                                            %Vektor um 100 vervielfachen
spaltenvektor_x = reshape(X, 10000, 1);                                    %Spaltenvektor erzeugen          

YRange=0.101432 * 10^9;                                                    %Länge der Messstrecke in y Richtung (in mm)
betragy = YRange/99;                                                       %gleichmäßige Aufteilung der Messpunkte auf y
werty = 0;                                                                 %Startwert y=0
vektory = werty + (0:99)*betragy;                                          %gleichmäßige aufteilung der Messstrecken (x-Richtung)
Y = repmat(vektory(:), 1, 100);                                            %Vektor um 100 vervielfachen
spaltenvektor_y = reshape(Y, 10000, 1);                                    %Spaltenvektor erzeugen


%Berechnung der Geraden
%in x-Richtung

data_2d_x = data1(50 , :);                                                 %Profilvektor aus Matrix data1 erzeugen
wertmax_x = max(data_2d_x);                                                %Maximum des Profilvektors
zeilemax_x = find (data_2d_x == wertmax_x);                                %finde Position des Maximums
wertmin_x = min(data_2d_x(data_2d_x > 1));                                 %Minimum des Profilvektors
zeilemin_x = find (data_2d_x == wertmin_x);                                %finde Position des Minimums

%eliminieren der Verkippung der Geraden in x-Richtung

start_l_x = zeilemin_x * betragx;                                          %Start bei x?
ende_l_x = zeilemax_x * betragx;                                           %Ende bei x?
l = ende_l_x - start_l_x;                                                  %ermittle Ankathete zu Alpha
h_max_x = wertmax_x - wertmin_x;                                           %ermittele Gegenkathete zu Alpha
alpha_x = atand (h_max_x / l);                                             %Alpha in Grad
hx = (((0:99) * betragx) * tand(alpha_x));                                 %gibt Gegenkathete zu steigendem x
data_2d_x_verkippt = data_2d_x - hx;                                       %eliminieren der Verkippung

%eliminieren der Verkippung der Matrix in x-Richtung

hx_matrix = repmat(hx(:), 1, 100);                                         %vektor hx um 100 vervielfachen
hx_matrix = reshape(hx_matrix, 100, 100);                                  %erzeugt 100x100 Matrix von hx
hx_matrix = hx_matrix';                                                    %transponiere hx
data1_x_verkippt = data1 - hx_matrix;                                      %eliminieren der Verkippung


%in y-Richtung

data_2d_y = data1_x_verkippt( :, 50);                                      %Schnitt durch Matrix bei Zeile 50
wertmax_y = max(data_2d_y);                                                %Maximum der Zeile
zeilemax_y = find (data_2d_y == wertmax_y);                                %Koordinate des Maximums
wertmin_y = min(data_2d_y(data_2d_y > 1));                                 %Minimum der Zeile aber größer 1
zeilemin_y = find (data_2d_y == wertmin_y);                                %Koordinate des Minimums


%eliminieren der Verkippung der Geraden in y-Richtung

start_l_y = zeilemax_y * betragy;                                          %start bei y?
ende_l_y = zeilemin_y * betragy;                                           %ende bei y?
l = ende_l_y - start_l_y;                                                  %Ankathete zu Alpha
h_max_y = wertmax_y - wertmin_y;                                           %Gegenkathete zu Alpha
alpha_y = atand (h_max_y/l);                                               %Verkippungswinkel
hy_50 = h_max_y - ((49 * betragy)*tand(alpha_y));
hy_1 = (h_max_y - (((0:99) * betragy) * tand(alpha_y)+ hy_50));            %zunahme der Gegenkathete um y
hy_1 = hy_1';                                                              %Transponierter Gegenkathetenvektor
data_2d_y_verkippt = data_2d_y - hy_1;                                     %Verkippung der untersuchten Zeilen

%eliminieren der Verkippung der Matrix in y-Richtung

hy = ((((0:99) * betragy) * tand(alpha_y)+ hy_50));
hy_matrix = repmat(hy(:), 1, 100);                                         %auffüllen des Gegenkathetenvektors
hy_matrix = reshape(hy_matrix, 100, 100);                                  %Gegenkathetenmatrix erzeugt
data1_y_verkippt = data1 - hy_matrix;                                      %Verkippung der Matrix
data1_verkippt = data1 - (data1_y_verkippt - data1_x_verkippt);            %nur zur Definition


%Berechnung der Durchbiegung

min_a=min(data1_verkippt(data1_verkippt > 10000));                         %ermitteln des Minimums jeder Spalte
min_aa = min(min_a);                                                       %ermittel des absoluten Minimums
max_a=max(data1_verkippt);                                                 %ermitteln des Maximums jeder Spalte
max_aa = max(max_a);                                                       %ermitteln des absoluten Maximums
hohe_a=(max_aa-min_aa);                                                    %maximale Höhe der Durchbiegung
waferdurchmesser=100*10^6;                                                 %Def. des Waferdurchmessers
radius_x=(((waferdurchmesser^2)/(8*hohe_a))+(hohe_a/2));                   %ermitteln des Krümmungsradius
R_ohne = radius_x;                                                         %Def. des Krümmungsradiuses ohne Beschichtung
%fprintf('radius %.5f \n', radius_x);                                       %Test Radius ohne Beschichtung
%fprintf('Höhe %.2f \n', hohe_a);                                           %Test Höhe ohne Beschichtung

 
%Diagramm erstellen

mesh (handles.axes1, data1);                                               %Diagramm 1 befüllen (3D)
plot (handles.axes2, data_2d_x_verkippt, 'r');                             %Diagramm 2 befüllen (2D-X)
plot (handles.axes3, data_2d_y_verkippt, 'r');                             %Diagramm 3 befüllen (2D-Y)

%übergabe von Daten zur weiteren Nutzung

handles.spaltenvektor_x = spaltenvektor_x;
handles.spaltenvektor_y = spaltenvektor_y;
handles.dataz = dataz;
handles.data1 = data1;
handles.data1_verkippt = data1_verkippt;
handles.data_2d_x_verkippt = data_2d_x_verkippt;
handles.data_2d_y_verkippt = data_2d_y_verkippt;
handles.R_ohne = R_ohne;
guidata(hObject, handles);                                                 % handles Struktur aktualisieren 



% --- Executes on button press in Oeffnennach.
function Oeffnennach_Callback(hObject, eventdata, handles)
% hObject    handle to Oeffnennach (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

% Einlesen vom Wafer

[txtfile,path2txt] = uigetfile('*.txt','Bitte Datei auswählen');           %Datei kann vom Nutzer selbst gewählt werden
fid = fopen(fullfile(path2txt,txtfile),'r');
    rawdata1 = textscan(fid,'%f %f %f','headerlines',8);                   %Überschrift entfernen
    data1 = rawdata1{3};                                                   %nur die dritte Spalte einlesen
    dataz = reshape(data1,10000,1);                                        %Z-Vektor als Spaltenvektor von 1-10000 erzeugen
    data1 = reshape(data1,100,100);                                        %100x100 Matrix aus Vektor data erzeugen
    rawdata2 = textscan(fid,'%*7s','headerlines',5);
    laengex = rawdata2;
fclose(fid);


%Aufteilung von 100 Messwerten auf jeweiliger Achse
%Beginn bei x=0 und y=0

XRange=0.106977 * 10^9;                                                    %Länge der Messstrecke in x Richtung (in mm)
betragx = XRange/99;                                                       %gleichmäßige Aufteilung der Messpunkte auf x
wertx = 0;                                                                 %Startwert x=0
vektorx = wertx + (0:99)*betragx;                                          %gleichmäßige aufteilung der Messstrecken (x-Richtung)
vektorx = vektorx';                                                        %Transponieren des Vektors
X = repmat(vektorx(:), 1, 100);                                            %Vektor um 100 vervielfachen
spaltenvektor_x = reshape(X, 10000, 1);                                    %Spaltenvektor erzeugen          

YRange=0.101432 * 10^9;                                                    %Länge der Messstrecke in y Richtung (in mm)
betragy = YRange/99;                                                       %gleichmäßige Aufteilung der Messpunkte auf y
werty = 0;                                                                 %Startwert y=0
vektory = werty + (0:99)*betragy;                                          %gleichmäßige aufteilung der Messstrecken (x-Richtung)
Y = repmat(vektory(:), 1, 100);                                            %Vektor um 100 vervielfachen
spaltenvektor_y = reshape(Y, 10000, 1);                                    %Spaltenvektor erzeugen


%Berechnung der Geraden
%in x-Richtung

data_2d_x = data1(50 , :);                                                 %Profilvektor aus Matrix data1 erzeugen
wertmax_x = max(data_2d_x);
zeilemax_x = find (data_2d_x == wertmax_x);
wertmin_x = min(data_2d_x(data_2d_x > 1));
zeilemin_x = find (data_2d_x == wertmin_x);

%eliminieren der Verkippung der Geraden in x-Richtung

start_l_x = zeilemin_x * betragx;                                          %start bei x?
ende_l_x = zeilemax_x * betragx;                                           %ende bei x?
l = ende_l_x - start_l_x;                                                  %Ankathete zu Alpha
h_max_x = wertmax_x - wertmin_x;
alpha_x = atand (h_max_x / l);
hx = (((0:99) * betragx) * tand(alpha_x));
data_2d_x_verkippt = data_2d_x - hx;

%eliminieren der Verkippung der Matrix in x-Richtung

hx_matrix = repmat(hx(:), 1, 100);
hx_matrix = reshape(hx_matrix, 100, 100);
hx_matrix = hx_matrix';
data1_x_verkippt = data1 - hx_matrix;


%in y-Richtung

data_2d_y = data1_x_verkippt( :, 50);                                      %Schnitt durch Matrix bei Zeile 50
wertmax_y = max(data_2d_y);                                                %Maximum der Zeile
zeilemax_y = find (data_2d_y == wertmax_y);                                %Koordinate des Maximums
wertmin_y = min(data_2d_y(data_2d_y > 1));                                 %Minimum der Zeile aber größer 1
zeilemin_y = find (data_2d_y == wertmin_y);                                %Koordinate des Minimums

%eliminieren der Verkippung der Geraden in y-Richtung

start_l_y = zeilemax_y * betragy;                                          %start bei y?
ende_l_y = zeilemin_y * betragy;                                           %ende bei y?
l = ende_l_y - start_l_y;                                                  %Ankathete zu Alpha
h_max_y = wertmax_y - wertmin_y;                                           %Gegenkathete zu Alpha
alpha_y = atand (h_max_y/l);                                               %Verkippungswinkel
hy_50 = h_max_y - ((49 * betragy)*tand(alpha_y));
hy_1 = (h_max_y - (((0:99) * betragy) * tand(alpha_y)+ hy_50));            %zunahme der Gegenkathete um y
hy_1 = hy_1';                                                              %Transponierter Gegenkathetenvektor
data_2d_y_verkippt = data_2d_y - hy_1;                                     %Verkippung der untersuchten Zeilen

%eliminieren der Verkippung der Matrix in y-Richtung

hy = ((((0:99) * betragy) * tand(alpha_y)+ hy_50));
hy_matrix = repmat(hy(:), 1, 100);                                         %auffüllen des Gegenkathetenvektors
hy_matrix = reshape(hy_matrix, 100, 100);                                  %Gegenkathetenmatrix erzeugt
data1_y_verkippt = data1 - hy_matrix;                                      %Verkippung der Matrix
data1_verkippt = data1 - (data1_y_verkippt - data1_x_verkippt);            %nur zur Definition


%Berechnung der Durchbiegung

min_a=min(data1_verkippt(data1_verkippt > 10000));                         %ermitteln des Minimums jeder Spalte
min_aa = min(min_a);                                                       %ermittel des absoluten Minimums
max_a=max(data1_verkippt);                                                 %ermitteln des Maximums jeder Spalte
max_aa = max(max_a);                                                       %ermitteln des absoluten Maximums
hohe_a=(max_aa-min_aa);                                                    %maximale Höhe der Durchbiegung
waferdurchmesser=100*10^6;                                                 %Def. des Waferdurchmessers
radius_x=(((waferdurchmesser^2)/(8*hohe_a))+(hohe_a/2));                   %ermitteln des Krümmungsradius
R = radius_x;                                                              %Def. des Krümmungsradiuses mit Beschichtung
%fprintf('radius %.5f \n', radius_x);                                       %Test Radius mit Beschichtung
%fprintf('Höhe %.2f \n', hohe_a);                                           %Test Höhe mit Beschichtung


%Diagramm erstellen

mesh (handles.axes1, data1);                                               %Diagramm 1 befüllen (3D)
plot (handles.axes2, data_2d_x, 'r');                                      %Diagramm 2 befüllen (2D-X)
plot (handles.axes3, data_2d_y, 'r');                                      %Diagramm 3 befüllen (2D-Y)

%übergabe von daten zur weiteren Berechnung
handles.spaltenvektor_x = spaltenvektor_x;
handles.spaltenvektor_y = spaltenvektor_y;
handles.dataz = dataz;
handles.data1 = data1;
handles.data1_verkippt = data1_verkippt;
handles.data_2d_x_verkippt = data_2d_x_verkippt;
handles.data_2d_y_verkippt = data_2d_y_verkippt;
handles.R = R;
guidata(hObject, handles);                                                 % handles Struktur aktualisieren 



% --- Executes on button press in Speichern.                               % Entspricht Speicher unter
function Speichern_Callback(hObject, eventdata, handles)
% hObject    handle to Speichern (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)


bild = getframe;
[jpegfile,path2jpeg] = uiputfile('Bild.jpeg','Speichern unter ');
fid = fopen(fullfile(path2jpeg, jpegfile));
     save
fclose(fid);


% --- Executes on button press in Ebene.
function Ebene_Callback(hObject, eventdata, handles)                       %Verkippung eleminieren
% hObject    handle to Ebene (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)


%Daten und Werte holen

data1_verkippt = handles.data1_verkippt;

data1_verkippt(data1_verkippt<9000) = NaN;                                 %Werte kleiner 9000 nicht beachten

data1_x_verkippt = data1_verkippt(50, :);
data1_y_verkippt = data1_verkippt(: , 50);


meshc (handles.axes1, data1_verkippt);                                     %Diagramm 1 befüllen (3D)
plot (handles.axes2, data1_x_verkippt, 'r');                               %Diagramm 2 befüllen (2D-X)
plot (handles.axes3, data1_y_verkippt, 'r');                               %Diagramm 3 befüllen (2D-Y)


function Eingabe1_Callback(hObject, eventdata, handles)
% hObject    handle to Eingabe1 (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)


% Hints: get(hObject,'String') returns contents of Eingabe1 as text
%        str2double(get(hObject,'String')) returns contents of Eingabe1 as a double


% --- Executes during object creation, after setting all properties.
function Eingabe1_CreateFcn(hObject, eventdata, handles)
% hObject    handle to Eingabe1 (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    empty - handles not created until after all CreateFcns called

% Hint: edit controls usually have a white background on Windows.
%       See ISPC and COMPUTER.
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end


% --- Executes on button press in Spannung.
function Spannung_Callback(hObject, eventdata, handles)
% hObject    handle to Spannung (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

%Werte holen

R_ohne = handles.R_ohne;
R = handles.R;

Schichtdicke = str2double(get(handles.Eingabe1, 'string'));
E_Modul_Si = 188*10^3;                                                     %E-Modul von Silizium in MPa
Poissionzahl_Si = 0.279;                                                   %Querkontraktionszahl von Silizium
Waferdicke = 565000;                                                       %Waferdicke in nm

Zaehler = (E_Modul_Si*(Waferdicke*Waferdicke));
Nenner = (6*(1-Poissionzahl_Si)*Schichtdicke);
Durchbiegung = ((1/R_ohne)+(1/R));
Spannung = ((Zaehler/Nenner)*Durchbiegung); 
ff = num2str (Spannung);                                                   %Definition der Ausgabe Spannung
set(handles.Ausgabe,'string', ff);                                         %Ausgabe der Spannung im Textfeld Ausgabe
handles.ff = ff;
handles.current_data = handles.ff;


% --- Executes on button press in X.
function X_Callback(hObject, eventdata, handles)                           %Button schließt das Programm
% hObject    handle to X (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
   

   %display Goodbye
   close(handles.figure1);
   
% Hint: place code in OpeningFcn to populate axes1
% Hint: place code in OpeningFcn to populate axes2
