function selectitemsmain
%  

%   This software is protected by german copyright and international treaties.             
%   Copyright 2004 Markus Junghöfer & Peter Peyk. All Rights Reserved.                     
%                                                                                          
%   THIS SOFTWARE AND DOCUMENTATION IS PROVIDED "AS IS," AND COPYRIGHT HOLDERS MAKE        
%   NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO,    
%   WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE    
%   OF THE SOFTWARE OR DOCUMENTATION WILL NOT INFRINGE ANY THIRD PARTY PATENTS, COPYRIGHTS,
%   TRADEMARKS OR OTHER RIGHTS. COPYRIGHT HOLDERS WILL NOT BE LIABLE FOR ANY DIRECT,       
%   INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE SOFTWARE      
%   OR DOCUMENTATION.                                                                      
global stimnummercell gruppcell selectedstatus cellstr dim anzahldims anzahlstimuli paramat filenamecell...
    celladressmat groessenreqinds absolutreqs kleinerreqs groesserreqs gleichreqs
fprintfzaehler=1;selectedstatus=0;neuziehen=1;





vergleichemonitor = findobj('Tag','vergleichemonitor');
requirements = get(vergleichemonitor,'string');
anzahlreqs=length(requirements);anzahlgruppen=length(cellstr);
scenarioradio=findobj('tag','scenarioradio');


celladressmat=zeros(length(cellstr),1);
for i=1:length(cellstr)
celladressmat(i,1)=str2num(strrep(strrep(cellstr{i},' ',''),'cell',''));
end

%gruppengroessen
%----------------------------------------------------------------
% dlg=helpdlg('Lese requirements...','Requirements:');
% pause(1);
% close(dlg);
groessenreqinds=zeros(1,3); % :  reqnumber ; gruppengroesse ; celladdress;
j=1;
absolutreqs =cell(1,5); % reqnumber; absolutWert ; celladdress ; dimension; operator;
k=1;
kleinerreqs = cell(1,5); %reqnumber; cell1adress; cell2adress; dimension; alpha;
l_k=1;
groesserreqs = cell(1,5); %reqnumber; cell1adress; cell2adress; dimension; alpha;
l_g=1;
gleichreqs = cell(1,5); %reqnumber; cell1adress; cell2adress; dimension; alpha;
l_e=1;
%----------------------------------------------------------------



%reqs auslesen
%----------------------------------------------------------------
% dlg=helpdlg('Analysiere requirements....','Requirements:');
% pause(1);
% close(dlg);

for i=1:anzahlreqs
    if ~isempty(findstr(requirements{i},'anzahl'))
        groessenreqinds(j,1) = i;
        groessenreqinds(j,2) = str2num(requirements{i}(findstr(requirements{i},'n#=')+3:findstr(requirements{i},':')-1));
        groessenreqinds(j,3) = str2num(requirements{i}(findstr(requirements{i},'cell')+4:findstr(requirements{i},'n#=')-1));
        j=j+1;
    elseif ~isempty(findstr(requirements{i},'|>|'))
        absolutreqs{k,1} = i;
        absolutreqs{k,2} = str2num(requirements{i}(findstr(requirements{i},'|>|')+3:findstr(requirements{i},':')-1));
        absolutreqs{k,3} = str2num(requirements{i}(findstr(requirements{i},'cell')+4:findstr(requirements{i},'|>|')-1));
        absolutreqs{k,4} = requirements{i}(findstr(requirements{i},':')+1:findstr(requirements{i},'-')-1);
        absolutreqs{k,5} = requirements{i}(findstr(requirements{i},'|>|')+1);
        k=k+1;
    elseif ~isempty(findstr(requirements{i},'|<|'))
        absolutreqs{k,1} = i;
        absolutreqs{k,2} = str2num(requirements{i}(findstr(requirements{i},'|<|')+3:findstr(requirements{i},':')-1));
        absolutreqs{k,3} = str2num(requirements{i}(findstr(requirements{i},'cell')+4:findstr(requirements{i},'|<|')-1));
        absolutreqs{k,4} = requirements{i}(findstr(requirements{i},':')+1:findstr(requirements{i},'-')-1);
        absolutreqs{k,5} = requirements{i}(findstr(requirements{i},'|<|')+1);
        
        k=k+1;
    elseif ~isempty(findstr(requirements{i},' < '))
        kleinerreqs{l_k,1} = i;
        kleinerreqs{l_k,2} = str2num(requirements{i}(5:findstr(requirements{i},' < ')-1));
        kleinerreqs{l_k,3} = str2num(requirements{i}(findstr(requirements{i},' < ')+7:findstr(requirements{i},':')-1));
        kleinerreqs{l_k,4} = requirements{i}(findstr(requirements{i},':')+1:findstr(requirements{i},'-')-1);
        kleinerreqs{l_k,5} = str2num(requirements{i}(findstr(requirements{i},'-')+1:findstr(requirements{i},'-')+6));
        l_k=l_k+1;
    elseif ~isempty(findstr(requirements{i},' > '))
        groesserreqs{l_g,1} = i;
        groesserreqs{l_g,2} = str2num(requirements{i}(5:findstr(requirements{i},' > ')-1));
        groesserreqs{l_g,3} = str2num(requirements{i}(findstr(requirements{i},' > ')+7:findstr(requirements{i},':')-1));
        groesserreqs{l_g,4} = requirements{i}(findstr(requirements{i},':')+1:findstr(requirements{i},'-')-1);
        groesserreqs{l_g,5} = str2num(requirements{i}(findstr(requirements{i},'-')+1:findstr(requirements{i},'-')+6));
        l_g=l_g+1;
    elseif ~isempty(findstr(requirements{i},' = '))
        gleichreqs{l_e,1} = i;
        gleichreqs{l_e,2} = str2num(requirements{i}(5:findstr(requirements{i},' = ')-1));
        gleichreqs{l_e,3} = str2num(requirements{i}(findstr(requirements{i},' = ')+7:findstr(requirements{i},':')-1));
        gleichreqs{l_e,4} = requirements{i}(findstr(requirements{i},':')+1:findstr(requirements{i},'-')-1);
        gleichreqs{l_e,5} = str2num(requirements{i}(findstr(requirements{i},'-')+1:end));
        l_e=l_e+1;
    else
        msgbox('Es spukt in selectitemsmain!!');
    end       
end

if j<=anzahlgruppen
    errordlg('Nicht ausreichend Groessenangaben für gewählte Zellenanzahl!','Fehler!');
    return
end
anzahlsumvec=sum(groessenreqinds,1);
if anzahlsumvec(2)>anzahlstimuli
    errordlg('Nicht ausreichend Stimulidaten für gewählte Gruppengroessen!','Fehler!');
    return
end

% dlg=helpdlg('Ausreichend Groessenangaben gefunden!','Groessenangaben:');
% pause(1);
% close(dlg);

%Dialog vorbereiten
groesserreqstring=cell(1);
if ~isempty(groesserreqs{1,1}) 
for i=1:size(groesserreqs,1)
    groesserreqstring{i,1}=['cell',num2str(groesserreqs{i,2}),' > cell',num2str(groesserreqs{i,3}),' auf ',groesserreqs{i,4},' mit alpha = ',num2str(groesserreqs{i,5})];
end
end
kleinerreqstring=cell(1);
if ~isempty(kleinerreqs{1,1})  
for i=1:size(kleinerreqs,1)
    kleinerreqstring{i,1}=['cell',num2str(kleinerreqs{i,2}),' < cell',num2str(kleinerreqs{i,3}),' auf ',kleinerreqs{i,4},' mit alpha = ',num2str(kleinerreqs{i,5})];
