Example #1
0
    def run_fit_grains(self, config):
        self.fit_grains_results = None
        min_samples, mean_rpg = create_clustering_parameters(
            config, self.ome_maps)

        # Add fit_grains config
        dialog_config = HexrdConfig().indexing_config['fit_grains']
        config.set('fitgrains:npdiv', dialog_config['npdiv'])
        config.set('fitgrains:refit', dialog_config['refit'])
        config.set('fitgrains:threshold', dialog_config['threshold'])
        config.set('fitgrains:tth_max', dialog_config['tth_max'])
        config.set('fitgrains:tolerance:tth', dialog_config['tth_tolerances'])
        config.set('fitgrains:tolerance:eta', dialog_config['eta_tolerances'])
        config.set('fitgrains:tolerance:omega',
                   dialog_config['omega_tolerances'])

        kwargs = {
            'compl': self.completeness,
            'qfib': self.qfib,
            'qsym': config.material.plane_data.getQSym(),
            'cfg': config,
            'min_samples': min_samples,
            'compl_thresh': config.find_orientations.clustering.completeness,
            'radius': config.find_orientations.clustering.radius
        }
        self.update_progress_text('Running clustering')
        qbar, cl = run_cluster(**kwargs)

        # Generate grains table
        num_grains = qbar.shape[1]
        if num_grains == 0:
            print('Fit Grains Complete - no grains were found')
            return

        shape = (num_grains, 21)
        grains_table = np.empty(shape)
        gw = instrument.GrainDataWriter(array=grains_table)
        for gid, q in enumerate(qbar.T):
            phi = 2 * np.arccos(q[0])
            n = xfcapi.unitRowVector(q[1:])
            grain_params = np.hstack(
                [phi * n, const.zeros_3, const.identity_6x1])
            gw.dump_grain(gid, 1., 0., grain_params)
        gw.close()

        self.update_progress_text(
            f'Found {num_grains} grains. Running fit optimization.')

        self.fit_grains_results = fit_grains(config,
                                             grains_table,
                                             write_spots_files=False)
        print('Fit Grains Complete')
Example #2
0
    def run_fit_grains(self):
        cfg = create_indexing_config()
        write_spots = HexrdConfig().indexing_config.get('_write_spots', False)

        num_grains = self.grains_table.shape[0]
        self.update_progress_text(f'Running fit grains on {num_grains} grains')
        kwargs = {
            'cfg': cfg,
            'grains_table': self.grains_table,
            'write_spots_files': write_spots,
        }
        self.fit_grains_results = fit_grains(**kwargs)
        print('Fit Grains Complete')

        # If we wrote out the spots, let's write out the grains.out file too
        if write_spots:
            write_fit_grains_results(self.fit_grains_results, cfg)
Example #3
0
def test_fit_grains(single_ge_include_path, test_config, grains_file_path,
                    grains_reference_file_path):
    os.chdir(str(single_ge_include_path))

    grains_table = np.loadtxt(grains_reference_file_path, ndmin=2)
    ref_grain_params = grains_table[:, 3:15]
    gresults = fit_grains(test_config,
                          grains_table,
                          show_progress=False,
                          ids_to_refine=None,
                          write_spots_files=False)

    cresult = compare_grain_fits(np.vstack([i[-1] for i in gresults]),
                                 ref_grain_params,
                                 mtol=1.e-4,
                                 ctol=1.e-3,
                                 vtol=1.e-4)

    assert cresult
Example #4
0
    def run_fit_grains(self, config):
        min_samples, mean_rpg = create_clustering_parameters(
            config, self.ome_maps)

        kwargs = {
            'compl': self.completeness,
            'qfib': self.qfib,
            'qsym': config.material.plane_data.getQSym(),
            'cfg': config,
            'min_samples': min_samples,
            'compl_thresh': config.find_orientations.clustering.completeness,
            'radius': config.find_orientations.clustering.radius
        }
        self.update_progress_text('Running clustering')
        qbar, cl = run_cluster(**kwargs)

        # Generate grains table
        num_grains = qbar.shape[1]
        if num_grains == 0:
            QMessageBox.warning(self.parent, 'No Grains',
                                'Clustering found no grains')
            return

        shape = (num_grains, 21)
        grains_table = np.empty(shape)
        gw = instrument.GrainDataWriter(array=grains_table)
        for gid, q in enumerate(qbar.T):
            phi = 2 * np.arccos(q[0])
            n = xfcapi.unitRowVector(q[1:])
            grain_params = np.hstack(
                [phi * n, const.zeros_3, const.identity_6x1])
            gw.dump_grain(gid, 1., 0., grain_params)
        gw.close()

        self.update_progress_text(
            f'Found {num_grains} grains. Running fit optimization.')
        self.fit_grains_results = fit_grains(config,
                                             grains_table,
                                             write_spots_files=False)
        print('Fit Grains Complete')
