def chuckpdb_to_fragpdb( pdb, frag_size, overwrite ):
    junk, junk, pdbline_dict, junk = pdb_util.create_xyzDict( pdb )

    idx = 0
    rsds = sorted(pdbline_dict.keys())
    for rsd in rsds:
        frag_rsds = rsds[idx:idx+frag_size]
        if len(frag_rsds) < frag_size: break # bc we've sorted
        print frag_rsds
        frag_outfn = "after_rotation_frags.%s.%s.0.0.cmfg.pdb" %( frag_size, rsd )
        if not overwrite:
            assert not exists( frag_outfn ), frag_outfn + " existsed!"
        fraglines = open( frag_outfn, "w" )
        for i in frag_rsds:
            fraglines.write( pdbline_dict[ i ] )
        
        fraglines.close()
        idx+=1
    parser = ArgumentParser()
    parser.add_argument("--pdb", required=True, help="")
    parser.add_argument("-f1", "--fastaA", required=True, help="")
    parser.add_argument("-f2", "--fastaB", required=True, help="")
    parser.add_argument("-p", "--print_rsds", choices=["A", "B"], required=True, help="")
    parser.add_argument("--assigned_rsds", action="store_true", default=False, help="")
    args = parser.parse_args()

    seqA = ( seq_util.fasta_file_reader( args.fastaA ) )
    offset = len(seqA)
    seqB = ( seq_util.fasta_file_reader( args.fastaB ) )
    seqAB = seqA+seqB
    seqAB_rsds = range( 1, len(seqAB)+1 )
    #print len(seqAB_rsds)
    
    xyz_dict, junk, pdbline_dict = pdb_util.create_xyzDict( args.pdb )
    assigned_rsds = xyz_dict.keys()
    #print len(assigned_rsds)
    unassigned_rsds = list( set(seqAB_rsds) - set(assigned_rsds) )

    if args.assigned_rsds:
        print "# assigned_rsds"
        rsd_list = assigned_rsds
    else:
        print "# unassigned_rsds"
        rsd_list = unassigned_rsds

    rsds_A, rsds_B = separator( rsd_list, offset )
    
    if args.print_rsds == "A":
        printer( rsds_A )
    return (dist/gap_size)*((20/(1+math.exp(-0.1*(gap_size-40))))+1)


if __name__=="__main__":
    parser = ArgumentParser()
    parser.add_argument("-D1", "--domain_1", nargs="+", required=True, help="")
    parser.add_argument("-D2", "--domain_2", nargs="+", required=True, help="")
    parser.add_argument("-p", "--per_gap_length", default=5, type=float, help="")
    parser.add_argument("-o", "--per_overlap_score", default=1, type=float, help="")
    args = parser.parse_args()

    # create_xyzDict first 
    pdb_xyz_Dict = {}
    for pdb in ( args.domain_1 + args.domain_2 ):
        D1_pdb = basename(pdb)
        pdb_xyz_Dict[ basename(pdb) ] = pdb_util.create_xyzDict( pdb )[0]

    for D1 in args.domain_1:
        for D2 in args.domain_2:
            D1_fn, D2_fn = map( basename, (D1,D2) )

            if ( int(D2_fn[6]) - int(D1_fn[6]) <= 0 ):
                D1, D2 = D2, D1
                D1_fn, D2_fn = map( basename, (D1,D2) )

            if isAdjacent( D1_fn, D2_fn ):
                D1_cterm_rsn, D2_nterm_rsn, gap_size, dist = cal_dist( pdb_xyz_Dict[D1_fn], pdb_xyz_Dict[D2_fn] )
                rmsd = 0.0
                if gap_size >0:
                    #cutoff_score = cal_closability_score( gap_size )
                    #if dist < cutoff_score: