Home My Page Projects Code Snippets Project Openings SML/NJ
Summary Activity Forums Tracker Lists Tasks Docs Surveys News SCM Files

SCM Repository

[smlnj] Annotation of /sml/trunk/benchmarks/programs/b-hut/data-io.sml
ViewVC logotype

Annotation of /sml/trunk/benchmarks/programs/b-hut/data-io.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 193 - (view) (download)

1 : monnier 193 (* data-io.sml
2 :     *
3 :     * COPYRIGHT (c) 1993, AT&T Bell Laboratories.
4 :     *
5 :     * I/O routines for export version of hierarchical N-body code.
6 :     *)
7 :    
8 :     signature DATA_IO =
9 :     sig
10 :    
11 :     structure S : SPACE
12 :    
13 :     val inputData : string -> {
14 :     nbody : int,
15 :     bodies : S.body list,
16 :     tnow : real,
17 :     headline : string
18 :     }
19 :    
20 :     (* output routines *)
21 :     val initOutput : {
22 :     outfile : string, headline : string, nbody : int, tnow : real,
23 :     dtime : real, eps : real, tol : real, dtout : real, tstop : real
24 :     } -> unit
25 :     val output : {
26 :     nbody : int, bodies : S.body list, n2bcalc : int, nbccalc : int,
27 :     selfint : int, tnow : real
28 :     } -> unit
29 :     val stopOutput : unit -> unit
30 :    
31 :     end;
32 :    
33 :     functor DataIO (S : SPACE) : DATA_IO =
34 :     struct
35 :    
36 :     structure SS = Substring
37 :     structure S = S
38 :     structure V = S.V
39 :    
40 :     val atoi = valOf o Int.scan StringCvt.DEC SS.getc
41 :    
42 :     (* NOTE: this really out to be implemented using the lazy IO streams,
43 :     * but SML/NJ doesn't implement these correctly yet.
44 :     *)
45 :     fun inputData fname = let
46 :     val strm = TextIO.openIn fname
47 :     val buf = ref(SS.all "")
48 :     fun getLn () = (case (TextIO.inputLine strm)
49 :     of "" => raise Fail "inputData: EOF"
50 :     | s => buf := SS.all s
51 :     (* end case *))
52 :     fun skipWS () = let
53 :     val buf' = SS.dropl Char.isSpace (!buf)
54 :     in
55 :     if (SS.isEmpty buf')
56 :     then (getLn(); skipWS())
57 :     else buf'
58 :     end
59 :     fun readInt () = let
60 :     val (n, ss) = atoi (skipWS ())
61 :     in
62 :     buf := ss; n
63 :     end
64 :     fun readReal () = let
65 :     val (r, ss) = valOf (Real.scan SS.getc (skipWS()))
66 :     in
67 :     buf := ss; r
68 :     end
69 :     val nbody = readInt()
70 :     val _ = if (nbody < 1)
71 :     then raise Fail "absurd nbody"
72 :     else ()
73 :     val ndim = readInt()
74 :     val _ = if (ndim <> V.dim)
75 :     then raise Fail "absurd ndim"
76 :     else ()
77 :     val tnow = readReal()
78 :     fun iter f = let
79 :     fun loop (0, l) = l
80 :     | loop (n, l) = loop (n-1, f() :: l)
81 :     in
82 :     fn n => loop (n, [])
83 :     end
84 :     fun readVec () = V.implode (rev (iter readReal ndim))
85 :     val massList = iter readReal nbody
86 :     val posList = iter readVec nbody
87 :     val velList = iter readVec nbody
88 :     fun mkBodies ([], [], [], l) = l
89 :     | mkBodies (m::r1, p::r2, v::r3, l) = let
90 :     val b = S.Body{
91 :     mass = m,
92 :     pos = ref p,
93 :     vel = ref v,
94 :     acc = ref V.zerov,
95 :     phi = ref 0.0
96 :     }
97 :     in
98 :     mkBodies(r1, r2, r3, b::l)
99 :     end
100 :     in
101 :     TextIO.closeIn strm;
102 :     { nbody = nbody,
103 :     bodies = mkBodies (massList, posList, velList, []),
104 :     tnow = tnow,
105 :     headline = concat["Hack code: input file ", fname, "\n"]
106 :     }
107 :     end
108 :    
109 :     local
110 :     val timer = ref (Timer.startCPUTimer ())
111 :     in
112 :     fun initTimer () = timer := Timer.startCPUTimer()
113 :     fun cputime () = let
114 :     val {usr, sys, gc} = Timer.checkCPUTimer(!timer)
115 :     val totTim = Time.+(usr, gc)
116 :     in
117 :     (Time.toReal totTim) / 60.0
118 :     end
119 :     end
120 :    
121 :     type out_state = {
122 :     tout : real,
123 :     dtout : real,
124 :     dtime : real,
125 :     strm : TextIO.outstream
126 :     }
127 :     val outState = ref (NONE : out_state option)
128 :    
129 :     fun fprintf (strm, items) = TextIO.output(strm, String.concat items)
130 :     fun printf items = fprintf(TextIO.stdOut, items)
131 :     fun pad n s = StringCvt.padLeft #" " n s
132 :     fun fmtInt (wid, i) = pad wid (Int.toString i)
133 :     fun fmtReal (wid, prec, r) = pad wid (Real.fmt (StringCvt.FIX(SOME prec)) r)
134 :     fun fmtRealE (wid, prec, r) = pad wid (Real.fmt (StringCvt.SCI(SOME prec)) r)
135 :     local
136 :     fun itemFmt r = fmtReal (9, 4, r)
137 :     val fmt = V.format{lp="", sep="", rp="", cvt=itemFmt}
138 :     in
139 :     fun printvec (init, vec) = printf [
140 :     "\t ", pad 9 init, fmt vec, "\n"
141 :     ]
142 :     end (* local *)
143 :    
144 :     fun stopOutput () = (case (! outState)
145 :     of NONE => ()
146 :     | (SOME{strm, ...}) => (TextIO.closeOut strm; outState := NONE)
147 :     (* end case *))
148 :    
149 :     fun initOutput {outfile, headline, nbody, tnow, dtime, eps, tol, dtout, tstop} = (
150 :     initTimer();
151 :     printf ["\n\t\t", headline, "\n\n"];
152 :     printf (map (pad 12) ["nbody", "dtime", "eps", "tol", "dtout", "tstop"]);
153 :     printf ["\n"];
154 :     printf [fmtInt(12, nbody), fmtReal(12, 5, dtime)];
155 :     printf [
156 :     fmtInt(12, nbody), fmtReal(12, 5, dtime),
157 :     fmtReal(12, 4, eps), fmtReal(12, 2, tol),
158 :     fmtReal(12, 3, dtout), fmtReal(12, 2, tstop), "\n\n"
159 :     ];
160 :     case outfile
161 :     of "" => stopOutput()
162 :     | _ => outState := SOME{
163 :     dtime = dtime,
164 :     tout = tnow,
165 :     dtout = dtout,
166 :     strm = TextIO.openOut outfile
167 :     }
168 :     (* end case *))
169 :    
170 :     (* compute set of dynamical diagnostics. *)
171 :     fun diagnostics bodies = let
172 :     fun loop ([], arg) = {
173 :     mtot = #totM arg, (* total mass *)
174 :     totKE = #totKE arg, (* total kinetic energy *)
175 :     totPE = #totPE arg, (* total potential energy *)
176 :     cOfMPos = #cOfMPos arg, (* center of mass: position *)
177 :     cOfMVel = #cOfMVel arg, (* center of mass: velocity *)
178 :     amVec = #amVec arg (* angular momentum vector *)
179 :     }
180 :     | loop (S.Body{
181 :     mass, pos=ref pos, vel=ref vel, acc=ref acc, phi=ref phi
182 :     } :: r, arg) = let
183 :     val velsq = V.dotvp(vel, vel)
184 :     val halfMass = 0.5 * mass
185 :     val posXmass = V.mulvs(pos, mass)
186 :     in
187 :     loop ( r, {
188 :     totM = (#totM arg) + mass,
189 :     totKE = (#totKE arg) + halfMass * velsq,
190 :     totPE = (#totPE arg) + halfMass * phi,
191 :     keTen = V.addm(#keTen arg, V.outvp(V.mulvs(vel, halfMass), vel)),
192 :     peTen = V.addm(#peTen arg, V.outvp(posXmass, acc)),
193 :     cOfMPos = V.addv(#cOfMPos arg, posXmass),
194 :     cOfMVel = V.addv(#cOfMVel arg, V.mulvs(vel, mass)),
195 :     amVec = V.addv(#amVec arg, V.mulvs(V.crossvp(pos, vel), mass))
196 :     })
197 :     end
198 :     in
199 :     loop (bodies, {
200 :     totM = 0.0, totKE = 0.0, totPE = 0.0,
201 :     keTen = V.zerom, peTen = V.zerom,
202 :     cOfMPos = V.zerov, cOfMVel = V.zerov,
203 :     amVec = V.zerov
204 :     })
205 :     end (* diagnostics *)
206 :    
207 :     fun outputData (strm, tnow, nbody, bodies) = let
208 :     fun outInt i = fprintf(strm, [" ", Int.toString i, "\n"])
209 :     fun outReal r = fprintf(strm, [" ", fmtRealE(21, 14, r), "\n"])
210 :     fun prReal r = fprintf(strm, [" ", fmtRealE(21, 14, r)])
211 :     fun outVec v = let
212 :     fun out [] = TextIO.output(strm, "\n")
213 :     | out (x::r) = (prReal x; out r)
214 :     in
215 :     out(V.explode v)
216 :     end
217 :     in
218 :     outInt nbody;
219 :     outInt V.dim;
220 :     outReal tnow;
221 :     app (fn (S.Body{mass, ...}) => outReal mass) bodies;
222 :     app (fn (S.Body{pos, ...}) => outVec(!pos)) bodies;
223 :     app (fn (S.Body{vel, ...}) => outVec(!vel)) bodies;
224 :     printf ["\n\tparticle data written\n"]
225 :     end;
226 :    
227 :     fun output {nbody, bodies, n2bcalc, nbccalc, selfint, tnow} = let
228 :     val nttot = n2bcalc + nbccalc
229 :     val nbavg = floor(real n2bcalc / real nbody)
230 :     val ncavg = floor(real nbccalc / real nbody)
231 :     val data = diagnostics bodies
232 :     in
233 :     printf ["\n"];
234 :     printf (map (pad 9) [
235 :     "tnow", "T+U", "T/U", "nttot", "nbavg", "ncavg", "selfint",
236 :     "cputime"
237 :     ]);
238 :     printf ["\n"];
239 :     printf [
240 :     fmtReal(9, 3, tnow), fmtReal(9, 4, #totKE data + #totPE data),
241 :     fmtReal(9, 4, #totKE data / #totPE data), fmtInt(9, nttot),
242 :     fmtInt(9, nbavg), fmtInt(9, ncavg), fmtInt(9, selfint),
243 :     fmtReal(9, 2, cputime()), "\n\n"
244 :     ];
245 :     printvec ("cm pos", #cOfMPos data);
246 :     printvec ("cm vel", #cOfMVel data);
247 :     printvec ("am pos", #amVec data);
248 :     case !outState
249 :     of NONE => ()
250 :     | (SOME{tout, dtout, dtime, strm}) =>
251 :     if ((tout - 0.01 * dtime) <= tnow)
252 :     then (
253 :     outputData (strm, tnow, nbody, bodies);
254 :     outState := SOME{
255 :     tout=tout+dtout, dtout=dtout, dtime=dtime, strm=strm
256 :     })
257 :     else ()
258 :     (* end case *)
259 :     end
260 :    
261 :     end; (* DataIO *)
262 :    

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0