end
end
gleichreqstring=cell(1);
if ~isempty(gleichreqs{1,1})
for i=1:size(gleichreqs,1)
    gleichreqstring{i,1}=['cell',num2str(gleichreqs{i,2}),' = cell',num2str(gleichreqs{i,3}),' auf ',gleichreqs{i,4},' mit alpha = ',num2str(gleichreqs{i,5})];
end
end

textcell=cell(1);
if ~isempty(groesserreqstring{1,1})
   if ~isempty(kleinerreqstring{1,1})
       if ~isempty(gleichreqstring{1,1})
           textcell=[groesserreqstring;kleinerreqstring;gleichreqstring];
       else
           textcell=[groesserreqstring;kleinerreqstring];
       end
   elseif ~isempty(gleichreqstring{1,1})
        textcell=[groesserreqstring;gleichreqstring];
   else 
        textcell=[groesserreqstring];
   end
elseif ~isempty(kleinerreqstring{1,1})
       if ~isempty(gleichreqstring{1,1})
           textcell=[kleinerreqstring;gleichreqstring];
       else
       textcell=[kleinerreqstring];
       end
elseif ~isempty(gleichreqstring{1,1})
       textcell=[gleichreqstring];
end 
% if ~isempty(textcell{1,1})
%    uiwait(helpdlg(textcell,'Gefundene relative Requirements:'));
% else
%    dlg=helpdlg('Keine relativen Requirements gefunden....','Gefundene Requirements:'); 
%    pause(0.5);
%    close(dlg);
% end
%----------------------------------------------------------------


%reqsmetmat erstellen (1=nicht erfüllt, 0=erfüllt)
%----------------------------------------------------------------
if l_e~=1
    gleichreqsmetmat=zeros(length(gleichreqs),1);gleichreqsstatus=1;
else
    gleichreqsstatus=0;
end
if l_k~=1
    kleinerreqsmetmat=zeros(length(kleinerreqs),1);kleinerreqsstatus=1;
else
    kleinerreqsstatus=0;
end
if l_g~=1
    groesserreqsmetmat=zeros(length(groesserreqs),1);groesserreqsstatus=1;
else
    groesserreqsstatus=0;
end
%----------------------------------------------------------------




%Neuziehenschleife...

while neuziehen == 1
neuziehen=0;


infdlghandle=infdlg('Optimiere nach requirements...','','','');
infdlgtext1=findobj('tag','infdlgtext1');
infdlgtext2=findobj('tag','infdlgtext2');
statustext=findobj('tag','statustext');
pause(0.2); 



%stimuli ziehen nach absoluten Bedingungen
%----------------------------------------------------------------
% dlg=helpdlg('Ziehe Stimuli nach absoluten Bedinungen...','Stimuli ziehen:');
% pause(1);
% close(dlg);
dlg=helpdlg('Gefundene passende Stimuli...','Stimuli ziehen:');
%paramat durchnumerieren --> stimnummernliste
stimnummernliste=linspace(1,anzahlstimuli,anzahlstimuli);

%insgesamt gezogene Stimulinummern
totwiederholung=[];
totzaehler=1;

%mats mit stimnummern in reihenfolge von cellstr
stimnummercell=cell(length(cellstr),1);

%für Anzahl der Zellen wiederholen:
for z=1:length(cellstr)
    
    %
    trymat=[];
    
    %der Zelle entsprechende Groessenangabe herausfinden
    celladressstr=strrep(cellstr{z},' ','');
    celladress=str2num(strrep(celladressstr,'cell',''));
    aktivecell=find(groessenreqinds(:,3)==celladress);
    
    %stimnummercell nach Stimulianzahl vorbereiten
    stimnummercell{z,1}=zeros(groessenreqinds(aktivecell,2),1);
    
    
    %Welche absoluten Bedingungen sind für Zelle relevent --> applymat
    applymat=[];
    u=1;    
    for x=1:k-1 %k=anzahlabsolutreqs+1
        if ~isempty(absolutreqs{x,3})
            if celladress==absolutreqs{x,3}
                applymat(u,1)= x;
                u=u+1;
            end
        end
    end
    
    % Ziehen bis anzahlstimuli erreicht!
    for y=1:groessenreqinds(aktivecell,2)
    
        breakstatus = 0 ;
        
        %Absolute Bedingungsschleife
        while breakstatus == 0;
             wiederholung = 1;
             tried=1;
%-----------------------------------------------------------------------------------------------------             
             
             %zufällig Stimnummer ziehen und Schleife brechen (wiederholung und tried)
             while wiederholung == 1 | tried == 1
                wiederholung = 0;
                tried=0;
              
                rand('state',sum(100*clock));
                stimnummer=round(rand*(anzahlstimuli-1)+1);
              
                
                %Wiederholung in aktueller Zelle prüfen
                for widindex=1:length(stimnummercell{z,1})
                    if stimnummer==stimnummercell{z,1}(widindex,1)
                        wiederholung = 1;
                    end
                end
                
                %Gesamtwiederholung prüfen
                for c=1:length(totwiederholung)
                    if stimnummer==totwiederholung(c,1)
                        wiederholung = 1;
                    end
                end
                
                %Erfolglose Vorversuch auf Wiederholung prüfen
                for g=1:length(trymat)
                    if stimnummer==trymat(g,1)
                        tried=1;
                    end
                end
                
                %verbrauchte Stimuli ermitteln aus totwiederholung und stimnummernliste   
                wegindexmat=[];
                for g=1:length(totwiederholung)
                    wegindexmat(g)=find(totwiederholung(g)==stimnummernliste);
                end
                restliste=stimnummernliste;
                restliste(wegindexmat)=[];
                
                if length(trymat)>=length(restliste)
                    errordlg(['Absolute Bedingungen von Zelle ',num2str(celladressmat(z)),...
                            ' konnten mit den zur Verfügung stehenden Stimuli nicht erfüllt werden!'],'Fehler!');
                    return
                end
            end
            
%-----------------------------------------------------------------------------------------------------             


            
            %absolute Bedingungen prüfen
            breakstatus=1;
            
            %sind absolute Bedingungen relevant?
            if ~isempty(applymat)
                %für jede relevante Bedinung...
                for t=1:length(applymat)
                    
                    %Welche Dimension?
                    for dimzaehler=1:length(dim)
                        if ~isempty(findstr(dim{dimzaehler},absolutreqs{applymat(t,1),4}))
                            %Korrektur für paramat (ohne filenames)
                            dimnummer=dimzaehler-1;
                        end
                    end
                    
					%paramat(stimnummer,dimnummer)
					%absolutreqs{applymat(t,1),5}
					%absolutreqs{applymat(t,1),2}
					%pause
                    
                    %Bedingung für gezogenen Stimulus prüfen:
                    evalstring=[num2str(paramat(stimnummer,dimnummer)),absolutreqs{applymat(t,1),5},num2str(absolutreqs{applymat(t,1),2})];
                    if  ~eval(evalstring)               
                        breakstatus = 0 ; 
                        
                        %wenn noch nicht versucht zu trymat hinzufügen: trymat: versuchte, den 
                        %absoluten bedinungen nicht genügende Stimuli
                        
                        if ~isempty(trymat)
                            if ~(sum(trymat==stimnummer)>0)
                                trymat=[trymat;stimnummer];
                            end
                        end
                        
                    end
                    
                    
                end
                
            end
            
            %wenn absolute Bedingungen erfüllt, stimnummer zu stimnummercell und totwiederholung hinzufügen
            if breakstatus==1
                stimnummercell{z,1}(y,1)=stimnummer;
                totwiederholung (totzaehler,1)=stimnummer;
                totzaehler=totzaehler+1;
                
                string=get(dlg,'Children');
                set(string(3),'String',num2str(totzaehler));
                pause(0.01);
            end
            
