Esempio n. 1
0
                        help="file to read the zfactors")
    parser.add_argument("-m", "--masses", type=float, nargs="+", required=True,
                        help="list of masses for each level")
    parser.add_argument("-v", "--verbose", action="store_true",
                        help="increase output verbosity")

    args = parser.parse_args()
    if args.verbose:
        logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG)
        logging.debug("Verbose debuging mode activated")
    else:
        logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.INFO)

    N = len(args.masses)

    raw_Zs = zfactor.read_coeffs_file(args.overlapsfile)
    assert len(raw_Zs)==N*N, "Length missmatch in levels and coeffs"
    print raw_Zs
    Zs = np.matrix(raw_Zs.identities.values.reshape((N, N))).T
    print Zs
    print "blah"
    for i in range(N):
        for j in range(N):
            print "Correlator_{}{}".format(i,j)
            amps = [Zs[i,level]*Zs[j,level] for level in range(N)]
            print "newaps", amps
            cor = fakecor.make_fake_cor(args.configs, args.times, amps, args.masses)
            cor.writefullfile(args.output_stub+"{}_{}".format(i,j), comp=True)

    logging.info("done")
def sh_optimized_zfacts():
    shops = readops(args.single_hadron_ops)
    mhops = readops(args.full_hadron_ops)
    rotco = overlaps(read_coeffs_file(args.rotation_coeffs))
    fullz = overlaps(read_file(args.full_zfactors))
    indicies = [mhops.index(o)+1 for o in shops]

    OptZ = {}
    # Main calculation below
    # TODO this should be done as matrix multiplication, would be WAY faster but this works.
    for m in range(1,rotco.levels+1):
        value = np.array([np.abs(np.array(np.matrix( np.conj(rotco.get_level(m))) * np.matrix([fullz.get_entry(i,l) for i in indicies]).T))**2 for l in range(1,fullz.levels+1)]).flatten()
        if np.all(value==0):
            break
        OptZ[m] = value

    with open(args.ordering) as orderfile:
        ordering = [int(i.strip()) for i in orderfile.readlines()]


    N = len(OptZ.keys())
    if args.number:
        N = min(N,args.number)
    if args.columns:
        Ncols = args.columns
    else:
        Ncols = ncols(N)
    rows = int(math.ceil(float(N)/Ncols))
    if not args.seperate:
        fig, ax = plt.subplots(ncols=Ncols, nrows=rows)
    with open(args.SHordering) as SHorderfile:
        SHordering = [int(i.strip()) for i in SHorderfile.readlines()]
    for index, m in enumerate(SHordering):
        if index >= N:
            break
        i = (index)/Ncols
        j = (index) % Ncols
        if args.seperate:
            fig, axe = plt.subplots(1)
        else:
            if N <= Ncols:
                axe=ax[j]
            else:
                axe=ax[i][j]
        reordered = [OptZ[m+1][reorderedlevel] for reorderedlevel in ordering]

        axe.bar(range(len(reordered)), reordered, 1.0, color="b")
        # axe.set_title("SH-opt level{}".format(index))
        axe.set_ylim((0,max(reordered)))
        axe.set_ylabel("$|Z|^2$", fontweight='bold', fontsize=30)
        axe.set_xlabel("Level", fontweight='bold', fontsize=30)
        axe.tick_params(axis='both', which='major', labelsize=20)
        plt.tight_layout()
        if args.seperate:
            outfilename = args.output_stub+"_{}.eps".format(index)
            logging.info("Saving plot to {}".format(outfilename))
            plt.savefig(outfilename)
            plt.clf()

    if args.seperate:
        return

    if args.output_stub:
        logging.info("Saving unreordered shopt_zfactors to {}".format(args.output_stub+".nonreordered.out"))
        with open(args.output_stub+".out", 'w') as outfile:
            for level,d in OptZ.iteritems():
                outfile.write("{}, {}\n".format(level, ", ".join(map(str,d))))
        logging.info("Saving shcandidates to {}".format(args.output_stub+".singleresonances"))
        with open(args.output_stub+".singleresonances", 'w') as resfile:
            for level,d in OptZ.iteritems():
                fixd = np.nan_to_num(d)
                if max(fixd) > 0:
                    resfile.write("{}, {}\n".format(level, np.argmax(fixd)))

        plt.rcParams.update({'font.size': 10})
        fig.set_size_inches(18.5,8.5)
        plt.tight_layout()
        if args.eps:
            logging.info("Saving plot to {}".format(args.output_stub+".eps"))
            plt.savefig(args.output_stub+".eps")
        else:
            logging.info("Saving plot to {}".format(args.output_stub+".png"))
            plt.savefig(args.output_stub+".png",dpi=100)
    else:
        plt.tight_layout()
        plt.show()
Esempio n. 3
0
def alt_zfactor(corwild, zrotfile, rotfile, ops, t0, outputstub,
                maxlevels=None, normalize=False, reconstruct_stub=None, inputemass=None):
    # zrots = read_zrots(zrotfile)
    fit_values = read_level_fits(zrotfile)
    N = len(fit_values)
    N = len(ops)
    levels_to_make = range(min(N, maxlevels, len(fit_values)))
    raw_v = zfactor.read_coeffs_file(rotfile)
    v = np.matrix(raw_v.identities.values.reshape((N, N))).T
    roterror = np.matrix(raw_v.error.values.reshape((N, N))).T
    cormat, errmat = build_cor_mat_error(corwild, ops, t0)

    Zs = {}
    err = {}
    ABS = np.abs
    def nothing(a):
        return a
    if args.complex:
        ABS = nothing

    for level in levels_to_make:
        zr = fit_values.amp[level]
        #err[level] = zrots.error[level]*np.ones(N)
        for op in range(N):
            v_n = (v[:, level])
            ev_n = np.ravel(roterror[:, level])
            Zs[level] = [ABS((cormat[j]*(v_n)).flat[0])*np.sqrt(zr) for j in range(len(ops))]
            err[level] = [ABS((cormat[j]*(v_n)).flat[0])*np.sqrt(fit_values.amp_error[level]) +
                          ABS((errmat[j]*(v_n)).flat[0])*np.sqrt(zr)
                          for j in range(len(ops))]
            #err[level] = np.sqrt(fit_values.amp_error[level])*ABS(v_n)+np.sqrt(zr)*ABS(ev_n)

    # normalized_Zs = zfactor.normalize_Zs(Zs, normalize)
    A = np.array(Zs.values())
    if normalize:
        maximums = np.array([max(np.abs(A[:, i])) for i in range(len(Zs[0]))])
        normalized_Zs = {k: np.abs(values)/maximums for k, values in Zs.iteritems()}
        normalized_err = {k: np.abs(values)/maximums for k, values in err.iteritems()}
    else:
        normalized_Zs = Zs
        normalized_err = err

    # print err
    # print normalized_err

    if(outputstub):
        logging.info("Writing alt_zfactors to {}".format(outputstub+".out"))
        with open(outputstub+".out", 'w') as outfile:
            outfile.write("# normalized Zfactors\n")
            for level in levels_to_make:
                for j in range(N):
                    if args.complex:
                        outfile.write("{:d}{:03d} ({},{}) ({},{})\n".format(j+1, level+1,
                                                                            np.real(normalized_Zs[level][j]), np.imag(normalized_Zs[level][j]),
                                                                            np.real(normalized_err[level][j]), np.imag(normalized_err[level][j])))
                    else:
                        outfile.write("{:d}{:03d} {} {}\n".format(j+1, level+1,
                                                                  normalized_Zs[level][j], normalized_err[level][j]))

    if(reconstruct_stub):
        reconstructed_correaltors(Zs, err, fit_values, ops, reconstruct_stub)