Changeset 3274 for branches

Timestamp:

01/26/12 21:06:59 (4 months ago)

Author:

erkn

Message:

Linear scanning based on ranges and lists

Location:

branches/mcxtrace-1.0/src/mcrun2

Files:

• main.py (modified) (8 diffs)
• mcstas.py (modified) (7 diffs)
• optimisation.py (added)

branches/mcxtrace-1.0/src/mcrun2/main.py

@@ -5 +5 @@
 from os.path import isfile, isdir, abspath, dirname
 from optparse import OptionParser, OptionGroup, OptionValueError
+from decimal import Decimal, InvalidOperation
 
 from mcstas import McStas
+from optimisation import Scanner, LinearInterval
 
 LOG = logging.getLogger('mcstas')
@@ -43 +45 @@
         help='set number of scan points')
 
+    add('-L', '--list',
+        action='store_true',
+        help='use a fixed list of points for linear scanning')
+
     # Multiprocessing
     add('--mpi',
@@ -71 +77 @@
 
     add('--optimise-file',
-        metavar='FILE',
+        metavar='FILE', default='mcstas.dat',
         help='store optimisation results in FILE '
-             '(defaults to: "mcoptim_####.dat")')
+             '(defaults to: "mcstas.dat")')
 
     # Misc options
@@ -96 +102 @@
     opt = OptionGroup(parser, 'Instrument options')
     add = opt.add_option
-
 
     # Misc options
@@ -120 +125 @@
     # Data options
     dir_exists = lambda path: isdir(abspath(path))
+
     def check_file(exist=True):
         ''' Validate the path to a file '''
@@ -126 +132 @@
         else:
             def is_valid(path):
-                ''' Ensure that path to file exists and filename is provided '''
+                ''' Ensure path to file exists and filename is provided '''
                 if not dir_exists(dirname(path)):
                     return False
@@ -174 +180 @@
 
 
+def is_decimal(string):
+    ''' Check if string is parsable as decimal/float '''
+    try:
+        Decimal(string)
+        return True
+    except InvalidOperation:
+        return False
+
+
+def get_parameters(options):
+    ''' Get fixed and scan/optimise parameters '''
+    fixed_params = {}
+    intervals = {}
+    for param in options.params:
+        if '=' in param:
+            key, value = param.split('=', 1)
+            interval = value.split(',')
+            # When just one point is present, fix as constant
+            if len(interval) == 1:
+                fixed_params[key] = Decimal(value)
+            else:
+                LOG.debug('interval: %s', interval)
+                intervals[key] = interval
+        else:
+            LOG.warning('Ignoring invalid parameter: "%s"', param)
+    return (fixed_params, intervals)
+
+
 def main():
     ''' Main routine '''
 
     # Setup logging
-    formatter = logging.Formatter('%(created)s, %(levelname)8s: %(message)s')
+    formatter = logging.Formatter('%(created).2f, %(levelname)8s: %(message)s')
 
     handler = logging.StreamHandler()
@@ -211 +245 @@
     # Run McStas
     mcstas = McStas(options.instr)
-
-    # Set parameters
-    for param in options.params:
-        if '=' in param:
-            key, value = param.split('=', 1)
-            mcstas.setParameter(key, value)
-        else:
-            LOG.warning('Ignoring invalid parameter: "%s"', param)
-
     mcstas.prepare(options)
-    mcstas.run()
+    instrs = mcstas.get_info().get_instrument()
+    LOG.debug('info: %s', instrs)
+
+    (fixed_params, intervals) = get_parameters(options)
+
+    # Set fixed parameters
+    for key, value in fixed_params.items():
+        mcstas.set_parameter(key, value)
+
+    # Check for linear scanning
+    linear_interval = None
+
+    # Can't both do list and interval scanning
+    if options.list and options.numpoints:
+        raise OptionValueError('--numpoints cannot be used with --list')
+
+    elif options.list:
+        if len(intervals) == 0:
+            raise OptionValueError(
+                '--list was chosen but no lists was presented.')
+        points = len(intervals.values()[0])
+        if not(all(map(lambda i: len(i) == points, intervals.values()))):
+            raise OptionValueError(
+                'All variables much have an equal amount of points.')
+        linear_interval = LinearInterval.from_list(
+            points, intervals)
+
+    elif options.numpoints is not None:
+        if options.numpoints < 2:
+            raise OptionValueError(
+                ('Cannot scan variable(s) %s using only one data point. '
+                 'Please use -N to specify the number of points.') % \
+                ', '.join(intervals.keys()))
+        # Check that input is valid decimals
+        if not all(map(lambda i:
+                       len(i) == 2 and
+                       all(map(is_decimal, i)), intervals.values())):
+            raise OptionValueError('Could not parse intervals.')
+
+        linear_interval = LinearInterval.from_range(
+            options.numpoints, intervals)
+
+    # Parameters for linear scanning present
+    if linear_interval:
+        scanner = Scanner(mcstas, intervals)
+        scanner.set_points(linear_interval)
+        scanner.run()
+    else:
+        mcstas.run()
 
 

branches/mcxtrace-1.0/src/mcrun2/mcstas.py

@@ -1 +1 @@
 
+import atexit
+import logging
+import os
+import re
 import tempfile
-import atexit
-import os
-import logging
+import yaml
 
 from os.path import isfile, dirname, basename, splitext
 from subprocess import Popen, PIPE
+from decimal import Decimal
 
 
@@ -31 +34 @@
                                                     ' '.join(self.args))
 
+
 class Process:
     ''' An external process '''