%-----------------------------------------------------------------------------------------------------                       
        end
    end
end    
close(dlg);
%-----------------------------------------------------------------------------------------------------                       








%Bedingungen prüfen
%-----------------------------------------------------------------------------------------------------      
%-----------------------------------------------------------------------------------------------------                       
%-----------------------------------------------------------------------------------------------------                       


reqsmet=0;



while reqsmet == 0 & neuziehen ==0

% dlg=helpdlg('Prüfe relative Requirements...','Prüfe:');
% pause(0.2);
% close(dlg);
    
for t=1:length(stimnummercell)
    if ~isempty(stimnummercell{t})
        stimnummercell{t}=shuffle(stimnummercell{t});
    end
end

%kleinerreqs
%-----------------------------------------------------------------------------------------------------                       

if ~isempty(kleinerreqs{1,1})
    
% dlg=helpdlg('Prüfe kleiner-requirements...','Prüfe:');
% pause(0.2);
% close(dlg);

for j=1:size(kleinerreqs,1)
        cell1adress=kleinerreqs{j,2};
        cell2adress=kleinerreqs{j,3};
        aktivecell1=find(groessenreqinds(:,3)==cell1adress);
        aktivecell2=find(groessenreqinds(:,3)==cell2adress);
        cell1anzahlstim=groessenreqinds(aktivecell1,2);
        cell2anzahlstim=groessenreqinds(aktivecell2,2);
        sample1=zeros(cell1anzahlstim,1);
        sample2=zeros(cell2anzahlstim,1);
        cellnummer1=find(celladressmat==kleinerreqs{j,2});
        cellnummer2=find(celladressmat==kleinerreqs{j,3});
        
        for dimzaehler=1:length(dim)
            if ~isempty(findstr(dim{dimzaehler},kleinerreqs{j,4}))
                %paramatkorrektur
                dimnummer=dimzaehler-1;
            end
        end
        for zaehler=1:cell1anzahlstim
            sample1(zaehler,1)=paramat(stimnummercell{cellnummer1}(zaehler),dimnummer);
        end
        for zaehler=1:cell2anzahlstim
            sample2(zaehler,1)=paramat(stimnummercell{cellnummer2}(zaehler),dimnummer);
        end
        h=1;
        
        if var(sample1)*var(sample2)~=0
                    [h,significance,ci] = ttest2(sample1,sample2,kleinerreqs{j,5},-1);
        else
            uiwait(helpdlg(['In einer der Stichproben besteht keine Varianz auf der Dimension "',dim{dimnummer},'"!',' Bedingung wird ignoriert!'],'Achtung:'));
        end  
        if h~=1
            kleinerreqsmetmat(j,1)=1;
        else
            kleinerreqsmetmat(j,1)=0;
        end
    end
else
    kleinerreqsmetmat=[];
end
 
%groesserreqs
%-----------------------------------------------------------------------------------------------------                       

if ~isempty(groesserreqs{1,1})
    
% dlg=helpdlg('Prüfe groesser-requirements...','Prüfe:');
% pause(0.2);
% close(dlg);

for j=1:size(groesserreqs,1)
        cell1adress=groesserreqs{j,2};
        cell2adress=groesserreqs{j,3};
        aktivecell1=find(groessenreqinds(:,3)==cell1adress);
        aktivecell2=find(groessenreqinds(:,3)==cell2adress);
        cell1anzahlstim=groessenreqinds(aktivecell1,2);
        cell2anzahlstim=groessenreqinds(aktivecell2,2);
        sample1=zeros(cell1anzahlstim,1);
        sample2=zeros(cell2anzahlstim,1);
        cellnummer1=find(celladressmat==groesserreqs{j,2});
        cellnummer2=find(celladressmat==groesserreqs{j,3});
        for dimzaehler=1:length(dim)
            if ~isempty(findstr(dim{dimzaehler},groesserreqs{j,4}))
                %paramatkorrektur
                dimnummer=dimzaehler-1;
            end
        end
        for zaehler=1:cell1anzahlstim
            sample1(zaehler,1)=paramat(stimnummercell{cellnummer1}(zaehler),dimnummer);
        end
        for zaehler=1:cell2anzahlstim
            sample2(zaehler,1)=paramat(stimnummercell{cellnummer2}(zaehler),dimnummer);
        end
        h=1;
        
        if var(sample1)*var(sample2)~=0
                    [h,significance,ci] = ttest2(sample1,sample2,groesserreqs{j,5},1);
        else
            uiwait(helpdlg(['In einer der Stichproben besteht keine Varianz auf der Dimension "',dim{dimnummer},'"!',' Bedingung wird ignoriert!'],'Achtung:'));
        end
        
        if h~=1
            groesserreqsmetmat(j,1)=1;
        else
            groesserreqsmetmat(j,1)=0;
        end
    end
else
    groesserreqsmetmat=[];
end       

%gleichreqs
%-----------------------------------------------------------------------------------------------------                       

if ~isempty(gleichreqs{1,1})
    
% dlg=helpdlg('Prüfe gleich-requirements...','Prüfe:');
% pause(0.2);
% close(dlg);

    for j=1:size(gleichreqs,1)
        cell1adress=gleichreqs{j,2};
        cell2adress=gleichreqs{j,3};
        aktivecell1=find(groessenreqinds(:,3)==cell1adress);
        aktivecell2=find(groessenreqinds(:,3)==cell2adress);
        cell1anzahlstim=groessenreqinds(aktivecell1,2);
        cell2anzahlstim=groessenreqinds(aktivecell2,2);
        sample1=zeros(cell1anzahlstim,1);
        sample2=zeros(cell2anzahlstim,1);
        cellnummer1=find(celladressmat==gleichreqs{j,2});
        cellnummer2=find(celladressmat==gleichreqs{j,3});
        for dimzaehler=1:length(dim)
            if ~isempty(findstr(dim{dimzaehler},gleichreqs{j,4}))
                %paramatkorrektur
                dimnummer=dimzaehler-1;
            end
        end
        for zaehler=1:cell1anzahlstim
            sample1(zaehler,1)=paramat(stimnummercell{cellnummer1}(zaehler),dimnummer);
        end
        for zaehler=1:cell2anzahlstim
            sample2(zaehler,1)=paramat(stimnummercell{cellnummer2}(zaehler),dimnummer);
        end
        h=0;
        
        if var(sample1)*var(sample2)~=0
                    [h,significance,ci] = ttest2(sample1,sample2,(1-gleichreqs{j,5}),0);
        else
           uiwait(helpdlg(['In einer der Stichproben besteht keine Varianz auf der Dimension "',dim{dimnummer},'"!',' Bedingung wird ignoriert!'],'Achtung:'));
        end
        if h~=0
             [h,significance,ci] = ttest2(sample1,sample2,(1-gleichreqs{j,5}),1);
            if h~=1
                gleichreqsmetmat(j,1)=2; % -->cell1 < cell2  
            else
               gleichreqsmetmat(j,1)=1;  % --> cell1 > cell2
            end
        else
            gleichreqsmetmat(j,1)=0;
        end
    end
else 
    gleichreqsmetmat=[];
end 


%Hauptabbruchbedingung
%-----------------------------------------------------------------------------------------------------                       

