ubuntuusers.de

Nacheinander aufgebaute Schleifen mit Dateinamenvariablen

Status: Gelöst | Ubuntu-Version: Ubuntu 16.04 (Xenial Xerus)
Antworten |

WildJaguar

Anmeldungsdatum:
30. Oktober 2018

Beiträge: Zähle...

Hallo allerseits, ich bin hier neu im Forum und hoffe auf weitere Hilfe. Ziel ist die automatisierte Simulation von zwei Vergleichseinstellungen von zwei verschiedenen Materialien. Dazu sind die Dateien "Hub_00a_Kupfer-000000.sim" und "Hub_00a_Stahl-000000.sim" als Startdateien vorhanden.

Angelegt habe ich die Arrays:

#Hubanzahl: 20 [0 1 ... 19]
Hubanzahlarray=(00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19)
#Hubarten: 2 [0 1]
Hubartarray=(a b) 
#Materialien: 2 [0 1]
#Materialarray=(Kupfer Stahl) 
#Zeitschritte: 41 [0 1 2 ... 40]
Zeitschrittarray=(000000 005000 015000 020000 030000 035000 045000 050000 060000 065000 075000 080000 090000 095000 105000 110000 120000 125000 135000 140000 150000 155000 165000 170000 180000 185000 195000 200000 210000 215000 225000 230000 240000 245000 255000 260000
270000 275000 285000 290000 300000)

Aufbauend auf den Startdateien wird eine Simulation gestartet:

/appl/jgen/bin/jgen -s -a Starccm -b prod -v 11.06.010 -j "Hub_${Hubanzahlarray[0]}${Hubartarray[0]}_Kupfer-${Zeitschrittarray[0]}" -m "cpus=128,proj=5ZA1389-00000,time=1000d,mem=9000,buser=vwmrxy0,delfiles=" -o "macgrp=own,macro=,mode=run,userinc="

Die Ausgabe erfolgt als

