source: trunk/readexp.tcl @ 396

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

# on 2001/06/29 17:54:33, toby did:
brace expr's for better speed
support refinement options: Marquardt, convergence, LeBail? damping
get tmin,tmax (for Cheb. computation)

  • Property rcs:author set to toby
  • Property rcs:date set to 2001/06/29 17:54:33
  • Property rcs:lines set to +147 -103
  • Property rcs:rev set to 1.27
  • Property rcs:state set to Exp
  • Property svn:keywords set to Author Date Revision Id
File size: 59.9 KB
Line 
1# $Id: readexp.tcl 396 2009-12-04 23:05:28Z toby $
2# Routines to deal with the .EXP "data structure"
3set expmap(Revision) {$Revision: 396 $ $Date: 2009-12-04 23:05:28 +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
993proc histinfo {histlist parm "action get" "value {}"} {
994    global expgui
995    foreach hist $histlist {
996        if {$hist < 10} {
997            set key "HST  $hist"
998        } else {
999            set key "HST $hist"
1000        }
1001        switch -glob ${parm}-$action {
1002            foextract-get {
1003                set line [readexp "${key} EPHAS"]
1004                # add a EPHAS if not exists
1005                if {$line == {}} {
1006                    makeexprec "${key} EPHAS"
1007                    # expedt defaults this to "F", but I think "T" is better
1008                    setexp "${key} EPHAS" "Y" 50 1
1009                    if $expgui(debug) {puts "Warning: creating a ${key} EPHAS record"}
1010                }
1011                if {[string toupper [string range $line 49 49]] == "T"} {
1012                    return 1
1013                }
1014                # the flag has changed to "Y/N" in the latest versions
1015                # of GSAS
1016                if {[string toupper [string range $line 49 49]] == "Y"} {
1017                    return 1
1018                }
1019                return 0
1020            }
1021            foextract-set {
1022                # the flag has changed to "Y/N" in the latest versions
1023                # of GSAS
1024                if $value {
1025                    setexp "${key} EPHAS" "Y" 50 1
1026                } else {
1027                    setexp "${key} EPHAS" "N" 50 1
1028                }
1029            }
1030            LBdamp-get {
1031                set v [string trim [string range [readexp "${key} EPHAS"] 54 54]]
1032                if {$v == ""} {return 0}
1033                return $v
1034            }
1035            LBdamp-set {
1036                if ![validint value 5] {return 0}
1037                setexp "${key} EPHAS" $value 51 5
1038            }
1039            title-get {
1040                return [string trim [readexp "${key}  HNAM"] ]
1041            }
1042            scale-get {
1043                return [string trim [string range [readexp ${key}HSCALE] 0 14]]
1044            }
1045            scale-set {
1046                if ![validreal value 15 6] {return 0}
1047                setexp ${key}HSCALE $value 1 15
1048            }
1049            sref-get {
1050                if {[string toupper [string range [readexp ${key}HSCALE] 19 19]] == "Y"} {
1051                    return 1
1052                }
1053                return 0
1054            }
1055            sref-set {
1056                if $value {
1057                    setexp ${key}HSCALE "Y" 20 1
1058                } else {
1059                    setexp ${key}HSCALE "N" 20 1
1060                }           
1061            }
1062            sdamp-get {
1063                set val [string range [readexp ${key}HSCALE] 24 24]
1064                if {$val == " "} {return 0}
1065                return $val
1066            }
1067            sdamp-set {
1068                setexp ${key}HSCALE $value 25 1
1069            }
1070
1071            difc-get -
1072            lam1-get {
1073                return [string trim [string range [readexp "${key} ICONS"] 0 9]]
1074            }
1075            difc-set -
1076            lam1-set {
1077                if ![validreal value 10 7] {return 0}
1078                setexp "${key} ICONS" $value 1 10
1079            }
1080            difa-get -
1081            lam2-get {
1082                return [string trim [string range [readexp "${key} ICONS"] 10 19]]
1083            }
1084            difa-set -
1085            lam2-set {
1086                if ![validreal value 10 7] {return 0}
1087                setexp "${key} ICONS" $value 11 10
1088            }
1089            zero-get {
1090                return [string trim [string range [readexp "${key} ICONS"] 20 29]]
1091            }
1092            zero-set {
1093                if ![validreal value 10 5] {return 0}
1094                setexp "${key} ICONS" $value 21 10
1095            }
1096            ipola-get {
1097                return [string trim [string range [readexp "${key} ICONS"] 54 54]]
1098            }
1099            ipola-set {
1100                if ![validint value 1] {return 0}
1101                setexp "${key} ICONS" $value 55 1
1102            }
1103            pola-get {
1104                return [string trim [string range [readexp "${key} ICONS"] 40 49]]
1105            }
1106            pola-set {
1107                if ![validreal value 10 5] {return 0}
1108                setexp "${key} ICONS" $value 41 10
1109            }
1110            kratio-get {
1111                return [string trim [string range [readexp "${key} ICONS"] 55 64]]
1112            }
1113            kratio-set {
1114                if ![validreal value 10 5] {return 0}
1115                setexp "${key} ICONS" $value 56 10
1116            }
1117
1118            wref-get {
1119            #------------------------------------------------------
1120            # col 33: refine flag for lambda, difc, ratio and theta
1121            #------------------------------------------------------
1122                if {[string toupper [string range \
1123                        [readexp "${key} ICONS"] 32 32]] == "L"} {
1124                    return 1
1125                }
1126                return 0
1127            }
1128            wref-set {
1129                if $value {
1130                    setexp "${key} ICONS" "L" 33 1
1131                } else {
1132                    setexp "${key} ICONS" " " 33 1
1133                }           
1134            }
1135            ratref-get {
1136                if {[string toupper [string range \
1137                        [readexp "${key} ICONS"] 32 32]] == "R"} {
1138                    return 1
1139                }
1140                return 0
1141            }
1142            ratref-set {
1143                if $value {
1144                    setexp "${key} ICONS" "R" 33 1
1145                } else {
1146                    setexp "${key} ICONS" " " 33 1
1147                }           
1148            }
1149            dcref-get {
1150                if {[string toupper [string range \
1151                        [readexp "${key} ICONS"] 32 32]] == "C"} {
1152                    return 1
1153                }
1154                return 0
1155            }
1156            dcref-set {
1157                if $value {
1158                    setexp "${key} ICONS" "C" 33 1
1159                } else {
1160                    setexp "${key} ICONS" " " 33 1
1161                }           
1162            }
1163            ttref-get {
1164                if {[string toupper [string range \
1165                        [readexp "${key} ICONS"] 32 32]] == "T"} {
1166                    return 1
1167                }
1168                return 0
1169            }
1170            ttref-set {
1171                if $value {
1172                    setexp "${key} ICONS" "T" 33 1
1173                } else {
1174                    setexp "${key} ICONS" " " 33 1
1175                }           
1176            }
1177
1178
1179            pref-get {
1180            #------------------------------------------------------
1181            # col 34: refine flag for POLA & DIFA
1182            #------------------------------------------------------
1183                if {[string toupper [string range \
1184                        [readexp "${key} ICONS"] 33 33]] == "P"} {
1185                    return 1
1186                }
1187                return 0
1188            }
1189            pref-set {
1190                if $value {
1191                    setexp "${key} ICONS" "P" 34 1
1192                } else {
1193                    setexp "${key} ICONS" " " 34 1
1194                }           
1195            }
1196            daref-get {
1197                if {[string toupper [string range \
1198                        [readexp "${key} ICONS"] 33 33]] == "A"} {
1199                    return 1
1200                }
1201                return 0
1202            }
1203            daref-set {
1204                if $value {
1205                    setexp "${key} ICONS" "A" 34 1
1206                } else {
1207                    setexp "${key} ICONS" " " 34 1
1208                }           
1209            }
1210
1211            zref-get {
1212            #------------------------------------------------------
1213            # col 34: refine flag for zero correction
1214            #------------------------------------------------------
1215                if {[string toupper [string range [readexp "${key} ICONS"] 34 34]] == "Z"} {
1216                    return 1
1217                }
1218                return 0
1219            }
1220            zref-set {
1221                if $value {
1222                    setexp "${key} ICONS" "Z" 35 1
1223                } else {
1224                    setexp "${key} ICONS" " " 35 1
1225                }           
1226            }
1227
1228            ddamp-get {
1229                set val [string range [readexp "${key} ICONS"] 39 39]
1230                if {$val == " "} {return 0}
1231                return $val
1232            }
1233            ddamp-set {
1234                setexp "${key} ICONS" $value 40 1
1235            }
1236
1237            backtype-get {
1238                set val [string trim [string range [readexp "${key}BAKGD "] 0 4]]
1239                if {$val == " "} {return 0}
1240                return $val
1241            }
1242            backtype-set {
1243                if ![validint value 5] {return 0}
1244                setexp "${key}BAKGD " $value 1 5
1245            }
1246            backterms-get {
1247                set val [string trim [string range [readexp "${key}BAKGD "] 5 9]]
1248                if {$val == " "} {return 0}
1249                return $val
1250            }
1251            backterms-set {
1252                # this takes a bit of work -- if terms are added, add lines as needed to the .EXP
1253                set oldval [string trim [string range [readexp "${key}BAKGD "] 5 9]]
1254                if ![validint value 5] {return 0}
1255                if {$oldval < $value} {
1256                    set line1  [expr {2 + ($oldval - 1) / 4}]
1257                    set line2  [expr {1 + ($value - 1) / 4}]
1258                    for {set i $line1} {$i <= $line2} {incr i} {
1259                        # create a blank entry if needed
1260                        makeexprec ${key}BAKGD$i
1261                    }
1262                    incr oldval
1263                    for {set num $oldval} {$num <= $value} {incr num} {
1264                        set f1 [expr {15*(($num - 1) % 4)}]
1265                        set f2 [expr {15*(1 + ($num - 1) % 4)-1}]
1266                        set line  [expr {1 + ($num - 1) / 4}]
1267                        if {[string trim [string range [readexp ${key}BAKGD$line] $f1 $f2]] == ""} {
1268                            set f1 [expr {15*(($num - 1) % 4)+1}]
1269                            setexp ${key}BAKGD$line 0.0 $f1 15                 
1270                        }
1271                    }
1272                }
1273                setexp "${key}BAKGD " $value 6 5
1274
1275            }
1276            bref-get {
1277                if {[string toupper [string range [readexp "${key}BAKGD"] 14 14]] == "Y"} {
1278                    return 1
1279                }
1280                return 0
1281            }
1282            bref-set {
1283                if $value {
1284                    setexp "${key}BAKGD "  "Y" 15 1
1285                } else {
1286                    setexp "${key}BAKGD "  "N" 15 1
1287                }
1288            }
1289            bdamp-get {
1290                set val [string range [readexp "${key}BAKGD "] 19 19]
1291                if {$val == " "} {return 0}
1292                return $val
1293            }
1294            bdamp-set {
1295                setexp "${key}BAKGD " $value 20 1
1296            }
1297            bterm*-get {
1298                regsub bterm $parm {} num
1299                set f1 [expr {15*(($num - 1) % 4)}]
1300                set f2 [expr {15*(1 + ($num - 1) % 4)-1}]
1301                set line  [expr {1 + ($num - 1) / 4}]
1302                return [string trim [string range [readexp ${key}BAKGD$line] $f1 $f2] ]
1303            }
1304            bterm*-set {
1305                regsub bterm $parm {} num
1306                if ![validreal value 15 6] {return 0}
1307                set f1 [expr {15*(($num - 1) % 4)+1}]
1308                set line  [expr {1 + ($num - 1) / 4}]
1309                setexp ${key}BAKGD$line $value $f1 15
1310            }
1311            bank-get {
1312                return [string trim [string range [readexp "${key} BANK"] 0 4]]
1313            }
1314            tofangle-get {
1315                return [string trim [string range [readexp "${key}BNKPAR"] 10 19]]
1316            }
1317            tmin-get {
1318                return [string trim [string range [readexp "${key} TRNGE"] 0 9]]
1319            }
1320            tmax-get {
1321                return [string trim [string range [readexp "${key} TRNGE"] 10 19]]
1322            }
1323            default {
1324                set msg "Unsupported histinfo access: parm=$parm action=$action"
1325                tk_dialog .badexp "Error in readexp" $msg error 0 Exit
1326            }
1327        }
1328    }
1329    return 1
1330}
1331
1332# read the information that differs by both histogram and phase (profile & phase fraction)
1333# use: hapinfo hist phase parm action value
1334
1335#     frac -- phase fraction (*)
1336#     frref/frdamp -- refinement flag/damping value for the phase fraction (*)
1337#     proftype -- profile function number (*)
1338#     profterms -- number of profile terms (*)
1339#     pdamp -- damping value for the profile (*)
1340#     pcut -- cutoff value for the profile (*)
1341#     pterm$n -- profile term #n (*)
1342#     pref$n -- refinement flag value for profile term #n (*)
1343#     extmeth -- Fobs extraction method (*)
1344#     POnaxis -- number of defined M-D preferred axes
1345proc hapinfo {histlist phaselist parm "action get" "value {}"} {
1346    foreach phase $phaselist hist $histlist {
1347        if {$phase == ""} {set phase [lindex $phaselist end]}
1348        if {$hist == ""} {set hist [lindex $histlist end]}
1349        if {$hist < 10} {
1350            set hist " $hist"
1351        }
1352        set key "HAP${phase}${hist}"
1353        switch -glob ${parm}-$action {
1354            extmeth-get {
1355                set i1 [expr {($phase - 1)*5}]
1356                set i2 [expr {$i1 + 4}]
1357                return [string trim [string range [readexp "HST $hist EPHAS"] $i1 $i2]]
1358            }
1359            extmeth-set {
1360                set i1 [expr {($phase - 1)*5 + 1}]
1361                if ![validint value 5] {return 0}
1362                setexp "HST $hist EPHAS" $value $i1 5
1363            }
1364            frac-get {
1365                return [string trim [string range [readexp ${key}PHSFR] 0 14]]
1366            }
1367            frac-set {
1368                if ![validreal value 15 6] {return 0}
1369                setexp ${key}PHSFR $value 1 15
1370            }
1371            frref-get {
1372                if {[string toupper [string range [readexp ${key}PHSFR] 19 19]] == "Y"} {
1373                    return 1
1374                }
1375                return 0
1376            }
1377            frref-set {
1378                if $value {
1379                    setexp ${key}PHSFR "Y" 20 1
1380                } else {
1381                    setexp ${key}PHSFR "N" 20 1
1382                }           
1383            }
1384            frdamp-get {
1385                set val [string range [readexp ${key}PHSFR] 24 24]
1386                if {$val == " "} {return 0}
1387                return $val
1388            }
1389            frdamp-set {
1390                setexp ${key}PHSFR $value 25 1
1391            }
1392            proftype-get {
1393                set val [string range [readexp "${key}PRCF "] 0 4]
1394                if {$val == " "} {return 0}
1395                return $val
1396            }
1397            proftype-set {
1398                if ![validint value 5] {return 0}
1399                setexp "${key}PRCF " $value 1 5
1400            }
1401            profterms-get {
1402                set val [string range [readexp "${key}PRCF "] 5 9]
1403                if {$val == " "} {return 0}
1404                return $val
1405            }
1406            profterms-set {
1407                if ![validint value 5] {return 0}
1408                setexp "${key}PRCF " $value 6 5
1409                # now check that all needed entries exist
1410                set lines [expr {1 + ($value - 1) / 4}]
1411                for {set i 1} {$i <= $lines} {incr i} {
1412                    makeexprec "${key}PRCF $i"
1413                }
1414            }
1415            pcut-get {
1416                return [string trim [string range [readexp "${key}PRCF "] 10 19]]
1417            }
1418            pcut-set {
1419                if ![validreal value 10 5] {return 0}
1420                setexp "${key}PRCF " $value 11 10
1421            }
1422            pdamp-get {
1423                set val [string range [readexp "${key}PRCF "] 24 24]
1424                if {$val == " "} {return 0}
1425                return $val
1426            }
1427            pdamp-set {
1428                setexp "${key}PRCF   " $value 25 1
1429            }
1430            pterm*-get {
1431                regsub pterm $parm {} num
1432                set f1 [expr {15*(($num - 1) % 4)}]
1433                set f2 [expr {15*(1 + ($num - 1) % 4)-1}]
1434                set line  [expr {1 + ($num - 1) / 4}]
1435                return [string trim [string range [readexp "${key}PRCF $line"] $f1 $f2] ]
1436            }
1437            pterm*-set {
1438                if ![validreal value 15 6] {return 0}
1439                regsub pterm $parm {} num
1440                set f1 [expr {1+ 15*(($num - 1) % 4)}]
1441                set line  [expr {1 + ($num - 1) / 4}]
1442                setexp "${key}PRCF $line" $value $f1 15
1443            }
1444            pref*-get {
1445                regsub pref $parm {} num
1446                set f [expr {24+$num}]
1447                if {[string toupper [string range [readexp "${key}PRCF  "] $f $f]] == "Y"} {
1448                    return 1
1449                }
1450                return 0
1451            }
1452            pref*-set {
1453                regsub pref $parm {} num
1454                set f [expr {25+$num}]
1455                if $value {
1456                    setexp ${key}PRCF "Y" $f 1
1457                } else {
1458                    setexp ${key}PRCF "N" $f 1
1459                }           
1460            }
1461            POnaxis-get {
1462                set val [string trim \
1463                        [string range [readexp "${key}NAXIS"] 0 4]]
1464                if {$val == ""} {return 0}
1465                return $val
1466            }
1467            POnaxis-set {
1468                if ![validint value 5] {return 0}
1469                # there should be a NAXIS record, but if not make one
1470                if {![existsexp "${key}NAXIS"]} {
1471                    makeexprec "${key}NAXIS"
1472                }
1473                setexp "${key}NAXIS  " $value 1 5
1474            }
1475            default {
1476                set msg "Unsupported hapinfo access: parm=$parm action=$action"
1477                tk_dialog .badexp "Error in readexp" $msg error 0 Exit
1478            }
1479        }
1480    }
1481    return 1
1482}
1483
1484#  get a logical constraint
1485#
1486#  type action
1487#  -----------
1488#  atom get  number        returns a list of constraints.
1489#   "   set  number value  replaces a list of constraints
1490#                          (value is a list of constraints)
1491#   "   add  number value  inserts a new list of constraints
1492#                          (number is ignored)
1493#   "   delete number      deletes a set of constraint entries
1494# Each item in the list of constraints is composed of 4 items:
1495#              phase, atom, variable, multiplier
1496# If variable=UISO atom can be ALL, otherwise atom is a number
1497# legal variable names: FRAC, X, Y, Z, UISO, U11, U22, U33, U12, U23, U13,
1498#                       MX, MY, MZ
1499#
1500#  type action
1501#  -----------
1502#  profileXX get number         returns a list of constraints for term XX=1-36
1503#                               use number=0 to get # of defined
1504#                                  constraints for term XX
1505#   "        set number value   replaces a list of constraints
1506#                               (value is a list of constraints)
1507#   "        add number value   inserts a new list of constraints
1508#                               (number is ignored)
1509#   "        delete number      deletes a set of constraint entries
1510# Each item in the list of constraints is composed of 3 items:
1511#              phase-list, histogram-list, multiplier
1512# Note that phase-list and/or histogram-list can be ALL
1513
1514proc constrinfo {type action number "value {}"} {
1515    switch -glob ${type}-$action {
1516        atom-get {
1517            # does this constraint exist?
1518            set key [format "LNCN%4d%4d" $number 1]
1519            if {![existsexp $key]} {return -1}
1520            set clist {}
1521            for {set i 1} {$i < 999} {incr i} {
1522                set key [format "LNCN%4d%4d" $number $i]
1523                if {![existsexp $key]} break
1524                set line [readexp $key]
1525                set j1 2
1526                set j2 17
1527                set seg [string range $line $j1 $j2]
1528                while {[string trim $seg] != ""} {
1529                    lappend clist [list \
1530                            [string range $seg 0 0] \
1531                            [string trim [string range $seg 1 3]] \
1532                            [string trim [string range $seg 4 7]] \
1533                            [string trim [string range $seg 8 end]]]
1534                    incr j1 16
1535                    incr j2 16
1536                    set seg [string range $line $j1 $j2]
1537                }
1538            }
1539            return $clist
1540        }
1541        atom-set {
1542            # delete records for current constraint
1543            for {set i 1} {$i < 999} {incr i} {
1544                set key [format "LNCN%4d%4d" $number $i]
1545                if {![existsexp $key]} break
1546                delexp $key
1547            }
1548            set line {}
1549            set i 1
1550            foreach tuple $value {
1551                if {[string toupper [lindex $tuple 1]] == "ALL"} {
1552                    set seg [format %1dALL%-4s%8.4f \
1553                            [lindex $tuple 0] \
1554                            [lindex $tuple 2] \
1555                            [lindex $tuple 3]]
1556                } else {
1557                    set seg [eval format %1d%3d%-4s%8.4f $tuple]
1558                }
1559                append line $seg
1560                if {[string length $line] > 50} {
1561                    set key  [format "LNCN%4d%4d" $number $i]
1562                    makeexprec $key
1563                    setexp $key $line 3 68
1564                    set line {}
1565                    incr i
1566                }
1567            }
1568            if {$line != ""} {
1569                set key  [format "LNCN%4d%4d" $number $i]
1570                makeexprec $key
1571                setexp $key $line 3 68
1572            }
1573            return
1574        }
1575        atom-add {
1576            # loop over defined constraints
1577            for {set j 1} {$j < 9999} {incr j} {
1578                set key [format "LNCN%4d%4d" $j 1]
1579                if {![existsexp $key]} break
1580            }
1581            set number $j
1582            # save the constraint
1583            set line {}
1584            set i 1
1585            foreach tuple $value {
1586                if {[string toupper [lindex $tuple 1]] == "ALL"} {
1587                    set seg [format %1dALL%-4s%8.4f \
1588                            [lindex $tuple 0] \
1589                            [lindex $tuple 2] \
1590                            [lindex $tuple 3]]
1591                } else {
1592                    set seg [eval format %1d%3d%-4s%8.4f $tuple]
1593                }
1594                append line $seg
1595                if {[string length $line] > 50} {
1596                    set key  [format "LNCN%4d%4d" $number $i]
1597                    makeexprec $key
1598                    setexp $key $line 3 68
1599                    set line {}
1600                    incr i
1601                }
1602            }
1603            if {$line != ""} {
1604                set key  [format "LNCN%4d%4d" $number $i]
1605                makeexprec $key
1606                setexp $key $line 3 68
1607            }
1608            return
1609        }
1610        atom-delete {
1611            for {set j $number} {$j < 9999} {incr j} {
1612                # delete records for current constraint
1613                for {set i 1} {$i < 999} {incr i} {
1614                    set key [format "LNCN%4d%4d" $j $i]
1615                    if {![existsexp $key]} break
1616                    delexp $key
1617                }
1618                # now copy records, from the next entry, if any
1619                set j1 $j
1620                incr j1
1621                set key1 [format "LNCN%4d%4d" $j1 1]
1622                # if there is no record, there is nothing to copy -- done
1623                if {![existsexp $key1]} return
1624                for {set i 1} {$i < 999} {incr i} {
1625                    set key1 [format "LNCN%4d%4d" $j1 $i]
1626                    if {![existsexp $key1]} break
1627                    set key  [format "LNCN%4d%4d" $j  $i]
1628                    makeexprec $key
1629                    setexp $key [readexp $key1] 1 68
1630                }
1631            }
1632        }
1633        profile*-delete {
1634            regsub profile $type {} term
1635            if {$term < 10} {
1636                set term " $term"
1637            }
1638            set key "LEQV PF$term   "
1639            # return nothing if no term exists
1640            if {![existsexp $key]} {return 0}
1641
1642            # number of constraint terms
1643            set nterms [string trim [string range [readexp ${key}] 0 4] ]
1644            # don't delete a non-existing entry
1645            if {$number > $nterms} {return 0}
1646            set val [expr {$nterms - 1}]
1647            validint val 5
1648            setexp $key $val 1 5
1649            for {set i1 $number} {$i1 < $nterms} {incr i1} {
1650                set i2 [expr {1 + $i1}]
1651                # move the contents of constraint #i2 -> i1
1652                if {$i1 > 9} {
1653                    set k1 [expr {($i1+1)/10}]
1654                    set l1 $i1
1655                } else {
1656                    set k1 " "
1657                    set l1 " $i1"
1658                }
1659                set key1 "LEQV PF$term  $k1"
1660                # number of constraint lines for #i1
1661                set n1 [string trim [string range [readexp ${key1}] \
1662                        [expr {($i1%10)*5}] [expr {4+(($i1%10)*5)}]] ]
1663                if {$i2 > 9} {
1664                    set k2 [expr {($i2+1)/10}]
1665                    set l2 $i2
1666                } else {
1667                    set k2 " "
1668                    set l2 " $i2"
1669                }
1670                set key2 "LEQV PF$term  $k2"
1671                # number of constraint lines for #i2
1672                set n2 [string trim [string range [readexp ${key2}] \
1673                        [expr {($i2%10)*5}] [expr {4+(($i2%10)*5)}]] ]
1674                set val $n2
1675                validint val 5
1676                # move the # of terms
1677                setexp $key1 $val [expr {1+(($i1%10)*5)}] 5
1678                # move the terms
1679                for {set j 1} {$j <= $n2} {incr j 1} {
1680                    set key "LEQV PF${term}${l1}$j"
1681                    makeexprec $key
1682                    setexp $key [readexp "LEQV PF${term}${l2}$j"] 1 68
1683                }
1684                # delete any remaining lines
1685                for {set j [expr {$n2+1}]} {$j <= $n1} {incr j 1} {
1686                    delexp "LEQV PF${term}${l1}$j"
1687                }
1688            }
1689
1690            # clear the last term
1691            if {$nterms > 9} {
1692                set i [expr {($nterms+1)/10}]
1693            } else {
1694                set i " "
1695            }
1696            set key "LEQV PF$term  $i"
1697            set cb [expr {($nterms%10)*5}]
1698            set ce [expr {4+(($nterms%10)*5)}]
1699            set n2 [string trim [string range [readexp ${key}] $cb $ce] ]
1700            incr cb
1701            setexp $key "     " $cb 5
1702            # delete any remaining lines
1703            for {set j 1} {$j <= $n2} {incr j 1} {
1704                delexp "LEQV PF${term}${nterms}$j"
1705            }
1706        }
1707        profile*-set {
1708            regsub profile $type {} term
1709            if {$term < 10} {
1710                set term " $term"
1711            }
1712            set key "LEQV PF$term   "
1713            # get number of constraint terms
1714            set nterms [string trim [string range [readexp ${key}] 0 4] ]
1715            # don't change a non-existing entry
1716            if {$number > $nterms} {return 0}
1717            if {$number > 9} {
1718                set k1 [expr {($number+1)/10}]
1719                set l1 $number
1720            } else {
1721                set k1 " "
1722                set l1 " $number"
1723            }
1724            set key1 "LEQV PF$term  $k1"
1725            # old number of constraint lines
1726            set n1 [string trim [string range [readexp ${key1}] \
1727                    [expr {($number%10)*5}] [expr {4+(($number%10)*5)}]] ]
1728            # number of new constraints
1729            set j2 [llength $value]
1730            # number of new constraint lines
1731            set val [set n2 [expr {($j2 + 2)/3}]]
1732            # store the new # of lines
1733            validint val 5
1734            setexp $key1 $val [expr {1+(($number%10)*5)}] 5
1735
1736            # loop over the # of lines in the old or new, whichever is greater
1737            set v0 0
1738            for {set j 1} {$j <= [expr {($n1 > $n2) ? $n1 : $n2}]} {incr j 1} {
1739                set key "LEQV PF${term}${l1}$j"
1740                # were there more lines in the old?
1741                if {$j > $n2} {
1742                    # this line is not needed
1743                    if {$j % 3 == 1} {
1744                        delexp %key
1745                    }
1746                    continue
1747                }
1748                # are we adding new lines?
1749                if {$j > $n1} {
1750                    makeexprec $key
1751                }
1752                # add the three constraints to the line
1753                foreach s {3 23 43} \
1754                        item [lrange $value $v0 [expr {2+$v0}]] {
1755                    if {$item != ""} {
1756                        set val [format %-10s%9.3f \
1757                                [lindex $item 0],[lindex $item 1] \
1758                                [lindex $item 2]]
1759                        setexp $key $val $s 19
1760                    } else {
1761                        setexp $key " " $s 19
1762                    }
1763                }
1764                incr v0 3
1765            }
1766        }
1767        profile*-add {
1768            regsub profile $type {} term
1769            if {$term < 10} {
1770                set term " $term"
1771            }
1772            set key "LEQV PF$term   "
1773            if {![existsexp $key]} {makeexprec $key}
1774            set nterms [string trim [string range [readexp ${key}] 0 4] ]
1775            if {$nterms == ""} {
1776                set nterms 1
1777            } elseif {$nterms >= 99} {
1778                return 0
1779            } else {
1780                incr nterms
1781            }
1782            # store the new # of constraints
1783            set val $nterms
1784            validint val 5
1785            setexp $key $val 1 5
1786
1787            if {$nterms > 9} {
1788                set k1 [expr {($nterms+1)/10}]
1789                set l1 $nterms
1790            } else {
1791                set k1 " "
1792                set l1 " $nterms"
1793            }
1794            set key1 "LEQV PF$term  $k1"
1795
1796            # number of new constraints
1797            set j2 [llength $value]
1798            # number of new constraint lines
1799            set val [set n2 [expr {($j2 + 2)/3}]]
1800            # store the new # of lines
1801            validint val 5
1802            setexp $key1 $val [expr {1+(($nterms%10)*5)}] 5
1803
1804            # loop over the # of lines to be added
1805            set v0 0
1806            for {set j 1} {$j <= $n2} {incr j 1} {
1807                set key "LEQV PF${term}${l1}$j"
1808                makeexprec $key
1809                # add the three constraints to the line
1810                foreach s {3 23 43} \
1811                        item [lrange $value $v0 [expr {2+$v0}]] {
1812                    if {$item != ""} {
1813                        set val [format %-10s%9.3f \
1814                                [lindex $item 0],[lindex $item 1] \
1815                                [lindex $item 2]]
1816                        setexp $key $val $s 19
1817                    } else {
1818                        setexp $key " " $s 19
1819                    }
1820                }
1821                incr v0 3
1822            }
1823        }
1824        profile*-get {
1825            regsub profile $type {} term
1826            if {$term < 10} {
1827                set term " $term"
1828            }
1829            if {$number > 9} {
1830                set i [expr {($number+1)/10}]
1831            } else {
1832                set i " "
1833            }
1834            set key "LEQV PF$term  $i"
1835            # return nothing if no term exists
1836            if {![existsexp $key]} {return 0}
1837            # number of constraint lines
1838           
1839            set numline [string trim [string range [readexp ${key}] \
1840                    [expr {($number%10)*5}] [expr {4+(($number%10)*5)}]] ]
1841            if {$number == 0} {return $numline}
1842            set clist {}
1843            if {$number < 10} {
1844                set number " $number"
1845            }
1846            for {set i 1} {$i <= $numline} {incr i} {
1847                set key "LEQV PF${term}${number}$i"
1848                set line [readexp ${key}]
1849                foreach s {1 21 41} e {20 40 60} {
1850                    set seg [string range $line $s $e]
1851                    if {[string trim $seg] == ""} continue
1852                    # parse the string segment
1853                    set parse [regexp { *([0-9AL]+),([0-9AL]+) +([0-9.]+)} \
1854                            $seg junk phase hist mult]
1855                    # was parse successful
1856                    if {!$parse} {continue}
1857                    lappend clist [list $phase $hist $mult]
1858                }
1859            }
1860            return $clist
1861        }
1862        default {
1863            set msg "Unsupported constrinfo access: type=$type action=$action"
1864            tk_dialog .badexp "Error in readexp access" $msg error 0 OK
1865        }
1866
1867    }
1868}
1869
1870# read the default profile information for a histogram
1871# use: profdefinfo hist set# parm action
1872
1873#     proftype -- profile function number
1874#     profterms -- number of profile terms
1875#     pdamp -- damping value for the profile (*)
1876#     pcut -- cutoff value for the profile (*)
1877#     pterm$n -- profile term #n
1878#     pref$n -- refinement flag value for profile term #n (*)
1879
1880proc profdefinfo {hist set parm "action get"} {
1881    global expgui
1882    if {$hist < 10} {
1883        set key "HST  $hist"
1884    } else {
1885        set key "HST $hist"
1886    }
1887    switch -glob ${parm}-$action {
1888        proftype-get {
1889            set val [string range [readexp "${key}PRCF$set"] 0 4]
1890            if {$val == " "} {return 0}
1891            return $val
1892        }
1893        profterms-get {
1894            set val [string range [readexp "${key}PRCF$set"] 5 9]
1895            if {$val == " "} {return 0}
1896            return $val
1897        }
1898        pcut-get {
1899            return [string trim [string range [readexp "${key}PRCF$set"] 10 19]]
1900        }
1901        pdamp-get {
1902                set val [string range [readexp "${key}PRCF$set"] 24 24]
1903            if {$val == " "} {return 0}
1904            return $val
1905        }
1906        pterm*-get {
1907            regsub pterm $parm {} num
1908            set f1 [expr {15*(($num - 1) % 4)}]
1909            set f2 [expr {15*(1 + ($num - 1) % 4)-1}]
1910            set line  [expr {1 + ($num - 1) / 4}]
1911            return [string trim [string range [\
1912                        readexp "${key}PRCF${set}$line"] $f1 $f2] ]
1913        }
1914        pref*-get {
1915            regsub pref $parm {} num
1916            set f [expr {24+$num}]
1917            if {[string toupper [string range [readexp "${key}PRCF$set"] $f $f]] == "Y"} {
1918                return 1
1919            }
1920            return 0
1921        }
1922        default {
1923            set msg "Unsupported profdefinfo access: parm=$parm action=$action"
1924            tk_dialog .badexp "Code Error" $msg error 0 Exit
1925        }
1926    }
1927}
1928
1929# get March-Dollase preferred orientation information
1930# use MDprefinfo hist phase axis-number parm action value
1931#    ratio    -- ratio of xtallites in PO direction vs random (>1 for more)
1932#    fraction -- fraction in this direction, when more than one axis is used
1933#    h k & l  -- indices of P.O. axis
1934#    ratioref -- flag to vary ratio
1935#    fracref  -- flag to vary fraction
1936#    damp     -- damping value
1937#    type     -- model type (0 = P.O. _|_ to beam, 1 = || to beam)
1938#    new      -- creates a new record with default values (set only)
1939proc MDprefinfo {histlist phaselist axislist parm "action get" "value {}"} {
1940    foreach phase $phaselist hist $histlist axis $axislist {
1941        if {$phase == ""} {set phase [lindex $phaselist end]}
1942        if {$hist == ""} {set hist [lindex $histlist end]}
1943        if {$axis == ""} {set axis [lindex $axislist end]}
1944        if {$hist < 10} {
1945            set hist " $hist"
1946        }
1947        if {$axis > 9} {
1948            set axis "0"
1949        }
1950        set key "HAP${phase}${hist}PREFO${axis}"
1951        switch -glob ${parm}-$action {
1952            ratio-get {
1953                return [string trim [string range [readexp $key] 0 9]]
1954            }
1955            ratio-set {
1956                if ![validreal value 10 6] {return 0}
1957                setexp $key $value 1 10
1958            }
1959            fraction-get {
1960                return [string trim [string range [readexp $key] 10 19]]
1961            }
1962            fraction-set {
1963                if ![validreal value 10 6] {return 0}
1964                setexp $key $value 11 10
1965            }
1966            h-get {
1967                set h [string trim [string range [readexp $key] 20 29]]
1968                # why not allow negative h values?
1969                #               if {$h < 1} {return 0}
1970                return $h
1971            }
1972            h-set {
1973                if ![validreal value 10 2] {return 0}
1974                setexp $key $value 21 10
1975            }
1976            k-get {
1977                set k [string trim [string range [readexp $key] 30 39]]
1978                #               if {$k < 1} {return 0}
1979                return $k
1980            }
1981            k-set {
1982                if ![validreal value 10 2] {return 0}
1983                setexp $key $value 31 10
1984            }
1985            l-get {
1986                set l [string trim [string range [readexp $key] 40 49]]
1987                #if {$l < 1} {return 0}
1988                return $l
1989            }
1990            l-set {
1991                if ![validreal value 10 2] {return 0}
1992                setexp $key $value 41 10
1993            }
1994            ratioref-get {
1995                if {[string toupper \
1996                        [string range [readexp $key] 53 53]] == "Y"} {
1997                    return 1
1998                }
1999                return 0
2000            }
2001            ratioref-set {
2002                if $value {
2003                    setexp $key "Y" 54 1
2004                } else {
2005                    setexp $key "N" 54 1
2006                }
2007            }
2008            fracref-get {
2009                if {[string toupper \
2010                        [string range [readexp $key] 54 54]] == "Y"} {
2011                    return 1
2012                }
2013                return 0
2014            }
2015            fracref-set {
2016                if $value {
2017                    setexp $key "Y" 55 1
2018                } else {
2019                    setexp $key "N" 55 1
2020              }
2021            }
2022            damp-get {
2023                set val [string trim [string range [readexp $key] 59 59]]
2024                if {$val == " "} {return 0}
2025                return $val
2026            }
2027            damp-set {
2028                setexp $key $value 60 1
2029            }
2030            type-get {
2031                set val [string trim [string range [readexp $key] 64 64]]
2032                if {$val == " "} {return 0}
2033                return $val
2034            }
2035            type-set {
2036                # only valid settings are 0 & 1
2037                if {$value != "0" && $value != "1"} {set value "0"}
2038                setexp $key $value 65 1
2039            }
2040            new-set {
2041                makeexprec $key
2042                setexp $key \
2043                        {  1.000000  1.000000  0.000000  0.000000  1.000000   NN    0    0} \
2044                        1 68
2045            }
2046            default {
2047                set msg "Unsupported MDprefinfo access: parm=$parm action=$action"
2048                tk_dialog .badexp "Error in readexp" $msg error 0 Exit
2049            }
2050
2051        }
2052
2053    }
2054}
2055
2056# write the .EXP file
2057proc expwrite {expfile} {
2058    global exparray
2059    set blankline \
2060     "                                                                        "
2061    set fp [open ${expfile} w]
2062    fconfigure $fp -translation crlf
2063    set keylist [lsort [array names exparray]]
2064    # reorder the keys so that VERSION comes 1st
2065    set pos [lsearch -exact $keylist {     VERSION}]
2066    set keylist "{     VERSION} [lreplace $keylist $pos $pos]"
2067    foreach key $keylist {
2068        puts $fp [string range \
2069                "$key$exparray($key)$blankline" 0 79]
2070    }
2071    close $fp
2072}
2073
2074# history commands -- delete all but last $keep history records,
2075# renumber if $renumber is true
2076proc DeleteHistory {keep renumber} {
2077    global exparray
2078    foreach y [lrange [lsort -decreasing \
2079            [array names exparray {    HSTRY*}]] $keep end] {
2080        unset exparray($y)
2081    }
2082    if !$renumber return
2083    # renumber
2084    set i 0
2085    foreach y [lsort -increasing \
2086            [array names exparray {    HSTRY*}]] {
2087        set key [format "    HSTRY%3d" [incr i]]
2088        set exparray($key) $exparray($y)
2089        unset exparray($y)
2090    }
2091    # list all history
2092    #    foreach y [lsort -decreasing [array names exparray {    HSTRY*}]] {puts "$y $exparray($y)"}
2093}
2094
2095proc CountHistory {} {
2096    global exparray
2097    return [llength [array names exparray {    HSTRY*}]]
2098}
2099
2100# set the phase flags for histogram $hist to $plist
2101proc SetPhaseFlag {hist plist} {
2102    # make a 2 digit key -- hh
2103    if {$hist < 10} {
2104        set hh " $hist"
2105    } else {
2106        set hh $hist
2107    }
2108    set key "HST $hh NPHAS"
2109    set str {}
2110    foreach iph {1 2 3 4 5 6 7 8 9} {
2111        if {[lsearch $plist $iph] != -1} {
2112            append str {    1}
2113        } else {
2114            append str {    0}     
2115        }
2116    }
2117    setexp $key $str 1 68
2118}
2119
2120# erase atom $atom from phase $phase
2121# update the list of atom types, erasing the record if not needed.
2122proc EraseAtom {atom phase} {
2123    set type [atominfo $phase $atom type]
2124    if {$type == ""} return
2125    if {$atom < 10} {
2126        set key "CRS$phase  AT  $atom"
2127    } elseif {$atom < 100} {
2128        set key "CRS$phase  AT $atom"
2129    } else {
2130        set key "CRS$phase  AT$atom"
2131    }
2132    # delete the records for the atom
2133    global exparray
2134    foreach k [array names exparray ${key}*] {
2135        delexp $k
2136    }
2137    # change the number of atoms in the phase
2138    phaseinfo $phase natoms set [expr {[phaseinfo $phase natoms] -1}]
2139
2140    # now adjust numbers in "EXPR ATYP" records and delete, if needed.
2141    set natypes [readexp " EXPR  NATYP"]
2142    if {$natypes == ""} return
2143    set j 0
2144    for {set i 1} {$i <= $natypes} {incr i} {
2145        incr j
2146        if {$j <10} {
2147            set key " EXPR ATYP $j"
2148        } else {
2149            set key " EXPR ATYP$j"
2150        }
2151        while {![existsexp $key]} {
2152            incr j
2153            if {$j > 99} {
2154                return
2155            } elseif {$j <10} {
2156                set key " EXPR ATYP $j"
2157            } else {
2158                set key " EXPR ATYP$j"
2159            }
2160        }
2161        set keytype [string trim [string range $exparray($key) 2 9]]
2162        if {$type == $keytype} {
2163            # found the type record
2164            set val [string trim [string range $exparray($key) 10 14]]
2165            incr val -1
2166            # if this is the last reference, remove the record,
2167            # otherwise, decrement the counter
2168            if {$val <= 0} {
2169                incr natypes -1 
2170                validint natypes 5
2171                setexp " EXPR  NATYP" $natypes 1 5
2172                delexp $key
2173            } else {
2174                validint val 5
2175                setexp $key $val 11 5
2176            }
2177            return
2178        }
2179    }
2180}
2181
2182# compute equivalent anisotropic temperature factor for Uequiv
2183proc CalcAniso {phase Uequiv} {
2184    foreach var {a b c alpha beta gamma} {
2185        set $var [phaseinfo $phase $var]
2186    }
2187
2188    set G(1,1) [expr {$a * $a}]
2189    set G(2,2) [expr {$b * $b}]
2190    set G(3,3) [expr {$c * $c}]
2191    set G(1,2) [expr {$a * $b * cos($gamma*0.017453292519943)}]
2192    set G(2,1) $G(1,2)
2193    set G(1,3) [expr {$a * $c * cos($beta *0.017453292519943)}]
2194    set G(3,1) $G(1,3)
2195    set G(2,3) [expr {$b * $c * cos($alpha*0.017453292519943)}]
2196    set G(3,2) $G(2,3)
2197
2198    # Calculate the volume**2
2199    set v2 0.0
2200    foreach i {1 2 3} {
2201        set J [expr {($i%3) + 1}]
2202        set K [expr {(($i+1)%3) + 1}]
2203        set v2 [expr {$v2+ $G(1,$i)*($G(2,$J)*$G(3,$K)-$G(3,$J)*$G(2,$K))}]
2204    }
2205    if {$v2 > 0} {
2206        set v [expr {sqrt($v2)}]
2207        foreach i {1 2 3} {
2208            set i1 [expr {($i%3) + 1}]
2209            set i2 [expr {(($i+1)%3) + 1}]
2210            foreach j {1 2 3} {
2211                set j1 [expr {($j%3) + 1}]
2212                set j2 [expr {(($j+1)%3) + 1}]
2213                set C($j,$i) [expr {(\
2214                        $G($i1,$j1) * $G($i2,$j2) - \
2215                        $G($i1,$j2)  * $G($i2,$j1)\
2216                        )/ $v}]
2217            }
2218        }
2219        set A(1,2) [expr {0.5 * ($C(1,2)+$C(2,1)) / sqrt( $C(1,1)* $C(2,2) )}]
2220        set A(1,3) [expr {0.5 * ($C(1,3)+$C(3,1)) / sqrt( $C(1,1)* $C(3,3) )}]
2221        set A(2,3) [expr {0.5 * ($C(2,3)+$C(3,2)) / sqrt( $C(2,2)* $C(3,3) )}]
2222        foreach i {1 1 2} j {2 3 3} {
2223            set A($i,$j) [expr {0.5 * ($C($i,$j) + $C($j,$i)) / \
2224                    sqrt( $C($i,$i)* $C($j,$j) )}]
2225            # clean up roundoff
2226            if {abs($A($i,$j)) < 1e-5} {set A($i,$j) 0.0}
2227        }
2228    } else {
2229        set A(1,2) 0.0
2230        set A(1,3) 0.0
2231        set A(2,3) 0.0
2232    }
2233    return "$Uequiv $Uequiv $Uequiv \
2234            [expr {$Uequiv * $A(1,2)}] \
2235            [expr {$Uequiv * $A(1,3)}] \
2236            [expr {$Uequiv * $A(2,3)}]"
2237}
Note: See TracBrowser for help on using the repository browser.