Exemple #1
0
def cml_refine_agls_wrap(vec_in, data, flag_weights=False):
    # vec_in: [phi_i, theta_i, psi_i]
    # data:   [Prj, Ori, iprj]

    # unpack
    phi, theta, psi = vec_in
    Prj, Ori, iprj = data

    # prepare the variables
    Ori[4 * iprj] = phi
    Ori[4 * iprj + 1] = theta
    Ori[4 * iprj + 2] = psi

    # compute the discrepancy
    disc = cml_disc(Prj, Ori, True, flag_weights)

    return -disc
Exemple #2
0
def cml_refine_agls_wrap(vec_in, data, flag_weights = False):
	# vec_in: [phi_i, theta_i, psi_i]
	# data:   [Prj, Ori, iprj]

	# unpack
	phi, theta, psi = vec_in
	Prj, Ori, iprj  = data

	# prepare the variables
	Ori[4*iprj]   = phi
	Ori[4*iprj+1] = theta
	Ori[4*iprj+2] = psi

	# compute the discrepancy
	disc = cml_disc(Prj, Ori, True, flag_weights)

	return -disc
Exemple #3
0
def cml_find_structure(Prj, Ori, Rot, outdir, outname, maxit, first_zero,
                       flag_weights):
    from projection import cml_export_progress, cml_disc, cml_export_txtagls
    import time, sys

    # global vars
    global g_i_prj, g_n_prj, g_n_anglst, g_anglst, g_d_psi, g_debug, g_n_lines, g_seq

    # list of free orientation
    ocp = [-1] * g_n_anglst

    if first_zero:
        listprj = range(1, g_n_prj)
        ocp[0] = 0
    else:
        listprj = range(g_n_prj)

    # to stop when the solution oscillates
    period_disc = [0, 0, 0]
    period_ct = 0
    period_th = 2

    # iteration loop
    for ite in xrange(maxit):
        t_start = time.time()

        # loop over i prj
        change = False
        for iprj in listprj:

            # Store current the current orientation
            ind = 4 * iprj
            store_phi = Ori[ind]
            store_theta = Ori[ind + 1]
            store_psi = Ori[ind + 2]
            cur_agl = Ori[ind + 3]
            if cur_agl != -1: ocp[cur_agl] = -1

            # prepare active index of cml for weighting in order to earn time later
            iw = [0] * (g_n_prj - 1)
            c = 0
            ct = 0
            for i in xrange(g_n_prj):
                for j in xrange(i + 1, g_n_prj):
                    if i == iprj or j == iprj:
                        iw[ct] = c
                        ct += 1
                    c += 1

            # loop over all angles
            best_disc = 1.0e20
            best_psi = -1
            best_iagl = -1
            for iagl in xrange(g_n_anglst):
                # if orientation is free
                if ocp[iagl] == -1:
                    # assign new orientation
                    Ori[ind] = g_anglst[iagl][0]
                    Ori[ind + 1] = g_anglst[iagl][1]
                    Rot = Util.cml_update_rot(Rot, iprj, Ori[ind],
                                              Ori[ind + 1], 0.0)
                    # weights
                    if flag_weights:
                        cml = Util.cml_line_in3d(Ori, g_seq, g_n_prj,
                                                 g_n_lines)
                        weights = Util.cml_weights(cml)
                        mw = max(weights)
                        for i in xrange(g_n_lines):
                            weights[i] = mw - weights[i]
                        sw = sum(weights)
                        if sw == 0:
                            weights = [6.28 / float(g_n_lines)] * g_n_lines
                        else:
                            for i in xrange(g_n_lines):
                                weights[i] /= sw
                                weights[i] *= weights[i]
                    else:
                        weights = [1.0] * g_n_lines

                    # spin all psi
                    com = Util.cml_line_insino(Rot, iprj, g_n_prj)
                    res = Util.cml_spin_psi(Prj, com, weights, iprj, iw,
                                            g_n_psi, g_d_psi, g_n_prj)

                    # select the best
                    if res[0] < best_disc:
                        best_disc = res[0]
                        best_psi = res[1]
                        best_iagl = iagl

                    if g_debug:
                        cml_export_progress(outdir, ite, iprj, iagl, res[1],
                                            res[0], 'progress')
                else:
                    if g_debug:
                        cml_export_progress(outdir, ite, iprj, iagl, -1, -1,
                                            'progress')

            # if change, assign
            if best_iagl != cur_agl:
                ocp[best_iagl] = iprj
                Ori[ind] = g_anglst[best_iagl][0]  # phi
                Ori[ind + 1] = g_anglst[best_iagl][1]  # theta
                Ori[ind + 2] = best_psi * g_d_psi  # psi
                Ori[ind + 3] = best_iagl  # index
                change = True
            else:
                if cur_agl != -1: ocp[cur_agl] = iprj
                Ori[ind] = store_phi
                Ori[ind + 1] = store_theta
                Ori[ind + 2] = store_psi
                Ori[ind + 3] = cur_agl

            Rot = Util.cml_update_rot(Rot, iprj, Ori[ind], Ori[ind + 1],
                                      Ori[ind + 2])

            if g_debug:
                cml_export_progress(outdir, ite, iprj, best_iagl,
                                    best_psi * g_d_psi, best_disc, 'choose')

        # if one change, compute new full disc
        disc = cml_disc(Prj, Ori, Rot, flag_weights)

        # display in the progress file
        cml_export_txtagls(outdir, outname, Ori, disc, 'Ite: %03i' % (ite + 1))

        if not change: break

        # to stop when the solution oscillates
        period_disc.pop(0)
        period_disc.append(disc)
        if period_disc[0] == period_disc[2]:
            period_ct += 1
            if period_ct >= period_th and min(period_disc) == disc:
                angfile = open(outdir + '/' + outname, 'a')
                angfile.write('\nSTOP SOLUTION UNSTABLE\n')
                angfile.write('Discrepancy period: %s\n' % period_disc)
                angfile.close()
                break
        else:
            period_ct = 0

    return Ori, disc, ite
Exemple #4
0
def cml_find_structure2(Prj, Ori, Rot, outdir, outname, maxit, first_zero,
                        flag_weights, myid, main_node, number_of_proc):
    from projection import cml_export_progress, cml_disc, cml_export_txtagls
    import time, sys
    from random import shuffle, random

    from mpi import MPI_FLOAT, MPI_INT, MPI_SUM, MPI_COMM_WORLD
    from mpi import mpi_reduce, mpi_bcast, mpi_barrier

    # global vars
    global g_i_prj, g_n_prj, g_n_anglst, g_anglst, g_d_psi, g_debug, g_n_lines, g_seq

    # list of free orientation
    ocp = [-1] * g_n_anglst

    if first_zero:
        listprj = range(1, g_n_prj)
        ocp[0] = 0
    else:
        listprj = range(g_n_prj)

    # to stop when the solution oscillates
    period_disc = [0, 0, 0]
    period_ct = 0
    period_th = 2
    #if not flag_weights:   weights = [1.0] * g_n_lines

    # iteration loop
    for ite in xrange(maxit):
        #print ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    ite = ", ite, "   myid = ", myid
        t_start = time.time()

        # loop over i prj
        change = False
        tlistprj = listprj[:]
        shuffle(tlistprj)
        nnn = len(tlistprj)
        tlistprj = mpi_bcast(tlistprj, nnn, MPI_INT, main_node, MPI_COMM_WORLD)
        tlistprj = map(int, tlistprj)
        """
		if(ite>1 and ite%5 == 0  and ite<140):
			if(myid == main_node):
				for i in xrange(0,len(tlistprj),5):
					ind          = 4*i
					Ori[ind]      =  360.*random()
					Ori[ind+1]    =  180.*random()
					Ori[ind+2]    =  360.*random()
					Ori[ind+3]    =  -1
				for i in xrange(len(tlistprj)):
					ind          = 4*i
					Ori[ind+3]    = float(Ori[ind+3])
			nnn = len(Ori)
			Ori = mpi_bcast(Ori, nnn, MPI_FLOAT, main_node, MPI_COMM_WORLD)
			Ori = map(float, Ori)
			for i in xrange(len(tlistprj)):
				ind          = 4*i
				Ori[ind+3]    = int(Ori[ind+3])
		"""

        for iprj in tlistprj:
            #print "**********************************  iprj = ", iprj, g_n_anglst

            # Store current the current orientation
            ind = 4 * iprj
            store_phi = Ori[ind]
            store_theta = Ori[ind + 1]
            store_psi = Ori[ind + 2]
            cur_agl = Ori[ind + 3]
            if cur_agl != -1: ocp[cur_agl] = -1

            # prepare active index of cml for weighting in order to earn time later
            iw = [0] * (g_n_prj - 1)
            c = 0
            ct = 0
            for i in xrange(g_n_prj):
                for j in xrange(i + 1, g_n_prj):
                    if i == iprj or j == iprj:
                        iw[ct] = c
                        ct += 1
                    c += 1

            # loop over all angles
            best_disc_list = [0] * g_n_anglst
            best_psi_list = [0] * g_n_anglst
            for iagl in xrange(myid, g_n_anglst, number_of_proc):
                # if orientation is free
                if ocp[iagl] == -1:
                    # assign new orientation
                    Ori[ind] = g_anglst[iagl][0]
                    Ori[ind + 1] = g_anglst[iagl][1]
                    Rot = Util.cml_update_rot(Rot, iprj, Ori[ind],
                                              Ori[ind + 1], 0.0)
                    # weights
                    if flag_weights:
                        cml = Util.cml_line_in3d(Ori, g_seq, g_n_prj,
                                                 g_n_lines)
                        weights = Util.cml_weights(cml)
                        mw = max(weights)
                        for i in xrange(g_n_lines):
                            weights[i] = mw - weights[i]
                        sw = sum(weights)
                        if sw == 0:
                            weights = [6.28 / float(g_n_lines)] * g_n_lines
                        else:
                            for i in xrange(g_n_lines):
                                weights[i] /= sw
                                weights[i] *= weights[i]

                    # spin all psi
                    com = Util.cml_line_insino(Rot, iprj, g_n_prj)
                    if flag_weights:
                        res = Util.cml_spin_psi(Prj, com, weights, iprj, iw,
                                                g_n_psi, g_d_psi, g_n_prj)
                    else:
                        res = Util.cml_spin_psi_now(Prj, com, iprj, iw,
                                                    g_n_psi, g_d_psi, g_n_prj)

                    # select the best
                    best_disc_list[iagl] = res[0]
                    best_psi_list[iagl] = res[1]

                    if g_debug:
                        cml_export_progress(outdir, ite, iprj, iagl, res[1],
                                            res[0], 'progress')
                else:
                    if g_debug:
                        cml_export_progress(outdir, ite, iprj, iagl, -1, -1,
                                            'progress')
            best_disc_list = mpi_reduce(best_disc_list, g_n_anglst, MPI_FLOAT,
                                        MPI_SUM, main_node, MPI_COMM_WORLD)
            best_psi_list = mpi_reduce(best_psi_list, g_n_anglst, MPI_FLOAT,
                                       MPI_SUM, main_node, MPI_COMM_WORLD)

            best_psi = -1
            best_iagl = -1

            if myid == main_node:
                best_disc = 1.0e20
                for iagl in xrange(g_n_anglst):
                    if best_disc_list[iagl] > 0.0 and best_disc_list[
                            iagl] < best_disc:
                        best_disc = best_disc_list[iagl]
                        best_psi = best_psi_list[iagl]
                        best_iagl = iagl
            best_psi = mpi_bcast(best_psi, 1, MPI_FLOAT, main_node,
                                 MPI_COMM_WORLD)
            best_iagl = mpi_bcast(best_iagl, 1, MPI_INT, main_node,
                                  MPI_COMM_WORLD)
            best_psi = float(best_psi[0])
            best_iagl = int(best_iagl[0])

            #print "xxxxx myid = ", myid, "    best_psi = ", best_psi, "   best_ialg = ", best_iagl

            # if change, assign
            if best_iagl != cur_agl:
                ocp[best_iagl] = iprj
                Ori[ind] = g_anglst[best_iagl][0]  # phi
                Ori[ind + 1] = g_anglst[best_iagl][1]  # theta
                Ori[ind + 2] = best_psi * g_d_psi  # psi
                Ori[ind + 3] = best_iagl  # index
                change = True
            else:
                if cur_agl != -1: ocp[cur_agl] = iprj
                Ori[ind] = store_phi
                Ori[ind + 1] = store_theta
                Ori[ind + 2] = store_psi
                Ori[ind + 3] = cur_agl

            Rot = Util.cml_update_rot(Rot, iprj, Ori[ind], Ori[ind + 1],
                                      Ori[ind + 2])

            if g_debug:
                cml_export_progress(outdir, ite, iprj, best_iagl,
                                    best_psi * g_d_psi, best_disc, 'choose')

        # if one change, compute new full disc
        disc = cml_disc(Prj, Ori, Rot, flag_weights)

        # display in the progress file
        if myid == main_node:
            cml_export_txtagls(outdir, outname, Ori, disc,
                               'Ite: %03i' % (ite + 1))

        if not change: break

        # to stop when the solution oscillates
        period_disc.pop(0)
        period_disc.append(disc)
        if period_disc[0] == period_disc[2]:
            period_ct += 1
            if period_ct >= period_th and min(
                    period_disc) == disc and myid == main_node:
                angfile = open(outdir + '/' + outname, 'a')
                angfile.write('\nSTOP SOLUTION UNSTABLE\n')
                angfile.write('Discrepancy period: %s\n' % period_disc)
                angfile.close()
                break
        else:
            period_ct = 0
        mpi_barrier(MPI_COMM_WORLD)

    return Ori, disc, ite
Exemple #5
0
def cml_find_structure2(Prj, Ori, Rot, outdir, outname, maxit, first_zero, flag_weights, myid, main_node, number_of_proc):
	from projection import cml_export_progress, cml_disc, cml_export_txtagls
	import time, sys
	from random import shuffle,random

	from mpi import MPI_FLOAT, MPI_INT, MPI_SUM, MPI_COMM_WORLD
	from mpi import mpi_reduce, mpi_bcast, mpi_barrier

	# global vars
	global g_i_prj, g_n_prj, g_n_anglst, g_anglst, g_d_psi, g_debug, g_n_lines, g_seq

	# list of free orientation
	ocp = [-1] * g_n_anglst

	if first_zero:
		listprj = range(1, g_n_prj)
		ocp[0]  = 0 
	else:   listprj = range(g_n_prj)

	# to stop when the solution oscillates
	period_disc = [0, 0, 0]
	period_ct   = 0
	period_th   = 2
	#if not flag_weights:   weights = [1.0] * g_n_lines

	# iteration loop
	for ite in xrange(maxit):
		#print ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    ite = ", ite, "   myid = ", myid
		t_start = time.time()

		# loop over i prj
		change = False
		tlistprj = listprj[:]
		shuffle(tlistprj)
		nnn = len(tlistprj)
		tlistprj = mpi_bcast(tlistprj, nnn, MPI_INT, main_node, MPI_COMM_WORLD)
		tlistprj = map(int, tlistprj)
		"""
		if(ite>1 and ite%5 == 0  and ite<140):
			if(myid == main_node):
				for i in xrange(0,len(tlistprj),5):
					ind          = 4*i
					Ori[ind]      =  360.*random()
					Ori[ind+1]    =  180.*random()
					Ori[ind+2]    =  360.*random()
					Ori[ind+3]    =  -1
				for i in xrange(len(tlistprj)):
					ind          = 4*i
					Ori[ind+3]    = float(Ori[ind+3])
			nnn = len(Ori)
			Ori = mpi_bcast(Ori, nnn, MPI_FLOAT, main_node, MPI_COMM_WORLD)
			Ori = map(float, Ori)
			for i in xrange(len(tlistprj)):
				ind          = 4*i
				Ori[ind+3]    = int(Ori[ind+3])
		"""

		for iprj in tlistprj:
			#print "**********************************  iprj = ", iprj, g_n_anglst

			# Store current the current orientation
			ind          = 4*iprj
			store_phi    = Ori[ind]
			store_theta  = Ori[ind+1]
			store_psi    = Ori[ind+2]
			cur_agl      = Ori[ind+3]
			if cur_agl  != -1: ocp[cur_agl] = -1

			# prepare active index of cml for weighting in order to earn time later
			iw = [0] * (g_n_prj - 1)
			c  = 0
			ct = 0
			for i in xrange(g_n_prj):
				for j in xrange(i+1, g_n_prj):
					if i == iprj or j == iprj:
						iw[ct] = c
						ct += 1
					c += 1

			# loop over all angles
			best_disc_list = [0]*g_n_anglst
			best_psi_list  = [0]*g_n_anglst
			for iagl in xrange(myid, g_n_anglst, number_of_proc):
				# if orientation is free
				if ocp[iagl] == -1:
					# assign new orientation
					Ori[ind]   = g_anglst[iagl][0]
					Ori[ind+1] = g_anglst[iagl][1]
					Rot        = Util.cml_update_rot(Rot, iprj, Ori[ind], Ori[ind+1], 0.0)
					# weights
					if flag_weights:
						cml = Util.cml_line_in3d(Ori, g_seq, g_n_prj, g_n_lines)
						weights = Util.cml_weights(cml)
						mw  = max(weights)
						for i in xrange(g_n_lines): weights[i]  = mw - weights[i]
						sw = sum(weights)
						if sw == 0:
							weights = [6.28 / float(g_n_lines)] * g_n_lines
						else:
							for i in xrange(g_n_lines):
								weights[i] /= sw
								weights[i] *= weights[i]

					# spin all psi
					com = Util.cml_line_insino(Rot, iprj, g_n_prj)
					if flag_weights:
						res = Util.cml_spin_psi(Prj, com, weights, iprj, iw, g_n_psi, g_d_psi, g_n_prj)
					else:
						res = Util.cml_spin_psi_now(Prj, com, iprj, iw, g_n_psi, g_d_psi, g_n_prj)

					# select the best
					best_disc_list[iagl] = res[0]
					best_psi_list[iagl]  = res[1]

					if g_debug: cml_export_progress(outdir, ite, iprj, iagl, res[1], res[0], 'progress')
				else:
					if g_debug: cml_export_progress(outdir, ite, iprj, iagl, -1, -1, 'progress')
			best_disc_list = mpi_reduce(best_disc_list, g_n_anglst, MPI_FLOAT, MPI_SUM, main_node, MPI_COMM_WORLD)
			best_psi_list = mpi_reduce(best_psi_list, g_n_anglst, MPI_FLOAT, MPI_SUM, main_node, MPI_COMM_WORLD)

			best_psi = -1
			best_iagl = -1

			if myid == main_node:
				best_disc = 1.0e20
				for iagl in xrange(g_n_anglst):
					if best_disc_list[iagl] > 0.0 and best_disc_list[iagl] < best_disc:
						best_disc = best_disc_list[iagl]
						best_psi = best_psi_list[iagl]
						best_iagl = iagl
			best_psi = mpi_bcast(best_psi, 1, MPI_FLOAT, main_node, MPI_COMM_WORLD)
			best_iagl = mpi_bcast(best_iagl, 1, MPI_INT, main_node, MPI_COMM_WORLD)
			best_psi = float(best_psi[0])
			best_iagl =  int(best_iagl[0])
			
			#print "xxxxx myid = ", myid, "    best_psi = ", best_psi, "   best_ialg = ", best_iagl

			# if change, assign
			if best_iagl != cur_agl:
				ocp[best_iagl] = iprj
				Ori[ind]       = g_anglst[best_iagl][0] # phi
				Ori[ind+1]     = g_anglst[best_iagl][1] # theta
				Ori[ind+2]     = best_psi * g_d_psi     # psi
				Ori[ind+3]     = best_iagl              # index
				change = True
			else:
				if cur_agl != -1: ocp[cur_agl] = iprj
				Ori[ind]    = store_phi
				Ori[ind+1]  = store_theta
				Ori[ind+2]  = store_psi
				Ori[ind+3]  = cur_agl

			Rot = Util.cml_update_rot(Rot, iprj, Ori[ind], Ori[ind+1], Ori[ind+2])

			if g_debug: cml_export_progress(outdir, ite, iprj, best_iagl, best_psi * g_d_psi, best_disc, 'choose')

		# if one change, compute new full disc
		disc = cml_disc(Prj, Ori, Rot, flag_weights)

		# display in the progress file
		if myid == main_node:
			cml_export_txtagls(outdir, outname, Ori, disc, 'Ite: %03i' % (ite + 1))

		if not change: break

		# to stop when the solution oscillates
		period_disc.pop(0)
		period_disc.append(disc)
		if period_disc[0] == period_disc[2]:
			period_ct += 1
			if period_ct >= period_th and min(period_disc) == disc and myid == main_node:
				angfile = open(outdir + '/' + outname, 'a')
				angfile.write('\nSTOP SOLUTION UNSTABLE\n')
				angfile.write('Discrepancy period: %s\n' % period_disc)
				angfile.close()
				break
		else:
			period_ct = 0
		mpi_barrier(MPI_COMM_WORLD)

	return Ori, disc, ite
Exemple #6
0
def cml_find_structure(Prj, Ori, Rot, outdir, outname, maxit, first_zero, flag_weights):
	from projection import cml_export_progress, cml_disc, cml_export_txtagls
	import time, sys

	# global vars
	global g_i_prj, g_n_prj, g_n_anglst, g_anglst, g_d_psi, g_debug, g_n_lines, g_seq

	# list of free orientation
	ocp = [-1] * g_n_anglst

	if first_zero:
		listprj = range(1, g_n_prj)
		ocp[0]  = 0 
	else:   listprj = range(g_n_prj)

	# to stop when the solution oscillates
	period_disc = [0, 0, 0]
	period_ct   = 0
	period_th   = 2

	# iteration loop
	for ite in xrange(maxit):
		t_start = time.time()

		# loop over i prj
		change = False
		for iprj in listprj:

			# Store current the current orientation
			ind          = 4*iprj
			store_phi    = Ori[ind]
			store_theta  = Ori[ind+1]
			store_psi    = Ori[ind+2]
			cur_agl      = Ori[ind+3]
			if cur_agl  != -1: ocp[cur_agl] = -1

			# prepare active index of cml for weighting in order to earn time later
			iw = [0] * (g_n_prj - 1)
			c  = 0
			ct = 0
			for i in xrange(g_n_prj):
				for j in xrange(i+1, g_n_prj):
					if i == iprj or j == iprj:
						iw[ct] = c
						ct += 1
					c += 1

			# loop over all angles
			best_disc = 1.0e20
			best_psi  = -1
			best_iagl = -1
			for iagl in xrange(g_n_anglst):
				# if orientation is free
				if ocp[iagl] == -1:
					# assign new orientation
					Ori[ind]   = g_anglst[iagl][0]
					Ori[ind+1] = g_anglst[iagl][1]
					Rot        = Util.cml_update_rot(Rot, iprj, Ori[ind], Ori[ind+1], 0.0)
					# weights
					if flag_weights:
						cml = Util.cml_line_in3d(Ori, g_seq, g_n_prj, g_n_lines)
						weights = Util.cml_weights(cml)
						mw  = max(weights)
						for i in xrange(g_n_lines): weights[i]  = mw - weights[i]
						sw = sum(weights)
						if sw == 0:
							weights = [6.28 / float(g_n_lines)] * g_n_lines
						else:
							for i in xrange(g_n_lines):
								weights[i] /= sw
								weights[i] *= weights[i]
					else:   weights = [1.0] * g_n_lines

					# spin all psi
					com = Util.cml_line_insino(Rot, iprj, g_n_prj)
					res = Util.cml_spin_psi(Prj, com, weights, iprj, iw, g_n_psi, g_d_psi, g_n_prj)

					# select the best
					if res[0] < best_disc:
						best_disc = res[0]
						best_psi  = res[1]
						best_iagl = iagl

					if g_debug: cml_export_progress(outdir, ite, iprj, iagl, res[1], res[0], 'progress')
				else:
					if g_debug: cml_export_progress(outdir, ite, iprj, iagl, -1, -1, 'progress')

			# if change, assign
			if best_iagl != cur_agl:
				ocp[best_iagl] = iprj
				Ori[ind]       = g_anglst[best_iagl][0] # phi
				Ori[ind+1]     = g_anglst[best_iagl][1] # theta
				Ori[ind+2]     = best_psi * g_d_psi     # psi
				Ori[ind+3]     = best_iagl              # index
				change = True
			else:
				if cur_agl != -1: ocp[cur_agl] = iprj
				Ori[ind]    = store_phi
				Ori[ind+1]  = store_theta
				Ori[ind+2]  = store_psi
				Ori[ind+3]  = cur_agl

			Rot = Util.cml_update_rot(Rot, iprj, Ori[ind], Ori[ind+1], Ori[ind+2])

			if g_debug: cml_export_progress(outdir, ite, iprj, best_iagl, best_psi * g_d_psi, best_disc, 'choose')

		# if one change, compute new full disc
		disc = cml_disc(Prj, Ori, Rot, flag_weights)

		# display in the progress file
		cml_export_txtagls(outdir, outname, Ori, disc, 'Ite: %03i' % (ite + 1))

		if not change: break

		# to stop when the solution oscillates
		period_disc.pop(0)
		period_disc.append(disc)
		if period_disc[0] == period_disc[2]:
			period_ct += 1
			if period_ct >= period_th and min(period_disc) == disc:
				angfile = open(outdir + '/' + outname, 'a')
				angfile.write('\nSTOP SOLUTION UNSTABLE\n')
				angfile.write('Discrepancy period: %s\n' % period_disc)
				angfile.close()
				break
		else:
			period_ct = 0

	return Ori, disc, ite