#!/usr/bin/perl -w


# --------------------------------------------------------------------------------------------------------------
# Kurzdokumentation  Schnittstelle und Gittergenerator von einem 2DlgmFIle zu einem Gitter im ng - Format 
# --------------------------------------------------------------------------------------------------------------
# Dirk Feuchter, August 2000
#--------------------------------------------------------------------------------------------------------------
# Input 2D-lgm File mit Namen "geometry"
# Aufruf: "lgm2ngrid geometry"
# Output: 3 Dateien in einem Unterverzeichnis "ng"
#         ==> ngfile        == Gitter im ng Format, das nun als geometry.ng verwendet werden kann
#         ==> ngfilegnu     == gnuplot File zum Gitter, das eine Visualisierung des Gitters ermoeglicht
#         ==> ngfiledebug   == zusaetzliche Debugausgaben, die im Konvertierungs und Vernetzungsalgorithmus
#                              ausgegeben werden.
# Anforderungen an das lgm-File:
#                           ==> Fuer jeden Lineknoten li einer Subdomain sollte gelten
#                               Die vertikale  Gerade "li + lambda * (0.0/1.0)" 
#                               sollte den SbdRand hoechstes zweimal schneiden.
#                               (d.h. Ueberhaenge sind noch nicht moeglich)
#                           ==> Fuer linkes(anfang) und rechtes Ende der Subdomain sin folgende 4 Faelle moeglch:
#                               1.) vertikaler Anfang und vertikales Ende  " |  | "
#                               2.) vertikaler Anfang und spitzes Ende     " |  > "
#                               3.) spitzer Anfang und spitzes Ende        " <  > "
#                               4.) spitzer Anfang und vertikales Ende     " <  | "
#                           ==> vertikale Segmente eines Subdomainrands sollten nur am linken Anfang oder rechten
#                               Ende einer Subdomain auftreten
#                           ==> Ein vertikaler Anfang/Ende sollte immer aus nur 2 Linepunkten bestehen.
#----------------------------------------------------------------------------------------------------------------


@ARGV==1 or die "usage: lgm2gnu <geometry>\n";
$real='[+-]?\d+\.?\d*[eE]?[+-]?\d+|[+-]?\d*\.?\d+[eE]?[+-]?\d+|[+-]?\d+';
$debug=0;

# admin
if (-e "ng") {system("rm -r ng");}
system("mkdir ng");

# functions
sub min
{
	$min_min=1000000;
	for ($min_i=0; $min_i<@_; $min_i++) {if ($min_min>$_[$min_i]) {$min_min=$_[$min_i];}}
	return ($min_min);
}
sub max 
{
	$max_max=-100000000;
	for ($max_i=0; $max_i<@_; $max_i++) {if ($max_max<$_[$max_i]) {$max_max=$_[$max_i];}}
	return ($max_max);
}


# Ueberschrift
print '-' x 80;
print "\n Schnittstelle und Gittergenerator lgm2D in das ng - Format \n";
print '-' x 80;
print "\n";

# check dimension
print "detect dimension ";
$dim=2;
$index=0;
open(IN,$ARGV[0]);
while($line=<IN>)
{
	if ($line=~/surface/)
	{
		$dim=3;
		last;
	}
	print ".";
}
close(IN);
print " found $dim, run ".$dim."d-check\n";