if ~isempty(kleinerreqsmetmat)
    %kleinerreqsnonmet: kleinerreqnummern die nicht erfüllt sind
    kleinerreqsnonmet=find(kleinerreqsmetmat==1);
    %anzahlnonmetkleinerreqs: anzahl der nicht erfüllten kleinerreqs
    anzahlnonmetkleinerreqs=sum(kleinerreqsmetmat);
else
    kleinerreqsnonmet=[];
    anzahlnonmetkleinerreqs=0;
end
   
if ~isempty(groesserreqsmetmat)
    groesserreqsnonmet=find(groesserreqsmetmat==1);
    anzahlnonmetgroesserreqs=sum(groesserreqsmetmat);
else
    groesserreqsnonmet=[];
    anzahlnonmetgroesserreqs=0;
end
   
if ~isempty(gleichreqsmetmat)
    gleichreqsnonmet=find(gleichreqsmetmat==1 | gleichreqsmetmat==2);
    anzahlnonmetgleichreqs=sum(find(gleichreqsmetmat==1 | gleichreqsmetmat==2));
else
    gleichreqsnonmet=[];
    anzahlnonmetgleichreqs=0;
end
gesamtzahlnonmetreqs=anzahlnonmetkleinerreqs+anzahlnonmetgroesserreqs+anzahlnonmetgleichreqs;

if gesamtzahlnonmetreqs>0
%     dlg=helpdlg(['Es gibt noch ',num2str(gesamtzahlnonmetreqs),' nicht erfüllte relative requirements!'],'Achtung:');
%     pause(0.2);
%     close(dlg);
else
    if exist('infdlghandle')
        close(infdlghandle);
    end
    uiwait(helpdlg('Alle requirements wurden erfüllt!','Achtung:'));
    break
end



%Optimierung
%-----------------------------------------------------------------------------------------------------                       
%-----------------------------------------------------------------------------------------------------                       
%-----------------------------------------------------------------------------------------------------                       




% set(infdlgtext1,'String',);
% set(infdlgtext2,'String',);
% set(statustext,'String',);


restlistezaehler=1;
zelle1zaehler=1;
zelle2zaehler=1;


%kleinerreqs
%-----------------------------------------------------------------------------------------------------                       

%Zwei Modi:1. aus restliste ziehen oder 2. mit andere Zelle vertauschen
ignorerestlistestatus=0;
ignoretauschstatus=0;
erfuellt=0;

if neuziehen~=1
if ~isempty(kleinerreqsnonmet)


    
%pro nichterfüllter Bedingung
for korrzaehler=1:anzahlnonmetkleinerreqs
    
    %entsprechende Zelle finden
    aktivecell1=kleinerreqs{kleinerreqsnonmet(korrzaehler),2};
    cellnummer1=find(celladressmat==aktivecell1);
    aktivecell2=kleinerreqs{kleinerreqsnonmet(korrzaehler),3};
    cellnummer2=find(celladressmat==aktivecell2);
    
    for dimzaehler=1:length(dim)
        if ~isempty(findstr(dim{dimzaehler},kleinerreqs{korrzaehler,4}))
            %Korrektur für paramat
            dimnummer=dimzaehler-1;
        end
    end
    restliste=[];
    erfuellt=0;
    repeatmat1=[];
    repeatmat2=[];
    repeatzaehler1=1;
    repeatzaehler2=1;
    notfound1=0;
    notfound2=0;
    found1=0;
    found2=0;
           
    while erfuellt==0 & (ignorerestlistestatus==0 | ignoretauschstatus==0) 
        set(statustext,'String',' < - restliste');
        %neues Item ziehen
        %------------------------------
        if anzahlsumvec(2)<anzahlstimuli & ignorerestlistestatus~=1 
            
            %restliste erstellen
            stimnummernliste=linspace(1,anzahlstimuli,anzahlstimuli);
            for g=1:length(totwiederholung)
                wegindexmat(g)=find(totwiederholung(g)==stimnummernliste);
            end
            restliste=stimnummernliste;
            restliste(wegindexmat)=[];
            
            while 1
                
                %item aus zelle ziehen
                %gezogene stimnummer in repeatmat schreiben
                
                %gibts noch nicht gezogenen stimnummern????
                if length(stimnummercell{cellnummer1})>length(repeatmat1)
                    
                    %wenn ja,solange ziehen bis noch nich vorher gewählte Nummer
                    while found2==0
                        z1=mod(zelle1zaehler,length(stimnummercell{cellnummer1}))+1;
                        zelle1zaehler=zelle1zaehler+1;
                        itemnummer1=stimnummercell{cellnummer1}(z1);
                        set(infdlgtext1,'String',num2str(itemnummer1));
                        %wiederholung prüfen
                        %erstes ziehen?
                        if ~isempty(repeatmat1)
                           %schon da gewesen?
                            if isempty(find(repeatmat1==z1))
                                repeatmat1(repeatzaehler1)=z1;
                                repeatzaehler1=repeatzaehler1+1;
                                found1=1;
                                break
                            end
                        else
                           repeatmat1(repeatzaehler1)=z1;
                           repeatzaehler1=repeatzaehler1+1; 
                           found1=1;
                           break
                        end
                        
                    end 
                %wenn nicht, dann modus abschalten
                else
                   notfound1=1;
                end  
                
                %item aus restliste ziehen
                if length(restliste)>length(repeatmat2)
                        while found1==1
                            z2=mod(restlistezaehler,length(restliste))+1;
                            restlistezaehler=restlistezaehler+13;
                            itemnummer2=restliste(z2);
                            set(infdlgtext2,'String',num2str(itemnummer2));
                            if ~isempty(repeatmat2)
                                if isempty(find(repeatmat2==z2))
                                    repeatmat2(repeatzaehler2)=z2;
                                    repeatzaehler2=repeatzaehler2+1;
                                    found2=1;
                                    break
                                end
                            else
                                repeatmat2(repeatzaehler2)=z2;
                                repeatzaehler2=repeatzaehler2+1;
                                found2=1;
                                break
                            end
                        end
                        
               else
                  notfound2=1;
               end  
                
               
                if notfound1==1
                   ignorerestlistestatus=1;
                    repeatmat1=[];
                   repeatzaehler1=1;
                   repeatmat2=[];
                   repeatzaehler2=1;
                   found1=0;
                   found2=0;
                   notfound1=0;
                   notfound2=0;
                   break
               elseif notfound2==1
                   notfound2=0;
                   found2=0;
                   repeatzaehler2=1;
                   repeatmat2=[];
               end
               
               
               %mit gezogenen Stimuli der Verhältnis und absolute reqs prüfen....
               if  paramat(itemnummer2,dimnummer)<paramat(itemnummer1,dimnummer)...
                  & checkabsreqs(itemnummer2,aktivecell1,stimnummercell,absolutreqs,dim,paramat)
              
                    stimnummercell{cellnummer1}(z1)=itemnummer2;
                    restliste(z2)=itemnummer1;
                    totwiederholung(find(totwiederholung==itemnummer1))=itemnummer2;
                    erfuellt=1;
                    break
               end
            
              
           end
        
       %items vertauschen
       %------------------------------
       elseif anzahlsumvec(2)<=anzahlstimuli & ignoretauschstatus~=1
       set(statustext,'String',' < - vertauschen');     
          if anzahlsumvec(2)>=anzahlstimuli
              ignorerestlistestatus=1;
          end
        
                while 1
                %item aus zelle1 ziehen
                if length(stimnummercell{cellnummer1})>length(repeatmat1)
                    while found2==0
                        z1=mod(zelle1zaehler,length(stimnummercell{cellnummer1}))+1;
                        zelle1zaehler=zelle1zaehler+1;
                        itemnummer1=stimnummercell{cellnummer1}(z1);
                        
                        set(infdlgtext1,'String',num2str(itemnummer1));
                        if ~isempty(repeatmat1)
                            if isempty(find(repeatmat1==z1))
                                repeatmat1(repeatzaehler1)=z1;
                                repeatzaehler1=repeatzaehler1+1;
                                found1=1;
                                break
                            end
                        else
                           repeatmat1(repeatzaehler1)=z1;
                           repeatzaehler1=repeatzaehler1+1;
                           found1=1;
                           break 
                        end
                    end
                else
                    notfound1=1;
                end  
                %item aus zelle2 ziehen
                if length(stimnummercell{cellnummer2})>length(repeatmat2)
                    while found1==1
                        z2=mod(zelle2zaehler,length(stimnummercell{cellnummer2}))+1;
                        zelle2zaehler=zelle2zaehler+1;
                        itemnummer2=stimnummercell{cellnummer2}(z2);
                        set(infdlgtext2,'String',num2str(itemnummer2));
                        if ~isempty(repeatmat2)
                            if isempty(find(repeatmat2==z2))
                                repeatmat2(repeatzaehler2)=z2;
                                repeatzaehler2=repeatzaehler2+1;
                                found2=1;
                                break
                            end
                        else
                           repeatmat2(repeatzaehler2)=z2;
                           repeatzaehler2=repeatzaehler2+1;
                           found2=1;
                           break
                        end
                    end
                else
                    notfound2=1;
                end
                
               if notfound1==1
                   ignoretauschstatus=1;
                    repeatmat1=[];
                   repeatzaehler1=1;
                   repeatmat2=[];
                   repeatzaehler2=1;
                   found1=0;
                   found2=0;
                   notfound1=0;
                   notfound2=0;
                   break
               elseif notfound2==1
                   notfound2=0;
                   repeatzaehler2=1;
                   repeatmat2=[];
                   found2=0;
               end
                
                
                if paramat(itemnummer2,dimnummer)<paramat(itemnummer1,dimnummer)...
                    & checkabsreqs(itemnummer2,aktivecell1,stimnummercell,absolutreqs,dim,paramat)...
                    & checkabsreqs(itemnummer1,aktivecell2,stimnummercell,absolutreqs,dim,paramat)
                    stimnummercell{cellnummer1}(z1)=itemnummer2;
                    stimnummercell{cellnummer2}(z2)=itemnummer1;
                    erfuellt=1;
                    break
                end
            end
        end
    end
    if ignorerestlistestatus==1 & ignoretauschstatus==1 & erfuellt==0
        dlg=helpdlg(['Bedingung ',num2str(aktivecell1),'<',num2str(aktivecell2),' auf ',dim{dimnummer},' konnte durch einfaches vertauschen nicht erfüllt werden'],'Achtung:');
        pause(0.3);
        close(dlg);
        neuziehen=1;
        break
    end    
end
if neuziehen == 1
    break
end
end
end



%groesserreqs
%----------------------------------------------------------------------------------------------------- 

ignorerestlistestatus=0;
ignoretauschstatus=0;
erfuellt=0;

if neuziehen~=1
if ~isempty(groesserreqsnonmet)
    
% dlg=helpdlg('Optimiere nach groesser-requirements...','Optimiere:');
% pause(0.2);
% close(dlg); 


for korrzaehler=1:anzahlnonmetgroesserreqs
    aktivecell1=groesserreqs{groesserreqsnonmet(korrzaehler),2};
    cellnummer1=find(celladressmat==aktivecell1);
    aktivecell2=groesserreqs{groesserreqsnonmet(korrzaehler),3};
    cellnummer2=find(celladressmat==aktivecell2);
    for dimzaehler=1:length(dim)
        if ~isempty(findstr(dim{dimzaehler},groesserreqs{korrzaehler,4}))
            %paramatkorrektur
            dimnummer=dimzaehler-1;
        end
    end
    
    restliste=[];
    erfuellt=0;
    repeatmat1=[];
    repeatmat2=[];
    repeatzaehler1=1;
    repeatzaehler2=1;
    notfound1=0;
    notfound2=0;
    found1=0;
    found2=0;
    %neues Item ziehen
    %----------------------
    while erfuellt==0 & (ignorerestlistestatus==0 | ignoretauschstatus==0) 
%        fprintf('\n*31'); 
       set(statustext,'String',' > - restliste');   
        if anzahlsumvec(2)<anzahlstimuli & ignorerestlistestatus~=1 
            
            %restliste erstellen
            stimnummernliste=linspace(1,anzahlstimuli,anzahlstimuli);
            for g=1:length(totwiederholung)
                wegindexmat(g)=find(totwiederholung(g)==stimnummernliste);
            end
            restliste=stimnummernliste;
            restliste(wegindexmat)=[];
            
            while 1
%                 fprintf('\n*7');
                %item aus zelle ziehen
                if length(stimnummercell{cellnummer1})>length(repeatmat1)
                    while found2==0
%                         fprintf('\n*8');
                        z1=mod(zelle1zaehler,length(stimnummercell{cellnummer1}))+1;
                        zelle1zaehler=zelle1zaehler+1;
                        itemnummer1=stimnummercell{cellnummer1}(z1);
                        
                        set(infdlgtext1,'String',num2str(itemnummer1));
                        
                        if ~isempty(repeatmat1)
                            if isempty(find(repeatmat1==z1))
                                repeatmat1(repeatzaehler1)=z1;
                                
                                repeatzaehler1=repeatzaehler1+1;
                                found1=1;
                                break
                            end
                        else
                            repeatmat1(repeatzaehler1)=z1;
                            repeatzaehler1=repeatzaehler1+1;
                            found1=1;
                            break
                        end
                    end
                else
                   notfound1=1;
                end  
                
                %item aus restliste ziehen
                if length(restliste)>length(repeatmat2)
                        while found1==1
%                             fprintf('\n*7.5');
                            z2=mod(restlistezaehler,length(restliste))+1;
                            restlistezaehler=restlistezaehler+13;
                            itemnummer2=restliste(z2);
                            set(infdlgtext2,'String',num2str(itemnummer2));
                            if ~isempty(repeatmat2)
                                if isempty(find(repeatmat2==z2))
                                    repeatmat2(repeatzaehler2)=z2;
                                    repeatzaehler2=repeatzaehler2+1;
                                    found2=1;
                                    break
                                end
                            else
                                 repeatmat2(repeatzaehler2)=z2;
                                 repeatzaehler2=repeatzaehler2+1;
                                 found2=1;
                                 break
                            end
                        end
               else
                  notfound2=1;
               end  
                
               
               if notfound1==1
                   ignorerestlistestatus=1;
                   repeatmat1=[];
                   repeatzaehler1=1;
                   repeatmat2=[];
                   repeatzaehler2=1;
                   found1=0;
                   found2=0;
                   notfound1=0;
                   notfound2=0;
                   break
               elseif notfound2==1
                   notfound2=0;
                   found2=0;
                   repeatzaehler2=1;
                   repeatmat2=[];
               end
               
               if paramat(itemnummer2,dimnummer)>paramat(itemnummer1,dimnummer) ...
                       & checkabsreqs(itemnummer2,aktivecell1,stimnummercell,absolutreqs,dim,paramat)
                                       
                    stimnummercell{cellnummer1}(z1)=itemnummer2;
                    restliste(z2)=itemnummer1;
                    totwiederholung(find(totwiederholung==itemnummer1))=itemnummer2;
                    erfuellt=1;
                    break
               end
           end
        
       %items vertauschen
       %----------------------
       elseif anzahlsumvec(2)<=anzahlstimuli & ignoretauschstatus~=1
       
       set(statustext,'String',' > - vertauschen'); 
          while 1
%                 fprintf('\n*10');
                %item aus zelle1 ziehen
                if length(stimnummercell{cellnummer1})>length(repeatmat1)
                    while found2==0
%                         fprintf('\n*11');
                        z1=mod(zelle1zaehler,length(stimnummercell{cellnummer1}))+1;
                        zelle1zaehler=zelle1zaehler+1;
                        itemnummer1=stimnummercell{cellnummer1}(z1);
                        
                        set(infdlgtext1,'String',num2str(itemnummer1));
                        if ~isempty(repeatmat1)
                            if isempty(find(repeatmat1==z1))
                                repeatmat1(repeatzaehler1)=z1;
                                repeatzaehler1=repeatzaehler1+1;
                                found1=1;
                                break
                            end
                        else
                            repeatmat1(repeatzaehler1)=z1;
                            repeatzaehler1=repeatzaehler1+1;
                            found1=1;
                            break
                        end
                    end
                else
                    notfound1=1;
                end  
                %item aus zelle2 ziehen
                if length(stimnummercell{cellnummer2})>length(repeatmat2)
                    while found1==1
%                         fprintf('\n*12');
                        z2=mod(zelle2zaehler,length(stimnummercell{cellnummer2}))+1;
                        zelle2zaehler=zelle2zaehler+1;
                        itemnummer2=stimnummercell{cellnummer2}(z2);
                        set(infdlgtext2,'String',num2str(itemnummer2));
                        if ~isempty(repeatmat2)
                            if isempty(find(repeatmat2==z2))
                                repeatmat2(repeatzaehler2)=z2;
                                repeatzaehler2=repeatzaehler2+1;
                                found2=1;
                                break
                            end
                        else
                            repeatmat2(repeatzaehler2)=z2;
                            repeatzaehler2=repeatzaehler2+1;
                            found2=1;
                            break
                        end
                    end
                else
                    notfound2=1;
                end
                
                 if notfound1==1
                   ignoretauschstatus=1;
                    repeatmat1=[];
                   repeatzaehler1=1;
                   repeatmat2=[];
                   repeatzaehler2=1;
                   found1=0;
                   found2=0;
                   notfound1=0;
                   notfound2=0;
                   break
               elseif notfound2==1
                   notfound2=0;
                   found2=0;
                   repeatzaehler2=1;
                   repeatmat2=[];
               end
                
                if paramat(itemnummer2,dimnummer)>paramat(itemnummer1,dimnummer)...
                    & checkabsreqs(itemnummer2,aktivecell1,stimnummercell,absolutreqs,dim,paramat)...
                    & checkabsreqs(itemnummer1,aktivecell2,stimnummercell,absolutreqs,dim,paramat)
                    stimnummercell{cellnummer1}(z1)=itemnummer2;
                    stimnummercell{cellnummer2}(z2)=itemnummer1;
                    erfuellt=1;
                    break
                end
            end
        end
    end
    if ignorerestlistestatus==1 & ignoretauschstatus==1 & erfuellt==0
        dlg=helpdlg(['Bedingung ',num2str(aktivecell1),'>',num2str(aktivecell2),' auf ',dim{dimnummer},' konnte durch einfaches vertauschen nicht erfüllt werden'],'Achtung:');
        pause(0.3);
        close(dlg);
        neuziehen=1;
        break
    end  

end

if neuziehen==1
    break
end

end
end


%gleichreqs 
%----------------------------------------------------------------------------------------------------- 

if neuziehen~=1
if ~isempty(gleichreqsnonmet)
    
    
% dlg=helpdlg('Optimiere nach gleich-requirements...','Optimiere:');
% pause(0.2);
% close(dlg); 


    
for korrzaehler=1:anzahlnonmetgleichreqs
    aktivecell1=gleichreqs{gleichreqsnonmet(korrzaehler),2};
    cellnummer1=find(celladressmat==aktivecell1);
    aktivecell2=gleichreqs{gleichreqsnonmet(korrzaehler),3};
    cellnummer2=find(celladressmat==aktivecell2);
    for dimzaehler=1:length(dim)
        if ~isempty(findstr(dim{dimzaehler},gleichreqs{korrzaehler,4}))
            %paramatkorrektur
            dimnummer=dimzaehler-1;
        end
    end
    ignorerestlistestatus=0;
    ignoretauschstatus=0;
    restliste=[];
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    %  gleichreqsmetmat(j,1)=1;  %  -->cell1 > cell2            %
    %  gleichreqsmetmat(j,1)=2;  %  -->cell1 < cell2            %
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    restliste=[];
    erfuellt=0;
    repeatmat1=[];
    repeatmat2=[];
    repeatzaehler1=1;
    repeatzaehler2=1;
    notfound1=0;
    notfound2=0;
    found1=0;
    found2=0;
    erfuellt=0;
    if gleichreqsmetmat(gleichreqsnonmet(korrzaehler))==1 %cell1>cell2
     
     while erfuellt==0 & (ignorerestlistestatus==0 | ignoretauschstatus==0)  
         
         
       set(statustext,'String',' = - 1>2 restliste'); 
%          fprintf('\n*32');
        if anzahlsumvec(2)<anzahlstimuli & ignorerestlistestatus==0
            
            %restliste erstellen
            stimnummernliste=linspace(1,anzahlstimuli,anzahlstimuli);
            for g=1:length(totwiederholung)
                wegindexmat(g)=find(totwiederholung(g)==stimnummernliste);
            end
            restliste=stimnummernliste;
            restliste(wegindexmat)=[];
           
            while 1
%                 fprintf('\n*13');
               
                %item aus zelle ziehen
                if length(stimnummercell{cellnummer1})>length(repeatmat1)
                    while found2==0
%                         fprintf('\n*14');
                        z1=mod(zelle1zaehler,length(stimnummercell{cellnummer1}))+1;
                        zelle1zaehler=zelle1zaehler+1;
                        itemnummer1=stimnummercell{cellnummer1}(z1);
                        set(infdlgtext1,'String',num2str(itemnummer1));
                       if ~isempty(repeatmat1)
                            if isempty(find(repeatmat1==z1))
                                repeatmat1(repeatzaehler1)=z1;
                                repeatzaehler1=repeatzaehler1+1;
                                found1=1;
                                break
                            end
                        else
                            repeatmat1(repeatzaehler1)=z1;
                            repeatzaehler1=repeatzaehler1+1;
                            found1=1;
                            break
                        end
                    end  
                else
                   notfound1=1;
                end                
            
                %item aus restliste ziehen
                if length(restliste)>length(repeatmat2)
                        while found1==1