@@ -48 +52 @@
 
         # Run executable
-        LOG.debug('CMD: %s %s', self.executable, args)
+        LOG.debug('CMD: %s %s', self.executable, ' '.join(args))
         fid = Popen([self.executable] + args,
                     stdout=pipe,
@@ -81 +85 @@
         atexit.register(self.cleanup)
 
-
-    def setParameter(self, key, value):
+    def set_parameter(self, key, value):
         ''' Set the value of an experiment parameter '''
         self.params[key] = value
-
 
     def prepare(self, options):
@@ -114 +116 @@
         # Compiler optimisation
         args = ['-o', self.binpath] + cflags + [self.cpath]
-
         Process(options.cc).run(args)
-
 
     def run(self, pipe=False):
@@ -140 +140 @@
 
         # Add parameters last
-        args += [ '%s=%s' % (key, value) for key, value in self.params.items() ]
+        args += ['%s=%s' % (key, value)
+                 for key, value in self.params.items()]
 
         # Run McStas
         if not mpi:
             LOG.info('Running: %s', self.binpath)
-            Process(self.binpath).run(args, pipe=pipe)
+            return Process(self.binpath).run(args, pipe=pipe)
         else:
             LOG.info('Running via MPI: %s', self.binpath)
             mpi_args = ['-np', str(options.mpi), self.binpath]
             mpi_args += args
-            Process(options.mpirun).run(mpi_args, pipe=pipe)
-
+            return Process(options.mpirun).run(mpi_args, pipe=pipe)
+
+    def get_info(self):
+        return McStasInfo(Process(self.binpath).run(['--info'], pipe=True))
 
     def cleanup(self):
@@ -163 +166 @@
         os.rmdir(self.dir)
 
+
+class Detector(object):
+    ''' A detector '''
+    def __init__(self, name, intensity, error, count, path):
+        self.name = name
+        self.intensity = Decimal(intensity)
+        self.error = Decimal(error)
+        self.count = Decimal(count)
+        self.path = path
+
+
+class McStasInfo:
+    ''' Parsing McStas experiment information (--info) '''
+
+    PARAMETERS_RE = re.compile(r'^\s*Parameters:(.*)', flags=re.MULTILINE)
+    SEPERATOR_RE = re.compile(r'^([^:]+):\s*')
+    QUOTE_RE = re.compile(r'^(\s*[^:]+):\s*([^\[\s].*)$', flags=re.MULTILINE)
+    GROUP_RE = re.compile(r'begin ([^\s]+)(.+)end \1', flags=re.DOTALL)
+    PARAM_RE = re.compile(r'^\s*Param:\s+"', flags=re.MULTILINE)
+
+    def __init__(self, data):
+        self.data = data
+        self.info = self._parse_info()
+
+    def _parse_info(self):
+        """
+        Parse the raw McStas info output
+        The output resembles YAML but not quite.
+        It's converted to YAML by:
+          0. Ensuring a space after 'key:' -> 'key: '
+          1. Adding qoutes 'key: value' -> 'key: "value"'
+          2. Changing 'begin foobar\n ...\n end foobar' -> 'foobar:\n'
+          3. Add unique suffix number to each param:
+               Param: lambda=0.7
+               Param: DM=1.8
+               -->
+               Param0: lambda=0.7
+               Param1: DM=1.8
+          4. Split up 'Parameters' to form a list
+        """
+
+        def escape(line):
+            ''' Escape \ and " '''
+            return line.replace('\\', '\\\\').replace('"', r'\"')
+
+        def quote(match):
+            ''' Quote a value '''
+            return '%s: "%s"' % (match.group(1), escape(match.group(2)))
+
+        def param_number(match):
+            ''' Assign unique number to each param '''
+            param_number.prev_param_number += 1
+            return match.group(0).replace('Param',
+                                          'Param%i' % param_number.prev_param_number)
+        # start count at 0 (previous is -1)
+        setattr(param_number, 'prev_param_number', -1)
+
+        def parameters_to_list(match):
+            old_str = match.group(1)
+            if old_str.strip():
+                new_str = ' [%s]' % ','.join(match.group(1).split())
+                return match.group(0).replace(old_str, new_str)
+            return match.group(0).strip() + ' []'
+
+        yaml_str = self.data
+        yaml_str = self.PARAMETERS_RE.sub(parameters_to_list, yaml_str)
+        yaml_str = self.SEPERATOR_RE.sub(r'\1: ', yaml_str)
+        yaml_str = self.QUOTE_RE.sub(quote, yaml_str)
+        yaml_str = self.GROUP_RE.sub(r'\1:\2', yaml_str)
+        yaml_str = self.PARAM_RE.sub(param_number, yaml_str)
+
+        return yaml.load(yaml_str)
+
+    def get(self, key):
+        return self.info[key]
+
+    def get_simulation(self):
+        return self.get('simulation')
+
+    def get_instrument(self):
+        return self.get('instrument')
+
+
+class McStasResult:
+    ''' Parsing of McStas experiment output '''
+
+    DETECTOR_RE = r'Detector: ([^\s]+)_I=([^ ]+) \1_ERR=([^\s]+) \1_N=([^ ]+) "(\1[^"]+)"'
+
+    def __init__(self, data):
+        self.data = data
+        self.detectors = None
+
+    def get_detectors(self):
+        ''' Extract detector information '''
+        if self.detectors is not None:
+            return self.detectors
+        res = re.findall(self.DETECTOR_RE, self.data)
+
+        return [Detector(name, intensity, error, count, path)
+                for name, intensity, error, count, path in res]