Example #5
0
def execute(args, parser):
    import logging
    import os
    import sys

    import yaml

    from hexrd import config
    from hexrd.fitgrains import fit_grains

    # load the configuration settings
    cfgs = config.open(args.yml)

    # configure logging to the console:
    log_level = logging.DEBUG if args.debug else logging.INFO
    if args.quiet:
        log_level = logging.ERROR
    logger = logging.getLogger('hexrd')
    logger.setLevel(log_level)
    ch = logging.StreamHandler()
    ch.setLevel(logging.CRITICAL if args.quiet else log_level)
    cf = logging.Formatter('%(asctime)s - %(message)s', '%y-%m-%d %H:%M:%S')
    ch.setFormatter(cf)
    logger.addHandler(ch)

    # ...make this an attribute in cfg?
    analysis_id = '%s_%s' % (
        cfgs[0].analysis_name.strip().replace(' ', '-'),
        cfgs[0].material.active.strip().replace(' ', '-'),
    )

    # if find-orientations has not already been run, do so:
    quats_f = os.path.join(cfgs[0].working_dir,
                           'accepted_orientations_%s.dat' % analysis_id)
    if not os.path.exists(quats_f):
        logger.info("Missing %s, running find-orientations", quats_f)
        logger.removeHandler(ch)
        from . import findorientations
        findorientations.execute(args, parser)
        logger.addHandler(ch)

    logger.info('=== begin fit-grains ===')

    clobber = args.force or args.clean
    for cfg in cfgs:
        # prepare the analysis directory
        if os.path.exists(cfg.analysis_dir) and not clobber:
            logger.error(
                'Analysis "%s" at %s already exists.'
                ' Change yml file or specify "force"', cfg.analysis_name,
                cfg.analysis_dir)
            sys.exit()
        if not os.path.exists(cfg.analysis_dir):
            os.makedirs(cfg.analysis_dir)

        logger.info('*** begin analysis "%s" ***', cfg.analysis_name)

        # configure logging to file for this particular analysis
        logfile = os.path.join(cfg.working_dir, cfg.analysis_name,
                               'fit-grains.log')
        fh = logging.FileHandler(logfile, mode='w')
        fh.setLevel(log_level)
        ff = logging.Formatter('%(asctime)s - %(name)s - %(message)s',
                               '%m-%d %H:%M:%S')
        fh.setFormatter(ff)
        logger.info("logging to %s", logfile)
        logger.addHandler(fh)

        if args.profile:
            import cProfile as profile, pstats, StringIO
            pr = profile.Profile()
            pr.enable()

        # process the data
        gid_list = None
        if args.grains is not None:
            gid_list = [int(i) for i in args.grains.split(',')]

        fit_grains(
            cfg,
            force=args.force,
            clean=args.clean,
            show_progress=not args.quiet,
            ids_to_refine=gid_list,
        )

        if args.profile:
            pr.disable()
            s = StringIO.StringIO()
            ps = pstats.Stats(pr, stream=s).sort_stats('cumulative')
            ps.print_stats(50)
            logger.info('%s', s.getvalue())

        # stop logging for this particular analysis
        fh.flush()
        fh.close()
        logger.removeHandler(fh)

        logger.info('*** end analysis "%s" ***', cfg.analysis_name)

    logger.info('=== end fit-grains ===')
    # stop logging to the console
    ch.flush()
    ch.close()
    logger.removeHandler(ch)
Example #6
0
def execute(args, parser):
    import logging
    import os
    import sys

    import yaml

    from hexrd import config
    from hexrd.fitgrains import fit_grains


    # load the configuration settings
    cfgs = config.open(args.yml)

    # configure logging to the console:
    log_level = logging.DEBUG if args.debug else logging.INFO
    if args.quiet:
        log_level = logging.ERROR
    logger = logging.getLogger('hexrd')
    logger.setLevel(log_level)
    ch = logging.StreamHandler()
    ch.setLevel(logging.CRITICAL if args.quiet else log_level)
    cf = logging.Formatter('%(asctime)s - %(message)s', '%y-%m-%d %H:%M:%S')
    ch.setFormatter(cf)
    logger.addHandler(ch)

    # ...make this an attribute in cfg?
    analysis_id = '%s_%s' %(
        cfgs[0].analysis_name.strip().replace(' ', '-'),
        cfgs[0].material.active.strip().replace(' ', '-'),
        )
    
    # if find-orientations has not already been run, do so:
    quats_f = os.path.join(
        cfgs[0].working_dir, 
        'accepted_orientations_%s.dat' %analysis_id
        )
    if not os.path.exists(quats_f):
        logger.info("Missing %s, running find-orientations", quats_f)
        logger.removeHandler(ch)
        from . import findorientations
        findorientations.execute(args, parser)
        logger.addHandler(ch)

    logger.info('=== begin fit-grains ===')

    clobber = args.force or args.clean
    for cfg in cfgs:
        # prepare the analysis directory
        if os.path.exists(cfg.analysis_dir) and not clobber:
            logger.error(
                'Analysis "%s" at %s already exists.'
                ' Change yml file or specify "force"',
                cfg.analysis_name, cfg.analysis_dir
                )
            sys.exit()
        if not os.path.exists(cfg.analysis_dir):
            os.makedirs(cfg.analysis_dir)

        logger.info('*** begin analysis "%s" ***', cfg.analysis_name)

        # configure logging to file for this particular analysis
        logfile = os.path.join(
            cfg.working_dir,
            cfg.analysis_name,
            'fit-grains.log'
            )
        fh = logging.FileHandler(logfile, mode='w')
        fh.setLevel(log_level)
        ff = logging.Formatter(
                '%(asctime)s - %(name)s - %(message)s',
                '%m-%d %H:%M:%S'
                )
        fh.setFormatter(ff)
        logger.info("logging to %s", logfile)
        logger.addHandler(fh)

        if args.profile:
            import cProfile as profile, pstats, StringIO
            pr = profile.Profile()
            pr.enable()

        # process the data
        if args.grains is not None:
            args.grains = [int(i) for i in args.grains.split(',')]
        fit_grains(
            cfg,
            force=args.force,
            clean=args.clean,
            show_progress=not args.quiet,
            ids_to_refine=args.grains,
            )

        if args.profile:
            pr.disable()
            s = StringIO.StringIO()
            ps = pstats.Stats(pr, stream=s).sort_stats('cumulative')
            ps.print_stats(50)
            logger.info('%s', s.getvalue())

        # stop logging for this particular analysis
        fh.flush()
        fh.close()
        logger.removeHandler(fh)

        logger.info('*** end analysis "%s" ***', cfg.analysis_name)

    logger.info('=== end fit-grains ===')
    # stop logging to the console
    ch.flush()
    ch.close()
    logger.removeHandler(ch)
Example #7
0
def execute(args, parser):
    import logging
    import os
    import sys

    import yaml

    from hexrd import config
    from hexrd.fitgrains import fit_grains


    # load the configuration settings
    cfgs = config.open(args.yml)

    # if find-orientations has not already been run, do so:
    quats_f = os.path.join(cfgs[0].working_dir, 'accepted_orientations.dat')
    if not os.path.exists(quats_f):
        from . import findorientations
        findorientations.execute(args, parser)

    # configure logging to the console:
    log_level = logging.DEBUG if args.debug else logging.INFO
    if args.quiet:
        log_level = logging.ERROR
    logger = logging.getLogger('hexrd')
    logger.setLevel(log_level)
    ch = logging.StreamHandler()
    ch.setLevel(logging.CRITICAL if args.quiet else log_level)
    cf = logging.Formatter('%(asctime)s - %(message)s', '%y-%m-%d %H:%M:%S')
    ch.setFormatter(cf)
    logger.addHandler(ch)
    logger.info('=== begin fit-grains ===')

    for cfg in config.open(args.yml):
        # prepare the analysis directory
        if os.path.exists(cfg.analysis_dir) and not args.force:
            logger.error(
                'Analysis "%s" at %s already exists.'
                ' Change yml file or specify "force"',
                cfg.analysis_name, cfg.analysis_dir
                )
            sys.exit()
        if not os.path.exists(cfg.analysis_dir):
            os.makedirs(cfg.analysis_dir)

        logger.info('*** begin analysis "%s" ***', cfg.analysis_name)

        # configure logging to file for this particular analysis
        logfile = os.path.join(
            cfg.working_dir,
            cfg.analysis_name,
            'fit-grains.log'
            )
        fh = logging.FileHandler(logfile, mode='w')
        fh.setLevel(log_level)
        ff = logging.Formatter(
                '%(asctime)s - %(name)s - %(message)s',
                '%m-%d %H:%M:%S'
                )
        fh.setFormatter(ff)
        logger.info("logging to %s", logfile)
        logger.addHandler(fh)

        # process the data
        fit_grains(cfg, force=args.force, show_progress=not args.quiet)

        # stop logging for this particular analysis
        fh.flush()
        fh.close()
        logger.removeHandler(fh)

        logger.info('*** end analysis "%s" ***', cfg.analysis_name)

    logger.info('=== end fit-grains ===')
    # stop logging to the console
    ch.flush()
    ch.close()
    logger.removeHandler(ch)
    for o, val in opts:
        if o == "-p":
            prof_dict["profile"] = True
        elif o == "-n":
            prof_dict["use_nvtx"] = True
        elif o=="-c":
            try:
                max_grains = int(val)
            except ValueError:
                print "invalid grain count"
                usage()
                sys.exit(2)
        else:
            assert False, "unhandled option '{0}'".format(o)

    if len(args) < 1:
        usage()
        sys.exit(2)
    cfg_filename = args[0]

    with profiling(**prof_dict):
        start = time.time()
        print "Using cfg file '%s'" % (cfg_filename)
        config = config.open(cfg_filename)[0]
        config._cfg['multiproc'] = 1 # force sequential run

        target.fit_grains(config, force=True, grains=range(max_grains))

        elapsed = time.time() - start
        print "\nTotal processing time %.2f seconds" % elapsed
Example #9
0
def execute(args, parser):
    # load the configuration settings
    cfgs = config.open(args.yml)

    # configure logging to the console:
    log_level = logging.DEBUG if args.debug else logging.INFO
    if args.quiet:
        log_level = logging.ERROR
    logger = logging.getLogger('hexrd')
    logger.setLevel(log_level)
    ch = logging.StreamHandler()
    ch.setLevel(logging.CRITICAL if args.quiet else log_level)
    cf = logging.Formatter('%(asctime)s - %(message)s', '%y-%m-%d %H:%M:%S')
    ch.setFormatter(cf)
    logger.addHandler(ch)

    # if find-orientations has not already been run, do so:
    quats_f = os.path.join(
        cfgs[0].working_dir,
        'accepted_orientations_%s.dat' % cfgs[0].analysis_id)
    if os.path.exists(quats_f):
        try:
            qbar = np.loadtxt(quats_f).T
        except (IOError):
            raise (RuntimeError,
                   "error loading indexing results '%s'" % quats_f)
    else:
        logger.info("Missing %s, running find-orientations", quats_f)
        logger.removeHandler(ch)
        from hexrd.findorientations import find_orientations
        results = find_orientations(cfgs[0])
        qbar = results['qbar']
        logger.addHandler(ch)

    logger.info('=== begin fit-grains ===')

    clobber = args.force or args.clean
    for cfg in cfgs:
        # prepare the analysis directory
        if os.path.exists(cfg.analysis_dir) and not clobber:
            logger.error(
                'Analysis "%s" at %s already exists.'
                ' Change yml file or specify "force"', cfg.analysis_name,
                cfg.analysis_dir)
            sys.exit()

        # make output directories
        instr = cfg.instrument.hedm
        if not os.path.exists(cfg.analysis_dir):
            os.makedirs(cfg.analysis_dir)
            for det_key in instr.detectors:
                os.mkdir(os.path.join(cfg.analysis_dir, det_key))
        else:
            # make sure panel dirs exist under analysis dir
            for det_key in instr.detectors:
                if not os.path.exists(os.path.join(cfg.analysis_dir, det_key)):
                    os.mkdir(os.path.join(cfg.analysis_dir, det_key))

        logger.info('*** begin analysis "%s" ***', cfg.analysis_name)

        # configure logging to file for this particular analysis
        logfile = os.path.join(cfg.working_dir, cfg.analysis_name,
                               'fit-grains.log')
        fh = logging.FileHandler(logfile, mode='w')
        fh.setLevel(log_level)
        ff = logging.Formatter('%(asctime)s - %(name)s - %(message)s',
                               '%m-%d %H:%M:%S')
        fh.setFormatter(ff)
        logger.info("logging to %s", logfile)
        logger.addHandler(fh)

        if args.profile:
            import cProfile as profile
            import pstats
            from io import StringIO

            pr = profile.Profile()
            pr.enable()

        grains_filename = os.path.join(cfg.analysis_dir, 'grains.out')

        # some conditions for arg handling
        existing_analysis = os.path.exists(grains_filename)
        new_with_estimate = not existing_analysis \
            and cfg.fit_grains.estimate is not None
        new_without_estimate = not existing_analysis \
            and cfg.fit_grains.estimate is None
        force_with_estimate = args.force \
            and cfg.fit_grains.estimate is not None
        force_without_estimate = args.force and cfg.fit_grains.estimate is None

        # handle args
        if args.clean or force_without_estimate or new_without_estimate:
            # need accepted orientations from indexing in this case
            if args.clean:
                logger.info(
                    "'clean' specified; ignoring estimate and using default")
            elif force_without_estimate:
                logger.info(
                    "'force' option specified, but no initial estimate; " +
                    "using default")
            try:
                gw = instrument.GrainDataWriter(grains_filename)
                for i_g, q in enumerate(qbar.T):
                    phi = 2 * np.arccos(q[0])
                    n = xfcapi.unitRowVector(q[1:])
                    grain_params = np.hstack(
                        [phi * n, cnst.zeros_3, cnst.identity_6x1])
                    gw.dump_grain(int(i_g), 1., 0., grain_params)
                gw.close()
            except (IOError):
                raise (RuntimeError, "indexing results '%s' not found!" %
                       'accepted_orientations_' + cfg.analysis_id + '.dat')
        elif force_with_estimate or new_with_estimate:
            grains_filename = cfg.fit_grains.estimate
        elif existing_analysis and not (clean or force):
            raise (RuntimeError, "fit results '%s' exist, " % grains_filename +
                   "but --clean or --force options not specified")

        grains_table = np.loadtxt(grains_filename, ndmin=2)

        # process the data
        gid_list = None
        if args.grains is not None:
            gid_list = [int(i) for i in args.grains.split(',')]
            pass

        cfg.fit_grains.qbar = qbar
        fit_results = fit_grains(
            cfg,
            grains_table,
            show_progress=not args.quiet,
            ids_to_refine=gid_list,
        )

        if args.profile:
            pr.disable()
            s = StringIO.StringIO()
            ps = pstats.Stats(pr, stream=s).sort_stats('cumulative')
            ps.print_stats(50)
            logger.info('%s', s.getvalue())

        # stop logging for this particular analysis
        fh.flush()
        fh.close()
        logger.removeHandler(fh)

        logger.info('*** end analysis "%s" ***', cfg.analysis_name)

        write_results(fit_results, cfg, grains_filename)

    logger.info('=== end fit-grains ===')
    # stop logging to the console
    ch.flush()
    ch.close()
    logger.removeHandler(ch)
Example #10
0
                        help="stretch threshold",
                        type=float,
                        default=1.e-4)

    args = parser.parse_args()

    cfg_file = args.cfg_file
    gt_ref = args.gt_ref
    mtol = args.misorientation
    ctol = args.centroid
    vtol = args.stretch

    # load the config object
    cfg = config.open(cfg_file)[0]
    grains_table = np.loadtxt(gt_ref, ndmin=2)
    ref_grain_params = grains_table[:, 3:15]
    gresults = fit_grains(cfg,
                          grains_table,
                          show_progress=False,
                          ids_to_refine=None,
                          write_spots_files=False)
    cresult = compare_grain_fits(np.vstack([i[-1] for i in gresults]),
                                 ref_grain_params,
                                 mtol=mtol,
                                 ctol=ctol,
                                 vtol=vtol)
    if cresult:
        print("test passed")
    else:
        print("test failed")