%                             fprintf('\n*15');
                             z2=mod(restlistezaehler,length(restliste))+1;
                            restlistezaehler=restlistezaehler+13;
                            itemnummer2=restliste(z2);
                            set(infdlgtext2,'String',num2str(itemnummer2));
                            if ~isempty(repeatmat2)
                                if isempty(find(repeatmat2==z2))
                                    repeatmat2(repeatzaehler2)=z2;
                                    repeatzaehler2=repeatzaehler2+1;
                                    found2=1;
                                    break
                                end
                            else
                                repeatmat2(repeatzaehler2)=z2;
                                repeatzaehler2=repeatzaehler2+1;
                                found2=1;
                                break
                            end
                        end
               else
                        notfound2=1;
               end  
               
               if notfound1==1
                   ignorerestlistestatus=1;
                    repeatmat1=[];
                   repeatzaehler1=1;
                   repeatmat2=[];
                   repeatzaehler2=1;
                   found1=0;
                   found2=0;
                   notfound1=0;
                   notfound2=0;
                   break
               elseif notfound2==1
                   notfound2=0;
                   found2=0;
                   repeatzaehler2=1;
                   repeatmat2=[];
               end
            
               if paramat(itemnummer2,dimnummer)<paramat(itemnummer1,dimnummer)...
                        & checkabsreqs(itemnummer2,aktivecell1,stimnummercell,absolutreqs,dim,paramat)
                    
                        stimnummercell{cellnummer1}(z1)=itemnummer2;
                        restliste(z2)=itemnummer1;
                        totwiederholung(find(totwiederholung==itemnummer1))=itemnummer2;
                        erfuellt=1;
                        break
               end
            
           end
        
       %items vertauschen
       elseif anzahlsumvec(2)<=anzahlstimuli | ignorerestlistestatus==1
            set(statustext,'String',' = - 1>2 vertauschen'); 
             while 1
                %fprintf('\n*16');
                %item aus zelle1 ziehen
                if length(stimnummercell{cellnummer1})>length(repeatmat1)
                    while found2==0
                        %fprintf('\n*17');
                        z1=mod(zelle1zaehler,length(stimnummercell{cellnummer1}))+1;
                        zelle1zaehler=zelle1zaehler+1;
                        itemnummer1=stimnummercell{cellnummer1}(z1);
                        set(infdlgtext1,'String',num2str(itemnummer1));
                        if ~isempty(repeatmat1)
                            if isempty(find(repeatmat1==z1))
                                repeatmat1(repeatzaehler1)=z1;
                                repeatzaehler1=repeatzaehler1+1;
                                found1=1;
                                break
                            end
                        else
                            repeatmat1(repeatzaehler1)=z1;
                            repeatzaehler1=repeatzaehler1+1;
                            found1=1;
                            break
                        end
                    end   
                else
                    notfound1=1;
                end                
            
                %item aus zelle2 ziehen
                if length(stimnummercell{cellnummer2})>length(repeatmat2)
                    while found1==1
                        %fprintf('\n*18');
                        z2=mod(zelle2zaehler,length(stimnummercell{cellnummer2}))+1;
                        zelle2zaehler=zelle2zaehler+1;
                        itemnummer2=stimnummercell{cellnummer2}(z2);
                        set(infdlgtext2,'String',num2str(itemnummer2));
                        if ~isempty(repeatmat2)
                            if isempty(find(repeatmat2==z2))
                                repeatmat2(repeatzaehler2)=z2;
                                repeatzaehler2=repeatzaehler2+1;
                                found2=1;
                                break
                            end
                        else
                            repeatmat2(repeatzaehler2)=z2;
                            repeatzaehler2=repeatzaehler2+1;
                            found2=1;
                            break
                        end
                    end 
                else
                    notfound2=1;
                end
            
                if notfound1==1
                   ignoretauschstatus=1;
                    repeatmat1=[];
                   repeatzaehler1=1;
                   repeatmat2=[];
                   repeatzaehler2=1;
                   found1=0;
                   found2=0;
                   notfound1=0;
                   notfound2=0;
                   break
               elseif notfound2==1
                   found2=0;
                   repeatzaehler2=1;
                   repeatmat2=[];
               end
                
                if paramat(itemnummer2,dimnummer)<paramat(itemnummer1,dimnummer)...
                    & checkabsreqs(itemnummer2,aktivecell1,stimnummercell,absolutreqs,dim,paramat)...
                    & checkabsreqs(itemnummer1,aktivecell2,stimnummercell,absolutreqs,dim,paramat)
                    stimnummercell{cellnummer1}(z1)=itemnummer2;
                    stimnummercell{cellnummer2}(z2)=itemnummer1;
                    erfuellt=1;
                    break
                end 
            end
        end
    end
    if ignorerestlistestatus==1 & ignoretauschstatus==1 
        dlg=helpdlg(['Bedingung ',num2str(aktivecell1),'=',num2str(aktivecell2),' auf ',dim{dimnummer},' konnte durch einfaches vertauschen nicht erfüllt werden'],'Achtung:'); 
        pause(0.3);
        close(dlg);
        neuziehen=1;
        break
    end 
    
    
    