Hub_${Hubanzahlarray[0]}${Hubartarray[0]}_Kupfer-${Zeitschrittarray[1]

6-stellig mit vorangehenden Nullen.

Anschließend soll geprüft werden, ob die Simulation durchgelaufen ist und ob die Datei

Hub_${Hubanzahlarray[0]}${Hubartarray[0]}_Kupfer-${Zeitschrittarray[1]

vorhanden ist. Was ich bisher gefunden habe ist folgendes:

if [ -s ./Hub_${Hubanzahlarray[0]}${Hubartarray[0]}_Kupfer-${Zeitschrittarray[1]}.sim ]
then
        sleep 100s #vollständiges Herunterladen der Datei
        führe weitere Befehle mit der neuen Datei aus
else
	warte ein paar Minuten und prüfe erneut auf Vorhandensein der Datei
fi 

Problem ist hier das warten, falls Datei noch nicht vorhanden ist innerhalb der Schleife sowie der Fehler für die vorangestellten Nullen bei Hubanzahl und Zeitschritt. Der Ausgabedateiname soll dabei immer gleich lang sein, sodass 10#08 mir nicht weitergeholfen hat.

Nach der Prüfung auf Vorhandensein der Datei, folgen der erste auszuführenden Befehle mit

cp -rp "Hub_${Hubanzahlarray[0]}${Hubartarray[0]}_Kupfer-${Zeitschrittarray[1]}.sim" "Hub_${Hubanzahlarray[0]}${Hubartarray[1]}_Kupfer}.sim" #kopieren der neu erstellten Datei in neuen Namen
/appl/star-cd/admin/ccmver 1106010 starccm+ -powerpre -batch Hub_${Hubanzahlarray[0]}${Hubartarray[1]}_Kupfer.java Hub_${Hubanzahlarray[0]}${Hubartarray[1]}_Kupfer.sim #Makro auf neuen Namen ausführen
/appl/jgen/bin/jgen -s -a Starccm -b prod -v 11.06.010 -j "Hub_${Hubanzahlarray[0]}${Hubartarray[1]}_Kupfer" -m "cpus=128,proj=5ZA1389-00000,time=1000d,mem=9000,buser=vwmrxy0,delfiles=" -o "macgrp=own,macro=,mode=run,userinc=" #Simulation mit neuen Namen starten

Folgendes Schema soll das voranschreiten der Parameter der Arrays visualisieren. Jeder Hub besteht aus der Hubart a und danach der Hubart b. Der Zeitschritt erhöht sich mit jedem Mal.

Hub_${Hubanzahlarray[00]}${Hubartarray[1]}_Kupfer-${Zeitschrittarray[1]}.sim
Hub_${Hubanzahlarray[01]}${Hubartarray[0]}_Kupfer-${Zeitschrittarray[2]}.sim
Hub_${Hubanzahlarray[01]}${Hubartarray[1]}_Kupfer-${Zeitschrittarray[3]}.sim
Hub_${Hubanzahlarray[02]}${Hubartarray[0]}_Kupfer-${Zeitschrittarray[4]}.sim
Hub_${Hubanzahlarray[02]}${Hubartarray[1]}_Kupfer-${Zeitschrittarray[5]}.sim
Hub_${Hubanzahlarray[03]}${Hubartarray[0]}_Kupfer-${Zeitschrittarray[6]}.sim
Hub_${Hubanzahlarray[03]}${Hubartarray[1]}_Kupfer-${Zeitschrittarray[7]}.sim
...

Ein weiteres Problem der Schleifen ist der Zugriff auf die Arrays. In den Schleifen will ich die Arraykastenzahl hochzählen, greife damit aber automatisch auf die Inhalte der Arrays zu, was ein rechnen mit Buchstaben verhindert. Meine Idee für eine Beispielhafte Schleife ist folgende:

for Anzahl in ${Hubanzahlarray[@]}; do
	Anzahl=$(echo "${Hubanzahlarray[$Anzahl]} + 1"|bc) 
	echo "$Anzahl"
done 

Leider habe ich keine Idee wie die verschiedenen Schleifen mit verschiedenen Zählungen zu verbinden sind. Bei den Hubarten ist auch nur ein wechseln, kein Zählen nötig, was vermutlich mit einer if-Bedingung gelöst werden kann. Derzeit "löse" ich das Problem indem ich 80 Aufrufe mit den Befehlen und per Hand geänderten Dateinamen aufrufe. Da noch weitere Simulationen folgen sollen, würde ich das aber lieber verbessern wollen und lernen wie man es richtig machen kann. (Die Simulationsbefehle können durch jeden x-beliebigen Befehl ersetzt werden, die Schleifen sind das interessante.)

Vielen Dank für Eure Mühe schon bis hier her gelesen zu haben. Falls Ihr Vorschläge habt immer her damit! Danke schon mal im Vorfeld. Beste Grüße Freddy

seahawk1986

Anmeldungsdatum:
27. Oktober 2006

Beiträge: 11265

Wohnort: München

Kannst du mal den zugrunde liegenden Algorithmus mal unabhängig von der Implementierung genauer beschreiben?

Wenn ich das richtig verstehe ist jgen ein Programm, das Jobs an einen Server weiterreicht.

Leider steht in dem Flyer nicht dabei, wie es sich sein Prozess dabei verhält - beendet er sich, sobald es die Datei auf den Server hochgeladen hat (wer schreibt dann die Datei ins lokale Dateisystem?) oder forkt es z.B. in den Hintergrund (dann könnte man mit wait darauf warten, dass es fertig ist)?

Zur Erzeugung der Dateinamen könnte man z.B. verschachtelte Schleifen nutzen und statt die Zahlen vorab mit führenden Nullen zu versehen würde ich das erst dann machen, wenn sie gebraucht werden, dann kann man damit auch noch Rechnen, falls das nötig sein sollte:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
format_filename() {
    printf "Hub_%02d%s_%s-%06d.sim" "$hub_nummer" "$hub" "$material" "${zeitschritte[$zeit_index]}"
}

zeitschritte=(
        0   5000  15000  20000  30000  35000  45000  50000  60000
    65000  75000  80000  90000  95000 105000 110000 120000 125000
   135000 140000 150000 155000 165000 170000 180000 185000 195000
   200000 210000 215000 225000 230000 240000 245000 255000 260000
   270000 275000 285000 290000 300000
)

zeit_index=0
for hub_nummer in {0..19}
do
    for hub in "a" "b"
    do
        for material in "Kupfer" "Stahl"
        do
            Datei=$(format_filename)
            echo "$Datei"
        done
    done
    (( zeit_index++ ))
done

Das liefert dann

Hub_00a_Kupfer-000000.sim
Hub_00a_Stahl-000000.sim
Hub_00b_Kupfer-000000.sim
Hub_00b_Stahl-000000.sim
Hub_01a_Kupfer-005000.sim
Hub_01a_Stahl-005000.sim
Hub_01b_Kupfer-005000.sim
Hub_01b_Stahl-005000.sim
Hub_02a_Kupfer-015000.sim
Hub_02a_Stahl-015000.sim
Hub_02b_Kupfer-015000.sim
Hub_02b_Stahl-015000.sim
Hub_03a_Kupfer-020000.sim
Hub_03a_Stahl-020000.sim
Hub_03b_Kupfer-020000.sim
Hub_03b_Stahl-020000.sim
Hub_04a_Kupfer-030000.sim
Hub_04a_Stahl-030000.sim
Hub_04b_Kupfer-030000.sim
Hub_04b_Stahl-030000.sim
Hub_05a_Kupfer-035000.sim
Hub_05a_Stahl-035000.sim
Hub_05b_Kupfer-035000.sim
Hub_05b_Stahl-035000.sim
Hub_06a_Kupfer-045000.sim
Hub_06a_Stahl-045000.sim
Hub_06b_Kupfer-045000.sim
Hub_06b_Stahl-045000.sim
Hub_07a_Kupfer-050000.sim
Hub_07a_Stahl-050000.sim
Hub_07b_Kupfer-050000.sim
Hub_07b_Stahl-050000.sim
Hub_08a_Kupfer-060000.sim
Hub_08a_Stahl-060000.sim
Hub_08b_Kupfer-060000.sim
Hub_08b_Stahl-060000.sim
Hub_09a_Kupfer-065000.sim
Hub_09a_Stahl-065000.sim
Hub_09b_Kupfer-065000.sim
Hub_09b_Stahl-065000.sim
Hub_10a_Kupfer-075000.sim
Hub_10a_Stahl-075000.sim
Hub_10b_Kupfer-075000.sim
Hub_10b_Stahl-075000.sim
Hub_11a_Kupfer-080000.sim
Hub_11a_Stahl-080000.sim
Hub_11b_Kupfer-080000.sim
Hub_11b_Stahl-080000.sim
Hub_12a_Kupfer-090000.sim
Hub_12a_Stahl-090000.sim
Hub_12b_Kupfer-090000.sim
Hub_12b_Stahl-090000.sim
Hub_13a_Kupfer-095000.sim
Hub_13a_Stahl-095000.sim
Hub_13b_Kupfer-095000.sim
Hub_13b_Stahl-095000.sim
Hub_14a_Kupfer-105000.sim
Hub_14a_Stahl-105000.sim
Hub_14b_Kupfer-105000.sim
Hub_14b_Stahl-105000.sim
Hub_15a_Kupfer-110000.sim
Hub_15a_Stahl-110000.sim
Hub_15b_Kupfer-110000.sim
Hub_15b_Stahl-110000.sim
Hub_16a_Kupfer-120000.sim
Hub_16a_Stahl-120000.sim
Hub_16b_Kupfer-120000.sim
Hub_16b_Stahl-120000.sim
Hub_17a_Kupfer-125000.sim
Hub_17a_Stahl-125000.sim
Hub_17b_Kupfer-125000.sim
Hub_17b_Stahl-125000.sim
Hub_18a_Kupfer-135000.sim
Hub_18a_Stahl-135000.sim
Hub_18b_Kupfer-135000.sim
Hub_18b_Stahl-135000.sim
Hub_19a_Kupfer-140000.sim
Hub_19a_Stahl-140000.sim
Hub_19b_Kupfer-140000.sim
Hub_19b_Stahl-140000.sim

WildJaguar

(Themenstarter)

Anmeldungsdatum:
30. Oktober 2018

Beiträge: 7

Hallo seahawk1986, vielen Dank für deine Antwort! Genau jgen ist das Programm zum Weiterleiten der Simulation zum Rechnen auf einem Server. Es ist beendet, sobald der Befehl abgesetzt ist, unabhängig von dem Stand der aktuellen Simulation. Wer die Datei zurück ins lokale Dateisystem schreibt ist mir leider auch nicht bekannt. Vermutlich schreibt ein serverseitiges Programm die Dateien zurück. Da man über jgen auch sehr viele Simulationen starten kann ist das wait hier schwierig, da ja dann erst alle Simulationen fertig sein müssten. Also hätte ich daran gedacht wiederkehrend nach sich ändernden Dateinamen zu suchen und dann wieder die Befehle für die neue Datei ausführen lassen.

Wow dein Programm löst so viele Probleme auf einmal super! Also zunächst zu den vorangestellten Nullen hast du absolut Recht, ich wusste nicht, dass man es auch so lösen kann. Die erzeugten Dateinamen sind nahezu perfekt. Einzig und allein die Zeitschritte müssen sich bei jedem Hubartwechsel wechseln, und nicht für jeden Hub. 00b baut auf der Lösung von 00a auf, 01a baut auf 00b auf, 01b baut auf 01a auf... Also muss der zeit_index ++ vermutlich nur in die Schleife darüber gesetzt werden?

Ist format_filename() eine Funktion die aufgerufen werden kann? Bedeuten die Prozentzeichen in printf den Anfang einer Variablen? Bisher hatte ich meine Versuche in .sh Skripte gepackt und per Terminal aufgerufen. Ist das mit der Funktion auch so möglich?

Vielen Dank auf jeden Fall! Das Bild wird klarer.

seahawk1986

Anmeldungsdatum:
27. Oktober 2006

Beiträge: 11265

Wohnort: München

WildJaguar schrieb:

Wer die Datei zurück ins lokale Dateisystem schreibt ist mir leider auch nicht bekannt. Vermutlich schreibt ein serverseitiges Programm die Dateien zurück.

Aber über welchen Mechanismus? Hast du mal versucht unmittelbar im Anschluss an den jgen-Befehl den Befehl jobs (vgl. Bash Job Control Commands) ausführen zu lassen?

Woran würde man denn erkennen, ob ein Job fehlgeschlagen ist? Sonst könnte man ja eigentlich nur endlos (oder für eine bestimmte Zeitspanne) auf die Datei warten - da gibt es mit inotify eine bequeme Möglichkeit, wenn man sich vom Kernel über eine neu angelegte bzw. fertig geschriebene und wieder geschlossene Datei informieren lassen möchte.

Da man über jgen auch sehr viele Simulationen starten kann ist das wait hier schwierig, da ja dann erst alle Simulationen fertig sein müssten. Also hätte ich daran gedacht wiederkehrend nach sich ändernden Dateinamen zu suchen und dann wieder die Befehle für die neue Datei ausführen lassen.

Das wait würde ja nur auf alle oder bestimmte von der aktuellen Shell gestarteten Prozesse warten. Wenn die einzelnen Simulationen aufeinander aufbauen, muss man sowieso auf das Ergebnis warten.

Wow dein Programm löst so viele Probleme auf einmal super! Also zunächst zu den vorangestellten Nullen hast du absolut Recht, ich wusste nicht, dass man es auch so lösen kann. Die erzeugten Dateinamen sind nahezu perfekt. Einzig und allein die Zeitschritte müssen sich bei jedem Hubartwechsel wechseln, und nicht für jeden Hub. 00b baut auf der Lösung von 00a auf, 01a baut auf 00b auf, 01b baut auf 01a auf... Also muss der zeit_index ++ vermutlich nur in die Schleife darüber gesetzt werden?

Ja, in dem Fall kannst du die Zeile 23 und 24 vertauschen.

Ist format_filename() eine Funktion die aufgerufen werden kann?

Ja, die ist in dem Beispielskript ganz am Anfang definiert:

1
2
3
format_filename() {
    printf "Hub_%02d%s_%s-%06d.sim" "$hub_nummer" "$hub" "$material" "${zeitschritte[$zeit_index]}"
}

Bedeuten die Prozentzeichen in printf den Anfang einer Variablen?

Genauer gesagt sind das Formatierungsbefehle für die Variablen, die printf als Argumente übergeben werden. %s ist ein String ohne Längenvorgabe, %02d ist ein Integer, der mit führenden Nullen auf zwei Stellen gebracht wird und %06d ist dann dementsprechend ein Integer, der auf 6 Stellen mit führenden Nullen formatiert wird.

Bisher hatte ich meine Versuche in .sh Skripte gepackt und per Terminal aufgerufen. Ist das mit der Funktion auch so möglich?

Du kannst die Funktion entweder mit ins Skript packen oder aus einer anderen Datei mit source (vergleiche auch https://www.gnu.org/software/bash/manual/html_node/Bourne-Shell-Builtins.html#Bourne-Shell-Builtins) einlesen.

WildJaguar

(Themenstarter)

Anmeldungsdatum:
30. Oktober 2018

Beiträge: 7

nach dem Ausführen von den jgen Befehl "bash $ jobs" probiert--kennt er nicht, "jobs" kennt er auch nicht. Wenn ein Job fehlschlägt merkt man das nicht direkt, sondern die erzeugte Datei ist kleiner und enthält einen Fehlercode. Die Simulation wird nur vorzeitig beendet.

Habe noch rausfinden können, dass der eigentliche Job über ein ssh Skript auf den Server sich einloggt und dort die Dateien hin speichert. Sprich das speichern der neuen Datei vom Server auf das lokale Dateisystem erfolgt serverseitig. Auf den Job kann ich lokal allerdings nicht zugreifen, beim ausführen des Befehls "top" taucht sie auch nicht auf.

Tatsächlich kann man sich nur über schon gelaufene Simulationszeiten ausrechnen wann Dateien fertig sein werden. "inotify" ist leider nicht installiert und ich besitze keine Rechte zur Installation. Wie könnte man denn ohne extra Paket auf eine Datei mit schon bekanntem Dateinamen warten bis es da ist und anschließend die Schleife weiter durchlaufen lassen?

Vielen Dank für die Erklärungen!

seahawk1986

Anmeldungsdatum:
27. Oktober 2006

Beiträge: 11265

Wohnort: München

WildJaguar schrieb:

Wie könnte man denn ohne extra Paket auf eine Datei mit schon bekanntem Dateinamen warten bis es da ist und anschließend die Schleife weiter durchlaufen lassen?

Zum Beispiel mit einer While-Schleife, die abbricht, sobald die erwartete Datei einen Inhalt hat. Danach könnte man z.B. zusätzlich mit lsof warten, bis kein Prozess mehr darauf zugreift, also der Server hoffentlich die Ausgabe des Jobs fertig geschrieben hat (vorausgesetzt die Datei wird in einem Rutsch geschrieben):

1
2
3
4
5
6
expected_file=foo.sim
while [ ! -s "$expected_file" ]
do
    sleep 1
done
lsof +r1 "$expected_file"

Edit: Test korrigiert, da ist mit ein Doppelpunkt reingerutscht

WildJaguar

(Themenstarter)

Anmeldungsdatum:
30. Oktober 2018

Beiträge: 7

Die Datei wird in einem Rutsch geschrieben. Leider erkennt das Betriebssystem auch nicht den Befehl "lsof"

bash: [: missing `]'
bash: lsof: command not found

Auch ohne lsof scheint er noch Probleme mit der while Schleife zu haben:

bash: [: missing `]'

Ohne while-Schleife klappt es sehr gut bis auf eine Kleinigkeit. Dateinamen

format_filename_after() {
    printf "Hub_%02d%s_%s-%06d" "$hub_nummer" "$hub" "$material" "${zeitschritte[$zeit_index]}"
}

format_filename_before() {
    printf "Hub_%02d%s_%s" "$hub_nummer" "$hub" "$material"
}

zeitschritte=(
            5000  15000  20000  30000  35000  45000  50000  60000
    65000  75000  80000  90000  95000 105000 110000 120000 125000
   135000 140000 150000 155000 165000 170000 180000 185000 195000
   200000 210000 215000 225000 230000 240000 245000 255000 260000
   270000 275000 285000 290000 300000
)

Schleife mit Befehlen

zeit_index=0
for hub_nummer in {1..20}
do
    for hub in "a" "b"
    do
        for material in "Kupfer" "Stahl"
        do
	    Begin_Sim=$(format_filename_after).sim
	    Result_Sim=$(format_filename_before).sim
	    	while [ ! -s "$(format_filename_after).sim" ]:
            	do
            	sleep 1
            	done
            	lsof +r1 "$(format_filename_after).sim"
		echo "                                                            "
		echo "COPY: $(format_filename_after).sim $(format_filename_before).sim"
		echo "                                                            "
		echo "MAKRO: $(format_filename_before).java $(format_filename_before).sim"
		echo "                                                            "
		echo "SIM: $(format_filename_before)"
		echo "                                                            "
        done
    (( zeit_index++ ))	
    done
done

Bei den erzeugten Namen stehen damit immer sich immer die gleiche Hubanzahl gegenüber wie bei MAKRO. Allerdings ist die Reihenfolge ja nacheinander. 00a-->00b-->01a-->01b-->02a... Daher muss die Hubzahl auch wechseln. Dementsprechend müsste hier die Funktion format_filename_after eine "Stufe" zurück und alles wär gut.

seahawk1986

Anmeldungsdatum:
27. Oktober 2006

Beiträge: 11265

Wohnort: München

WildJaguar schrieb:

Auch ohne lsof scheint er noch Probleme mit der while Schleife zu haben:

bash: [: missing `]'
 	    	while [ ! -s "$(format_filename_after).sim" ]:

Mir ist da wie im nachträglich geänderten Post erklärt ein Doppelpunkt am Ende der Zeile mit dem while reingerutscht, der da nicht hingehört.

Bei den erzeugten Namen stehen damit immer sich immer die gleiche Hubanzahl gegenüber wie bei MAKRO. Allerdings ist die Reihenfolge ja nacheinander. 00a-->00b-->01a-->01b-->02a... Daher muss die Hubzahl auch wechseln. Dementsprechend müsste hier die Funktion format_filename_after eine "Stufe" zurück und alles wär gut.

Du willst also hub_nummer um eins vermindert für den printf-Befehl nutzen?

1
2
3
4
format_filename_after() {
    local vorherige_hub_nummer=$(( $hub_nummer - 1 ))
    printf "Hub_%02d%s_%s-%06d" "$vorherige_hub_nummer" "$hub" "$material" "${zeitschritte[$zeit_index]}"
}

WildJaguar

(Themenstarter)

Anmeldungsdatum:
30. Oktober 2018

Beiträge: 7

Den Doppelpunkt habe ich bei der roten Farbe leider nicht gesehen und dachte er wäre schon weg. Bei der Hubänderung hatte ich noch einen Denkfehler, es ist unterschiedlich. Je nachdem ändert sich entweder die Hubanzahl und die Hubart: 2b auf 3a oder es ändert sich nur die Hubart: 2a auf 2b.

Zur Veranschaulichung hier die noch nicht ganz korrekte Version und die gewünschte:

#falsch
COPY: Hub_01a_Stahl-005000.sim Hub_01a_Stahl.sim
MAKRO: Hub_01a_Stahl.java Hub_01a_Stahl.sim
SIM: Hub_01a_Stahl

COPY: Hub_01b_Stahl-015000.sim Hub_01b_Stahl.sim
MAKRO: Hub_01b_Stahl.java Hub_01b_Stahl.sim
SIM: Hub_01b_Stahl

COPY: Hub_02a_Stahl-020000.sim Hub_02a_Stahl.sim
MAKRO: Hub_02a_Stahl.java Hub_02a_Stahl.sim
SIM: Hub_02a_Stahl
-------------------------------------------------------
#korrekt
COPY: Hub_01a_Stahl-005000.sim Hub_01b_Stahl.sim
MAKRO: Hub_01b_Stahl.java Hub_01b_Stahl.sim
SIM: Hub_01b_Stahl

COPY: Hub_01b_Stahl-015000.sim Hub_02a_Stahl.sim
MAKRO: Hub_02a_Stahl.java Hub_02a_Stahl.sim
SIM: Hub_02a_Stahl

COPY: Hub_02a_Stahl-020000.sim Hub_02b_Stahl.sim
MAKRO: Hub_02b_Stahl.java Hub_02b_Stahl.sim
SIM: Hub_02b_Stahl

Wie kann man diese Änderung berücksichtigen? Anbei noch die aktuelle Version für ein Material, da sie unabhängig voneinander sind. Zum Start ist noch die erste Simulation angeführt, welche auf keine erzeugte Datei warten kann/muss.

#Stahl
format_filename_after() {
    printf "Hub_%02d%s_Stahl-%06d" "$hub_nummer" "$hub" "${zeitschritte[$zeit_index]}"
}

format_filename_before() {
    printf "Hub_%02d%s_Stahl" "$hub_nummer" "$hub"
}

zeitschritte=(
            5000  15000  20000  30000  35000  45000  50000  60000
    65000  75000  80000  90000  95000 105000 110000 120000 125000
   135000 140000 150000 155000 165000 170000 180000 185000 195000
   200000 210000 215000 225000 230000 240000 245000 255000 260000
   270000 275000 285000 290000 300000
)

#/appl/jgen/bin/jgen -s -a Starccm -b prod -v 11.06.010 -j "Hub_01a_Stahl" -m "cpus=128,proj=5ZA1389-00000,time=1000d,mem=9000,buser=vwmrxy0,delfiles=" -o "macgrp=own,macro=,mode=run,userinc="	    	    

zeit_index=0
for hub_nummer in {1..20}
do
    for hub in "a" "b"
    do
	    Begin_Sim=$(format_filename_after).sim
	    Result_Sim=$(format_filename_before).sim
	    echo "COPY: $(format_filename_after).sim $(format_filename_before).sim"
	    echo "MAKRO: $(format_filename_before).java $(format_filename_before).sim"
	    echo "SIM: $(format_filename_before)"
     (( zeit_index++ ))       
    done
done

seahawk1986

Anmeldungsdatum:
27. Oktober 2006

Beiträge: 11265

Wohnort: München

WildJaguar schrieb:

#korrekt
COPY: Hub_01a_Stahl-005000.sim Hub_01b_Stahl.sim
MAKRO: Hub_01b_Stahl.java Hub_01b_Stahl.sim
SIM: Hub_01b_Stahl

COPY: Hub_01b_Stahl-015000.sim Hub_02a_Stahl.sim
MAKRO: Hub_02a_Stahl.java Hub_02a_Stahl.sim
SIM: Hub_02a_Stahl

COPY: Hub_02a_Stahl-020000.sim Hub_02b_Stahl.sim
MAKRO: Hub_02b_Stahl.java Hub_02b_Stahl.sim
SIM: Hub_02b_Stahl

Wie kann man diese Änderung berücksichtigen?

Man könnte den zuletzt genutzten Simulationsnamen speichern und dann nur etwas tun, wenn der nicht leer ist:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
zeit_index=0
for hub_nummer in {1..20}
do
    for hub in "a" "b"
    do
        begin_sim="$(format_filename_after).sim"
        result_sim="$(format_filename_before).sim"
        [ -n "$last_sim" ] && {
            echo "COPY: $last_sim $result_sim"
            echo "MAKRO: $(format_filename_before).java" "$result_sim"
            echo "SIM: $result_sim"
            echo
        }
        last_sim="$begin_sim"
        (( zeit_index++ ))
    done
done

Das sollte dann sowas liefern:

COPY: Hub_01a_Stahl-005000.sim Hub_01b_Stahl.sim
MAKRO: Hub_01b_Stahl.java Hub_01b_Stahl.sim
SIM: Hub_01b_Stahl.sim

COPY: Hub_01b_Stahl-015000.sim Hub_02a_Stahl.sim
MAKRO: Hub_02a_Stahl.java Hub_02a_Stahl.sim
SIM: Hub_02a_Stahl.sim

COPY: Hub_02a_Stahl-020000.sim Hub_02b_Stahl.sim
MAKRO: Hub_02b_Stahl.java Hub_02b_Stahl.sim
SIM: Hub_02b_Stahl.sim

COPY: Hub_02b_Stahl-030000.sim Hub_03a_Stahl.sim
MAKRO: Hub_03a_Stahl.java Hub_03a_Stahl.sim
SIM: Hub_03a_Stahl.sim

COPY: Hub_03a_Stahl-035000.sim Hub_03b_Stahl.sim
MAKRO: Hub_03b_Stahl.java Hub_03b_Stahl.sim
SIM: Hub_03b_Stahl.sim

COPY: Hub_03b_Stahl-045000.sim Hub_04a_Stahl.sim
MAKRO: Hub_04a_Stahl.java Hub_04a_Stahl.sim
SIM: Hub_04a_Stahl.sim

COPY: Hub_04a_Stahl-050000.sim Hub_04b_Stahl.sim
MAKRO: Hub_04b_Stahl.java Hub_04b_Stahl.sim
SIM: Hub_04b_Stahl.sim

COPY: Hub_04b_Stahl-060000.sim Hub_05a_Stahl.sim
MAKRO: Hub_05a_Stahl.java Hub_05a_Stahl.sim
SIM: Hub_05a_Stahl.sim

COPY: Hub_05a_Stahl-065000.sim Hub_05b_Stahl.sim
MAKRO: Hub_05b_Stahl.java Hub_05b_Stahl.sim
SIM: Hub_05b_Stahl.sim

COPY: Hub_05b_Stahl-075000.sim Hub_06a_Stahl.sim
MAKRO: Hub_06a_Stahl.java Hub_06a_Stahl.sim
SIM: Hub_06a_Stahl.sim

COPY: Hub_06a_Stahl-080000.sim Hub_06b_Stahl.sim
MAKRO: Hub_06b_Stahl.java Hub_06b_Stahl.sim
SIM: Hub_06b_Stahl.sim

COPY: Hub_06b_Stahl-090000.sim Hub_07a_Stahl.sim
MAKRO: Hub_07a_Stahl.java Hub_07a_Stahl.sim
SIM: Hub_07a_Stahl.sim

COPY: Hub_07a_Stahl-095000.sim Hub_07b_Stahl.sim
MAKRO: Hub_07b_Stahl.java Hub_07b_Stahl.sim
SIM: Hub_07b_Stahl.sim

COPY: Hub_07b_Stahl-105000.sim Hub_08a_Stahl.sim
MAKRO: Hub_08a_Stahl.java Hub_08a_Stahl.sim
SIM: Hub_08a_Stahl.sim

COPY: Hub_08a_Stahl-110000.sim Hub_08b_Stahl.sim
MAKRO: Hub_08b_Stahl.java Hub_08b_Stahl.sim
SIM: Hub_08b_Stahl.sim

COPY: Hub_08b_Stahl-120000.sim Hub_09a_Stahl.sim
MAKRO: Hub_09a_Stahl.java Hub_09a_Stahl.sim
SIM: Hub_09a_Stahl.sim

COPY: Hub_09a_Stahl-125000.sim Hub_09b_Stahl.sim
MAKRO: Hub_09b_Stahl.java Hub_09b_Stahl.sim
SIM: Hub_09b_Stahl.sim

COPY: Hub_09b_Stahl-135000.sim Hub_10a_Stahl.sim
MAKRO: Hub_10a_Stahl.java Hub_10a_Stahl.sim
SIM: Hub_10a_Stahl.sim

COPY: Hub_10a_Stahl-140000.sim Hub_10b_Stahl.sim
MAKRO: Hub_10b_Stahl.java Hub_10b_Stahl.sim
SIM: Hub_10b_Stahl.sim

COPY: Hub_10b_Stahl-150000.sim Hub_11a_Stahl.sim
MAKRO: Hub_11a_Stahl.java Hub_11a_Stahl.sim
SIM: Hub_11a_Stahl.sim

COPY: Hub_11a_Stahl-155000.sim Hub_11b_Stahl.sim
MAKRO: Hub_11b_Stahl.java Hub_11b_Stahl.sim
SIM: Hub_11b_Stahl.sim

COPY: Hub_11b_Stahl-165000.sim Hub_12a_Stahl.sim
MAKRO: Hub_12a_Stahl.java Hub_12a_Stahl.sim
SIM: Hub_12a_Stahl.sim

COPY: Hub_12a_Stahl-170000.sim Hub_12b_Stahl.sim
MAKRO: Hub_12b_Stahl.java Hub_12b_Stahl.sim
SIM: Hub_12b_Stahl.sim

COPY: Hub_12b_Stahl-180000.sim Hub_13a_Stahl.sim
MAKRO: Hub_13a_Stahl.java Hub_13a_Stahl.sim
SIM: Hub_13a_Stahl.sim

COPY: Hub_13a_Stahl-185000.sim Hub_13b_Stahl.sim
MAKRO: Hub_13b_Stahl.java Hub_13b_Stahl.sim
SIM: Hub_13b_Stahl.sim

COPY: Hub_13b_Stahl-195000.sim Hub_14a_Stahl.sim
MAKRO: Hub_14a_Stahl.java Hub_14a_Stahl.sim
SIM: Hub_14a_Stahl.sim

COPY: Hub_14a_Stahl-200000.sim Hub_14b_Stahl.sim
MAKRO: Hub_14b_Stahl.java Hub_14b_Stahl.sim
SIM: Hub_14b_Stahl.sim

COPY: Hub_14b_Stahl-210000.sim Hub_15a_Stahl.sim
MAKRO: Hub_15a_Stahl.java Hub_15a_Stahl.sim
SIM: Hub_15a_Stahl.sim

COPY: Hub_15a_Stahl-215000.sim Hub_15b_Stahl.sim
MAKRO: Hub_15b_Stahl.java Hub_15b_Stahl.sim
SIM: Hub_15b_Stahl.sim

COPY: Hub_15b_Stahl-225000.sim Hub_16a_Stahl.sim
MAKRO: Hub_16a_Stahl.java Hub_16a_Stahl.sim
SIM: Hub_16a_Stahl.sim

COPY: Hub_16a_Stahl-230000.sim Hub_16b_Stahl.sim
MAKRO: Hub_16b_Stahl.java Hub_16b_Stahl.sim
SIM: Hub_16b_Stahl.sim

COPY: Hub_16b_Stahl-240000.sim Hub_17a_Stahl.sim
MAKRO: Hub_17a_Stahl.java Hub_17a_Stahl.sim
SIM: Hub_17a_Stahl.sim

COPY: Hub_17a_Stahl-245000.sim Hub_17b_Stahl.sim
MAKRO: Hub_17b_Stahl.java Hub_17b_Stahl.sim
SIM: Hub_17b_Stahl.sim

COPY: Hub_17b_Stahl-255000.sim Hub_18a_Stahl.sim
MAKRO: Hub_18a_Stahl.java Hub_18a_Stahl.sim
SIM: Hub_18a_Stahl.sim

COPY: Hub_18a_Stahl-260000.sim Hub_18b_Stahl.sim
MAKRO: Hub_18b_Stahl.java Hub_18b_Stahl.sim
SIM: Hub_18b_Stahl.sim

COPY: Hub_18b_Stahl-270000.sim Hub_19a_Stahl.sim
MAKRO: Hub_19a_Stahl.java Hub_19a_Stahl.sim
SIM: Hub_19a_Stahl.sim

COPY: Hub_19a_Stahl-275000.sim Hub_19b_Stahl.sim
MAKRO: Hub_19b_Stahl.java Hub_19b_Stahl.sim
SIM: Hub_19b_Stahl.sim

COPY: Hub_19b_Stahl-285000.sim Hub_20a_Stahl.sim
MAKRO: Hub_20a_Stahl.java Hub_20a_Stahl.sim
SIM: Hub_20a_Stahl.sim

COPY: Hub_20a_Stahl-290000.sim Hub_20b_Stahl.sim
MAKRO: Hub_20b_Stahl.java Hub_20b_Stahl.sim
SIM: Hub_20b_Stahl.sim
 

WildJaguar

(Themenstarter)

Anmeldungsdatum:
30. Oktober 2018

Beiträge: 7

Ja genau das was ich suchte! Jetzt fehlt nur noch der Start der ersten Datei ohne dass die Befehle zum Kopieren und Makro ausführen darauf angewendet werden. Vor die Schleife schreiben mit bringt nicht den erwünschten Effekt, da innerhalb der Schleife dann die Ergebnisdatei kopiert und erneut die erste Variante gestartet wird. Habe probiert vor der Schleife eine Datei zu simulieren, deren Ergebniswert in der last Variable steht und diesen dann auf den ersten Ergebnisdateinamen umzubenennen. Durch while startet dann automatisch die Simulation erneut aufbauend auf dieser Datei. Gibt es eine Variante den ersten Schleifendateinamen nur auf einen Befehl anzuwenden? (Simulation)

unset notimestep_sim 
unset timestep_sim 
last="Hub_00b_Stahl-000010"
/appl/jgen/bin/jgen -s -a Starccm -b prod -v 11.06.010 -j "Hub_00b_Stahl" -m "cpus=128,proj=5ZA1389-00000,time=1000d,mem=9000,buser=vwmrxy0,delfiles=" -o "macgrp=own,macro=,mode=run,userinc="  
for hub_nummer in {1..20}
do
    for hub in "a" "b"
    do
	    timestep=$(format_filename_timestep)
	    echo "$timestep"	    
	    notimestep=$(format_filename_notimestep)
	    #echo "Ergebnis aktuelle Variante: $notimestep"	  
	    while [ ! -s "${notimestep}.sim" ]
            do
            sleep 30
	    echo "Warte auf Ergebnisdatei "${notimestep}.sim""
	    mv Hub_00b_Stahl-000010.sim Hub_01a_Stahl-005000.sim
            done 
            [ -n "$last_sim" ] && { 
	    #echo "--------------------------------------------------"    
	    #echo "COPY: ${last}.sim ${timestep}.sim" 	    	    
	    cp -rp ${last}.sim ${timestep}.sim
	    chmod 777 *
	    rm *sim~
	    #echo "MAKRO: ${timestep}.java ${timestep}.sim"	    		        
	    /appl/star-cd/admin/ccmver 1106010 starccm+ -powerpre -batch ${timestep}.java ${timestep}.sim
	    /appl/star-cd/admin/ccmver 1106010 starccm+ -powerpre -batch ${last}_Auswertung.java   ${last}.sim
	    #echo "SIM: $timestep"
	    #echo "--------------------------------------------------"    
            /appl/jgen/bin/jgen -s -a Starccm -b prod -v 11.06.010 -j "$timestep" -m "cpus=128,proj=5ZA1389-00000,time=1000d,mem=9000,buser=vwmrxy0,delfiles=" -o "macgrp=own,macro=,mode=run,userinc="		    
	    }	        	   
	    last="$notimestep"
	    echo "$last"	
	    (( zeit_index++ ))
     done 
done

Also vom Prinzip mit den Echos innerhalb der Schleife muss sich dann ergeben:

SIM: Hub_01a_Stahl

COPY: Hub_01a_Stahl-005000.sim Hub_01b_Stahl.sim
MAKRO: Hub_01b_Stahl.java Hub_01b_Stahl.sim
SIM: Hub_01b_Stahl

COPY: Hub_01b_Stahl-015000.sim Hub_02a_Stahl.sim
MAKRO: Hub_02a_Stahl.java Hub_02a_Stahl.sim
SIM: Hub_02a_Stahl

Entschuldige bitte die Änderung der Variablen, ich hatte selbst nicht mehr durchgesehen. Vielen Dank für deine Energie und Kompetenz!

seahawk1986

Anmeldungsdatum:
27. Oktober 2006

Beiträge: 11265

Wohnort: München

WildJaguar schrieb:

Gibt es eine Variante den ersten Schleifendateinamen nur auf einen Befehl anzuwenden? (Simulation)

Man könnte die Simulation aus der Bedingung heraus lösen - auf die Schnelle mal mit meinem Beispielcode von weiter oben:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
zeit_index=0
for hub_nummer in {1..20}
do
    for hub in "a" "b"
    do
        begin_sim="$(format_filename_after).sim"
        result_sim="$(format_filename_before).sim"
        [ -n "$last_sim" ] && {
            echo "COPY: $last_sim $result_sim"
            echo "MAKRO: $(format_filename_before).java" "$result_sim"
        }
        echo "SIM: $result_sim"
        echo
        last_sim="$begin_sim"
        (( zeit_index++ ))
    done
done

Wobei $last_sim vor dem ersten Durchlauf nicht definiert sein bzw. keinen Inhalt haben darf:

Das liefert dann:

SIM: Hub_01a_Stahl.sim

COPY: Hub_01a_Stahl-005000.sim Hub_01b_Stahl.sim
MAKRO: Hub_01b_Stahl.java Hub_01b_Stahl.sim
SIM: Hub_01b_Stahl.sim

COPY: Hub_01b_Stahl-015000.sim Hub_02a_Stahl.sim
MAKRO: Hub_02a_Stahl.java Hub_02a_Stahl.sim
SIM: Hub_02a_Stahl.sim

COPY: Hub_02a_Stahl-020000.sim Hub_02b_Stahl.sim
MAKRO: Hub_02b_Stahl.java Hub_02b_Stahl.sim
SIM: Hub_02b_Stahl.sim

COPY: Hub_02b_Stahl-030000.sim Hub_03a_Stahl.sim
MAKRO: Hub_03a_Stahl.java Hub_03a_Stahl.sim
SIM: Hub_03a_Stahl.sim

COPY: Hub_03a_Stahl-035000.sim Hub_03b_Stahl.sim
MAKRO: Hub_03b_Stahl.java Hub_03b_Stahl.sim
SIM: Hub_03b_Stahl.sim

COPY: Hub_03b_Stahl-045000.sim Hub_04a_Stahl.sim
MAKRO: Hub_04a_Stahl.java Hub_04a_Stahl.sim
SIM: Hub_04a_Stahl.sim

COPY: Hub_04a_Stahl-050000.sim Hub_04b_Stahl.sim
MAKRO: Hub_04b_Stahl.java Hub_04b_Stahl.sim
SIM: Hub_04b_Stahl.sim

COPY: Hub_04b_Stahl-060000.sim Hub_05a_Stahl.sim
MAKRO: Hub_05a_Stahl.java Hub_05a_Stahl.sim
SIM: Hub_05a_Stahl.sim

COPY: Hub_05a_Stahl-065000.sim Hub_05b_Stahl.sim
MAKRO: Hub_05b_Stahl.java Hub_05b_Stahl.sim
SIM: Hub_05b_Stahl.sim

COPY: Hub_05b_Stahl-075000.sim Hub_06a_Stahl.sim
MAKRO: Hub_06a_Stahl.java Hub_06a_Stahl.sim
SIM: Hub_06a_Stahl.sim

COPY: Hub_06a_Stahl-080000.sim Hub_06b_Stahl.sim
MAKRO: Hub_06b_Stahl.java Hub_06b_Stahl.sim
SIM: Hub_06b_Stahl.sim

COPY: Hub_06b_Stahl-090000.sim Hub_07a_Stahl.sim
MAKRO: Hub_07a_Stahl.java Hub_07a_Stahl.sim
SIM: Hub_07a_Stahl.sim

COPY: Hub_07a_Stahl-095000.sim Hub_07b_Stahl.sim
MAKRO: Hub_07b_Stahl.java Hub_07b_Stahl.sim
SIM: Hub_07b_Stahl.sim

COPY: Hub_07b_Stahl-105000.sim Hub_08a_Stahl.sim
MAKRO: Hub_08a_Stahl.java Hub_08a_Stahl.sim
SIM: Hub_08a_Stahl.sim

COPY: Hub_08a_Stahl-110000.sim Hub_08b_Stahl.sim
MAKRO: Hub_08b_Stahl.java Hub_08b_Stahl.sim
SIM: Hub_08b_Stahl.sim

COPY: Hub_08b_Stahl-120000.sim Hub_09a_Stahl.sim
MAKRO: Hub_09a_Stahl.java Hub_09a_Stahl.sim
SIM: Hub_09a_Stahl.sim

COPY: Hub_09a_Stahl-125000.sim Hub_09b_Stahl.sim
MAKRO: Hub_09b_Stahl.java Hub_09b_Stahl.sim
SIM: Hub_09b_Stahl.sim

COPY: Hub_09b_Stahl-135000.sim Hub_10a_Stahl.sim
MAKRO: Hub_10a_Stahl.java Hub_10a_Stahl.sim
SIM: Hub_10a_Stahl.sim

COPY: Hub_10a_Stahl-140000.sim Hub_10b_Stahl.sim
MAKRO: Hub_10b_Stahl.java Hub_10b_Stahl.sim
SIM: Hub_10b_Stahl.sim

COPY: Hub_10b_Stahl-150000.sim Hub_11a_Stahl.sim
MAKRO: Hub_11a_Stahl.java Hub_11a_Stahl.sim
SIM: Hub_11a_Stahl.sim

COPY: Hub_11a_Stahl-155000.sim Hub_11b_Stahl.sim
MAKRO: Hub_11b_Stahl.java Hub_11b_Stahl.sim
SIM: Hub_11b_Stahl.sim

COPY: Hub_11b_Stahl-165000.sim Hub_12a_Stahl.sim
MAKRO: Hub_12a_Stahl.java Hub_12a_Stahl.sim
SIM: Hub_12a_Stahl.sim

COPY: Hub_12a_Stahl-170000.sim Hub_12b_Stahl.sim
MAKRO: Hub_12b_Stahl.java Hub_12b_Stahl.sim
SIM: Hub_12b_Stahl.sim

COPY: Hub_12b_Stahl-180000.sim Hub_13a_Stahl.sim
MAKRO: Hub_13a_Stahl.java Hub_13a_Stahl.sim
SIM: Hub_13a_Stahl.sim

COPY: Hub_13a_Stahl-185000.sim Hub_13b_Stahl.sim
MAKRO: Hub_13b_Stahl.java Hub_13b_Stahl.sim
SIM: Hub_13b_Stahl.sim

COPY: Hub_13b_Stahl-195000.sim Hub_14a_Stahl.sim
MAKRO: Hub_14a_Stahl.java Hub_14a_Stahl.sim
SIM: Hub_14a_Stahl.sim

COPY: Hub_14a_Stahl-200000.sim Hub_14b_Stahl.sim
MAKRO: Hub_14b_Stahl.java Hub_14b_Stahl.sim
SIM: Hub_14b_Stahl.sim

COPY: Hub_14b_Stahl-210000.sim Hub_15a_Stahl.sim
MAKRO: Hub_15a_Stahl.java Hub_15a_Stahl.sim
SIM: Hub_15a_Stahl.sim

COPY: Hub_15a_Stahl-215000.sim Hub_15b_Stahl.sim
MAKRO: Hub_15b_Stahl.java Hub_15b_Stahl.sim
SIM: Hub_15b_Stahl.sim

COPY: Hub_15b_Stahl-225000.sim Hub_16a_Stahl.sim
MAKRO: Hub_16a_Stahl.java Hub_16a_Stahl.sim
SIM: Hub_16a_Stahl.sim

COPY: Hub_16a_Stahl-230000.sim Hub_16b_Stahl.sim
MAKRO: Hub_16b_Stahl.java Hub_16b_Stahl.sim
SIM: Hub_16b_Stahl.sim

COPY: Hub_16b_Stahl-240000.sim Hub_17a_Stahl.sim
MAKRO: Hub_17a_Stahl.java Hub_17a_Stahl.sim
SIM: Hub_17a_Stahl.sim

COPY: Hub_17a_Stahl-245000.sim Hub_17b_Stahl.sim
MAKRO: Hub_17b_Stahl.java Hub_17b_Stahl.sim
SIM: Hub_17b_Stahl.sim

COPY: Hub_17b_Stahl-255000.sim Hub_18a_Stahl.sim
MAKRO: Hub_18a_Stahl.java Hub_18a_Stahl.sim
SIM: Hub_18a_Stahl.sim

COPY: Hub_18a_Stahl-260000.sim Hub_18b_Stahl.sim
MAKRO: Hub_18b_Stahl.java Hub_18b_Stahl.sim
SIM: Hub_18b_Stahl.sim

COPY: Hub_18b_Stahl-270000.sim Hub_19a_Stahl.sim
MAKRO: Hub_19a_Stahl.java Hub_19a_Stahl.sim
SIM: Hub_19a_Stahl.sim

COPY: Hub_19a_Stahl-275000.sim Hub_19b_Stahl.sim
MAKRO: Hub_19b_Stahl.java Hub_19b_Stahl.sim
SIM: Hub_19b_Stahl.sim

COPY: Hub_19b_Stahl-285000.sim Hub_20a_Stahl.sim
MAKRO: Hub_20a_Stahl.java Hub_20a_Stahl.sim
SIM: Hub_20a_Stahl.sim

COPY: Hub_20a_Stahl-290000.sim Hub_20b_Stahl.sim
MAKRO: Hub_20b_Stahl.java Hub_20b_Stahl.sim
SIM: Hub_20b_Stahl.sim
 

WildJaguar

(Themenstarter)

Anmeldungsdatum:
30. Oktober 2018

Beiträge: 7

Guten Morgen! Vielen Dank für die geniale Hilfe bei der Umsetzung seahawk! Es klappt jetzt alles wie geplant und läuft durch! Vielen Dank für deine Geduld, Kompetenz und schnellen Antworten!

Anbei das fertige Skript für aufeinander aufbauenden Simulationen per bash-Skript mit Veränderungen über Makros.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#Skript zur automatischen Simulation
#Prozess der Abkühlung eines Bleches
#
Starttime=`date --date='now' +%s`
format_filename_notimestep() {
    printf "Hub_%02d%s_Stahl-%06d" "$hub_nummer" "$hub" "${zeitschritte[$zeit_index]}"
}

format_filename_timestep() {
    printf "Hub_%02d%s_Stahl" "$hub_nummer" "$hub"
}

zeitschritte=(
            5000  15000  20000  30000  35000  45000  50000  60000
    65000  75000  80000  90000  95000 105000 110000 120000 125000
   135000 140000 150000 155000 165000 170000 180000 185000 195000
   200000 210000 215000 225000 230000 240000 245000 255000 260000
   270000 275000 285000 290000 300000
)
zeit_index=0
last="Hub_01a_Stahl-000000"
for hub_nummer in {1..20}
do
     for hub in "a" "b"
     do
	    timestep=$(format_filename_timestep)    
	    notimestep=$(format_filename_notimestep)
	 
	        while [ ! -s "${last}.sim" ]
		do
	   echo "warte auf: $last"	
		sleep 1m
		done
            [ -n "$last" ] && {	    
            #echo "COPY: ${last}.sim ${timestep}.sim"
	    cp -rp ${last}.sim ${timestep}.sim
#
            #echo "MAKRO: ${timestep}.java" "${timestep}.sim"
	    /appl/star-cd/admin/ccmver 1106010 starccm+ -powerpre -batch ${timestep}.java ${timestep}.sim  
#
            }
            #echo "SIM: $timestep"
	    /appl/jgen/bin/jgen -s -a Starccm -b prod -v 11.06.010 -j "$timestep" -m "cpus=128,proj=5ZA1389-00000,time=1000d,mem=9000,buser=vwmrxy0,delfiles=" -o "macgrp=own,macro=,mode=run,userinc="		    
#
	    last="$notimestep"
	    (( zeit_index++ ))
     done 
done
Endtime=`date --date='now' +%s`
Stunden=$((($Endtime - $Starttime)/3600))
Minuten=$((($Endtime - $Starttime)/60))
echo "Gesamte Skriptzeit: $Stunden Stunden und $Minuten Minuten"
#Auswertung Zeit für eine Simulation
grep "Run time" *.cpr
#Auswertung CPU Zeit
grep "Maximum Physical Time" -B 2 -H --colour -n *.out

Damit ist die Aufgabe gelöst.

Bearbeitet von rklm:

Syntaxhighlighting. Bitte beachte Forum/Syntax!

Antworten |