Home Search Reference Manuals Return
Inledning
Allmänt om inläsningen och användarhandledningen
Felutskrifter
Läsning av indata från separat ascii-fil
Definiering och inläsning av substrukturer
Beskrivning av beräkningsmetod
Indatabeskrivning
Kommandon som beskrivs CALC-användarhandledningen
Kommandon som gäller speciellt PREDAT
Command line options
Exempel
PREdat är ett program för att enkelt kunna skapa en indata till beräkningsprogrammet CALC i GENSYS. Indata till PREdat är uppbyggt i tre delar:
Inläsningen sker i frifältsinmatning. Indatatolkaren läser ett ord
i taget från indatafilen, ny rad tecken har ingen betydelse för
inläsningen. För vissa kommandon där inte antalet indata på förväg är
känt, avbryts kommandoinläsningen genom att ett nytt huvudkommando
inläses.
Som avgränsare mellan olika kommandon och indata fungerar tecknen
mellanslag, likhetstecken och komma.
Vid angivande av huvudkommandon går det bra med stora eller små
bokstäver, men vid signalnamn eller under funktioner så skiljer programmet
på små och stora bokstäver.
Indataläsningen till programmet är uppbyggt på följande sätt:
`coupl` = `c_type`, input(*)
`c_type` = `p_lin` => input(*) = `p_name' value0 `value
En koppling definieras med huvudkommandot `coupl`, typen för kopplingar
betecknas `c_type` och kan bl.a. sättas till `p_lin` vilket betyder en
koppling med linjär karakteristik. När `c_type` är vald till `p_lin` då
är också övriga indata bestämda vad de skall betyda. Indata till `p_lin`
består av tre komponenter `p_name', value0 och `value.
För att skilja på vad som är i programmet bestämda nyckelord, signaler
eller konstanter, är de olika orden i användarhandledningen markerade
med olika typer av accenter och förtecken, tecknan har följande
betydelser:
Indatafilen avslutas med tecknen EOF för att markera att filen är till ända. Anledningen till att det är gjort så är att huvudprogrammet skall kunna avgöra att expandering av indatafilen och substrukturer har fungerat som det ska.
PREdat skiljer på fatala fel där exekvering inte kan fortsätta, och icke fatala fel där endast warningsutskrift erhålles. Ett fatalt fel har följande principiella utseende:
***ERROR*** In In_mass:
max no. of masses= 400
mass type = m_rigid_6
mass name = car_1
cannot be created, skip the rest of datagroup
Efter ***ERROR*** texten anges vilken subrutin som har genererat
utskriften. På andra raden anges vad felet är, och på tredje och
fjärde raden anges vilken komponenttyp och komponentnamn som är under
bearbetning när felet uppstod. Med sista raden menas att programmet
slaskläser det antal poster som finns kvar att läsa till indatagruppen.
Efter denna utskrift kommer programmet att stoppas och körscriptet att
avbrytas.
Ett icke fatalt fel har följande principiella utseende:
* warning * In Error: from routine=In_coupl
variablename kxkb_1h is already defined
coupling type = k_lin
coupling name = kxkb_1h
cannot be created, skip the rest of datagroup
Efter * warning * texten anges vilken subrutin som har genererat utskriften, och i detta fall har utskriften skett i rutinen Error på uppdrag av rutinen In_coupl. På andra raden anges felorsaken, och på tredje och fjärde raden anges vilken komponenttyp och komponentnamn som var under bearbetning när felet uppstod. Med sista raden menas att programmet slaskläser det antal poster som finns kvar att läsa till indatagruppen, så att nästa indatagrupp kan läsas.
Med hjälp av kommando `insert` kan ascii-filer expanderas in till indatafilen. V.v. se användarhandledningen för program CALC för ytterligare information.
För att göra indata mera lätthanterligt är det möjligt att definiera substrukturer över indatagrupper som förekommer på flera ställen. En substruktur definieras med kommandot:
substruct struct_name [
_ _ _ _ _
_ _ _ _ _
indata kommandon
_ _ _ _ _
_ _ _ _ _
]
Varje substruktur tilldelas ett namn "struct_name" och inom klamrar
[ ] defineras vad substrukturen skall innehålla. Denna struktur
lagras nu undan på en egen temporär fil för att bli uppkallad av
direktivet in_substruct. Denna substruktur har vissa likheter med
ett UNIX-script det innehåller kommandoradsargument $1, $2, osv upp
till $9. När sedan kommandot in_substruct ges måste dessa argument
ersättas med en teckensträng eller ett tal. Rutinen som sätter in
argumenten i substrukturen är en ren texteditor, om ett tal anges
som argument vid anrop av en substruktur så behandlas det ändock
som en textsträng som ersätter tecknet $1 i substrukturen.
Inläsning av en definierad substruktur till indatafilen görs med
kommandot:
in_substruct struct_name [ arg1 arg2 osv ]
definiering av argumenten till substrukturen görs inom klammerparenteser.
Indatamodellen byggs upp på följande sätt, först beskrivs geometrin för programmet med kommandona `lsys`, `mass` och `coupl` sedan kan styvheter och dämpningar beräknas med kommandona `coupl pre_efreq`, `coupl pre_edamp`, `coupl pre_twist` och `coupl pre_sway'. Dessa kommandon skapar kopplingsproperties av typ p_lin i minnet. Om flera kommandon ges med samma propertynamn så blir minnet överskrivet för varje kommando och resultatet som kvarsår när alla indata har lästs gäller vid utskrift av utdata.
Program PREDAT förstår alla indatakommandon som program CALC gör v.g. se dokumentationen i CALC-manualen.
| coupl | = | Definierar en kopplingsegenskap eller en koppling. |
| lsys | = | Inläsning av koordinatsystem. |
| mass | = | Inläsning av massa. |
Definierar hur en kopplingsegenskap skall beräknas.
Till huvudkommando `coupl` finns fyra olika typer av
underkommandon, dessa är:
Följande underkommandon är speciella för PREdat och är avsedda för att beräkna kopplingsegenskaper enligt önskad metod:
| pre_copy | = | Kopiera en tidigare definierad egenskap. |
| pre_edamp | = | Beräkna dämpkoefficient m.h.t. önskad relativdämpning. |
| pre_efreq1 | = | Beräkna styvhet m.h.t. önskad egenfrekvens. |
| pre_efreq2 | = | Samma som pre_efreq1 men styvheten beräknas i QUASI. |
| pre_load | = | Beräkna statiska lasten genom en vertikalfjäder. |
| pre_oper | = | Beräkning av egenskap analogt med kommandot `func oper`. |
| pre_twist | = | Styvheten beräknas m.h.t. till hjulomlastningen. |
| pre_twist_u | = | Tidigare beräknad styvhet begränsas uppåt m.h.t. till krav på hjulomlastning. |
| pre_sway | = | Styvheten beräknas ur krängningskoefficienten. |
| pre_sway_l | = | Tidigare beräknad styvhet begränsas nedåt m.h.t. till krav på maximal krängning. |
Kopierar en kopplingsegenskap från en tidigare definierad egenskap.
input(*) = `p_name', `p2_name'
| p_name | = | Namngivning av denna egenskap. |
| p2_name | = | Namngivning av befintlig egenskap. |
| p_name.F0 | = | Kraft vid nollförskjutning. |
| p_name.v1 | = | Kopplingens egenskapsvärde. |
Beräknar en kopplingsegenskap ur önskad relativdämpning.
input(*) = `p_name', `mass', `dire`, set
| p_name | = | Namngivning av denna egenskap. |
| mass | = | Massa vars egenfrekvens skall tilldelas önskad relativdämpning. |
| dire | = | Svängningsriktning för massan. Tillåtna rörelseriktningar är: x, y, z, f, k och p. |
| set | = | Relativdämpningens värde. |
Beräkningen av dämpningsegenskapen tillgår på följande sätt:
c = 2. * set * sqrt(k*m)
Där: c = Infästningsdämpningen.
k = Infästningsstyvheten
m = Massans värde i aktuell riktning dire.
| p_name.v1 | = | Dämparens dämpningskoefficient. |
Beräknar en kopplingsegenskap ur önskad egenfrekvens. C_type=`pre_efreq1` används då omgivande massor kan anses vara stillastående när önskad egenfrekvens exciteras. C_type=`pre_efreq2` används då omgivande massor följer med när önskad egenfrekvens exciteras.
input(*) = `p_name', `mass', `dire`, freq
| p_name | = | Namngivning av denna egenskap. |
| mass | = | Massa vars egenfrekvens skall tilldelas önskad egenfrekvens. |
| dire | = | Svängningsriktning för massan. Tillåtna rörelseriktningar är: x, y, z, f, k och p. |
| freq | = | Önskad egenfrekvens. |
Beräkningen av styvhetsegenskapen tillgår på följande sätt:
k = ( 2.*pi*freq)**2 * m
Där:| k | = | Infästningsstyvheten. |
| m | = | Massans värde i aktuell riktning dire. |
| pi | = | 3.14159 |
| p_name.v1 | = | Kopplingens egenskapsvärde. |
Beräkna statiska lasten genom en vertikalstyvhet.
input(*) = `p_name', `signal'
| p_name | = | Namngivning av denna egenskap. |
| signal | = | Signal vars värde skall hämtas och tilldelas kopplingsegenskapen dess förspänningskraft. Lämpligen väljes denna signal lika med c_name.F1z där c_name bär namnet från kopplingen vars property skall ställas. |
Beräkningen av statiska lasten tillgår på följande sätt:
Programmet uppsöker den kvasistationära jämnvikten i systemet.
Fordonet måste då sjunka så lågt att, fjädrarna tar upp
massornas statiska last. Värdet som erhålls i signalen `signal'
vilket är kraften i fjädern, läses av och dess värde
kopieras till p_name.F0. Därefter görs en förnyad kvasistationär
beräkning så att systemet hittar sin nya kvasistationära position.
| p_name.F0 | = | Kraft vid nollförskjutning. |
Definierar en kopplingsegenskap som beräknas ur konstanter och tidigare definierade signaler.
input(*) = `p_name', -`var1, `oper1`, -`var2, `oper2, ....osv.
| p_name | = | Namngivning av denna egenskap. |
| var1 | = | Namn på insignal eller indata 1. |
| oper1 | = | Operation nummer 1. |
| var2 | = | Namn på insignal eller indata 2. |
| oper2 | = | Operation nummer 2. |
| `+` | = | Addition. |
| `-` | = | Subtraktion. |
| `*` | = | Multiplikation. |
| `/` | = | Division. |
| `(` | = | Vänsterparentes. |
| `)` | = | Högerparentes. |
Observera att mellan varje `var` och `oper` måste ett avskiljningstecken finnas. Ett avskiljningstecken är ett mellanslag eller ett , (komma). Operationerna görs från vänster till höger utan prioritering mellan operationerna. Parenteser är bara tillåtna upp till en nivå.
Lagrade signaler till minnet:| p_name.v1 | = | Kopplingens egenskapsvärde. |
Styvheten beräknas m.h.t. till hjulomlastningen. Axlarnas och spårstyckenas vaggningsvinkel kan ställas individuellt och ett numeriskt värde på hur mycket kontaktkraften mellan hjul och räl får ändras efter vinkelställningen kan anges. Därigenom kan den vertikala styvheten beräknas. Antalet massor(spårstycken) som skall vridas vid en beräkning är godtyckligt, parentesen kring de sista tre argumenten markerar att PREdat läser indatagrupper om tre tills ett nytt huvudkommando ges.
input(*) = `p_name', `Fvar', rel_sig, (mass, dire, angle)
| p_name | = | Namngivning av denna egenskap. |
| Fvar | = | Namn på signal vars värdesförändring skall ställas. |
| rel_sig | = | Anger hur mycket `Fvar' får förändras efter vinkling av spårstyckena. |
| mass | = | Namn på spårstyckena. |
| dire | = | Riktning som spårstyckena skall röra sig i, normalt är riktningen lika med `f`. |
| angle | = | Vinkel som spårstyckena skall vinkla sig, vid beräkning av förändringen `Fvar'. |
Beräkningen av styvheten tillgår på följande sätt:
rel_sig2 = abs ((Fvar(1) - Fvar(2)) / Fvar(1))
Där:| Fvar(1) | = | Första avläsningen. |
| Fvar(2) | = | Andra avläsningen. |
Styvhetsegenskapen beräknas på samma sätt som för kommando
`pre_twist` med den skillnaden att detta kommando ger ett
övre gränsvärde för styvheten. Är den befintliga styvheten
lägre än det beräknade med 'pre_twist' så görs ingen åtgärd.
Men om styvheten är högre så blir den sänkt till den nivå som
anges av värdet i rel_sig.
Om styvheten inte tidigare finns definierad så får
kommandot samma effekt som kommando `pre_twist`.
Indata och beräkningsmetod är lika som för pre_twist
enligt ovan.
Styvheten i p_name beräknas ur krängningsskillnaden mellan korgen och spåret. Spårets vaggningsvinkel kan ställas individuellt för varje axel och ett numeriskt värde på krängningsskillnaden mellan korg och underlag kan anges. Därigenom kan den vertikala styvheten beräknas. Antalet massor(spårstycken) som skall vridas vid en beräkning är godtyckligt, parentesen kring det sista argumenten markerar att PREdat läser kroppar(axlar) tills ett nytt huvudkommando ges.
input(*) = `p_name', `mass1', `dire`, rcoeff, (`mass2')
| p_name | = | Namngivning av denna egenskap. |
| mass1 | = | Namn på kroppen, vars krängningskoefficient skall ställas till önskat värde. Normalt är kroppen lika med fordonets korg. |
| dire | = | Rörelseriktning för vilken signalskillnaden skall beräknas, är normalt lika med `f`. |
| rcoeff | = | Anger hur mycket `mass1' får förändras i riktning `dire`, efter ändring av mass2 ett stycke epsilon i riktningen `dire`. |
| mass2 | = | Namn på kropparna som ändras ett stycke epsilon. Normalt är kropparna lika med spårstyckena under axlarna. |
Beräkningen av styvheten tillgår på följande sätt:
rcoeff2 = (mass1.dire(2) - mass1.dire(1)) / 0.0001
Där:| mass1.dire(1) | = | Första avläsningen. |
| mass1.dire(2) | = | Andra avläsningen. |
Styvhetsegenskapen beräknas på samma sätt som för kommando
`pre_sway` med den skillnaden att detta kommando ger ett
nedre gränsvärde för styvheten. Är den befintliga styvheten
högre än det beräknade med 'pre_sway' så görs ingen åtgärd.
Men om styvheten är lägre så höjs den till den nivå som
anges av värdet i rcoeff.
Om styvheten inte tidigare finns definierad så får
kommandot samma effekt som kommando `pre_sway`.
Indata och beräkningsmetod är lika som för pre_sway
enligt ovan.
För att kunna definiera en massa krävs att det finns ett lsys som massan kan relateras till, och för att kunna definiera ett lsys krävs ett esys som lsys kan relateras till. Se mera detal- jerad beskrivning i användarhandledningen till CALC och teori- rapporten för GENSYS-programmen.
Följande typer koordinatsystem är gemensamma för CALC och PREdat, dessa beskrivs närmare i användarhandledningen för CALC-programmet:
| `e_fix` | = | Skapar ett fixt esys. |
| `e_abs_bend` | = | Skapar ett esys som styrs av en krökningssignal. |
| `l_local` | = | Skapar ett linjärt lokalt lsys. |
Följande koordinatsystem gäller speciellt för PREdat:
`pre_local` = Skapar ett koordinatsystem typ l_local.
Skillnaden mellan pre_local och l_local är att pre_local tillåter att signaler kan användas som argument i indata.
input(*) = `l_name', `esys', -`xk, -`yk, -`zk
| l_name | = | Namn på det skapade koordinatsystemet. |
| esys | = | Namn på det eulersystem, som l_name relateras till. Om ett lsys anges istället för ett esys, så söker pro- grammet det esys som ligger bakom det angivna lsys sytemet, och xk,yk,zk summeras upp från de båda systemen. |
| xk,yk,zk | = | Koordinatsystemets placering relativt esys. |
Definition av massa.
Förutom alla masstyper som beskrivs i CALC-manualen finns även följande masstyper att tillgå i program PREDAT:
| pre_box1 | = | Från lådform skapa en massa typ m_rigid_6. |
| pre_rigid_1 | = | Skapar en massa som endast har frihetsgrader i en riktning. |
| pre_wset1 | = | Från axelform skapa en massa typ m_rigid_6. |
PREdat skapar en massa av typ m_rigid_6 ur indata givna till detta kommando.
input(*) = `m_name', `lsys', mass, rel_a, rel_b, rel_h,
atp, btp, htp, dim_a, dim_b, dim_h
| m_name | = | Namn på den skapade massan. |
| lsys | = | Namn på det lokala koordinatsystemet. |
| mass | = | Kroppens vikt. |
| rel_a | = | Kroppens relativa tröghetsradie i X-led. |
| rel_b | = | Kroppens relativa tröghetsradie i Y-led. |
| rel_h | = | Kroppens relativa tröghetsradie i Z-led. |
| atp | = | Kroppens tyngdpunktskoordinat i X-led relativt lsys. |
| btp | = | Kroppens tyngdpunktskoordinat i Y-led relativt lsys. |
| htp | = | Kroppens tyngdpunktskoordinat i Z-led relativt lsys. |
| dim_a | = | Kroppens huvudmått i X-led. |
| dim_b | = | Kroppens huvudmått i Y-led. |
| dim_h | = | Kroppens huvudmått i Z-led. |
Kommandot genererar en massa typ m_rigid_6 där indata ser ut på följande sätt:
input(*) = `m_name', `lsys' atp, btp, htp, m_diag
Där m_name, lsys, atp, btp, htp direkt kopieras från indata till pre_box1. Och m_diag beräknas på följande sätt:
| m_diag(1) | = | mass |
| m_diag(2) | = | mass |
| m_diag(3) | = | mass |
| m_diag(4) | = | ((rel_b*dim_b)2 + (rel_h*dim_h)2) / 48 |
| m_diag(5) | = | ((rel_h*dim_h)2 + (rel_a*dim_a)2) / 48 |
| m_diag(6) | = | ((rel_a*dim_a)2 + (rel_b*dim_b)2) / 48 |
Kroppar med liknande utseende och form får relativt konstanta värden på rel_a, rel_b och rel_h, dessa tal är avsedda att vara konstanta från fall till fall. Däremot ändras kropparnas dimensioner mellan olika projekt varför dim_a, dim_b och dim_h måste uppdateras.
Skapar en 3-dimensionell massa men 5 av massans rörelseriktningar är låsta.
input(*) = `m_name', `lsys' -`atp, -`btp, -`htp, `mass, `dire`
| m_name | = | Namn på den skapade massan. |
| lsys | = | Namn på det lokala koordinatsystem vilket massan relateras till. |
| atp,btp,htp | = | Massans tyngdpunkt relativt lsys. |
| mass | = | Massans vikt eller tröghetsmoment i riktning dire. |
| dire | = | Koordinatriktning som massan har rörelsefrihetsgrad. |
PREdat skapar en massa av typ `m_rigid_6` ur indata givna till detta kommando.
input(*) = `m_name', `lsys', mass, rel_a, rel_b, rel_h, spv, diam
| m_name | = | Namn på den skapade massan. |
| lsys | = | Namn på det lokala koordinatsystemet. |
| mass | = | Kroppens vikt. |
| rel_a | = | Kroppens relativa tröghetsradie i X-led. |
| rel_b | = | Kroppens relativa tröghetsradie i Y-led. |
| rel_h | = | Kroppens relativa tröghetsradie i Z-led. |
| spv | = | Spårvidd. |
| diam | = | Hjuldiameter. |
Kommandot genererar en massa typ m_rigid_6 där indata ser ut på följande sätt:
input(*) = `m_name', `lsys' atp, btp, htp, m_diag
Där m_name, lsys, atp, btp, htp direkt kopieras från indata till pre_box1. Och m_diag beräknas på följande sätt:
| atp | = | 0. |
| btp | = | 0. |
| htp | = | -diam / 2. |
| m_diag(1) | = | mass |
| m_diag(2) | = | mass |
| m_diag(3) | = | mass |
| m_diag(4) | = | ((rel_b*spv )2 + (rel_h*diam)2) / 48 |
| m_diag(5) | = | ((rel_h*diam)2 + (rel_a*diam)2) / 48 |
| m_diag(6) | = | ((rel_a*diam)2 + (rel_b*spv )2) / 48 |
For program PREDAT a number of command line options are available. The user can put his or hers favorite options in a file named .gen_conf. Program PREDAT searches primarily for the .gen_conf-file in the local working directory. If the file not can be found in the local working directory, program PREDAT searches for the .gen_conf-file in the users home-directory. At last if no .gen_conf-file can be found program PREDAT reads the file $gensys/bin/gen_conf. Following options are understood:
| -addarg | = | Prompt for more arguments before calculation starts |
| -debug | = | Don't remove temporary workfiles after execution |
| -help | = | Print this help information |
| -overwrite | = | Overwrite old results without questions. |
| -qident | = | Ask for an ident before starting the execution |
| -qread_runf | = | Ask if a new input data file shall be opened in an editor before execution. |
| arg(1) | = | Inputdatafile |
| arg(2) | = | Ident |
All of the above options can be given with the prefix no_. If the prefix no_ has been given, the opposite meaning of the option will apply.
Following example: Master.predatf can be used as a master file:
head 1 Create a mass of 2(kg)
head 2 Create a stiffness and a damper giving the system properties
head 3 fo= 0.8 Hz and zeta= 0.2
#
#
idebug = 1
tsim_param= heun_u 1 #Select an integrator with variable step
tstart= 0. tstop= 16. #Select start and stop times.
tout= 0.020 tstep= 0.001 #Select storing step and initial integration step
#
#
# Create coordinate systems
#
# lsys typ namn koordinat
lsys e_fix esys 0. 0. 0.
lsys l_local lsys esys 0. 0. 0.
#
#
# Create the mass
#
# mass m_type m_name lsys c.g. diagonal of mass matrix
mass m_rigid_6 massa lsys 0. 0. 0. 2 2 2 2 2 2
mass fixpoint_6 point lsys 0. 0. 0.
#
constr fix_rigid_1 massa x 0.
constr fix_rigid_1 massa z 0.
constr fix_rigid_1 massa f 0.
constr fix_rigid_1 massa k 0.
constr fix_rigid_1 massa p 0.
#
#
# Create couplings
#
# coupl c_type c_name koppl infästn.punkt styvhet
#
coupl k kyy point 0. 0. 0.
massa 0. 0. 0. kyyp esys y
coupl c cyy point 0. 0. 0.
massa 0. 0. 0. cyyp esys y
#
#
# Create properties
#
coupl pre_efreq1 kyyp massa y .8
coupl pre_edamp cyyp massa y .2
#
eof