else %cell1 < cell2
     while erfuellt==0 & (ignorerestlistestatus==0 | ignoretauschstatus==0) 
          set(statustext,'String',' = - 2>1 restliste'); 
         %fprintf('\n*33');
        if anzahlsumvec(2)<anzahlstimuli & ignorerestlistestatus==0
            
            %restliste erstellen
            stimnummernliste=linspace(1,anzahlstimuli,anzahlstimuli);
            for g=1:length(totwiederholung)
                wegindexmat(g)=find(totwiederholung(g)==stimnummernliste);
            end
            restliste=stimnummernliste;
            restliste(wegindexmat)=[];
            while 1
                %fprintf('\n*19');
              
                %item aus zelle ziehen
                if length(stimnummercell{cellnummer1})>length(repeatmat1)
                    while found2==0
                        %fprintf('\n*20');
                        z1=mod(zelle1zaehler,length(stimnummercell{cellnummer1}))+1;
                        zelle1zaehler=zelle1zaehler+1;
                        itemnummer1=stimnummercell{cellnummer1}(z1);
                        set(infdlgtext1,'String',num2str(itemnummer1));
                        if ~isempty(repeatmat1)
                            if isempty(find(repeatmat1==z1))
                                repeatmat1(repeatzaehler1)=z1;
                                repeatzaehler1=repeatzaehler1+1;
                                found1=1;
                                break
                            end
                        else
                             repeatmat1(repeatzaehler1)=z1;
                             repeatzaehler1=repeatzaehler1+1;
                             found1=1;
                             break
                        end
                    end
                else
                   notfound1=1;
                end                
            
                %item aus restliste ziehen
                
                if length(restliste)>length(repeatmat2)
                        while found1==1
                            %fprintf('\n*21');
                             z2=mod(restlistezaehler,length(restliste))+1;
                            restlistezaehler=restlistezaehler+13;
                            itemnummer2=restliste(z2);
                            set(infdlgtext2,'String',num2str(itemnummer2));
                            if ~isempty(repeatmat2)
                                if isempty(find(repeatmat2==z2))
                                    repeatmat2(repeatzaehler2)=z2;
                                    repeatzaehler2=repeatzaehler2+1;
                                    found2=1;
                                    break
                                end
                            else
                               repeatmat2(repeatzaehler2)=z2;
                               repeatzaehler2=repeatzaehler2+1;
                               found2=1;
                               break
                            end
                        end    
               else
                        notfound2=1;
               end  
                
                if notfound1==1
                   ignorerestlistestatus=1;
                    repeatmat1=[];
                   repeatzaehler1=1;
                   repeatmat2=[];
                   repeatzaehler2=1;
                   found1=0;
                   found2=0;
                   notfound1=0;
                   notfound2=0;
                   break
               elseif notfound2==1
                   found2=0;
                   repeatzaehler2=1;
                   repeatmat2=[];
                   notfound2=0;
               end
               
               if paramat(itemnummer2,dimnummer)>paramat(itemnummer1,dimnummer)...
                       & checkabsreqs(itemnummer2,aktivecell1,stimnummercell,absolutreqs,dim,paramat)
                                               
                        stimnummercell{cellnummer1}(z1)=itemnummer2;
                        restliste(z2)=itemnummer1;
                        totwiederholung(find(totwiederholung==itemnummer1))=itemnummer2;
                        erfuellt=1;
                        break
               end
           end
        
       %items vertauschen
       elseif anzahlsumvec(2)<=anzahlstimuli | ignorerestlistestatus==1
          set(statustext,'String',' = - 2>1 vertauschen'); 
            while 1
                %fprintf('\n*22');
                %item aus zelle1 ziehen
                if length(stimnummercell{cellnummer1})>length(repeatmat1)
                    while found2==0
                        %fprintf('\n*23');
                        z1=mod(zelle1zaehler,length(stimnummercell{cellnummer1}))+1;
                        zelle1zaehler=zelle1zaehler+1;
                        itemnummer1=stimnummercell{cellnummer1}(z1);
                        set(infdlgtext1,'String',num2str(itemnummer1));
                        if ~isempty(repeatmat1)
                            if isempty(find(repeatmat1==z1))
                                 repeatmat1(repeatzaehler1)=z1;
                                repeatzaehler1=repeatzaehler1+1;
                                found1=1;
                                break
                            end
                        else
                            repeatmat1(repeatzaehler1)=z1;
                            repeatzaehler1=repeatzaehler1+1;
                            found1=1;
                            break
                        end
                    end
                else
                    notfound1=1;
                end                
            
                %item aus zelle2 ziehen
                if length(stimnummercell{cellnummer2})>length(repeatmat2)
                    while found1==1
                        %%fprintf('\n*24');
                        z2=mod(zelle2zaehler,length(stimnummercell{cellnummer2}))+1;
                        zelle2zaehler=zelle2zaehler+1;
                        itemnummer2=stimnummercell{cellnummer2}(z2);
                        set(infdlgtext2,'String',num2str(itemnummer2));
                        if ~isempty(repeatmat2)
                            if isempty(find(repeatmat2==z2))
                                repeatmat2(repeatzaehler2)=z2;
                                repeatzaehler2=repeatzaehler2+1;
                                found2=1;
                                break
                            end
                        else
                            repeatmat2(repeatzaehler2)=z2;
                            repeatzaehler2=repeatzaehler2+1;
                            found2=1;
                            break
                        end
                    end   
                else
                    notfound2=1;
                end
                
                 if notfound1==1
                   ignoretauschstatus=1;
                    repeatmat1=[];
                   repeatzaehler1=1;
                   repeatmat2=[];
                   repeatzaehler2=1;
                   found1=0;
                   found2=0;
                   notfound1=0;
                   notfound2=0;
                   break
               elseif notfound2==1
                   found2=0;
                   notfound2=0;
                   repeatzaehler2=1;
                   repeatmat2=[];
               end
                
                if paramat(itemnummer2,dimnummer)>paramat(itemnummer1,dimnummer)...
                    & checkabsreqs(itemnummer2,aktivecell1,stimnummercell,absolutreqs,dim,paramat)...
                    & checkabsreqs(itemnummer1,aktivecell2,stimnummercell,absolutreqs,dim,paramat)
                    stimnummercell{cellnummer1}(z1)=itemnummer2;
                    stimnummercell{cellnummer2}(z2)=itemnummer1;
                    erfuellt=1;
                    break
                end
            end
        end
    end
    if ignorerestlistestatus==1 & ignoretauschstatus==1 
        dlg=helpdlg(['Bedingung ',num2str(aktivecell1),'=',num2str(aktivecell2),' auf ',dim{dimnummer},' konnte durch einfaches vertauschen nicht erfüllt werden'],'Achtung:'); 
        pause(0.3);
        close(dlg);
        neuziehen=1;
        break
    end    
end
if neuziehen == 1
    break
end
end


end
end


end

if neuziehen == 1
    if exist('infdlghandle');
        close(infdlghandle);
    end
%     uiwait(helpdlg('Es wird neu gezogen...','Note:'));
end


end

if exist('infdlghandle');
  if ~isempty(findobj('tag','infdlg'))
      infdlghandle=findobj('tag','infdlg');
    close(infdlghandle);
  end
end

selectedstatus=1;
%-------------------------------------------------------------------------------------------
%-------------------------------------------------------------------------------------------
%-------------------------------------------------------------------------------------------


%Nummern ausgeben
%-------------------------------------------------------------------------------------------


disp('Stimulinummern:');
for p = 1:length(stimnummercell)
    disp(['cell ',num2str(p),':']);
    disp(stimnummercell{p});
end


figure('NumberTitle','off','Name','Gruppenübersicht');
hold on
for i=1:size(stimnummercell,1)
    if ~isempty(stimnummercell{i})
        
		subplot(size(stimnummercell,1),1,i)
		plot(stimnummercell{i},'o','LineWidth',8);
		
		for j=1:length(stimnummercell{i})
		   text(j,(stimnummercell{i}(j))*1.02,num2str(filenamecell{stimnummercell{i}(j)}));
		end
    else
        subplot(size(stimnummercell,1),1,i);
        axes
    end

end
hold off


parameterfilesettingsmenuitem=findobj('tag','parameterfilesettingsmenuitem');
statisticsfilesettingsmenuitem=findobj('tag','statisticsfilesettingsmenuitem');
scenariofilesettingsmenuitem=findobj('tag','scenariofilesettingsmenuitem');
stimulibatchfilesettingsmenuitem=findobj('tag','stimulibatchfilesettingsmenuitem');


%Statistik schreiben
%---------------------------------
if strcmp(get(statisticsfilesettingsmenuitem,'checked'),'on')
    
	statisticsradio = findobj('Tag','statisticsradio');
	statisticsstatus = get(statisticsradio,'Value');
	if statisticsstatus==1
        writestatistics(paramat,stimnummercell,filenamecell,celladressmat,groessenreqinds,absolutreqs,kleinerreqs,groesserreqs,gleichreqs,dim,2);
	end
end


%Scenario schreiben
%-------------------------------------------------------------------------------------------
if strcmp(get(scenariofilesettingsmenuitem,'checked'),'on')
	scenarioradio = findobj('Tag','scenarioradio');
	scenariostatus = get(scenarioradio,'Value');
	if scenariostatus==1
        writescenario(stimnummercell,filenamecell,celladressmat);
	end
end

%Paremeterfile updaten
%-------------------------------------------------------------------------------------------
if strcmp(get(parameterfilesettingsmenuitem,'checked'),'on')
	parameterfileradio = findobj('Tag','parameterfileradio');
	parameterfilestatus = get(parameterfileradio,'Value');
	if parameterfilestatus==1
        writeparameterfile;
	end
end


%stimulibatchfile
%------------------
if strcmp(get(stimulibatchfilesettingsmenuitem,'checked'),'on')
	answer = questdlg('Möchten Sie ein Batchfile der Stimulidateien erstellen?','Batchfile:','ja','nein','ja');
	if strcmp(answer,'ja')
       [batchfilename,batchfilepath]=uiputfile('*.m','Bitte benennen Sie das batchfile:');
       [dummy,targetdirectory]=uigetfile('*.*','Bitte wählen Sie ein File aus der Stimuli-directory:');
       
       batchfile=[batchfilepath,batchfilename];
       if isempty(findstr('.m',batchfile))
           batchfile=[batchfile,'.m'];
       end
       fid = fopen(batchfile,'wt');
       
       for z=1:length(stimnummercell)
           if ~isempty(stimnummercell{z})
               for q=1:length(stimnummercell{z})
                   fprintf(fid,'%s',[targetdirectory,filenamecell{stimnummercell{z}(q)}]);
                   fprintf(fid,'\n');
               end
           end
       end
       fclose(fid);
	end
end
        
        
        
        
return





