source: trunk/readexp.tcl @ 415

Last change on this file since 415 was 415, checked in by toby, 11 years ago

# on 2001/09/04 22:04:24, toby did:
excluded region support
bank & file names

  • Property rcs:author set to toby
  • Property rcs:date set to 2001/09/04 22:04:24
  • Property rcs:lines set to +33 -0
  • Property rcs:rev set to 1.28
  • Property rcs:state set to Exp
  • Property svn:keywords set to Author Date Revision Id
File size: 60.7 KB
Line 
1# $Id: readexp.tcl 415 2009-12-04 23:05:47Z toby $
2# Routines to deal with the .EXP "data structure"
3set expmap(Revision) {$Revision: 415 $ $Date: 2009-12-04 23:05:47 +0000 (Fri, 04 Dec 2009) $}
4
5#  The GSAS data is read from an EXP file.
6#   ... reading an EXP file into an array
7# returns -1 on error
8# returns 0 if the file is old-style UNIX format (no CR/LF)
9# returns 1 if the file is 80 char/line + cr/lf
10# returns 2 if the file is sequential but not fixed-record length
11proc expload {expfile} {
12    global exparray tcl_platform
13    # $expfile is the path to the data file.
14
15    # is this a compressed file?
16    if {[string match {*.EXP.[0-9][0-9][0-9].gz} $expfile] && \
17            $tcl_platform(platform) == "unix"} {
18        if [catch {set fil [open "| gunzip < $expfile" r]} err] {
19            tk_dialog .expFileErrorMsg "File Open Error" \
20                    "Unable to uncompress file $expfile\nerror: $err" error 0 "Exit"
21            return -1
22        }
23    } elseif [catch {set fil [open "$expfile" r]}] {
24        tk_dialog .expFileErrorMsg "File Open Error" \
25                "Unable to open file $expfile" error 0 "Exit" ; return -1
26    }
27    fconfigure $fil -translation lf
28    set len [gets $fil line]
29    if {[string length $line] != $len} {
30        tk_dialog .expConvErrorMsg "old tcl" \
31                "You are using an old version of Tcl/Tk and your .EXP file has binary characters; run convstod or upgrade" \
32                error 0 "Exit"
33        return -1
34    }
35    catch {
36        unset exparray
37    }
38    if {$len > 160} {
39        set fmt 0
40        # a UNIX-type file
41        set i1 0
42        set i2 79
43        while {$i2 < $len} {
44            set nline [string range $line $i1 $i2]
45            incr i1 80
46            incr i2 80
47            set key [string range $nline 0 11]
48            set exparray($key) [string range $nline 12 end]
49        }
50    } else {
51        set fmt 1
52        while {$len > 0} {
53            set key [string range $line 0 11]
54            set exparray($key) [string range $line 12 79]
55            if {$len != 81 || [string range $line end end] != "\r"} {set fmt 2}
56            set len [gets $fil line]
57        }
58    }
59    close $fil
60    return $fmt
61}
62
63proc createexp {expfile title} {
64    global exparray expmap
65    catch {unset exparray}
66    foreach key   {"     VERSION" "      DESCR" "ZZZZZZZZZZZZ" " EXPR NPHAS"} \
67            value {"   6"         ""            "  Last EXP file record" ""} {
68        # truncate long keys & pad short ones
69        set key [string range "$key        " 0 11]
70        set exparray($key) $value
71    }
72    expinfo title set $title
73    exphistory add " created readexp.tcl [lindex $expmap(Revision) 1] [clock format [clock seconds]]"
74    expwrite $expfile
75}
76
77# get information out from an EXP file
78#   creates the following entries in global array expmap
79#     expmap(phaselist)     gives a list of defined phases
80#     expmap(phasetype)     gives the phase type for each defined phase
81#                           =1 nuclear; 2 mag+nuc; 3 mag; 4 macro
82#     expmap(atomlist_$p)   gives a list of defined atoms in phase $p
83#     expmap(htype_$n)      gives the GSAS histogram type for histogram
84#     expmap(powderlist)    gives a list of powder histograms
85#     expmap(phaselist_$n)  gives a list of phases used in histogram $n
86#
87proc mapexp {} {
88    global expmap exparray
89    # clear out the old array
90    set expmap_Revision $expmap(Revision)
91    unset expmap
92    set expmap(Revision) $expmap_Revision
93    # get the defined phases
94    set line [readexp " EXPR NPHAS"]
95#    if {$line == ""} {
96#       set msg "No EXPR NPHAS entry. This is an invalid .EXP file"
97#       tk_dialog .badexp "Error in EXP" $msg error 0 Exit
98#       destroy .
99#    }
100    set expmap(phaselist) {}
101    set expmap(phasetype) {}
102    # loop over phases
103    foreach iph {1 2 3 4 5 6 7 8 9} {
104        set i5s [expr {($iph - 1)*5}]
105        set i5e [expr {$i5s + 4}]
106        set flag [string trim [string range $line $i5s $i5e]]
107        if {$flag == ""} {set flag 0}
108        if $flag {
109            lappend expmap(phaselist) $iph
110            lappend expmap(phasetype) $flag
111        }
112    }
113    # get the list of defined atoms for each phase
114    foreach iph $expmap(phaselist) {
115        set expmap(atomlist_$iph) {}
116        foreach key [array names exparray "CRS$iph  AT*A"] {
117            regexp { AT *([0-9]+)A} $key a num
118            lappend expmap(atomlist_$iph) $num
119        }
120        # note that sometimes an .EXP file contains more atoms than are actually defined
121        # drop the extra ones
122        set expmap(atomlist_$iph) [lsort -integer $expmap(atomlist_$iph)]
123        set natom [phaseinfo $iph natoms]
124        if {$natom != [llength $expmap(atomlist_$iph)]} {
125            set expmap(atomlist_$iph) [lrange $expmap(atomlist_$iph) 0 [expr {$natom-1}]]
126        }
127    }
128    # now get the histogram types
129    set nhist [string trim [readexp { EXPR  NHST }]]
130    set n 0
131    set expmap(powderlist) {}
132    for {set i 0} {$i < $nhist} {incr i} {
133        set ihist [expr {$i + 1}]
134        if {[expr {$i % 12}] == 0} {
135            incr n
136            set line [readexp " EXPR  HTYP$n"]
137            if {$line == ""} {
138                set msg "No HTYP$n entry for Histogram $ihist. This is an invalid .EXP file"
139                tk_dialog .badexp "Error in readexp" $msg error 0 Exit
140            }
141            set j 0
142        } else {
143            incr j
144        }
145        set expmap(htype_$ihist) [lindex $line $j]
146        # at least for now, ignore non-powder histograms
147        if {[string range $expmap(htype_$ihist) 0 0] == "P" && \
148                [string range $expmap(htype_$ihist) 3 3] != "*"} {
149            lappend expmap(powderlist) $ihist
150        }
151    }
152
153    # now process powder histograms
154    foreach ihist $expmap(powderlist) {
155        # make a 2 digit key -- hh
156        if {$ihist < 10} {
157            set hh " $ihist"
158        } else {
159            set hh $ihist
160        }
161        set line [readexp "HST $hh NPHAS"]
162        if {$line == ""} {
163            set msg "No NPHAS entry for Histogram $ihist. This is an invalid .EXP file"
164            tk_dialog .badexp "Error in readexp" $msg error 0 Exit
165        }
166        set expmap(phaselist_$ihist) {}
167        # loop over phases
168        foreach iph {1 2 3 4 5 6 7 8 9} {
169            set i5s [expr {($iph - 1)*5}]
170            set i5e [expr {$i5s + 4}]
171            set flag [string trim [string range $line $i5s $i5e]]
172            if {$flag == ""} {set flag 0}
173            if $flag {lappend expmap(phaselist_$ihist) $iph}
174        }
175    }
176}
177
178# return the value for a ISAM key
179proc readexp {key} {
180    global exparray
181    # truncate long keys & pad short ones
182    set key [string range "$key        " 0 11]
183    if [catch {set val $exparray($key)}] {
184        global expgui
185        if $expgui(debug) {puts "Error accessing record $key"}
186        return ""
187    }
188    return $val
189}
190
191# return the number of records matching ISAM key (may contain wildcards)
192proc existsexp {key} {
193    global exparray
194    # key can contain wild cards so don't pad
195    return [llength [array names exparray  $key]]
196}
197
198
199# replace a section of the exparray with $value
200#   replace $char characters starting at character $start (numbered from 1)
201proc setexp {key value start chars} {
202    global exparray
203    # truncate long keys & pad short ones
204    set key [string range "$key        " 0 11]
205    if [catch {set exparray($key)}] {
206        global expgui
207        if $expgui(debug) {puts "Error accessing record $key"}
208        return ""
209    }
210
211    # pad value to $chars
212    set l0 [expr {$chars - 1}]
213    set value [string range "$value                                           " 0 $l0]
214
215    if {$start == 1} {
216        set ret {}
217        set l1 $chars
218    } else {
219        set l0 [expr {$start - 2}]
220        set l1 [expr {$start + $chars - 1}]
221        set ret [string range $exparray($key) 0 $l0]
222    }
223    append ret $value [string range $exparray($key) $l1 end]
224    set exparray($key) $ret
225}
226
227proc makeexprec {key} {
228    global exparray
229    # truncate long keys & pad short ones
230    set key [string range "$key        " 0 11]
231    if [catch {set exparray($key)}] {
232        # set to 68 blanks
233        set exparray($key) [format %68s " "]
234    }
235}
236
237# delete an exp record
238# returns 1 if OK; 0 if not found
239proc delexp {key} {
240    global exparray
241    # truncate long keys & pad short ones
242    set key [string range "$key        " 0 11]
243    if [catch {unset exparray($key)}] {
244        return 0
245    }
246    return 1
247}
248# test an argument if it is a valid number; reform the number to fit
249proc validreal {val length decimal} {
250    upvar $val value
251    if [catch {expr {$value}}] {return 0}
252    if [catch {
253        set tmp [format "%${length}.${decimal}f" $value]
254        while {[string length $tmp] > $length} {
255            set tmp [format "%${length}.${decimal}E" $value]
256            incr decimal -1
257        }
258        set value $tmp
259    }] {return 0}
260    return 1
261}
262
263# test an argument if it is a valid integer; reform the number into
264# an integer, if appropriate -- be sure to pass the name of the variable not the value
265proc validint {val length} {
266    upvar $val value
267    # FORTRAN type assumption: blank is 0
268    if {$value == ""} {set value 0}
269    if [catch {
270        set tmp [expr {round($value)}]
271        if {$tmp != $value} {return 0}
272        set value [format "%${length}d" $tmp]
273    }] {return 0}
274    return 1
275}
276
277# process history information
278#    action == last
279#       returns number and value of last record
280#    action == add
281#
282proc exphistory {action "value 0"} {
283    global exparray
284    if {$action == "last"} {
285        set key [lindex [lsort -decreasing [array names exparray *HSTRY*]] 0]
286        if {$key == ""} {return ""}
287        return [list [string trim [string range $key 9 end]] $exparray($key)]
288    } elseif {$action == "add"} {
289        set key [lindex [lsort -decreasing [array names exparray *HSTRY*]] 0]
290        if {$key == ""} {
291            set index 1
292        } else {
293            set index [string trim [string range $key 9 end]]
294            if {$index != "***"} {
295                if {$index < 999} {incr index}
296                set key [format "    HSTRY%3d" $index]
297                set exparray($key) $value
298            }
299        }
300        set key [format "    HSTRY%3d" $index]
301        set exparray($key) $value
302    }
303}
304# get overall info
305#   parm:
306#     print     -- GENLES print option (*)
307#     cycles    -- number of GENLES cycles (*)
308#     title     -- the overall title (*)
309#     convg     -- convergence criterion: -200 to 200 (*)
310#     marq      -- Marquardt damping factor: 1.0 to 9.99 (*)
311proc expinfo {parm "action get" "value {}"} {
312    switch ${parm}-$action {
313        title-get {
314            return [string trim [readexp "      DESCR"]]
315        }
316        title-set {
317            setexp "      DESCR" "  $value" 2 68
318        }
319        cycles-get {
320            return [string trim [cdatget MXCY]]
321        }
322        cycles-set {
323            if ![validint value 1] {return 0}
324            cdatset MXCY [format %4d $value]
325        }
326        print-get {
327            set print [string trim [cdatget PRNT]]
328            if {$print != ""} {return $print}
329            return 0
330        }
331        print-set {
332            if ![validint value 1] {return 0}
333            cdatset PRNT [format %3d $value]
334        }
335        convg-get {
336            set cvg [string trim [cdatget CVRG]]
337            if {$cvg == ""} {return -200}
338            if [catch {expr {$cvg}}] {return -200}
339            return $cvg
340        }
341        convg-set {
342            if ![validint value 1] {return 0}
343            set value [expr {-200>$value?-200:$value}]
344            set value [expr {200<$value?200:$value}]
345            cdatset CVRG [format %4d $value]
346        }
347        marq-get {
348            set mar [string trim [cdatget MARQ]]
349            if {$mar == ""} {return 1.0}
350            if [catch {expr $mar}] {return 1.}
351            return $mar
352        }
353        marq-set {
354            if [catch {
355                set value [expr {1.0>$value?1.0:$value}]
356                set value [expr {9.99<$value?9.99:$value}]
357            }] {return 0}
358            if ![validreal value 4 2] {return 0}
359            cdatset MARQ $value
360        }
361        default {
362            set msg "Unsupported expinfo access: parm=$parm action=$action"
363            tk_dialog .badexp "Error in readexp" $msg error 0 Exit
364        }
365    }
366    return 1
367}
368
369proc cdatget {key} {
370    foreach i {1 2 3 4 5 6 7 8 9} {
371        if {[existsexp "  GNLS CDAT$i"] == 0} break
372        set line [readexp "  GNLS CDAT$i"]
373        if {$line == {}} break
374        foreach i1 {2 10 18 26 34 42 50 58 66} \
375                i2 {9 17 25 33 41 49 57 65 73} {
376            set item [string range $line $i1 $i2]
377            if {[string trim $item] == {}} continue
378            if [regexp "${key}(.*)" $item a b] {return $b}
379        }
380    }
381    return {}
382}
383
384proc cdatset {key value} {
385    # round 1 see if we can find the string
386    foreach i {1 2 3 4 5 6 7 8 9} {
387        set line [readexp "  GNLS CDAT$i"]
388        if {$line == {}} break
389        foreach i1 {2 10 18 26 34 42 50 58 66} \
390                i2 {9 17 25 33 41 49 57 65 73} {
391            set item [string range $line $i1 $i2]
392            if {[string trim $item] == {}} continue
393            if [regexp "${key}(.*)" $item a b] {
394                # found it now replace it
395                incr i1
396                setexp "  GNLS CDAT$i" "${key}${value}" $i1 8
397                return
398            }
399        }
400    }
401    # not found, take the 1st blank space, creating a card if needed
402    foreach i {1 2 3 4 5 6 7 8 9} {
403        set line [readexp "  GNLS CDAT$i"]
404        if {$line == {}} {makeexprec "  GNLS CDAT$i"}
405        foreach i1 {2 10 18 26 34 42 50 58 66} \
406                i2 {9 17 25 33 41 49 57 65 73} {
407            set item [string range $line $i1 $i2]
408            if {[string trim $item] == {}} {
409                # found a blank space: now replace it
410                incr i1
411                setexp "  GNLS CDAT$i" "${key}${value}" $i1 8
412                return
413            }
414        }
415    }
416    return {}
417}
418
419# get phase information: phaseinfo phase parm action value
420#   phase: 1 to 9 (as defined)
421#   parm:
422#     name -- phase name
423#     natoms -- number of atoms (*)
424#     a b c alpha beta gamma -- cell parameters (*)
425#     cellref -- refinement flag for the unit cell(*)
426#     celldamp  -- damping for the unit cell refinement (*)
427#     spacegroup -- space group symbol (*)
428#     ODForder -- spherical harmonic order (*)
429#     ODFsym   -- sample symmetry (0-3) (*)
430#     ODFdampA -- damping for angles (*)
431#     ODFdampC -- damping for coefficients (*)
432#     ODFomega -- omega oriention angle (*)
433#     ODFchi -- chi oriention angle (*)
434#     ODFphi -- phi oriention angle (*)
435#     ODFomegaRef -- refinement flag for omega (*)
436#     ODFchiRef -- refinement flag for chi (*)
437#     ODFphiRef -- refinement flag for phi (*)
438#     ODFterms -- a list of the {l m n} values for each ODF term (*)
439#     ODFcoefXXX -- the ODF coefficient for for ODF term XXX (*)
440#     ODFRefcoef -- refinement flag for ODF terms (*)
441#  action: get (default) or set
442#  value: used only with set
443#  * =>  read+write supported
444proc phaseinfo {phase parm "action get" "value {}"} {
445    switch -glob ${parm}-$action {
446
447        name-get {
448            return [string trim [readexp "CRS$phase    PNAM"]]
449        }
450
451        name-set {
452            setexp "CRS$phase    PNAM" " $value" 2 68
453        }
454
455        spacegroup-get {
456            return [string trim [readexp "CRS$phase  SG SYM"]]
457        }
458
459        spacegroup-set {
460            setexp "CRS$phase  SG SYM" " $value" 2 68
461        }
462
463        natoms-get {
464            return [string trim [readexp "CRS$phase   NATOM"]]     
465        }
466
467        natoms-set {
468            if ![validint value 5] {return 0}
469            setexp "CRS$phase   NATOM" $value 1 5
470        }
471
472        a-get {
473           return [string trim [string range [readexp "CRS$phase  ABC"] 0 9]]
474        }
475        b-get {
476           return [string trim [string range [readexp "CRS$phase  ABC"] 10 19]]
477        }
478        c-get {
479           return [string trim [string range [readexp "CRS$phase  ABC"] 20 29]]
480        }
481        alpha-get {
482           return [string trim [string range [readexp "CRS$phase  ANGLES"] 0 9]]
483        }
484        beta-get {
485           return [string trim [string range [readexp "CRS$phase  ANGLES"] 10 19]]
486        }
487        gamma-get {
488           return [string trim [string range [readexp "CRS$phase  ANGLES"] 20 29]]
489        }
490
491        a-set {
492            if ![validreal value 10 6] {return 0}
493            setexp "CRS$phase  ABC" $value 1 10             
494        }
495        b-set {
496            if ![validreal value 10 6] {return 0}
497            setexp "CRS$phase  ABC" $value 11 10           
498        }
499        c-set {
500            if ![validreal value 10 6] {return 0}
501            setexp "CRS$phase  ABC" $value 21 10           
502        }
503        alpha-set {
504            if ![validreal value 10 4] {return 0}
505            setexp "CRS$phase  ANGLES" $value 1 10         
506        }
507        beta-set {
508            if ![validreal value 10 4] {return 0}
509            setexp "CRS$phase  ANGLES" $value 11 10         
510        }
511        gamma-set {
512            if ![validreal value 10 4] {return 0}
513            setexp "CRS$phase  ANGLES" $value 21 10         
514        }
515        cellref-get {
516            if {[string toupper [string range [readexp "CRS$phase  ABC"] 34 34]] == "Y"} {
517                return 1
518            }
519            return 0
520        }
521        cellref-set {
522            if $value {
523                setexp "CRS$phase  ABC" "Y" 35 1
524            } else {
525                setexp "CRS$phase  ABC" "N" 35 1
526            }       
527        }
528        celldamp-get {
529            set val [string range [readexp "CRS$phase  ABC"] 39 39]
530            if {$val == " "} {return 0}
531            return $val
532        }
533        celldamp-set {
534            setexp "CRS$phase  ABC" $value 40 1
535        }
536
537        ODForder-get {
538            set val [string trim [string range [readexp "CRS$phase  ODF"] 0 4]]
539            if {$val == " "} {return 0}
540            return $val
541        }
542        ODForder-set {
543            if ![validint value 5] {return 0}
544            setexp "CRS$phase  ODF" $value 1 5
545        }
546        ODFsym-get {
547            set val [string trim [string range [readexp "CRS$phase  ODF"] 10 14]]
548            if {$val == " "} {return 0}
549            return $val
550        }
551        ODFsym-set {
552            if ![validint value 5] {return 0}
553            setexp "CRS$phase  ODF" $value 11 5
554        }
555        ODFdampA-get {
556            set val [string range [readexp "CRS$phase  ODF"] 24 24]
557            if {$val == " "} {return 0}
558            return $val
559        }
560        ODFdampA-set {
561            setexp "CRS$phase  ODF" $value 25 1
562        }
563        ODFdampC-get {
564            set val [string range [readexp "CRS$phase  ODF"] 29 29]
565            if {$val == " "} {return 0}
566            return $val
567        }
568        ODFdampC-set {
569            setexp "CRS$phase  ODF" $value 30 1
570        }
571        ODFomegaRef-get {
572            if {[string toupper [string range [readexp "CRS$phase  ODF"] 16 16]] == "Y"} {
573                return 1
574            }
575            return 0
576        }
577        ODFomegaRef-set {
578            if $value {
579                setexp "CRS$phase  ODF" "Y" 17 1
580            } else {
581                setexp "CRS$phase  ODF" "N" 17 1
582            }       
583        }
584        ODFchiRef-get {
585            if {[string toupper [string range [readexp "CRS$phase  ODF"] 17 17]] == "Y"} {
586                return 1
587            }
588            return 0
589        }
590        ODFchiRef-set {
591            if $value {
592                setexp "CRS$phase  ODF" "Y" 18 1
593            } else {
594                setexp "CRS$phase  ODF" "N" 18 1
595            }       
596        }
597        ODFphiRef-get {
598            if {[string toupper [string range [readexp "CRS$phase  ODF"] 18 18]] == "Y"} {
599                return 1
600            }
601            return 0
602        }
603        ODFphiRef-set {
604            if $value {
605                setexp "CRS$phase  ODF" "Y" 19 1
606            } else {
607                setexp "CRS$phase  ODF" "N" 19 1
608            }       
609        }
610        ODFcoef*-get {
611            regsub ODFcoef $parm {} term
612            set k [expr {($term+5)/6}]
613            if {$k <= 9} {set k " $k"}
614            set j [expr {(($term-1) % 6)+1}]
615            set lineB [readexp "CRS$phase  ODF${k}B"]
616            set j0 [expr { ($j-1) *10}]
617            set j1 [expr {$j0 + 9}]
618            set val [string trim [string range $lineB $j0 $j1]]
619            if {$val == ""} {return 0.0}
620            return $val
621        }
622        ODFcoef*-set {
623            regsub ODFcoef $parm {} term
624            if ![validreal value 10 3] {return 0}
625            set k [expr {($term+5)/6}]
626            if {$k <= 9} {set k " $k"}
627            set j [expr {(($term-1) % 6)+1}]
628            set col [expr { ($j-1)*10 + 1}]
629            setexp "CRS$phase  ODF${k}B" $value $col 10
630        }
631        ODFRefcoef-get {
632            if {[string toupper [string range [readexp "CRS$phase  ODF"] 19 19]] == "Y"} {
633                return 1
634            }
635            return 0
636        }
637        ODFRefcoef-set {
638            if $value {
639                setexp "CRS$phase  ODF" "Y" 20 1
640            } else {
641                setexp "CRS$phase  ODF" "N" 20 1
642            }       
643        }
644        ODFomega-get {
645           return [string trim [string range [readexp "CRS$phase  ODF"] 30 39]]
646        }
647        ODFchi-get {
648           return [string trim [string range [readexp "CRS$phase  ODF"] 40 49]]
649        }
650        ODFphi-get {
651           return [string trim [string range [readexp "CRS$phase  ODF"] 50 59]]
652        }
653        ODFomega-set {
654            if ![validreal value 10 4] {return 0}
655            setexp "CRS$phase  ODF" $value 31 10
656        }
657        ODFchi-set {
658            if ![validreal value 10 4] {return 0}
659            setexp "CRS$phase  ODF" $value 41 10
660        }
661        ODFphi-set {
662            if ![validreal value 10 4] {return 0}
663            setexp "CRS$phase  ODF" $value 51 10
664        }
665
666        ODFterms-get {
667            set vallist {}
668            set val [string trim [string range [readexp "CRS$phase  ODF"] 5 9]]
669            for {set i 1} {$i <= $val} {incr i 6} {
670                set k [expr {1+($i-1)/6}]
671                if {$k <= 9} {set k " $k"}
672                set lineA [readexp "CRS$phase  ODF${k}A"]
673                set k 0
674                for {set j $i} {$j <= $val && $j < $i+6} {incr j} {
675                    set j0 [expr {($k)*10}]
676                    set j1 [expr {$j0 + 9}]
677                    lappend vallist [string trim [string range $lineA $j0 $j1]]
678                    incr k
679                }
680            }
681            return $vallist
682        }
683        ODFterms-set {
684            set key "CRS$phase  ODF   "
685            if {![existsexp $key]} {
686                makeexprec $key
687                set oldlen 0
688            } else {
689                set oldlen [string trim [string range [readexp $key] 5 9]]
690            }
691            set len [llength $value]
692            if ![validint len 5] {return 0}
693            setexp $key $len 6 5
694            set j 0
695            set k 0
696            foreach item $value {
697                incr j
698                if {$j % 6 == 1} {
699                    incr k
700                    if {$k <= 9} {set k " $k"}
701                    set col 1
702                    set keyA "CRS$phase  ODF${k}A"
703                    set keyB "CRS$phase  ODF${k}B"
704                    if {![existsexp $keyA]} {
705                        makeexprec $keyA
706                        makeexprec $keyB
707                    }
708                }
709                set col1 [expr {$col + 1}]
710                foreach n [lrange $item 0 2] {
711                    if ![validint n 3] {return 0}
712                    setexp $keyA $n $col1 3
713                    incr col1 3
714                }
715                incr col 10
716            }
717            for {incr j} {$j <= $oldlen} {incr j} {
718                if {$j % 6 == 1} {
719                    incr k
720                    if {$k <= 9} {set k " $k"}
721                    set col 1
722                    set keyA "CRS$phase  ODF${k}A"
723                    set keyB "CRS$phase  ODF${k}B"
724                    delexp $keyA
725                    delexp $keyB
726                }
727                if {[existsexp $keyA]} {
728                    setexp $keyA "          " $col 10
729                    setexp $keyB "          " $col 10
730                }
731                incr col 10
732            }
733        }
734
735        default {
736            set msg "Unsupported phaseinfo access: parm=$parm action=$action"
737            tk_dialog .badexp "Error in readexp" $msg error 0 Exit
738        }
739    }
740    return 1
741}
742
743
744# get atom information: atominfo phase atom parm action value
745#   phase: 1 to 9 (as defined)
746#   atom: a valid atom number [see expmap(atomlist_$phase)]
747#      Note that atom and phase can be paired lists, but if there are extra
748#      entries in the atoms list, the last phase will be repeated.
749#      so that atominfo 1 {1 2 3} xset 1
750#               will set the xflag for atoms 1-3 in phase 1
751#      but atominfo {1 2 3} {1 1 1} xset 1
752#               will set the xflag for atoms 1 in phase 1-3
753#   parm:
754#     type -- element code
755#     mult -- atom multiplicity
756#     label -- atom label (*)
757#     x y z -- coordinates (*)
758#     frac --  occupancy (*)
759#     temptype -- I or A for Isotropic/Anisotropic (*)
760#     Uiso  -- Isotropic temperature factor (*)
761#     U11  -- Anisotropic temperature factor (*)
762#     U22  -- Anisotropic temperature factor (*)
763#     U33  -- Anisotropic temperature factor (*)
764#     U12  -- Anisotropic temperature factor (*)
765#     U13  -- Anisotropic temperature factor (*)
766#     U23  -- Anisotropic temperature factor (*)
767#     xref/xdamp -- refinement flag/damping value for the coordinates (*)
768#     uref/udamp -- refinement flag/damping value for the temperature factor(s)  (*)
769#     fref/fdamp -- refinement flag/damping value for the occupancy (*)
770#  action: get (default) or set
771#  value: used only with set
772#  * =>  read+write supported
773
774proc atominfo {phaselist atomlist parm "action get" "value {}"} {
775    foreach phase $phaselist atom $atomlist {
776        if {$phase == ""} {set phase [lindex $phaselist end]}
777        if {$atom < 10} {
778            set key "CRS$phase  AT  $atom"
779        } elseif {$atom < 100} {
780            set key "CRS$phase  AT $atom"
781        } else {
782            set key "CRS$phase  AT$atom"
783        }
784        switch -glob ${parm}-$action {
785            type-get {
786                return [string trim [string range [readexp ${key}A] 2 9] ]
787            }
788            mult-get {
789                return [string trim [string range [readexp ${key}A] 58 61] ]
790            }
791            label-get {
792                return [string trim [string range [readexp ${key}A] 50 57] ]
793            }
794            label-set {
795                setexp ${key}A $value 51 8
796            }
797            temptype-get {
798                return [string trim [string range [readexp ${key}B] 62 62] ]
799            }
800            temptype-set {
801                if {$value == "A"} {
802                    setexp ${key}B A 63 1
803                    # copy the Uiso to the diagonal terms
804                    set Uiso [string range [readexp ${key}B] 0 9]
805                    foreach value [CalcAniso $phase $Uiso] \
806                            col {1 11 21 31 41 51} {
807                        validreal value 10 6
808                        setexp ${key}B $value $col 10
809                    }
810                } else {
811                    setexp ${key}B I 63 1
812                    set value 0.0
813                    catch {
814                        # get the trace
815                        set value [expr {( \
816                                [string range [readexp ${key}B] 0 9] + \
817                                [string range [readexp ${key}B] 10 19] + \
818                                [string range [readexp ${key}B] 20 29])/3.}]
819                    }
820                    validreal value 10 6
821                    setexp ${key}B $value 1 10
822                    # blank out the remaining terms
823                    set value " "
824                    setexp ${key}B $value 11 10
825                    setexp ${key}B $value 21 10
826                    setexp ${key}B $value 31 10
827                    setexp ${key}B $value 41 10
828                    setexp ${key}B $value 51 10
829                }
830            }
831            x-get {
832                return [string trim [string range [readexp ${key}A] 10 19] ]
833            }
834            x-set {
835                if ![validreal value 10 6] {return 0}
836                setexp ${key}A $value 11 10
837            }
838            y-get {
839                return [string trim [string range [readexp ${key}A] 20 29] ]
840            }
841            y-set {
842                if ![validreal value 10 6] {return 0}
843                setexp ${key}A $value 21 10
844            }
845            z-get {
846                return [string trim [string range [readexp ${key}A] 30 39] ]
847            }
848            z-set {
849                if ![validreal value 10 6] {return 0}
850                setexp ${key}A $value 31 10
851            }
852            frac-get {
853                return [string trim [string range [readexp ${key}A] 40 49] ]
854            }
855            frac-set {
856                if ![validreal value 10 6] {return 0}
857                setexp ${key}A $value 41 10
858            }
859            U*-get {
860                regsub U $parm {} type
861                if {$type == "iso" || $type == "11"} {
862                    return [string trim [string range [readexp ${key}B] 0 9] ]
863                } elseif {$type == "22"} {
864                    return [string trim [string range [readexp ${key}B] 10 19] ]
865                } elseif {$type == "33"} {
866                    return [string trim [string range [readexp ${key}B] 20 29] ]
867                } elseif {$type == "12"} {
868                    return [string trim [string range [readexp ${key}B] 30 39] ]
869                } elseif {$type == "13"} {
870                    return [string trim [string range [readexp ${key}B] 40 49] ]
871                } elseif {$type == "23"} {
872                    return [string trim [string range [readexp ${key}B] 50 59] ]
873                }
874            }
875            U*-set {
876                if ![validreal value 10 6] {return 0}
877                regsub U $parm {} type
878                if {$type == "iso" || $type == "11"} {
879                    setexp ${key}B $value 1 10
880                } elseif {$type == "22"} {
881                    setexp ${key}B $value 11 10
882                } elseif {$type == "33"} {
883                    setexp ${key}B $value 21 10
884                } elseif {$type == "12"} {
885                    setexp ${key}B $value 31 10
886                } elseif {$type == "13"} {
887                    setexp ${key}B $value 41 10
888                } elseif {$type == "23"} {
889                    setexp ${key}B $value 51 10
890                }
891            }
892            xref-get {
893                if {[string toupper [string range [readexp ${key}B] 64 64]] == "X"} {
894                    return 1
895                }
896                return 0
897            }
898            xref-set {
899                if $value {
900                    setexp ${key}B "X" 65 1
901                } else {
902                    setexp ${key}B " " 65 1
903                }           
904            }
905            xdamp-get {
906                set val [string range [readexp ${key}A] 64 64]
907                if {$val == " "} {return 0}
908                return $val
909            }
910            xdamp-set {
911                setexp ${key}A $value 65 1
912            }
913            fref-get {
914                if {[string toupper [string range [readexp ${key}B] 63 63]] == "F"} {
915                    return 1
916                }
917                return 0
918            }
919            fref-set {
920                if $value {
921                    setexp ${key}B "F" 64 1
922                } else {
923                    setexp ${key}B " " 64 1
924                }           
925            }
926            fdamp-get {
927                set val [string range [readexp ${key}A] 63 63]
928                if {$val == " "} {return 0}
929                return $val
930            }
931            fdamp-set {
932                setexp ${key}A $value 64 1
933            }
934
935            uref-get {
936                if {[string toupper [string range [readexp ${key}B] 65 65]] == "U"} {
937                    return 1
938                }
939                return 0
940            }
941            uref-set {
942                if $value {
943                    setexp ${key}B "U" 66 1
944                } else {
945                    setexp ${key}B " " 66 1
946                }           
947            }
948            udamp-get {
949                set val [string range [readexp ${key}A] 65 65]
950                if {$val == " "} {return 0}
951                return $val
952            }
953            udamp-set {
954                setexp ${key}A $value 66 1
955            }
956            default {
957                set msg "Unsupported atominfo access: parm=$parm action=$action"
958                tk_dialog .badexp "Error in readexp" $msg error 0 Exit
959            }
960        }
961    }
962    return 1
963}
964
965# get histogram information: histinfo histlist parm action value
966# histlist is a list of histogram numbers
967# parm:
968#     title
969#     scale (*)
970#     sref/sdamp -- refinement flag/damping value for the scale factor (*)
971#     lam1, lam2 (*)
972#     ttref refinement flag for the 2theta (ED Xray) (*)
973#     wref refinement flag for the wavelength (*)
974#     ratref refinement flag for the wavelength ratio (*)
975#     difc, difa -- TOF calibration constants (*)
976#     dcref,daref -- refinement flag for difc, difa (*)
977#     zero (*)
978#     zref refinement flag for the zero correction (*)
979#     ipola (*)
980#     pola (*)
981#     pref refinement flag for the polarization (*)
982#     kratio (*)
983#     ddamp -- damping value for the diffractometer constants (*)
984#     backtype -- background function number *
985#     backterms -- number of background terms *
986#     bref/bdamp -- refinement flag/damping value for the background (*)
987#     bterm$n -- background term #n (*)
988#     bank -- Bank number
989#     tofangle -- detector angle (TOF only)
990#     foextract  -- Fobs extraction flag (*)
991#     LBdamp  -- LeBail damping value (*)
992#     tmin/tmax -- minimum & maximum usable 2theta/TOF/energy
993#     excl -- excluded regions (*)
994proc histinfo {histlist parm "action get" "value {}"} {
995    global expgui
996    foreach hist $histlist {
997        if {$hist < 10} {
998            set key "HST  $hist"
999        } else {
1000            set key "HST $hist"
1001        }
1002        switch -glob ${parm}-$action {
1003            foextract-get {
1004                set line [readexp "${key} EPHAS"]
1005                # add a EPHAS if not exists
1006                if {$line == {}} {
1007                    makeexprec "${key} EPHAS"
1008                    # expedt defaults this to "F", but I think "T" is better
1009                    setexp "${key} EPHAS" "Y" 50 1
1010                    if $expgui(debug) {puts "Warning: creating a ${key} EPHAS record"}
1011                }
1012                if {[string toupper [string range $line 49 49]] == "T"} {
1013                    return 1
1014                }
1015                # the flag has changed to "Y/N" in the latest versions
1016                # of GSAS
1017                if {[string toupper [string range $line 49 49]] == "Y"} {
1018                    return 1
1019                }
1020                return 0
1021            }
1022            foextract-set {
1023                # the flag has changed to "Y/N" in the latest versions
1024                # of GSAS
1025                if $value {
1026                    setexp "${key} EPHAS" "Y" 50 1
1027                } else {
1028                    setexp "${key} EPHAS" "N" 50 1
1029                }
1030            }
1031            LBdamp-get {
1032                set v [string trim [string range [readexp "${key} EPHAS"] 54 54]]
1033                if {$v == ""} {return 0}
1034                return $v
1035            }
1036            LBdamp-set {
1037                if ![validint value 5] {return 0}
1038                setexp "${key} EPHAS" $value 51 5
1039            }
1040            title-get {
1041                return [string trim [readexp "${key}  HNAM"] ]
1042            }
1043            scale-get {
1044                return [string trim [string range [readexp ${key}HSCALE] 0 14]]
1045            }
1046            scale-set {
1047                if ![validreal value 15 6] {return 0}
1048                setexp ${key}HSCALE $value 1 15
1049            }
1050            sref-get {
1051                if {[string toupper [string range [readexp ${key}HSCALE] 19 19]] == "Y"} {
1052                    return 1
1053                }
1054                return 0
1055            }
1056            sref-set {
1057                if $value {
1058                    setexp ${key}HSCALE "Y" 20 1
1059                } else {
1060                    setexp ${key}HSCALE "N" 20 1
1061                }           
1062            }
1063            sdamp-get {
1064                set val [string range [readexp ${key}HSCALE] 24 24]
1065                if {$val == " "} {return 0}
1066                return $val
1067            }
1068            sdamp-set {
1069                setexp ${key}HSCALE $value 25 1
1070            }
1071
1072            difc-get -
1073            lam1-get {
1074                return [string trim [string range [readexp "${key} ICONS"] 0 9]]
1075            }
1076            difc-set -
1077            lam1-set {
1078                if ![validreal value 10 7] {return 0}
1079                setexp "${key} ICONS" $value 1 10
1080            }
1081            difa-get -
1082            lam2-get {
1083                return [string trim [string range [readexp "${key} ICONS"] 10 19]]
1084            }
1085            difa-set -
1086            lam2-set {
1087                if ![validreal value 10 7] {return 0}
1088                setexp "${key} ICONS" $value 11 10
1089            }
1090            zero-get {
1091                return [string trim [string range [readexp "${key} ICONS"] 20 29]]
1092            }
1093            zero-set {
1094                if ![validreal value 10 5] {return 0}
1095                setexp "${key} ICONS" $value 21 10
1096            }
1097            ipola-get {
1098                return [string trim [string range [readexp "${key} ICONS"] 54 54]]
1099            }
1100            ipola-set {
1101                if ![validint value 1] {return 0}
1102                setexp "${key} ICONS" $value 55 1
1103            }
1104            pola-get {
1105                return [string trim [string range [readexp "${key} ICONS"] 40 49]]
1106            }
1107            pola-set {
1108                if ![validreal value 10 5] {return 0}
1109                setexp "${key} ICONS" $value 41 10
1110            }
1111            kratio-get {
1112                return [string trim [string range [readexp "${key} ICONS"] 55 64]]
1113            }
1114            kratio-set {
1115                if ![validreal value 10 5] {return 0}
1116                setexp "${key} ICONS" $value 56 10
1117            }
1118
1119            wref-get {
1120            #------------------------------------------------------
1121            # col 33: refine flag for lambda, difc, ratio and theta
1122            #------------------------------------------------------
1123                if {[string toupper [string range \
1124                        [readexp "${key} ICONS"] 32 32]] == "L"} {
1125                    return 1
1126                }
1127                return 0
1128            }
1129            wref-set {
1130                if $value {
1131                    setexp "${key} ICONS" "L" 33 1
1132                } else {
1133                    setexp "${key} ICONS" " " 33 1
1134                }           
1135            }
1136            ratref-get {
1137                if {[string toupper [string range \
1138                        [readexp "${key} ICONS"] 32 32]] == "R"} {
1139                    return 1
1140                }
1141                return 0
1142            }
1143            ratref-set {
1144                if $value {
1145                    setexp "${key} ICONS" "R" 33 1
1146                } else {
1147                    setexp "${key} ICONS" " " 33 1
1148                }           
1149            }
1150            dcref-get {
1151                if {[string toupper [string range \
1152                        [readexp "${key} ICONS"] 32 32]] == "C"} {
1153                    return 1
1154                }
1155                return 0
1156            }
1157            dcref-set {
1158                if $value {
1159                    setexp "${key} ICONS" "C" 33 1
1160                } else {
1161                    setexp "${key} ICONS" " " 33 1
1162                }           
1163            }
1164            ttref-get {
1165                if {[string toupper [string range \
1166                        [readexp "${key} ICONS"] 32 32]] == "T"} {
1167                    return 1
1168                }
1169                return 0
1170            }
1171            ttref-set {
1172                if $value {
1173                    setexp "${key} ICONS" "T" 33 1
1174                } else {
1175                    setexp "${key} ICONS" " " 33 1
1176                }           
1177            }
1178
1179
1180            pref-get {
1181            #------------------------------------------------------
1182            # col 34: refine flag for POLA & DIFA
1183            #------------------------------------------------------
1184                if {[string toupper [string range \
1185                        [readexp "${key} ICONS"] 33 33]] == "P"} {
1186                    return 1
1187                }
1188                return 0
1189            }
1190            pref-set {
1191                if $value {
1192                    setexp "${key} ICONS" "P" 34 1
1193                } else {
1194                    setexp "${key} ICONS" " " 34 1
1195                }           
1196            }
1197            daref-get {
1198                if {[string toupper [string range \
1199                        [readexp "${key} ICONS"] 33 33]] == "A"} {
1200                    return 1
1201                }
1202                return 0
1203            }
1204            daref-set {
1205                if $value {
1206                    setexp "${key} ICONS" "A" 34 1
1207                } else {
1208                    setexp "${key} ICONS" " " 34 1
1209                }           
1210            }
1211
1212            zref-get {
1213            #------------------------------------------------------
1214            # col 34: refine flag for zero correction
1215            #------------------------------------------------------
1216                if {[string toupper [string range [readexp "${key} ICONS"] 34 34]] == "Z"} {
1217                    return 1
1218                }
1219                return 0
1220            }
1221            zref-set {
1222                if $value {
1223                    setexp "${key} ICONS" "Z" 35 1
1224                } else {
1225                    setexp "${key} ICONS" " " 35 1
1226                }           
1227            }
1228
1229            ddamp-get {
1230                set val [string range [readexp "${key} ICONS"] 39 39]
1231                if {$val == " "} {return 0}
1232                return $val
1233            }
1234            ddamp-set {
1235                setexp "${key} ICONS" $value 40 1
1236            }
1237
1238            backtype-get {
1239                set val [string trim [string range [readexp "${key}BAKGD "] 0 4]]
1240                if {$val == " "} {return 0}
1241                return $val
1242            }
1243            backtype-set {
1244                if ![validint value 5] {return 0}
1245                setexp "${key}BAKGD " $value 1 5
1246            }
1247            backterms-get {
1248                set val [string trim [string range [readexp "${key}BAKGD "] 5 9]]
1249                if {$val == " "} {return 0}
1250                return $val
1251            }
1252            backterms-set {
1253                # this takes a bit of work -- if terms are added, add lines as needed to the .EXP
1254                set oldval [string trim [string range [readexp "${key}BAKGD "] 5 9]]
1255                if ![validint value 5] {return 0}
1256                if {$oldval < $value} {
1257                    set line1  [expr {2 + ($oldval - 1) / 4}]
1258                    set line2  [expr {1 + ($value - 1) / 4}]
1259                    for {set i $line1} {$i <= $line2} {incr i} {
1260                        # create a blank entry if needed
1261                        makeexprec ${key}BAKGD$i
1262                    }
1263                    incr oldval
1264                    for {set num $oldval} {$num <= $value} {incr num} {
1265                        set f1 [expr {15*(($num - 1) % 4)}]
1266                        set f2 [expr {15*(1 + ($num - 1) % 4)-1}]
1267                        set line  [expr {1 + ($num - 1) / 4}]
1268                        if {[string trim [string range [readexp ${key}BAKGD$line] $f1 $f2]] == ""} {
1269                            set f1 [expr {15*(($num - 1) % 4)+1}]
1270                            setexp ${key}BAKGD$line 0.0 $f1 15                 
1271                        }
1272                    }
1273                }
1274                setexp "${key}BAKGD " $value 6 5
1275
1276            }
1277            bref-get {
1278                if {[string toupper [string range [readexp "${key}BAKGD"] 14 14]] == "Y"} {
1279                    return 1
1280                }
1281                return 0
1282            }
1283            bref-set {
1284                if $value {
1285                    setexp "${key}BAKGD "  "Y" 15 1
1286                } else {
1287                    setexp "${key}BAKGD "  "N" 15 1
1288                }
1289            }
1290            bdamp-get {
1291                set val [string range [readexp "${key}BAKGD "] 19 19]
1292                if {$val == " "} {return 0}
1293                return $val
1294            }
1295            bdamp-set {
1296                setexp "${key}BAKGD " $value 20 1
1297            }
1298            bterm*-get {
1299                regsub bterm $parm {} num
1300                set f1 [expr {15*(($num - 1) % 4)}]
1301                set f2 [expr {15*(1 + ($num - 1) % 4)-1}]
1302                set line  [expr {1 + ($num - 1) / 4}]
1303                return [string trim [string range [readexp ${key}BAKGD$line] $f1 $f2] ]
1304            }
1305            bterm*-set {
1306                regsub bterm $parm {} num
1307                if ![validreal value 15 6] {return 0}
1308                set f1 [expr {15*(($num - 1) % 4)+1}]
1309                set line  [expr {1 + ($num - 1) / 4}]
1310                setexp ${key}BAKGD$line $value $f1 15
1311            }
1312            bank-get {
1313                return [string trim [string range [readexp "${key} BANK"] 0 4]]
1314            }
1315            tofangle-get {
1316                return [string trim [string range [readexp "${key}BNKPAR"] 10 19]]
1317            }
1318            tmin-get {
1319                return [string trim [string range [readexp "${key} TRNGE"] 0 9]]
1320            }
1321            tmax-get {
1322                return [string trim [string range [readexp "${key} TRNGE"] 10 19]]
1323            }
1324            excl-get {
1325                set n [string trim [string range [readexp "${key} NEXC"] 0 4]]
1326                set exlist {}
1327                for {set i 1} {$i <= $n} {incr i} {
1328                    lappend exlist \
1329                            [string trim [readexp [format "${key}EXC%3d" $i]]]
1330                }
1331                return $exlist
1332            }
1333            excl-set {
1334                set n [llength $value]
1335                if ![validint n 5] {return 0}
1336                setexp "${key} NEXC" $n 1 5
1337                set i 0
1338                foreach p $value {
1339                    incr i
1340                    foreach {r1 r2} $p {}
1341                    validreal r1 10 3
1342                    validreal r2 10 3
1343                    set k [format "${key}EXC%3d" $i]
1344                    if {![existsexp $k]} {
1345                        makeexprec $k
1346                    }
1347                    setexp $k ${r1}${r2} 1 20
1348                }
1349            }
1350            file-get {
1351                return [string trim [readexp "${key}  HFIL"] ]
1352            }
1353            bank-get {
1354                return [string trim [string range [readexp "${key} BANK"] 0 4]]
1355            }
1356            default {
1357                set msg "Unsupported histinfo access: parm=$parm action=$action"
1358                tk_dialog .badexp "Error in readexp" $msg error 0 Exit
1359            }
1360        }
1361    }
1362    return 1
1363}
1364
1365# read the information that differs by both histogram and phase (profile & phase fraction)
1366# use: hapinfo hist phase parm action value
1367
1368#     frac -- phase fraction (*)
1369#     frref/frdamp -- refinement flag/damping value for the phase fraction (*)
1370#     proftype -- profile function number (*)
1371#     profterms -- number of profile terms (*)
1372#     pdamp -- damping value for the profile (*)
1373#     pcut -- cutoff value for the profile (*)
1374#     pterm$n -- profile term #n (*)
1375#     pref$n -- refinement flag value for profile term #n (*)
1376#     extmeth -- Fobs extraction method (*)
1377#     POnaxis -- number of defined M-D preferred axes
1378proc hapinfo {histlist phaselist parm "action get" "value {}"} {
1379    foreach phase $phaselist hist $histlist {
1380        if {$phase == ""} {set phase [lindex $phaselist end]}
1381        if {$hist == ""} {set hist [lindex $histlist end]}
1382        if {$hist < 10} {
1383            set hist " $hist"
1384        }
1385        set key "HAP${phase}${hist}"
1386        switch -glob ${parm}-$action {
1387            extmeth-get {
1388                set i1 [expr {($phase - 1)*5}]
1389                set i2 [expr {$i1 + 4}]
1390                return [string trim [string range [readexp "HST $hist EPHAS"] $i1 $i2]]
1391            }
1392            extmeth-set {
1393                set i1 [expr {($phase - 1)*5 + 1}]
1394                if ![validint value 5] {return 0}
1395                setexp "HST $hist EPHAS" $value $i1 5
1396            }
1397            frac-get {
1398                return [string trim [string range [readexp ${key}PHSFR] 0 14]]
1399            }
1400            frac-set {
1401                if ![validreal value 15 6] {return 0}
1402                setexp ${key}PHSFR $value 1 15
1403            }
1404            frref-get {
1405                if {[string toupper [string range [readexp ${key}PHSFR] 19 19]] == "Y"} {
1406                    return 1
1407                }
1408                return 0
1409            }
1410            frref-set {
1411                if $value {
1412                    setexp ${key}PHSFR "Y" 20 1
1413                } else {
1414                    setexp ${key}PHSFR "N" 20 1
1415                }           
1416            }
1417            frdamp-get {
1418                set val [string range [readexp ${key}PHSFR] 24 24]
1419                if {$val == " "} {return 0}
1420                return $val
1421            }
1422            frdamp-set {
1423                setexp ${key}PHSFR $value 25 1
1424            }
1425            proftype-get {
1426                set val [string range [readexp "${key}PRCF "] 0 4]
1427                if {$val == " "} {return 0}
1428                return $val
1429            }
1430            proftype-set {
1431                if ![validint value 5] {return 0}
1432                setexp "${key}PRCF " $value 1 5
1433            }
1434            profterms-get {
1435                set val [string range [readexp "${key}PRCF "] 5 9]
1436                if {$val == " "} {return 0}
1437                return $val
1438            }
1439            profterms-set {
1440                if ![validint value 5] {return 0}
1441                setexp "${key}PRCF " $value 6 5
1442                # now check that all needed entries exist
1443                set lines [expr {1 + ($value - 1) / 4}]
1444                for {set i 1} {$i <= $lines} {incr i} {
1445                    makeexprec "${key}PRCF $i"
1446                }
1447            }
1448            pcut-get {
1449                return [string trim [string range [readexp "${key}PRCF "] 10 19]]
1450            }
1451            pcut-set {
1452                if ![validreal value 10 5] {return 0}
1453                setexp "${key}PRCF " $value 11 10
1454            }
1455            pdamp-get {
1456                set val [string range [readexp "${key}PRCF "] 24 24]
1457                if {$val == " "} {return 0}
1458                return $val
1459            }
1460            pdamp-set {
1461                setexp "${key}PRCF   " $value 25 1
1462            }
1463            pterm*-get {
1464                regsub pterm $parm {} num
1465                set f1 [expr {15*(($num - 1) % 4)}]
1466                set f2 [expr {15*(1 + ($num - 1) % 4)-1}]
1467                set line  [expr {1 + ($num - 1) / 4}]
1468                return [string trim [string range [readexp "${key}PRCF $line"] $f1 $f2] ]
1469            }
1470            pterm*-set {
1471                if ![validreal value 15 6] {return 0}
1472                regsub pterm $parm {} num
1473                set f1 [expr {1+ 15*(($num - 1) % 4)}]
1474                set line  [expr {1 + ($num - 1) / 4}]
1475                setexp "${key}PRCF $line" $value $f1 15
1476            }
1477            pref*-get {
1478                regsub pref $parm {} num
1479                set f [expr {24+$num}]
1480                if {[string toupper [string range [readexp "${key}PRCF  "] $f $f]] == "Y"} {
1481                    return 1
1482                }
1483                return 0
1484            }
1485            pref*-set {
1486                regsub pref $parm {} num
1487                set f [expr {25+$num}]
1488                if $value {
1489                    setexp ${key}PRCF "Y" $f 1
1490                } else {
1491                    setexp ${key}PRCF "N" $f 1
1492                }           
1493            }
1494            POnaxis-get {
1495                set val [string trim \
1496                        [string range [readexp "${key}NAXIS"] 0 4]]
1497                if {$val == ""} {return 0}
1498                return $val
1499            }
1500            POnaxis-set {
1501                if ![validint value 5] {return 0}
1502                # there should be a NAXIS record, but if not make one
1503                if {![existsexp "${key}NAXIS"]} {
1504                    makeexprec "${key}NAXIS"
1505                }
1506                setexp "${key}NAXIS  " $value 1 5
1507            }
1508            default {
1509                set msg "Unsupported hapinfo access: parm=$parm action=$action"
1510                tk_dialog .badexp "Error in readexp" $msg error 0 Exit
1511            }
1512        }
1513    }
1514    return 1
1515}
1516
1517#  get a logical constraint
1518#
1519#  type action
1520#  -----------
1521#  atom get  number        returns a list of constraints.
1522#   "   set  number value  replaces a list of constraints
1523#                          (value is a list of constraints)
1524#   "   add  number value  inserts a new list of constraints
1525#                          (number is ignored)
1526#   "   delete number      deletes a set of constraint entries
1527# Each item in the list of constraints is composed of 4 items:
1528#              phase, atom, variable, multiplier
1529# If variable=UISO atom can be ALL, otherwise atom is a number
1530# legal variable names: FRAC, X, Y, Z, UISO, U11, U22, U33, U12, U23, U13,
1531#                       MX, MY, MZ
1532#
1533#  type action
1534#  -----------
1535#  profileXX get number         returns a list of constraints for term XX=1-36
1536#                               use number=0 to get # of defined
1537#                                  constraints for term XX
1538#   "        set number value   replaces a list of constraints
1539#                               (value is a list of constraints)
1540#   "        add number value   inserts a new list of constraints
1541#                               (number is ignored)
1542#   "        delete number      deletes a set of constraint entries
1543# Each item in the list of constraints is composed of 3 items:
1544#              phase-list, histogram-list, multiplier
1545# Note that phase-list and/or histogram-list can be ALL
1546
1547proc constrinfo {type action number "value {}"} {
1548    switch -glob ${type}-$action {
1549        atom-get {
1550            # does this constraint exist?
1551            set key [format "LNCN%4d%4d" $number 1]
1552            if {![existsexp $key]} {return -1}
1553            set clist {}
1554            for {set i 1} {$i < 999} {incr i} {
1555                set key [format "LNCN%4d%4d" $number $i]
1556                if {![existsexp $key]} break
1557                set line [readexp $key]
1558                set j1 2
1559                set j2 17
1560                set seg [string range $line $j1 $j2]
1561                while {[string trim $seg] != ""} {
1562                    lappend clist [list \
1563                            [string range $seg 0 0] \
1564                            [string trim [string range $seg 1 3]] \
1565                            [string trim [string range $seg 4 7]] \
1566                            [string trim [string range $seg 8 end]]]
1567                    incr j1 16
1568                    incr j2 16
1569                    set seg [string range $line $j1 $j2]
1570                }
1571            }
1572            return $clist
1573        }
1574        atom-set {
1575            # delete records for current constraint
1576            for {set i 1} {$i < 999} {incr i} {
1577                set key [format "LNCN%4d%4d" $number $i]
1578                if {![existsexp $key]} break
1579                delexp $key
1580            }
1581            set line {}
1582            set i 1
1583            foreach tuple $value {
1584                if {[string toupper [lindex $tuple 1]] == "ALL"} {
1585                    set seg [format %1dALL%-4s%8.4f \
1586                            [lindex $tuple 0] \
1587                            [lindex $tuple 2] \
1588                            [lindex $tuple 3]]
1589                } else {
1590                    set seg [eval format %1d%3d%-4s%8.4f $tuple]
1591                }
1592                append line $seg
1593                if {[string length $line] > 50} {
1594                    set key  [format "LNCN%4d%4d" $number $i]
1595                    makeexprec $key
1596                    setexp $key $line 3 68
1597                    set line {}
1598                    incr i
1599                }
1600            }
1601            if {$line != ""} {
1602                set key  [format "LNCN%4d%4d" $number $i]
1603                makeexprec $key
1604                setexp $key $line 3 68
1605            }
1606            return
1607        }
1608        atom-add {
1609            # loop over defined constraints
1610            for {set j 1} {$j < 9999} {incr j} {
1611                set key [format "LNCN%4d%4d" $j 1]
1612                if {![existsexp $key]} break
1613            }
1614            set number $j
1615            # save the constraint
1616            set line {}
1617            set i 1
1618            foreach tuple $value {
1619                if {[string toupper [lindex $tuple 1]] == "ALL"} {
1620                    set seg [format %1dALL%-4s%8.4f \
1621                            [lindex $tuple 0] \
1622                            [lindex $tuple 2] \
1623                            [lindex $tuple 3]]
1624                } else {
1625                    set seg [eval format %1d%3d%-4s%8.4f $tuple]
1626                }
1627                append line $seg
1628                if {[string length $line] > 50} {
1629                    set key  [format "LNCN%4d%4d" $number $i]
1630                    makeexprec $key
1631                    setexp $key $line 3 68
1632                    set line {}
1633                    incr i
1634                }
1635            }
1636            if {$line != ""} {
1637                set key  [format "LNCN%4d%4d" $number $i]
1638                makeexprec $key
1639                setexp $key $line 3 68
1640            }
1641            return
1642        }
1643        atom-delete {
1644            for {set j $number} {$j < 9999} {incr j} {
1645                # delete records for current constraint
1646                for {set i 1} {$i < 999} {incr i} {
1647                    set key [format "LNCN%4d%4d" $j $i]
1648                    if {![existsexp $key]} break
1649                    delexp $key
1650                }
1651                # now copy records, from the next entry, if any
1652                set j1 $j
1653                incr j1
1654                set key1 [format "LNCN%4d%4d" $j1 1]
1655                # if there is no record, there is nothing to copy -- done
1656                if {![existsexp $key1]} return
1657                for {set i 1} {$i < 999} {incr i} {
1658                    set key1 [format "LNCN%4d%4d" $j1 $i]
1659                    if {![existsexp $key1]} break
1660                    set key  [format "LNCN%4d%4d" $j  $i]
1661                    makeexprec $key
1662                    setexp $key [readexp $key1] 1 68
1663                }
1664            }
1665        }
1666        profile*-delete {
1667            regsub profile $type {} term
1668            if {$term < 10} {
1669                set term " $term"
1670            }
1671            set key "LEQV PF$term   "
1672            # return nothing if no term exists
1673            if {![existsexp $key]} {return 0}
1674
1675            # number of constraint terms
1676            set nterms [string trim [string range [readexp ${key}] 0 4] ]
1677            # don't delete a non-existing entry
1678            if {$number > $nterms} {return 0}
1679            set val [expr {$nterms - 1}]
1680            validint val 5
1681            setexp $key $val 1 5
1682            for {set i1 $number} {$i1 < $nterms} {incr i1} {
1683                set i2 [expr {1 + $i1}]
1684                # move the contents of constraint #i2 -> i1
1685                if {$i1 > 9} {
1686                    set k1 [expr {($i1+1)/10}]
1687                    set l1 $i1
1688                } else {
1689                    set k1 " "
1690                    set l1 " $i1"
1691                }
1692                set key1 "LEQV PF$term  $k1"
1693                # number of constraint lines for #i1
1694                set n1 [string trim [string range [readexp ${key1}] \
1695                        [expr {($i1%10)*5}] [expr {4+(($i1%10)*5)}]] ]
1696                if {$i2 > 9} {
1697                    set k2 [expr {($i2+1)/10}]
1698                    set l2 $i2
1699                } else {
1700                    set k2 " "
1701                    set l2 " $i2"
1702                }
1703                set key2 "LEQV PF$term  $k2"
1704                # number of constraint lines for #i2
1705                set n2 [string trim [string range [readexp ${key2}] \
1706                        [expr {($i2%10)*5}] [expr {4+(($i2%10)*5)}]] ]
1707                set val $n2
1708                validint val 5
1709                # move the # of terms
1710                setexp $key1 $val [expr {1+(($i1%10)*5)}] 5
1711                # move the terms
1712                for {set j 1} {$j <= $n2} {incr j 1} {
1713                    set key "LEQV PF${term}${l1}$j"
1714                    makeexprec $key
1715                    setexp $key [readexp "LEQV PF${term}${l2}$j"] 1 68
1716                }
1717                # delete any remaining lines
1718                for {set j [expr {$n2+1}]} {$j <= $n1} {incr j 1} {
1719                    delexp "LEQV PF${term}${l1}$j"
1720                }
1721            }
1722
1723            # clear the last term
1724            if {$nterms > 9} {
1725                set i [expr {($nterms+1)/10}]
1726            } else {
1727                set i " "
1728            }
1729            set key "LEQV PF$term  $i"
1730            set cb [expr {($nterms%10)*5}]
1731            set ce [expr {4+(($nterms%10)*5)}]
1732            set n2 [string trim [string range [readexp ${key}] $cb $ce] ]
1733            incr cb
1734            setexp $key "     " $cb 5
1735            # delete any remaining lines
1736            for {set j 1} {$j <= $n2} {incr j 1} {
1737                delexp "LEQV PF${term}${nterms}$j"
1738            }
1739        }
1740        profile*-set {
1741            regsub profile $type {} term
1742            if {$term < 10} {
1743                set term " $term"
1744            }
1745            set key "LEQV PF$term   "
1746            # get number of constraint terms
1747            set nterms [string trim [string range [readexp ${key}] 0 4] ]
1748            # don't change a non-existing entry
1749            if {$number > $nterms} {return 0}
1750            if {$number > 9} {
1751                set k1 [expr {($number+1)/10}]
1752                set l1 $number
1753            } else {
1754                set k1 " "
1755                set l1 " $number"
1756            }
1757            set key1 "LEQV PF$term  $k1"
1758            # old number of constraint lines
1759            set n1 [string trim [string range [readexp ${key1}] \
1760                    [expr {($number%10)*5}] [expr {4+(($number%10)*5)}]] ]
1761            # number of new constraints
1762            set j2 [llength $value]
1763            # number of new constraint lines
1764            set val [set n2 [expr {($j2 + 2)/3}]]
1765            # store the new # of lines
1766            validint val 5
1767            setexp $key1 $val [expr {1+(($number%10)*5)}] 5
1768
1769            # loop over the # of lines in the old or new, whichever is greater
1770            set v0 0
1771            for {set j 1} {$j <= [expr {($n1 > $n2) ? $n1 : $n2}]} {incr j 1} {
1772                set key "LEQV PF${term}${l1}$j"
1773                # were there more lines in the old?
1774                if {$j > $n2} {
1775                    # this line is not needed
1776                    if {$j % 3 == 1} {
1777                        delexp %key
1778                    }
1779                    continue
1780                }
1781                # are we adding new lines?
1782                if {$j > $n1} {
1783                    makeexprec $key
1784                }
1785                # add the three constraints to the line
1786                foreach s {3 23 43} \
1787                        item [lrange $value $v0 [expr {2+$v0}]] {
1788                    if {$item != ""} {
1789                        set val [format %-10s%9.3f \
1790                                [lindex $item 0],[lindex $item 1] \
1791                                [lindex $item 2]]
1792                        setexp $key $val $s 19
1793                    } else {
1794                        setexp $key " " $s 19
1795                    }
1796                }
1797                incr v0 3
1798            }
1799        }
1800        profile*-add {
1801            regsub profile $type {} term
1802            if {$term < 10} {
1803                set term " $term"
1804            }
1805            set key "LEQV PF$term   "
1806            if {![existsexp $key]} {makeexprec $key}
1807            set nterms [string trim [string range [readexp ${key}] 0 4] ]
1808            if {$nterms == ""} {
1809                set nterms 1
1810            } elseif {$nterms >= 99} {
1811                return 0
1812            } else {
1813                incr nterms
1814            }
1815            # store the new # of constraints
1816            set val $nterms
1817            validint val 5
1818            setexp $key $val 1 5
1819
1820            if {$nterms > 9} {
1821                set k1 [expr {($nterms+1)/10}]
1822                set l1 $nterms
1823            } else {
1824                set k1 " "
1825                set l1 " $nterms"
1826            }
1827            set key1 "LEQV PF$term  $k1"
1828
1829            # number of new constraints
1830            set j2 [llength $value]
1831            # number of new constraint lines
1832            set val [set n2 [expr {($j2 + 2)/3}]]
1833            # store the new # of lines
1834            validint val 5
1835            setexp $key1 $val [expr {1+(($nterms%10)*5)}] 5
1836
1837            # loop over the # of lines to be added
1838            set v0 0
1839            for {set j 1} {$j <= $n2} {incr j 1} {
1840                set key "LEQV PF${term}${l1}$j"
1841                makeexprec $key
1842                # add the three constraints to the line
1843                foreach s {3 23 43} \
1844                        item [lrange $value $v0 [expr {2+$v0}]] {
1845                    if {$item != ""} {
1846                        set val [format %-10s%9.3f \
1847                                [lindex $item 0],[lindex $item 1] \
1848                                [lindex $item 2]]
1849                        setexp $key $val $s 19
1850                    } else {
1851                        setexp $key " " $s 19
1852                    }
1853                }
1854                incr v0 3
1855            }
1856        }
1857        profile*-get {
1858            regsub profile $type {} term
1859            if {$term < 10} {
1860                set term " $term"
1861            }
1862            if {$number > 9} {
1863                set i [expr {($number+1)/10}]
1864            } else {
1865                set i " "
1866            }
1867            set key "LEQV PF$term  $i"
1868            # return nothing if no term exists
1869            if {![existsexp $key]} {return 0}
1870            # number of constraint lines
1871           
1872            set numline [string trim [string range [readexp ${key}] \
1873                    [expr {($number%10)*5}] [expr {4+(($number%10)*5)}]] ]
1874            if {$number == 0} {return $numline}
1875            set clist {}
1876            if {$number < 10} {
1877                set number " $number"
1878            }
1879            for {set i 1} {$i <= $numline} {incr i} {
1880                set key "LEQV PF${term}${number}$i"
1881                set line [readexp ${key}]
1882                foreach s {1 21 41} e {20 40 60} {
1883                    set seg [string range $line $s $e]
1884                    if {[string trim $seg] == ""} continue
1885                    # parse the string segment
1886                    set parse [regexp { *([0-9AL]+),([0-9AL]+) +([0-9.]+)} \
1887                            $seg junk phase hist mult]
1888                    # was parse successful
1889                    if {!$parse} {continue}
1890                    lappend clist [list $phase $hist $mult]
1891                }
1892            }
1893            return $clist
1894        }
1895        default {
1896            set msg "Unsupported constrinfo access: type=$type action=$action"
1897            tk_dialog .badexp "Error in readexp access" $msg error 0 OK
1898        }
1899
1900    }
1901}
1902
1903# read the default profile information for a histogram
1904# use: profdefinfo hist set# parm action
1905
1906#     proftype -- profile function number
1907#     profterms -- number of profile terms
1908#     pdamp -- damping value for the profile (*)
1909#     pcut -- cutoff value for the profile (*)
1910#     pterm$n -- profile term #n
1911#     pref$n -- refinement flag value for profile term #n (*)
1912
1913proc profdefinfo {hist set parm "action get"} {
1914    global expgui
1915    if {$hist < 10} {
1916        set key "HST  $hist"
1917    } else {
1918        set key "HST $hist"
1919    }
1920    switch -glob ${parm}-$action {
1921        proftype-get {
1922            set val [string range [readexp "${key}PRCF$set"] 0 4]
1923            if {$val == " "} {return 0}
1924            return $val
1925        }
1926        profterms-get {
1927            set val [string range [readexp "${key}PRCF$set"] 5 9]
1928            if {$val == " "} {return 0}
1929            return $val
1930        }
1931        pcut-get {
1932            return [string trim [string range [readexp "${key}PRCF$set"] 10 19]]
1933        }
1934        pdamp-get {
1935                set val [string range [readexp "${key}PRCF$set"] 24 24]
1936            if {$val == " "} {return 0}
1937            return $val
1938        }
1939        pterm*-get {
1940            regsub pterm $parm {} num
1941            set f1 [expr {15*(($num - 1) % 4)}]
1942            set f2 [expr {15*(1 + ($num - 1) % 4)-1}]
1943            set line  [expr {1 + ($num - 1) / 4}]
1944            return [string trim [string range [\
1945                        readexp "${key}PRCF${set}$line"] $f1 $f2] ]
1946        }
1947        pref*-get {
1948            regsub pref $parm {} num
1949            set f [expr {24+$num}]
1950            if {[string toupper [string range [readexp "${key}PRCF$set"] $f $f]] == "Y"} {
1951                return 1
1952            }
1953            return 0
1954        }
1955        default {
1956            set msg "Unsupported profdefinfo access: parm=$parm action=$action"
1957            tk_dialog .badexp "Code Error" $msg error 0 Exit
1958        }
1959    }
1960}
1961
1962# get March-Dollase preferred orientation information
1963# use MDprefinfo hist phase axis-number parm action value
1964#    ratio    -- ratio of xtallites in PO direction vs random (>1 for more)
1965#    fraction -- fraction in this direction, when more than one axis is used
1966#    h k & l  -- indices of P.O. axis
1967#    ratioref -- flag to vary ratio
1968#    fracref  -- flag to vary fraction
1969#    damp     -- damping value
1970#    type     -- model type (0 = P.O. _|_ to beam, 1 = || to beam)
1971#    new      -- creates a new record with default values (set only)
1972proc MDprefinfo {histlist phaselist axislist parm "action get" "value {}"} {
1973    foreach phase $phaselist hist $histlist axis $axislist {
1974        if {$phase == ""} {set phase [lindex $phaselist end]}
1975        if {$hist == ""} {set hist [lindex $histlist end]}
1976        if {$axis == ""} {set axis [lindex $axislist end]}
1977        if {$hist < 10} {
1978            set hist " $hist"
1979        }
1980        if {$axis > 9} {
1981            set axis "0"
1982        }
1983        set key "HAP${phase}${hist}PREFO${axis}"
1984        switch -glob ${parm}-$action {
1985            ratio-get {
1986                return [string trim [string range [readexp $key] 0 9]]
1987            }
1988            ratio-set {
1989                if ![validreal value 10 6] {return 0}
1990                setexp $key $value 1 10
1991            }
1992            fraction-get {
1993                return [string trim [string range [readexp $key] 10 19]]
1994            }
1995            fraction-set {
1996                if ![validreal value 10 6] {return 0}
1997                setexp $key $value 11 10
1998            }
1999            h-get {
2000                set h [string trim [string range [readexp $key] 20 29]]
2001                # why not allow negative h values?
2002                #               if {$h < 1} {return 0}
2003                return $h
2004            }
2005            h-set {
2006                if ![validreal value 10 2] {return 0}
2007                setexp $key $value 21 10
2008            }
2009            k-get {
2010                set k [string trim [string range [readexp $key] 30 39]]
2011                #               if {$k < 1} {return 0}
2012                return $k
2013            }
2014            k-set {
2015                if ![validreal value 10 2] {return 0}
2016                setexp $key $value 31 10
2017            }
2018            l-get {
2019                set l [string trim [string range [readexp $key] 40 49]]
2020                #if {$l < 1} {return 0}
2021                return $l
2022            }
2023            l-set {
2024                if ![validreal value 10 2] {return 0}
2025                setexp $key $value 41 10
2026            }
2027            ratioref-get {
2028                if {[string toupper \
2029                        [string range [readexp $key] 53 53]] == "Y"} {
2030                    return 1
2031                }
2032                return 0
2033            }
2034            ratioref-set {
2035                if $value {
2036                    setexp $key "Y" 54 1
2037                } else {
2038                    setexp $key "N" 54 1
2039                }
2040            }
2041            fracref-get {
2042                if {[string toupper \
2043                        [string range [readexp $key] 54 54]] == "Y"} {
2044                    return 1
2045                }
2046                return 0
2047            }
2048            fracref-set {
2049                if $value {
2050                    setexp $key "Y" 55 1
2051                } else {
2052                    setexp $key "N" 55 1
2053              }
2054            }
2055            damp-get {
2056                set val [string trim [string range [readexp $key] 59 59]]
2057                if {$val == " "} {return 0}
2058                return $val
2059            }
2060            damp-set {
2061                setexp $key $value 60 1
2062            }
2063            type-get {
2064                set val [string trim [string range [readexp $key] 64 64]]
2065                if {$val == " "} {return 0}
2066                return $val
2067            }
2068            type-set {
2069                # only valid settings are 0 & 1
2070                if {$value != "0" && $value != "1"} {set value "0"}
2071                setexp $key $value 65 1
2072            }
2073            new-set {
2074                makeexprec $key
2075                setexp $key \
2076                        {  1.000000  1.000000  0.000000  0.000000  1.000000   NN    0    0} \
2077                        1 68
2078            }
2079            default {
2080                set msg "Unsupported MDprefinfo access: parm=$parm action=$action"
2081                tk_dialog .badexp "Error in readexp" $msg error 0 Exit
2082            }
2083
2084        }
2085
2086    }
2087}
2088
2089# write the .EXP file
2090proc expwrite {expfile} {
2091    global exparray
2092    set blankline \
2093     "                                                                        "
2094    set fp [open ${expfile} w]
2095    fconfigure $fp -translation crlf
2096    set keylist [lsort [array names exparray]]
2097    # reorder the keys so that VERSION comes 1st
2098    set pos [lsearch -exact $keylist {     VERSION}]
2099    set keylist "{     VERSION} [lreplace $keylist $pos $pos]"
2100    foreach key $keylist {
2101        puts $fp [string range \
2102                "$key$exparray($key)$blankline" 0 79]
2103    }
2104    close $fp
2105}
2106
2107# history commands -- delete all but last $keep history records,
2108# renumber if $renumber is true
2109proc DeleteHistory {keep renumber} {
2110    global exparray
2111    foreach y [lrange [lsort -decreasing \
2112            [array names exparray {    HSTRY*}]] $keep end] {
2113        unset exparray($y)
2114    }
2115    if !$renumber return
2116    # renumber
2117    set i 0
2118    foreach y [lsort -increasing \
2119            [array names exparray {    HSTRY*}]] {
2120        set key [format "    HSTRY%3d" [incr i]]
2121        set exparray($key) $exparray($y)
2122        unset exparray($y)
2123    }
2124    # list all history
2125    #    foreach y [lsort -decreasing [array names exparray {    HSTRY*}]] {puts "$y $exparray($y)"}
2126}
2127
2128proc CountHistory {} {
2129    global exparray
2130    return [llength [array names exparray {    HSTRY*}]]
2131}
2132
2133# set the phase flags for histogram $hist to $plist
2134proc SetPhaseFlag {hist plist} {
2135    # make a 2 digit key -- hh
2136    if {$hist < 10} {
2137        set hh " $hist"
2138    } else {
2139        set hh $hist
2140    }
2141    set key "HST $hh NPHAS"
2142    set str {}
2143    foreach iph {1 2 3 4 5 6 7 8 9} {
2144        if {[lsearch $plist $iph] != -1} {
2145            append str {    1}
2146        } else {
2147            append str {    0}     
2148        }
2149    }
2150    setexp $key $str 1 68
2151}
2152
2153# erase atom $atom from phase $phase
2154# update the list of atom types, erasing the record if not needed.
2155proc EraseAtom {atom phase} {
2156    set type [atominfo $phase $atom type]
2157    if {$type == ""} return
2158    if {$atom < 10} {
2159        set key "CRS$phase  AT  $atom"
2160    } elseif {$atom < 100} {
2161        set key "CRS$phase  AT $atom"
2162    } else {
2163        set key "CRS$phase  AT$atom"
2164    }
2165    # delete the records for the atom
2166    global exparray
2167    foreach k [array names exparray ${key}*] {
2168        delexp $k
2169    }
2170    # change the number of atoms in the phase
2171    phaseinfo $phase natoms set [expr {[phaseinfo $phase natoms] -1}]
2172
2173    # now adjust numbers in "EXPR ATYP" records and delete, if needed.
2174    set natypes [readexp " EXPR  NATYP"]
2175    if {$natypes == ""} return
2176    set j 0
2177    for {set i 1} {$i <= $natypes} {incr i} {
2178        incr j
2179        if {$j <10} {
2180            set key " EXPR ATYP $j"
2181        } else {
2182            set key " EXPR ATYP$j"
2183        }
2184        while {![existsexp $key]} {
2185            incr j
2186            if {$j > 99} {
2187                return
2188            } elseif {$j <10} {
2189                set key " EXPR ATYP $j"
2190            } else {
2191                set key " EXPR ATYP$j"
2192            }
2193        }
2194        set keytype [string trim [string range $exparray($key) 2 9]]
2195        if {$type == $keytype} {
2196            # found the type record
2197            set val [string trim [string range $exparray($key) 10 14]]
2198            incr val -1
2199            # if this is the last reference, remove the record,
2200            # otherwise, decrement the counter
2201            if {$val <= 0} {
2202                incr natypes -1 
2203                validint natypes 5
2204                setexp " EXPR  NATYP" $natypes 1 5
2205                delexp $key
2206            } else {
2207                validint val 5
2208                setexp $key $val 11 5
2209            }
2210            return
2211        }
2212    }
2213}
2214
2215# compute equivalent anisotropic temperature factor for Uequiv
2216proc CalcAniso {phase Uequiv} {
2217    foreach var {a b c alpha beta gamma} {
2218        set $var [phaseinfo $phase $var]
2219    }
2220
2221    set G(1,1) [expr {$a * $a}]
2222    set G(2,2) [expr {$b * $b}]
2223    set G(3,3) [expr {$c * $c}]
2224    set G(1,2) [expr {$a * $b * cos($gamma*0.017453292519943)}]
2225    set G(2,1) $G(1,2)
2226    set G(1,3) [expr {$a * $c * cos($beta *0.017453292519943)}]
2227    set G(3,1) $G(1,3)
2228    set G(2,3) [expr {$b * $c * cos($alpha*0.017453292519943)}]
2229    set G(3,2) $G(2,3)
2230
2231    # Calculate the volume**2
2232    set v2 0.0
2233    foreach i {1 2 3} {
2234        set J [expr {($i%3) + 1}]
2235        set K [expr {(($i+1)%3) + 1}]
2236        set v2 [expr {$v2+ $G(1,$i)*($G(2,$J)*$G(3,$K)-$G(3,$J)*$G(2,$K))}]
2237    }
2238    if {$v2 > 0} {
2239        set v [expr {sqrt($v2)}]
2240        foreach i {1 2 3} {
2241            set i1 [expr {($i%3) + 1}]
2242            set i2 [expr {(($i+1)%3) + 1}]
2243            foreach j {1 2 3} {
2244                set j1 [expr {($j%3) + 1}]
2245                set j2 [expr {(($j+1)%3) + 1}]
2246                set C($j,$i) [expr {(\
2247                        $G($i1,$j1) * $G($i2,$j2) - \
2248                        $G($i1,$j2)  * $G($i2,$j1)\
2249                        )/ $v}]
2250            }
2251        }
2252        set A(1,2) [expr {0.5 * ($C(1,2)+$C(2,1)) / sqrt( $C(1,1)* $C(2,2) )}]
2253        set A(1,3) [expr {0.5 * ($C(1,3)+$C(3,1)) / sqrt( $C(1,1)* $C(3,3) )}]
2254        set A(2,3) [expr {0.5 * ($C(2,3)+$C(3,2)) / sqrt( $C(2,2)* $C(3,3) )}]
2255        foreach i {1 1 2} j {2 3 3} {
2256            set A($i,$j) [expr {0.5 * ($C($i,$j) + $C($j,$i)) / \
2257                    sqrt( $C($i,$i)* $C($j,$j) )}]
2258            # clean up roundoff
2259            if {abs($A($i,$j)) < 1e-5} {set A($i,$j) 0.0}
2260        }
2261    } else {
2262        set A(1,2) 0.0
2263        set A(1,3) 0.0
2264        set A(2,3) 0.0
2265    }
2266    return "$Uequiv $Uequiv $Uequiv \
2267            [expr {$Uequiv * $A(1,2)}] \
2268            [expr {$Uequiv * $A(1,3)}] \
2269            [expr {$Uequiv * $A(2,3)}]"
2270}
Note: See TracBrowser for help on using the repository browser.