if ($dim==2)
{
	# admin
	open(IN,$ARGV[0]);
	$sd_min=1000000; $sd_max=-1;

	# get lines
	$l=0;
	while($line=<IN>)
	{
		if ($line=~/points:/)
		{
			$n[$l]=0;
			if (!($line=~/left=(\d+);\s*right=(\d+)/)) {die "ERROR: cannot read left/right info\n";}
			$left[$l]=$1; $right[$l]=$2;
			if ($left[$l]==$right[$l]) {die "ERROR: line $l references subdomain $right[$l] on both sides\n";}
			$sd_max=max($sd_max,$1,$2);
			$sd_min=min($sd_min,$1,$2);
			$line=~s/line\s*\d+:\s*left=\d+;\s*right=\d+;\s*points:\s*//g;
			while(1)
			{
				if ($line=~/(\d+)\s*/)
				{
					$lp[$l][$n[$l]++]=$1;			
					$line=~s/\d+\s*//;
				}
				else
				{
					last;
				}
			}
			print "l", $l, ":  l:",  $left[$l], "r:",$right[$l], "pts:";
			$ind = 0;
			while($lp[$l][$ind])
			{
				print $lp[$l][$ind], " ";
				$ind++;
			}
			print "\n";
			$l ++;
		}
		if ($line=~/Point-Info/) {last;}
	}

	# get points
	$m=0;
	while($line=<IN>)
	{
		if ($line=~/\s*($real)\s+($real)/)
		{
			$p[$m][0]=$1; $p[$m][1]=$2; $p_ref[$m]=0;
print "p", $m, ": ", $p[$m][0], ", ", $p[$m][1], "\n";
			$m++;
		}
	}
	close(IN);
	if ($m<3) {print "ERROR: $m points detected\n";}
	else {print "$m points detected\n";}

	# check point references
	#  laeuft ueber alle Lines 
	#    laeuft ueber alle Points der Lines
	#      gibt den Points ein Flag
	#  zu guter letzt sollte jeder Point ein Flag erhalten haben else ERR.
	for ($i=0; $i<$l; $i++) 
	{
		for ($j=0; $j<$n[$i]; $j++)
		{

			# Eintrag der lokalen Parameter:
			$p_lineID[$lp[$i][$j]] [$p_ref[$lp[$i][$j]]] = $i;
			$p_lokPar[$lp[$i][$j]] [$p_ref[$lp[$i][$j]]] = $j;
			$p_ref[$lp[$i][$j]]+=1; # in p_ref steht nun, wieviel Linereferenzen dieser Punkt hat.

		}
	}
	$err=0; 
	for ($i=0; $i<$m; $i++) 
	{
		if ($p_ref[$i]==0)
		{
			$err=1;
			print "ERROR: point $i not referenced\n";
		}
	}
	if (!$err) {$i=$m-1; print "point 0 ... $i referenced correctly\n";}


open(NG,">ng/ngfile");
open(NGD,">ng/ngfiledebug");
open(NGG,">ng/ngfilegnu");


	# check subdomains
	$err=0; for ($i=0; $i<=$sd_max; $i++) {$sd_ref[$i]=0;}
	for ($i=0; $i<$l; $i++) {$sd_ref[$left[$i]]=1; $sd_ref[$right[$i]]=1;}
	for ($i=0; $i<=$sd_max; $i++) # laufe ueber alle Subdomains
	{
		$knfindex[$i] = 0;	
		if (!$sd_ref[$i]) {print "ERROR: subdomain $i not referenced\n";$err=1;}
		else
		{
			$nl=0;
			for ($j=0; $j<$l; $j++) # laufe ueber alle Lines
			{
				if ($left[$j]==$i) # wenn Subdomain links der Line
				{
					$start[$nl]=$lp[$j][0];
					$end[$nl]=$lp[$j][$n[$j]-1];
					$nl++;
					# Knoten in knotenfeld eintragen mit Start aber ohne Endpunkt um Clonen zu vermeiden.
					for ($nn=0;$nn<($n[$j]-1);$nn++){
						$knotenfeld[$i][$knfindex[$i]] = $lp[$j][$nn];
						$knfindex[$i]++;
					}
				}
				if ($right[$j]==$i)
				{
					$end[$nl]=$lp[$j][0];
					$start[$nl]=$lp[$j][$n[$j]-1];
					$nl++;
					# Knoten in knotenfeld eintragen mit Start aber ohne Endpunkt um Clonen zu vermeiden.
					for ($nn=($n[$j]-1);$nn>0;$nn--){
						$knotenfeld[$i][$knfindex[$i]] = $lp[$j][$nn];
						$knfindex[$i]++;
					}
				}
			}
			for ($j=0; $j<$nl; $j++)
			{
				$sum=0;
				for ($k=0; $k<$nl; $k++) 
				{
					if( $start[$j]==$end[$k] )
					{
						$sum++;
					}
				}
				if ($sum!=1) {print "ERROR: subdomain $i not surrounded correctly\n"; $err=1; last;}
			}
		}
	} # Lauf ueber Subdomains
	if (!$err) {print "subdomain 0 ... $sd_max: ok\n";}
    
	# laufe ueber alle Subdomains OK
	# laufe ueber alle lines OK
	# laufe ueber alle knoten und spiele sie in knotenfeld[sbd] aber nicht doppelt OK
    # addiere dabei knotenfeld_N[sbd] auf, das ist die Summe aller einmaligen linenodes dieser Subdomain.OK
	# hinxu kommen spaeter noch ggf. einige Knoten der ganz Neuen.




	# Bereits beim Einlesen wurden in einem Lauf ueber alle Lines  OK
	# allen Knoten ihre LineIDs mit den zugehoerigen Paramterwerten zugewiesen. (s.o.) OK
	
	# Vorbereitung : Bau der Neuen ...

    # Laufe ueber alle lines und setze die X-Abmessungen dieser Line, lineX[i][0,1]
	for ($ll = 0; $ll < $l; $ll++)
	{
		$lineX[$ll][0] = $p[$lp[$ll][0]][0]; $lineX[$ll][1] =  $p[$lp[$ll][0]][0];
		for ($lpn = 0; $lpn < $n[$ll]; $lpn++)
		{
			if ($p[$lp[$ll][$lpn]][0] >=  $lineX[$ll][1])
			{   $lineX[$ll][1] = $p[$lp[$ll][$lpn]][0];}
			elsif ($p[$lp[$ll][$lpn]][0] <=  $lineX[$ll][0])
			{   $lineX[$ll][0] = $p[$lp[$ll][$lpn]][0];}
		}
		print NGD "Line $ll hat ein X_min von $lineX[$ll][0]   und ein X_max von $lineX[$ll][1]  \n";
	}
	
	# d.h. der X-Achsenbereich, den diese Line abdeckt

	# Merke INdex lgm_nodes!
	$lgmnodes = $m;
	print NGD "Lgm_Nodes_Anzahl ist $lgmnodes \n";

    # Laufe ueber alle lines la 
	  for ($la = 0; $la < $l; $la++)
	  {
		  #	laufe ueber alle knoten ka(la)
		  for ($lpn = 0; $lpn < $n[$la]; $lpn++)
		  {
			  $ka = $lp[$la][$lpn];

			  # laufe ueber alle lines lb != la
			  for ($lb = 0; $lb < $l; $lb++)
			  {
				  if($lb != $la)
				  {
					  # nur wenn ka in X-Abm-Bereich von lb liegt weitermachen ...
					  if( ($p[$ka][0] > $lineX[$lb][0]) && ($p[$ka][0] < $lineX[$lb][1]) ) 
					  {
						  # laufe ueber alle knoten kb(lb)					  
						  # suche unter den kb minmalenover>= und maximalenunder<= X(ka)						  
						  if ($p[$lp[$lb][0]][0] >  $p[$lp[$lb][$n[$lb]-1]][0]){
							  $minmalenover =  $lp[$lb][0]; $maximalenunder = $lp[$lb][$n[$lb]-1];}
							  else {  $minmalenover = $lp[$lb][$n[$lb]-1]; $maximalenunder =  $lp[$lb][0]; }

						  for ($lpn2 = 0; $lpn2 < $n[$lb]; $lpn2++)					  
						  {
							  $kb = $lp[$lb][$lpn2];
							  if($p[$kb][0] >= $p[$ka][0]){
								  if(($p[$kb][0]) <= $p[$minmalenover][0]){
									  $minmalenover =  $kb; $max_lpn2 = $lpn2;}}
							  if($p[$kb][0] <= $p[$ka][0]){
								  if(($p[$kb][0]) >= $p[$maximalenunder][0]){
									  $maximalenunder =  $kb; $min_lpn2 = $lpn2;}}
						  } # von  laufe ueber alle knoten kb(lb)
						  # if minmalenover == maximalenunder, d.h es ex. bereits ein vertikaler Partner d.f. weiter
						  if ( $minmalenover != $maximalenunder )
						  {
							  # if !OK Berchne anhand maximalenunder und minmalenover einen neuen Punkt
							  $x3 = $p[$ka][0]; $x1 = $p[$maximalenunder][0]; $x2 =  $p[$minmalenover][0];
							  $y1 = $p[$maximalenunder][1]; $y2 =  $p[$minmalenover][1];
							  $c = ($x3-$x1)/($x2-$x1); $lokkoord = $c + $min_lpn2; 
                              # oder aber min_lpn2 + 1 - c falls nach links orientiert
							  if($p[$lp[$lb][0]][0] >  $p[$lp[$lb][$n[$lb]-1]][0])
							  {  $lokkoord = $min_lpn2 - $c; }
							  $y3 = $y1 + $c * ($y2 - $y1);
							  $gibtsschon =0;
							  for($lff = 0; $lff < $index; $lff++)
								 {
									 if (($x3 == $aufschreiben[$lff][0]) &&( $y3 == $aufschreiben[$lff][1]))
									 {$gibtsschon = 1;}
								 }
							  if($gibtsschon == 0){
								  $aufschreiben[$index][0] = $x3; $aufschreiben[$index][1] = $y3;$index++;
								  print NGD "NEWNODE L $lb zwischen N $maximalenunder und N $minmalenover mit lokK = $lokkoord und x3 = $x3 und y3 = $y3 \n";
								  # Trage den Neuen auch in die Pointliste und das knotenfeld[sbd] ein.
								  print NGD "NeuimRennen $m \n";
								  $p[$m][0] = $x3; $p[$m][1] = $y3;  $p_lineID[$m][0] = $lb; $p_lokPar[$m][0] = $lokkoord;  $p_ref[$m] = 1;
						   		  $knotenfeld[$left[$lb]] [$knfindex[$left[$lb]]] = $m;  $knotenfeld[$right[$lb]] [$knfindex[$right[$lb]]] = $m; $m++;
								  $knfindex[$left[$lb]] ++;  $knfindex[$right[$lb]] ++; 
							  }

						  }

					  } # von nur wenn ka in X-Abm-Bereich von lb liegt weitermachen ...
				  } #von if(lb != la)
			  } # von laufe ueber alle lines lb != la
		  
		  } # von laufe ueber alle knoten ka(la)

	  } # von Laufe ueber alle lines la		  

	


	# sortiere nun knotenfeldsbd nach dem X-Wert
	for ($i=0; $i<=$sd_max; $i++) # laufe ueber alle Subdomains
	{
                
		print NGD "\n";
		print NGD " Subdomain $i - der Bubbelsort \n";
		print NGD "IDsPrae:"; 
		for ($kkk = 0; $kkk < $knfindex[$i]; $kkk++)
		{
			print NGD " $knotenfeld[$i][$kkk]";
		}
		print NGD "\n";

		$oben = $knfindex[$i] - 1;
		for ($iiii =0; $iiii<  ($knfindex[$i] - 1); $iiii++)
		{
			for($ii = 0; $ii < $oben; $ii++)
			{
			        # Befoerdere den groessten X Wert hoch  GOONHERE nicht groesste ID  sondern groessten X-Wert hoch befoerdern ...
				if ($p[$knotenfeld[$i][$ii]][0] > $p[$knotenfeld[$i][$ii +1]][0] ){
					$merke = $knotenfeld[$i][$ii];
					$knotenfeld[$i][$ii] = $knotenfeld[$i][$ii +1];
					$knotenfeld[$i][$ii +1] = $merke;
				
				}
				
			}
			$oben --;
		}
		print NGD "IDsPost:";
                 for ($kkk = 0; $kkk < $knfindex[$i]; $kkk++)
                {
                        print NGD " $knotenfeld[$i][$kkk]";
                }
                print NGD "\n";

 
 	}



	for($nde = 0; $nde < $m; $nde++){
		print NG "B $p[$nde][0] $p[$nde][1]";
		for($lne = 0; $lne < $p_ref[$nde] ; $lne++){
			print NG " L $p_lineID[$nde][$lne] $p_lokPar[$nde][$lne]";}
		print NG ";\n";
		}

	}
    # laufe in den knotefeld arrays ueber alle sbds
    # ABER NICHT ueber Subdomain 0 !
	# speyial baue erstes element
	# speyial baue letytes element
	# baue in Schleife alle Element dazwischen
	# und gib sie dabei gleich aus.



	for ($i=1; $i<=$sd_max; $i++) # laufe ueber alle Subdomains
    {
		$beg = -1; $end = -1;    
		
        # if spitzer Beginn
		if ($p[$knotenfeld[$i][0]][0] != $p[$knotenfeld[$i][1]][0])
		{
			$beginn = "spitz";
			# if einziges Element
			if($knfindex[$i] == 3)
			{
				print NG "E $i $knotenfeld[$i][0] $knotenfeld[$i][1] $knotenfeld[$i][2] ";

				print NGG "$p[$knotenfeld[$i][0]][0] $p[$knotenfeld[$i][0]][1]\n"; 
				print NGG "$p[$knotenfeld[$i][1]][0] $p[$knotenfeld[$i][1]][1]\n\n"; 
				print NGG "$p[$knotenfeld[$i][1]][0] $p[$knotenfeld[$i][1]][1]\n"; 
				print NGG "$p[$knotenfeld[$i][2]][0] $p[$knotenfeld[$i][2]][1]\n\n"; 
				print NGG "$p[$knotenfeld[$i][2]][0] $p[$knotenfeld[$i][2]][1]\n"; 
				print NGG "$p[$knotenfeld[$i][0]][0] $p[$knotenfeld[$i][0]][1]\n\n\n"; 

				print NG "S $knotenfeld[$i][0] $knotenfeld[$i][1] S $knotenfeld[$i][1] $knotenfeld[$i][2] S $knotenfeld[$i][2] $knotenfeld[$i][0]; \n";
			}
			# else spitzer Beginn aber nicht einziges Element
			else
			{
				print NG "E $i $knotenfeld[$i][0] $knotenfeld[$i][1] $knotenfeld[$i][2] ";

				print NGG "$p[$knotenfeld[$i][0]][0] $p[$knotenfeld[$i][0]][1]\n"; 
				print NGG "$p[$knotenfeld[$i][1]][0] $p[$knotenfeld[$i][1]][1]\n\n"; 
				print NGG "$p[$knotenfeld[$i][1]][0] $p[$knotenfeld[$i][1]][1]\n"; 
				print NGG "$p[$knotenfeld[$i][2]][0] $p[$knotenfeld[$i][2]][1]\n\n"; 
				print NGG "$p[$knotenfeld[$i][2]][0] $p[$knotenfeld[$i][2]][1]\n"; 
				print NGG "$p[$knotenfeld[$i][0]][0] $p[$knotenfeld[$i][0]][1]\n\n\n"; 

				print NG "S $knotenfeld[$i][0] $knotenfeld[$i][1] S $knotenfeld[$i][2] $knotenfeld[$i][0]; \n";
			}
		}

		# if spitzes Ende
		if ($p[$knotenfeld[$i][$knfindex[$i]-2]][0] != $p[$knotenfeld[$i][$knfindex[$i]-1]][0])
		{
			$ende = "spitz";
			# if einziges Element
			if($knfindex[$i] == 3)
			{
				print NG "E $i $knotenfeld[$i][0] $knotenfeld[$i][1] $knotenfeld[$i][2] ";

				print NGG "$p[$knotenfeld[$i][0]][0] $p[$knotenfeld[$i][0]][1]\n"; 
				print NGG "$p[$knotenfeld[$i][1]][0] $p[$knotenfeld[$i][1]][1]\n\n"; 
				print NGG "$p[$knotenfeld[$i][1]][0] $p[$knotenfeld[$i][1]][1]\n"; 
				print NGG "$p[$knotenfeld[$i][2]][0] $p[$knotenfeld[$i][2]][1]\n\n"; 
				print NGG "$p[$knotenfeld[$i][2]][0] $p[$knotenfeld[$i][2]][1]\n"; 
				print NGG "$p[$knotenfeld[$i][0]][0] $p[$knotenfeld[$i][0]][1]\n\n\n"; 

				print NG "S $knotenfeld[$i][0] $knotenfeld[$i][1] S $knotenfeld[$i][1] $knotenfeld[$i][2] S $knotenfeld[$i][2] $knotenfeld[$i][0]; \n";
				$beg = 3; $end = 3;
			}
			# else spitzes Ende aber nicht einziges Element
			else
			{
				print NG "E $i $knotenfeld[$i][$knfindex[$i]-3] $knotenfeld[$i][$knfindex[$i]-2] $knotenfeld[$i][$knfindex[$i]-1] ";

				print NGG "$p[$knotenfeld[$i][$knfindex[$i]-3]][0] $p[$knotenfeld[$i][$knfindex[$i]-3]][1]\n"; 
				print NGG "$p[$knotenfeld[$i][$knfindex[$i]-2]][0] $p[$knotenfeld[$i][$knfindex[$i]-2]][1]\n\n"; 
				print NGG "$p[$knotenfeld[$i][$knfindex[$i]-2]][0] $p[$knotenfeld[$i][$knfindex[$i]-2]][1]\n"; 
				print NGG "$p[$knotenfeld[$i][$knfindex[$i]-1]][0] $p[$knotenfeld[$i][$knfindex[$i]-1]][1]\n\n"; 
				print NGG "$p[$knotenfeld[$i][$knfindex[$i]-1]][0] $p[$knotenfeld[$i][$knfindex[$i]-1]][1]\n"; 
				print NGG "$p[$knotenfeld[$i][$knfindex[$i]-3]][0] $p[$knotenfeld[$i][$knfindex[$i]-3]][1]\n\n\n"; 

				print NG "S $knotenfeld[$i][$knfindex[$i]-3] $knotenfeld[$i][$knfindex[$i]-1] S $knotenfeld[$i][$knfindex[$i]-2] $knotenfeld[$i][$knfindex[$i]-1]; \n";
			}
		}

		# normaler Beginn
		if ($p[$knotenfeld[$i][0]][0] == $p[$knotenfeld[$i][1]][0])
		{
			$beginn = "normal";
			# if einziges Element
			if($knfindex[$i] == 4)
			{

				if($p[$knotenfeld[$i][1]][1] > $p[$knotenfeld[$i][0]][1])
				{
					if($p[$knotenfeld[$i][3]][1] > $p[$knotenfeld[$i][2]][1])
					{
						print NG "E $i $knotenfeld[$i][0] $knotenfeld[$i][2] $knotenfeld[$i][3]  $knotenfeld[$i][1] ";

						print NGG "$p[$knotenfeld[$i][0]][0] $p[$knotenfeld[$i][0]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][2]][0] $p[$knotenfeld[$i][2]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][2]][0] $p[$knotenfeld[$i][2]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][3]][0] $p[$knotenfeld[$i][3]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][3]][0] $p[$knotenfeld[$i][3]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][1]][0] $p[$knotenfeld[$i][1]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][1]][0] $p[$knotenfeld[$i][1]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][0]][0] $p[$knotenfeld[$i][0]][1]\n\n\n"; 

						print NG "S $knotenfeld[$i][0] $knotenfeld[$i][2] S $knotenfeld[$i][2] $knotenfeld[$i][3] S $knotenfeld[$i][3] $knotenfeld[$i][1] S $knotenfeld[$i][1] $knotenfeld[$i][0]; \n";						
					}
				    else # 2 > 3
					{
						print NG "E $i $knotenfeld[$i][0] $knotenfeld[$i][3] $knotenfeld[$i][2] $knotenfeld[$i][1] ";

						print NGG "$p[$knotenfeld[$i][0]][0] $p[$knotenfeld[$i][0]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][3]][0] $p[$knotenfeld[$i][3]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][3]][0] $p[$knotenfeld[$i][3]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][2]][0] $p[$knotenfeld[$i][2]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][2]][0] $p[$knotenfeld[$i][2]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][1]][0] $p[$knotenfeld[$i][1]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][1]][0] $p[$knotenfeld[$i][1]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][0]][0] $p[$knotenfeld[$i][0]][1]\n\n\n"; 

						print NG "S $knotenfeld[$i][0] $knotenfeld[$i][3] S $knotenfeld[$i][3] $knotenfeld[$i][2] S $knotenfeld[$i][2] $knotenfeld[$i][1] S $knotenfeld[$i][1] $knotenfeld[$i][0]; \n";		
					}
				}
				else # 0 > 1
				{
					if($p[$knotenfeld[$i][3]][1] > $p[$knotenfeld[$i][2]][1])
					{
						print NG "E $i $knotenfeld[$i][1] $knotenfeld[$i][2] $knotenfeld[$i][3] $knotenfeld[$i][0] ";

						print NGG "$p[$knotenfeld[$i][1]][0] $p[$knotenfeld[$i][1]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][2]][0] $p[$knotenfeld[$i][2]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][2]][0] $p[$knotenfeld[$i][2]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][3]][0] $p[$knotenfeld[$i][3]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][3]][0] $p[$knotenfeld[$i][3]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][0]][0] $p[$knotenfeld[$i][0]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][0]][0] $p[$knotenfeld[$i][0]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][1]][0] $p[$knotenfeld[$i][1]][1]\n\n\n"; 

						print NG "S $knotenfeld[$i][1] $knotenfeld[$i][2] S $knotenfeld[$i][2] $knotenfeld[$i][3] S $knotenfeld[$i][3] $knotenfeld[$i][0] S $knotenfeld[$i][0] $knotenfeld[$i][1]; \n";		
					}
				    else # 2 > 3
					{
						print NG "E $i $knotenfeld[$i][1] $knotenfeld[$i][3] $knotenfeld[$i][2] $knotenfeld[$i][0] ";

						print NGG "$p[$knotenfeld[$i][1]][0] $p[$knotenfeld[$i][1]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][3]][0] $p[$knotenfeld[$i][3]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][3]][0] $p[$knotenfeld[$i][3]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][2]][0] $p[$knotenfeld[$i][2]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][2]][0] $p[$knotenfeld[$i][2]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][0]][0] $p[$knotenfeld[$i][0]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][0]][0] $p[$knotenfeld[$i][0]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][1]][0] $p[$knotenfeld[$i][1]][1]\n\n\n"; 

						print NG "S $knotenfeld[$i][1] $knotenfeld[$i][3] S $knotenfeld[$i][3] $knotenfeld[$i][2] S $knotenfeld[$i][2] $knotenfeld[$i][0] S $knotenfeld[$i][0] $knotenfeld[$i][1]; \n";		
					}
				}
				$beg = 4; $end = 4;				# das war schon alles
			}
			# else normaler Beginn aber nicht einziges Element
			else
			{
				if($p[$knotenfeld[$i][1]][1] > $p[$knotenfeld[$i][0]][1])
				{
					if($p[$knotenfeld[$i][3]][1] > $p[$knotenfeld[$i][2]][1])
					{
						print NG "E $i $knotenfeld[$i][0] $knotenfeld[$i][2] $knotenfeld[$i][3] $knotenfeld[$i][1] ";

						print NGG "$p[$knotenfeld[$i][0]][0] $p[$knotenfeld[$i][0]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][2]][0] $p[$knotenfeld[$i][2]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][2]][0] $p[$knotenfeld[$i][2]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][3]][0] $p[$knotenfeld[$i][3]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][3]][0] $p[$knotenfeld[$i][3]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][1]][0] $p[$knotenfeld[$i][1]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][1]][0] $p[$knotenfeld[$i][1]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][0]][0] $p[$knotenfeld[$i][0]][1]\n\n\n"; 

						print NG "S $knotenfeld[$i][0] $knotenfeld[$i][2] S $knotenfeld[$i][3] $knotenfeld[$i][1] S $knotenfeld[$i][1] $knotenfeld[$i][0]; \n";
					}
				    else # 2 > 3
					{
						print NG "E $i $knotenfeld[$i][0] $knotenfeld[$i][3] $knotenfeld[$i][2] $knotenfeld[$i][1] ";

						print NGG "$p[$knotenfeld[$i][0]][0] $p[$knotenfeld[$i][0]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][3]][0] $p[$knotenfeld[$i][3]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][3]][0] $p[$knotenfeld[$i][3]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][2]][0] $p[$knotenfeld[$i][2]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][2]][0] $p[$knotenfeld[$i][2]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][1]][0] $p[$knotenfeld[$i][1]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][1]][0] $p[$knotenfeld[$i][1]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][0]][0] $p[$knotenfeld[$i][0]][1]\n\n\n"; 

						print NG "S $knotenfeld[$i][0] $knotenfeld[$i][3] S $knotenfeld[$i][2] $knotenfeld[$i][1] S $knotenfeld[$i][1] $knotenfeld[$i][0]; \n";		
					}
				}
				else # 0 > 1
				{
					if($p[$knotenfeld[$i][3]][1] > $p[$knotenfeld[$i][2]][1])
					{
						print NG "E $i $knotenfeld[$i][1] $knotenfeld[$i][2] $knotenfeld[$i][3] $knotenfeld[$i][0] ";

						print NGG "$p[$knotenfeld[$i][1]][0] $p[$knotenfeld[$i][1]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][2]][0] $p[$knotenfeld[$i][2]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][2]][0] $p[$knotenfeld[$i][2]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][3]][0] $p[$knotenfeld[$i][3]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][3]][0] $p[$knotenfeld[$i][3]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][0]][0] $p[$knotenfeld[$i][0]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][0]][0] $p[$knotenfeld[$i][0]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][1]][0] $p[$knotenfeld[$i][1]][1]\n\n\n"; 

						print NG "S $knotenfeld[$i][1] $knotenfeld[$i][2] S $knotenfeld[$i][3] $knotenfeld[$i][0] S $knotenfeld[$i][0] $knotenfeld[$i][1]; \n";		
					}
				    else # 2 > 3
					{
						print NG "E $i $knotenfeld[$i][1] $knotenfeld[$i][3] $knotenfeld[$i][2] $knotenfeld[$i][0] ";

						print NGG "$p[$knotenfeld[$i][1]][0] $p[$knotenfeld[$i][1]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][3]][0] $p[$knotenfeld[$i][3]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][3]][0] $p[$knotenfeld[$i][3]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][2]][0] $p[$knotenfeld[$i][2]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][2]][0] $p[$knotenfeld[$i][2]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][0]][0] $p[$knotenfeld[$i][0]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][0]][0] $p[$knotenfeld[$i][0]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][1]][0] $p[$knotenfeld[$i][1]][1]\n\n\n"; 

						print NG "S $knotenfeld[$i][1] $knotenfeld[$i][3] S $knotenfeld[$i][2] $knotenfeld[$i][0] S $knotenfeld[$i][0] $knotenfeld[$i][1]; \n";		
					}
				}
			}			
	
		}


		#normales Ende -> einziges Element muss nicht mehr beruecksiichtigt werden
		if($knfindex[$i] > 4){
		if ($p[$knotenfeld[$i][$knfindex[$i]-2]][0] == $p[$knotenfeld[$i][$knfindex[$i]-1]][0])
		{
			$ende = "normal";
				if($p[$knotenfeld[$i][$knfindex[$i]-3]][1] > $p[$knotenfeld[$i][$knfindex[$i]-4]][1])
				{
					if($p[$knotenfeld[$i][$knfindex[$i]-1]][1] > $p[$knotenfeld[$i][$knfindex[$i]-2]][1])
					{
						print NG "E $i $knotenfeld[$i][$knfindex[$i]-4] $knotenfeld[$i][$knfindex[$i]-2] $knotenfeld[$i][$knfindex[$i]-1] $knotenfeld[$i][$knfindex[$i]-3] ";

						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-4]][0] $p[$knotenfeld[$i][$knfindex[$i]-4]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-2]][0] $p[$knotenfeld[$i][$knfindex[$i]-2]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-2]][0] $p[$knotenfeld[$i][$knfindex[$i]-2]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-1]][0] $p[$knotenfeld[$i][$knfindex[$i]-1]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-1]][0] $p[$knotenfeld[$i][$knfindex[$i]-1]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-3]][0] $p[$knotenfeld[$i][$knfindex[$i]-3]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-3]][0] $p[$knotenfeld[$i][$knfindex[$i]-3]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-4]][0] $p[$knotenfeld[$i][$knfindex[$i]-4]][1]\n\n\n"; 
    
						print NG "S $knotenfeld[$i][$knfindex[$i]-4] $knotenfeld[$i][$knfindex[$i]-2] S $knotenfeld[$i][$knfindex[$i]-1] $knotenfeld[$i][$knfindex[$i]-3] S $knotenfeld[$i][$knfindex[$i]-2] $knotenfeld[$i][$knfindex[$i]-1]; \n";						
					}
				    else # 2 > 3
					{
						print NG "E $i $knotenfeld[$i][$knfindex[$i]-4] $knotenfeld[$i][$knfindex[$i]-1] $knotenfeld[$i][$knfindex[$i]-2] $knotenfeld[$i][$knfindex[$i]-3] ";

						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-4]][0] $p[$knotenfeld[$i][$knfindex[$i]-4]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-1]][0] $p[$knotenfeld[$i][$knfindex[$i]-1]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-1]][0] $p[$knotenfeld[$i][$knfindex[$i]-1]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-2]][0] $p[$knotenfeld[$i][$knfindex[$i]-2]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-2]][0] $p[$knotenfeld[$i][$knfindex[$i]-2]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-3]][0] $p[$knotenfeld[$i][$knfindex[$i]-3]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-3]][0] $p[$knotenfeld[$i][$knfindex[$i]-3]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-4]][0] $p[$knotenfeld[$i][$knfindex[$i]-4]][1]\n\n\n"; 

						print NG "S $knotenfeld[$i][$knfindex[$i]-4] $knotenfeld[$i][$knfindex[$i]-1] S $knotenfeld[$i][$knfindex[$i]-2] $knotenfeld[$i][$knfindex[$i]-3] S $knotenfeld[$i][$knfindex[$i]-1] $knotenfeld[$i][$knfindex[$i]-2]; \n";		
					}
				}
				else # 0 > 1
				{
					if($p[$knotenfeld[$i][$knfindex[$i]-1]][1] > $p[$knotenfeld[$i][$knfindex[$i]-2]][1])
					{
						print NG "E $i $knotenfeld[$i][$knfindex[$i]-3] $knotenfeld[$i][$knfindex[$i]-2] $knotenfeld[$i][$knfindex[$i]-1] $knotenfeld[$i][$knfindex[$i]-4] ";

						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-3]][0] $p[$knotenfeld[$i][$knfindex[$i]-3]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-2]][0] $p[$knotenfeld[$i][$knfindex[$i]-2]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-2]][0] $p[$knotenfeld[$i][$knfindex[$i]-2]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-1]][0] $p[$knotenfeld[$i][$knfindex[$i]-1]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-1]][0] $p[$knotenfeld[$i][$knfindex[$i]-1]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-4]][0] $p[$knotenfeld[$i][$knfindex[$i]-4]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-4]][0] $p[$knotenfeld[$i][$knfindex[$i]-4]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-3]][0] $p[$knotenfeld[$i][$knfindex[$i]-3]][1]\n\n\n"; 

						print NG "S $knotenfeld[$i][$knfindex[$i]-3] $knotenfeld[$i][$knfindex[$i]-2] S $knotenfeld[$i][$knfindex[$i]-1] $knotenfeld[$i][$knfindex[$i]-4] S $knotenfeld[$i][$knfindex[$i]-2] $knotenfeld[$i][$knfindex[$i]-1]; \n";		
					}
				    else # 2 > 3
					{
						print NG "E $i $knotenfeld[$i][$knfindex[$i]-3] $knotenfeld[$i][$knfindex[$i]-1] $knotenfeld[$i][$knfindex[$i]-2] $knotenfeld[$i][$knfindex[$i]-4] ";

						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-3]][0] $p[$knotenfeld[$i][$knfindex[$i]-3]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-1]][0] $p[$knotenfeld[$i][$knfindex[$i]-1]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-1]][0] $p[$knotenfeld[$i][$knfindex[$i]-1]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-2]][0] $p[$knotenfeld[$i][$knfindex[$i]-2]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-2]][0] $p[$knotenfeld[$i][$knfindex[$i]-2]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-4]][0] $p[$knotenfeld[$i][$knfindex[$i]-4]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-4]][0] $p[$knotenfeld[$i][$knfindex[$i]-4]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$knfindex[$i]-3]][0] $p[$knotenfeld[$i][$knfindex[$i]-3]][1]\n\n\n"; 

						print NG "S $knotenfeld[$i][$knfindex[$i]-3] $knotenfeld[$i][$knfindex[$i]-1] S $knotenfeld[$i][$knfindex[$i]-2] $knotenfeld[$i][$knfindex[$i]-4] S $knotenfeld[$i][$knfindex[$i]-1] $knotenfeld[$i][$knfindex[$i]-2]; \n";		
					}
				}
		}}



            # wenn kein Einzelelementfall vorliegt
			if(($beg == -1)&&($end == -1))
			{
				if( ( $beginn eq "spitz" ) && ( $ende eq "spitz" ) ){ 
					if ($knfindex[$i] >= 6) { $beg = 5; $end = $knfindex[$i] + 1; } }
				if( ( $beginn eq "spitz" ) && ( $ende eq "normal" ) ){ 
					if ($knfindex[$i] >= 7) { $beg = 5; $end = $knfindex[$i]; } }
				if( ( $beginn eq "normal" ) && ( $ende eq "spitz" ) ){ 
					if ($knfindex[$i] >= 7) { $beg = 6; $end = $knfindex[$i] + 1; } }
				if( ( $beginn eq "normal" ) && ( $ende eq "normal" ) ){ 
					if ($knfindex[$i] >= 8) { $beg = 6; $end = $knfindex[$i]; } }
				print NGD "\n \n Sbd $i ist $beginn $ende \n \n";
			}
			# laufe uber die oben gesetzten Indizes und baue die fehlenden Vierecke
		for($li = $beg; $li < $end; $li +=2)
		{
				if($p[$knotenfeld[$i][$li-3]][1] > $p[$knotenfeld[$i][$li-4]][1])
				{
					if($p[$knotenfeld[$i][$li-1]][1] > $p[$knotenfeld[$i][$li-2]][1])
					{
						print NG "E $i $knotenfeld[$i][$li-4] $knotenfeld[$i][$li-2] $knotenfeld[$i][$li-1] $knotenfeld[$i][$li-3] ";

						print NGG "$p[$knotenfeld[$i][$li-4]][0] $p[$knotenfeld[$i][$li-4]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$li-2]][0] $p[$knotenfeld[$i][$li-2]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][$li-2]][0] $p[$knotenfeld[$i][$li-2]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$li-1]][0] $p[$knotenfeld[$i][$li-1]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][$li-1]][0] $p[$knotenfeld[$i][$li-1]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$li-3]][0] $p[$knotenfeld[$i][$li-3]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][$li-3]][0] $p[$knotenfeld[$i][$li-3]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$li-4]][0] $p[$knotenfeld[$i][$li-4]][1]\n\n\n"; 

						print NG "S $knotenfeld[$i][$li-4] $knotenfeld[$i][$li-2] S $knotenfeld[$i][$li-1] $knotenfeld[$i][$li-3]; \n";						
					}
				    else # 2 > 3
					{
						print NG "E $i $knotenfeld[$i][$li-4] $knotenfeld[$i][$li-1] $knotenfeld[$i][$li-2] $knotenfeld[$i][$li-3] ";

						print NGG "$p[$knotenfeld[$i][$li-4]][0] $p[$knotenfeld[$i][$li-4]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$li-1]][0] $p[$knotenfeld[$i][$li-1]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][$li-1]][0] $p[$knotenfeld[$i][$li-1]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$li-2]][0] $p[$knotenfeld[$i][$li-2]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][$li-2]][0] $p[$knotenfeld[$i][$li-2]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$li-3]][0] $p[$knotenfeld[$i][$li-3]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][$li-3]][0] $p[$knotenfeld[$i][$li-3]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$li-4]][0] $p[$knotenfeld[$i][$li-4]][1]\n\n\n"; 

						print NG "S $knotenfeld[$i][$li-4] $knotenfeld[$i][$li-1] S $knotenfeld[$i][$li-2] $knotenfeld[$i][$li-3]; \n";		
					}
				}
				else # 0 > 1
				{
					if($p[$knotenfeld[$i][$li-1]][1] > $p[$knotenfeld[$i][$li-2]][1])
					{
						print NG "E $i $knotenfeld[$i][$li-3] $knotenfeld[$i][$li-2] $knotenfeld[$i][$li-1] $knotenfeld[$i][$li-4] ";

						print NGG "$p[$knotenfeld[$i][$li-3]][0] $p[$knotenfeld[$i][$li-3]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$li-2]][0] $p[$knotenfeld[$i][$li-2]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][$li-2]][0] $p[$knotenfeld[$i][$li-2]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$li-1]][0] $p[$knotenfeld[$i][$li-1]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][$li-1]][0] $p[$knotenfeld[$i][$li-1]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$li-4]][0] $p[$knotenfeld[$i][$li-4]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][$li-4]][0] $p[$knotenfeld[$i][$li-4]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$li-3]][0] $p[$knotenfeld[$i][$li-3]][1]\n\n\n"; 

						print NG "S $knotenfeld[$i][$li-3] $knotenfeld[$i][$li-2] S $knotenfeld[$i][$li-1] $knotenfeld[$i][$li-4]; \n";		
					}
				    else # 2 > 3
					{
						print NG "E $i $knotenfeld[$i][$li-3] $knotenfeld[$i][$li-1] $knotenfeld[$i][$li-2] $knotenfeld[$i][$li-4] ";

						print NGG "$p[$knotenfeld[$i][$li-3]][0] $p[$knotenfeld[$i][$li-3]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$li-1]][0] $p[$knotenfeld[$i][$li-1]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][$li-1]][0] $p[$knotenfeld[$i][$li-1]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$li-2]][0] $p[$knotenfeld[$i][$li-2]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][$li-2]][0] $p[$knotenfeld[$i][$li-2]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$li-4]][0] $p[$knotenfeld[$i][$li-4]][1]\n\n"; 
						print NGG "$p[$knotenfeld[$i][$li-4]][0] $p[$knotenfeld[$i][$li-4]][1]\n"; 
						print NGG "$p[$knotenfeld[$i][$li-3]][0] $p[$knotenfeld[$i][$li-3]][1]\n\n\n"; 

						print NG "S $knotenfeld[$i][$li-3] $knotenfeld[$i][$li-1] S $knotenfeld[$i][$li-2] $knotenfeld[$i][$li-4]; \n";		
					}
				} # else 0 > 1
			} # for li
	} # for Subdomains
	for ($i=0; $i<=$sd_max; $i++) # laufe ueber alle Subdomains
{
	print NGD "Sbd $i: hat $knfindex[$i] Knoten und das sind die KnotenISs \n";
	for ($ii = 0; $ii < $knfindex[$i]; $ii++)
	{ print NGD "$knotenfeld[$i][$ii] \n";}

}




	close(NG);
	close(NGD);
	close(NGG);


