def check_consistency_uids_gids(is_uvps, uids, gids): u_seq = 0 for seq, is_uvp in enumerate(is_uvps): if is_uvp: equal(uids[seq], u_seq) equal(gids[u_seq], seq) u_seq += 1
def test_opf(): csv_folder_name = os.path.join(os.path.dirname(__file__), "..", "examples", "opf-storage-hvdc","opf-storage-data") n = pypsa.Network(csv_folder_name) target_path = os.path.join(csv_folder_name,"results","generators-p.csv") target_gen_p = pd.read_csv(target_path, index_col=0) #test results were generated with GLPK and other solvers may differ for solver_name in solvers: n.lopf(solver_name=solver_name, pyomo=True) equal(n.generators_t.p.reindex_like(target_gen_p), target_gen_p, decimal=2) if sys.version_info.major >= 3: for solver_name in solvers: status, cond = n.lopf(solver_name=solver_name, pyomo=False) assert status == 'ok' equal(n.generators_t.p.reindex_like(target_gen_p), target_gen_p, decimal=2)
def test_circum_center_radius(): ''' circum_center_radius(): boundary, near lon=0, big triangle ''' from numpy import pi from circumcircle import circum_center_radius from sphere import angle from convert_coord.cart_ll import latlon2xyz # boundary ll1, ll2, ll3 = (0,pi/3), (0,2/3*pi), (pi/6,pi/2) xyz1, xyz2, xyz3 = [latlon2xyz(*ll) for ll in [ll1,ll2,ll3]] center, radius = circum_center_radius(xyz1, xyz2, xyz3) equal(center, (0,1,0)) # near lon=0 ll1, ll2, ll3 = (pi/5, 2*pi-pi/6), (0,pi/7), (pi/7,pi/6) xyz1, xyz2, xyz3 = [latlon2xyz(*ll) for ll in [ll1,ll2,ll3]] center, radius = circum_center_radius(xyz1, xyz2, xyz3) d1 = angle(center, xyz1) d2 = angle(center, xyz2) d3 = angle(center, xyz3) aa_equal(d1, radius, 15) aa_equal(d2, radius, 15) aa_equal(d3, radius, 15) # big triangle ll1, ll2, ll3 = (pi/2,0), (0,0), (0,pi/2) xyz1, xyz2, xyz3 = [latlon2xyz(*ll) for ll in [ll1,ll2,ll3]] center, radius = circum_center_radius(xyz1, xyz2, xyz3) aa_equal(center, latlon2xyz(0.61547970867038737,pi/4), 15)
def main(): ''' main() ''' # # fibonacci() 함수 테스트 # fib_list = list() for fib in fibonacci(): if fib > 89: break else: fib_list.append(fib) a_equal(fib_list, [1, 2, 3, 5, 8, 13, 21, 34, 55, 89]) # # sum_fibonacci_under() 함수 테스트 # equal(sum_fibonacci_under(89), sum([2, 8, 34])) # # 문제 풀이 # summed = sum_fibonacci_under(4000000) print('짝수이면서 4백만 이하인 피보나치 수열의 합?', summed)
def test_make_parameter_header_c(): ''' make_parameter_header(): c ''' import yaml from build import make_parameter_header code_type = 'c' dpath = join(current_dpath, 'src') with open(join(dpath, 'build.yaml'), 'r') as f: build_dict = yaml.load(f) for target_name, src_dict in build_dict['param_header'].items(): header = make_parameter_header(src_dict, code_type, dpath) if target_name == 'param1': expect = ''' // Automatically generated by build.py // Caution: Do Not Modify Manually #define KK 2 #define LLL 3.5 ''' equal(header, expect) elif target_name == 'param2': expect = ''' // Automatically generated by build.py // Caution: Do Not Modify Manually #define MM -1.7 ''' equal(header, expect)
def test_scarr(self): inp = np.array([np.arange(100), np.arange(100, 200)]).reshape(100, 2) inp95 = scarr(inp, "sig95") inpwt = scarr(inp, "whiten") aequal(inp95[:, 0], inp95[:, 1]) equal(inp95[1, 1], 0.0105715990067) assert (inpwt[:, 0] - inpwt[:, 1] < 0).all()
def test_scarr(self): inp = np.array([np.arange(100), np.arange(100, 200)]).reshape(100,2) inp95 = scarr(inp, "sig95") inpwt = scarr(inp, "whiten") aequal(inp95[:,0], inp95[:,1]) equal(inp95[1,1], 0.0105715990067) assert (inpwt[:,0] - inpwt[:,1] < 0).all()
def test_dsig(self): inp = range(100) res50 = dsig(inp, 0, 0, 50) assert min(res50) >= 0.5 assert max(res50) < 1.0 res99 = dsig(inp, 0, 0, 99) assert res99[10] - res50[10] < 0 equal(res99[5], 0.52523106, 6)
def test_make_signature_c(): ''' make_signature_c() ''' from source_module import make_signature_c src_c = ''' void add(int nx, double *a, double *b, double *c) { // size and intent of array arguments for f2py // a :: nx, in // b :: nx, in // c :: nx, inout int i; for (i=0; i<nx; i++) { c[i] = a[i] + b[i]; } } void dummy(int nx, double k, double *a, double *b) { // size and intent of array arguments for f2py // a :: nx, in // b :: nx, inout int i; for (i=0; i<nx; i++) { b[i] = a[i] + k*b[i]; } } ''' ref_sig_c = ''' python module $MODNAME interface subroutine add(nx, a, b, c) intent(c) :: add intent(c) integer, required, intent(in) :: nx real(8), dimension(nx), intent(in) :: a real(8), dimension(nx), intent(in) :: b real(8), dimension(nx), intent(inout) :: c end subroutine subroutine dummy(nx, k, a, b) intent(c) :: dummy intent(c) integer, required, intent(in) :: nx real(8), intent(in) :: k real(8), dimension(nx), intent(in) :: a real(8), dimension(nx), intent(inout) :: b end subroutine end interface end python module ''' sig_c = make_signature_c(src_c) equal(ref_sig_c, sig_c)
def main(): ''' main() ''' cmath = CMath() x = uniform(-1, 1) equal(cmath.cos(x), cos(x))
def test_scale_diff(): mkdir(path("test_scale_diff")) assert sh("cp ../data/test_ab_cnt_deseq.arr test_scale_diff") == 0 assert sh("epicode.py scale_diff test_scale_diff/test_ab_cnt_deseq.arr") == 0 with open("test_scale_diff/test_ab_cnt_deseq_lvl.arr") as fh: head = fh.readline() firs = fh.readline() equal(float(firs.split("\t")[1]), 3.635961336943780431e-01) assert sh("rm -rf test_scale_diff") == 0
def test_scale_features(): mkdir(path("test_scale_features")) assert sh("cp ../data/test_ab_cnt_deseq_lvl.arr test_scale_features") == 0 assert sh("epicode.py scale_features -scalgo sig95 test_scale_features/test_ab_cnt_deseq_lvl.arr") == 0 with open("test_scale_features/test_ab_cnt_deseq_lvl_sig95.arr") as fh: head = fh.readline() firs = fh.readline() equal(float(firs.split("\t")[1]), 1.211047172546386719e-02) assert sh("rm -rf test_scale_features") == 0
def test_code_sklearn(): mkdir(path("test_code_sklearn")) assert sh("cp ../data/a549_start_lvl_sig95.arr test_code_sklearn") == 0 assert sh("epicode.py code_sklearn -c 6 test_code_sklearn/a549_start_lvl_sig95.arr") == 0 with open("test_code_sklearn/a549_start_lvl_sig95_pgnmf-c#6-i#None-p#.epi") as fh: head = fh.readline() firs = fh.readline() equal(float(firs.split("\t")[0]), 4.0693399501) assert sh("rm -rf test_code_sklearn") == 0
def test_scale_pairs(): mkdir(path("test_scale_pairs")) assert sh("cp ../data/test_ab_cnt.arr test_scale_pairs") == 0 assert sh("epicode.py scale_pairs test_scale_pairs/test_ab_cnt.arr") == 0 with open("test_scale_pairs/test_ab_cnt_deseq.arr") as fh: head = fh.readline() firs = fh.readline() equal(float(firs.split("\t")[1]), 1.632993161855451847e+00) assert sh("rm -rf test_scale_pairs") == 0
def test_pypower_case(): #ppopt is a dictionary with the details of the optimization routine to run ppopt = ppoption(PF_ALG=2) #choose DC or AC ppopt["PF_DC"] = True #ppc is a dictionary with details about the network, including baseMVA, branches and generators ppc = case() results, success = runpf(ppc, ppopt) #store results in a DataFrame for easy access results_df = {} #branches columns = 'bus0, bus1, r, x, b, rateA, rateB, rateC, ratio, angle, status, angmin, angmax, p0, q0, p1, q1'.split( ", ") results_df['branch'] = pd.DataFrame(data=results["branch"], columns=columns) #buses columns = [ "bus", "type", "Pd", "Qd", "Gs", "Bs", "area", "v_mag_pu_set", "v_ang_set", "v_nom", "zone", "Vmax", "Vmin" ] results_df['bus'] = pd.DataFrame(data=results["bus"], columns=columns, index=results["bus"][:, 0]) #generators columns = "bus, p, q, q_max, q_min, Vg, mBase, status, p_max, p_min, Pc1, Pc2, Qc1min, Qc1max, Qc2min, Qc2max, ramp_agc, ramp_10, ramp_30, ramp_q, apf".split( ", ") results_df['gen'] = pd.DataFrame(data=results["gen"], columns=columns) #now compute in PyPSA network = pypsa.Network() network.import_from_pypower_ppc(ppc) network.lpf() #compare generator dispatch p_pypsa = network.generators_t.p.loc["now"].values p_pypower = results_df['gen']["p"].values equal(p_pypsa, p_pypower) #compare branch flows for item in ["lines", "transformers"]: df = getattr(network, item) pnl = getattr(network, item + "_t") for si in ["p0", "p1"]: si_pypsa = getattr(pnl, si).loc["now"].values si_pypower = results_df['branch'][si][df.original_index].values equal(si_pypsa, si_pypower)
def test_recode_sklearn(): mkdir(path("test_recode_sklearn")) assert sh("cp ../data/0*sig95.arr test_recode_sklearn") == 0 assert sh("cp ../data/tss_vs_enh_pgnmf-c#6-i#None-p#.epi test_recode_sklearn") == 0 assert sh("epicode.py recode_sklearn -arr test_recode_sklearn/0_tss_vs_enh_lvl_sig95.arr -epi test_recode_sklearn/tss_vs_enh_pgnmf-c#6-i#None-p#.epi -base recode -odn test_recode_sklearn") == 0 with open("test_recode_sklearn/recode.arr") as fh: head = fh.readline() firs = fh.readline() equal(float(firs.split("\t")[0]), 1.250747926106863528e-01) assert sh("rm -rf test_recode_sklearn") == 0
def test_scale_diff(): mkdir(path("test_scale_diff")) assert sh("cp ../data/test_ab_cnt_deseq.arr test_scale_diff") == 0 assert sh( "epicode.py scale_diff test_scale_diff/test_ab_cnt_deseq.arr") == 0 with open("test_scale_diff/test_ab_cnt_deseq_lvl.arr") as fh: head = fh.readline() firs = fh.readline() equal(float(firs.split("\t")[1]), 3.635961336943780431e-01) assert sh("rm -rf test_scale_diff") == 0
def test_scale_features(): mkdir(path("test_scale_features")) assert sh("cp ../data/test_ab_cnt_deseq_lvl.arr test_scale_features") == 0 assert sh( "epicode.py scale_features -scalgo sig95 test_scale_features/test_ab_cnt_deseq_lvl.arr" ) == 0 with open("test_scale_features/test_ab_cnt_deseq_lvl_sig95.arr") as fh: head = fh.readline() firs = fh.readline() equal(float(firs.split("\t")[1]), 1.211047172546386719e-02) assert sh("rm -rf test_scale_features") == 0
def test_load_yaml_dict(): from load_yaml import load_yaml_dict conf_dict = load_yaml_dict('sample.yaml', select=[('ne',30),('np',4)]) ref_dict = {'aa':5, 'bb':2, 'cc':3, 'dd':90., 'ee':5, 'ff':18., \ 'parameter':{'a':4.5, 'b':3.2, 'c':3e5, 'd':4.5+3.2, 'e':4.5/(4.5+3.2)}} for k, v in conf_dict.items(): equal(v, ref_dict[k])
def test_code_sklearn(): mkdir(path("test_code_sklearn")) assert sh("cp ../data/a549_start_lvl_sig95.arr test_code_sklearn") == 0 assert sh( "epicode.py code_sklearn -c 6 test_code_sklearn/a549_start_lvl_sig95.arr" ) == 0 with open("test_code_sklearn/a549_start_lvl_sig95_pgnmf-c#6-i#None-p#.epi" ) as fh: head = fh.readline() firs = fh.readline() equal(float(firs.split("\t")[0]), 4.0693399501) assert sh("rm -rf test_code_sklearn") == 0
def test_multi_code_sklearn(): mkdir(path("test_multicode_sklearn")) assert sh("cp ../data/[01]*sig95.arr test_multicode_sklearn") == 0 assert sh("epicode.py multi_code_sklearn -base test_multicode_sklearn/tve -c 6 test_multicode_sklearn/[01]*sig95.arr") == 0 with open("test_multicode_sklearn/tve_pgnmf-c#6-i#None-p#.epi") as fh: head = fh.readline() firs = fh.readline() equal(float(firs.split("\t")[1]), 2.75326630104) with open("test_multicode_sklearn/tve_pgnmf-c#6-i#None-p#.arr") as fh: head = fh.readline() firs = fh.readline() equal(float(firs.split("\t")[0]), 1.250747926106863528e-01) assert sh("rm -rf test_multicode_sklearn") == 0
def test_sclopf(): csv_folder_name = os.path.join( os.path.dirname(__file__), "..", "examples", "scigrid-de", "scigrid-with-load-gen-trafos", ) n = pypsa.Network(csv_folder_name) # test results were generated with GLPK and other solvers may differ # There are some infeasibilities without line extensions for line_name in ["316", "527", "602"]: n.lines.loc[line_name, "s_nom"] = 1200 # choose the contingencies branch_outages = n.lines.index[:2] objectives = [] for pyomo in [True, False]: n.sclopf( n.snapshots[0], branch_outages=branch_outages, pyomo=pyomo, solver_name=solver_name, ) # For the PF, set the P to the optimised P n.generators_t.p_set = n.generators_t.p.copy() n.generators.loc[:, "p_set_t"] = True n.storage_units_t.p_set = n.storage_units_t.p.copy() n.storage_units.loc[:, "p_set_t"] = True # Check no lines are overloaded with the linear contingency analysis p0_test = n.lpf_contingency(n.snapshots[0], branch_outages=branch_outages) # check loading as per unit of s_nom in each contingency max_loading = (abs(p0_test.divide(n.passive_branches().s_nom, axis=0)).describe().loc["max"]) arr_equal(max_loading, np.ones((len(max_loading))), decimal=4) objectives.append(n.objective) equal(*objectives, decimal=1)
def test_recode_sklearn(): mkdir(path("test_recode_sklearn")) assert sh("cp ../data/0*sig95.arr test_recode_sklearn") == 0 assert sh( "cp ../data/tss_vs_enh_pgnmf-c#6-i#None-p#.epi test_recode_sklearn" ) == 0 assert sh( "epicode.py recode_sklearn -arr test_recode_sklearn/0_tss_vs_enh_lvl_sig95.arr -epi test_recode_sklearn/tss_vs_enh_pgnmf-c#6-i#None-p#.epi -base recode -odn test_recode_sklearn" ) == 0 with open("test_recode_sklearn/recode.arr") as fh: head = fh.readline() firs = fh.readline() equal(float(firs.split("\t")[0]), 1.250747926106863528e-01) assert sh("rm -rf test_recode_sklearn") == 0
def test_pt_in_polygon(): ''' pt_in_polygon(): out, border, in ''' from sphere import pt_in_polygon from convert_coord.cart_ll import latlon2xyz # out polygon = [latlon2xyz(*ll) for ll in [(pi/2,0), (0,0), (0,pi/4)]] point = latlon2xyz(pi/4,2*pi/6) ret = pt_in_polygon(polygon, point) equal(ret, 'out') polygon = [latlon2xyz(*ll) for ll in [(pi/2,0), (0,0), (0,pi/4)]] point = latlon2xyz(-pi/6,pi/4) ret = pt_in_polygon(polygon, point) equal(ret, 'out') # border polygon = [latlon2xyz(*ll) for ll in [(pi/2,0), (0,0), (0,pi/4)]] point = latlon2xyz(pi/4,pi/4) ret = pt_in_polygon(polygon, point) equal(ret, 'border') # in polygon = [latlon2xyz(*ll) for ll in [(pi/2,0), (0,0), (0,pi/4)]] point = latlon2xyz(pi/4,pi/6) ret = pt_in_polygon(polygon, point) equal(ret, 'in')
def test_check_and_make_parameter_header_f90(): ''' check_and_make_parameter_header(): f90 ''' import yaml import os import io import sys from build import check_and_make_parameter_header code_type = 'f90' suffix = '.f90.h' if code_type == 'f90' else '.h' dpath = join(current_dpath, 'src') src_dir = {'f90':'f90', 'c':'c', 'cu':'cuda', 'cl':'opencl'}[code_type] build_dpath = join(dpath, src_dir, 'build') with open(join(dpath, 'build.yaml'), 'r') as f: build_dict = yaml.load(f) # # Remove previous generated files # for target_name, src_dict in build_dict['param_header'].items(): f90_fpath = join(build_dpath, target_name+suffix) if os.path.exists(f90_fpath): os.remove(f90_fpath) # # Make and compile header file # verify stdout and file existence # ret, out, err = capture(check_and_make_parameter_header)(code_type, dpath) expect_list = list() for target_name in sorted(build_dict['param_header'].keys()): f90_fpath = join(build_dpath, target_name+suffix) expect_list.append('{} is generated.'.format(f90_fpath)) equal(out, '\n'.join(expect_list)) for target_name in sorted(build_dict['param_header'].keys()): f90_fpath = join(build_dpath, target_name+suffix) ok_( os.path.exists(f90_fpath) ) # # verify stdout if revision # ret, out, err = capture(check_and_make_parameter_header)(code_type, dpath) expect_list = list() for target_name in sorted(build_dict['param_header'].keys()): f90_fpath = join(build_dpath, target_name+suffix) expect_list.append('{} is up to date.'.format(f90_fpath)) equal(out, '\n'.join(expect_list))
def test_multi_code_sklearn(): mkdir(path("test_multicode_sklearn")) assert sh("cp ../data/[01]*sig95.arr test_multicode_sklearn") == 0 assert sh( "epicode.py multi_code_sklearn -base test_multicode_sklearn/tve -c 6 test_multicode_sklearn/[01]*sig95.arr" ) == 0 with open("test_multicode_sklearn/tve_pgnmf-c#6-i#None-p#.epi") as fh: head = fh.readline() firs = fh.readline() equal(float(firs.split("\t")[1]), 2.75326630104) with open("test_multicode_sklearn/tve_pgnmf-c#6-i#None-p#.arr") as fh: head = fh.readline() firs = fh.readline() equal(float(firs.split("\t")[0]), 1.250747926106863528e-01) assert sh("rm -rf test_multicode_sklearn") == 0
def test_remove_duplicates(): ''' remove_duplicates() : normal case, latlons ''' from duplicate import remove_duplicates # normal case xyzs = [(0,0.5,0),(-0.5,0,0),(0.5,0,0),(1,1.2,0),(0.5,0,0)] ret = remove_duplicates(xyzs) equal(ret, [(0,0.5,0),(-0.5,0,0),(0.5,0,0),(1,1.2,0)]) xyzs = [(0,0.5,0),(-0.5,0,0),(0.5,0,0),(1,1.2,0),(0.5,0,0),(1.2,2.3,0),(-0.5,0,0)] ret = remove_duplicates(xyzs) equal(ret, [(0,0.5,0),(-0.5,0,0),(0.5,0,0),(1,1.2,0),(1.2,2.3,0)])
def main(): ''' main() ''' # # 함수 테스트 # equal(sum_multiple_under(10), 23) # # 문제 풀이 # summed = sum_multiple_under(1000) print('1000보다 작은 자연수 중에서 3 또는 5의 배수의 합?', summed)
def test_intersect_two_greatcircles(): ''' intersect_two_greatcircles(): axis circles, oblique circles, identical ''' from sphere import plane_origin, intersect_two_greatcircles from convert_coord.cart_ll import latlon2xyz #--------------------------------------- # axis circles #--------------------------------------- xyz1 = (1,0,0) xyz2 = (0,1,0) xyz3 = (0,0,1) # x axis plane1 = plane_origin(xyz1, xyz2) plane2 = plane_origin(xyz1, xyz3) ret = intersect_two_greatcircles(plane1, plane2) equal(ret, [(1,0,0), (-1,0,0)]) # y axis plane1 = plane_origin(xyz1, xyz2) plane2 = plane_origin(xyz2, xyz3) ret = intersect_two_greatcircles(plane1, plane2) equal(ret, [(0,1,0), (0,-1,0)]) # z axis plane1 = plane_origin(xyz1, xyz3) plane2 = plane_origin(xyz2, xyz3) ret = intersect_two_greatcircles(plane1, plane2) equal(ret, [(0,0,1), (0,0,-1)]) #--------------------------------------- # oblique circles #--------------------------------------- xyz1 = (0, 0, 1) xyz2 = latlon2xyz(pi/4, pi/4) xyz3 = (1,0,0) plane1 = plane_origin(xyz1, xyz2) plane2 = plane_origin(xyz2, xyz3) ret = intersect_two_greatcircles(plane1, plane2) aa_equal(ret, [xyz2, latlon2xyz(-pi/4, 5*pi/4)], 15) #--------------------------------------- # identical #--------------------------------------- xyz1 = (0, 0, 1) xyz2 = latlon2xyz(pi/4, pi/4) plane = plane_origin(xyz1, xyz2) ret = intersect_two_greatcircles(plane, plane) equal(ret, [None, None])
def test_replace_braket(): from load_yaml import replace_braket conf_dict = { \ 'a': 4.5, \ 'b': 3.2, \ 'c': '3.e5', \ 'd': '<a>+<b>', \ 'e': '<a>/<d>'} for k, v in conf_dict.items(): conf_dict[k] = replace_braket(conf_dict, k) ref_dict = {'a':4.5, 'b':3.2, 'c':3e5, 'd':4.5+3.2, 'e':4.5/(4.5+3.2)} for k, v in conf_dict.items(): equal(v, ref_dict[k])
def test_get_surround_idxs(): ''' LatlonGridRemap.get_surround_idxs(): nlat=180, nlon=360 (regular) ''' from cube_remap import LatlonGridRemap nlat, nlon = 180, 360 tx = 1e-3 ll = LatlonGridRemap(nlat, nlon, 'regular') # Near south pole lat0 = ll.tmp_lats[1] lon0 = ll.tmp_lons[7] ret_idxs = ll.get_surround_idxs(lat0-tx,lon0+tx) equal(ret_idxs, (7,-1,-1,-1)) # Near north pole lat0 = ll.tmp_lats[-2] lon0 = ll.tmp_lons[-2] ret_idxs = ll.get_surround_idxs(lat0+tx,lon0+tx) equal(ret_idxs, (nlat*nlon-1,-1,-1,-1)) # First box lat0 = ll.tmp_lats[1] lon0 = ll.tmp_lons[0] ret_idxs = ll.get_surround_idxs(lat0+tx,lon0+tx) a_equal(ret_idxs, [0,1,nlon,nlon+1]) # Last box lat0 = ll.tmp_lats[-2] lon0 = ll.tmp_lons[-2] ret_idxs = ll.get_surround_idxs(lat0-tx,lon0+tx) a_equal(ret_idxs, [(nlat-1)*nlon-1, (nlat-2)*nlon, nlat*nlon-1, (nlat-1)*nlon]) # Near Meridian lat0 = ll.tmp_lats[1] lon0 = ll.tmp_lons[-2] ret_idxs = ll.get_surround_idxs(lat0+tx,lon0+tx) a_equal(ret_idxs, [nlon-1,0,nlon*2-1,nlon]) # Error cases lat, lon = -0.785398163397, 6.28318530718 ret_idxs = ll.get_surround_idxs(lat,lon) a_equal(ret_idxs, [16199, 15840, 16559, 16200])
def test_minimum_up_time(): """This test is based on https://pypsa.readthedocs.io/en/latest/examples/unit-commitment.html and is not very comprehensive.""" nu = pypsa.Network() snapshots = range(4) nu.set_snapshots(snapshots) nu.add("Bus", "bus") nu.add("Generator", "coal", bus="bus", committable=True, p_min_pu=0.3, marginal_cost=20, p_nom=10000) nu.add("Generator", "gas", bus="bus", committable=True, marginal_cost=70, p_min_pu=0.1, up_time_before=0, min_up_time=3, p_nom=1000) nu.add("Load", "load", bus="bus", p_set=[4000, 800, 5000, 3000]) nu.lopf(nu.snapshots, solver_name=solver_name) expected_status = np.array([[1, 0, 1, 1], [1, 1, 1, 0]], dtype=float).T equal(nu.generators_t.status.values, expected_status) expected_dispatch = np.array([[3900, 0, 4900, 3000], [100, 800, 100, 0]], dtype=float).T equal(nu.generators_t.p.values, expected_dispatch)
def test_polygon_line(): ''' intersection between polygon and line ''' #------------------------------------------------- # inclusion #------------------------------------------------- poly = Polygon([(0,0),(0,1),(1,1),(1,0)]) line = LineString([(0,0), (0.5,0.5)]) iline = poly.intersection(line) equal(np.sqrt(2)*0.5, iline.length) a_equal(line, np.array(iline.coords)) #------------------------------------------------- # partially #------------------------------------------------- poly = Polygon([(0,0),(0,1),(1,1),(1,0)]) line = LineString([(0.5,0.5),(1.5,1.5)]) iline = poly.intersection(line) equal(np.sqrt(2)*0.5, iline.length) a_equal(LineString([(0.5,0.5),(1,1)]), np.array(iline.coords)) #------------------------------------------------- # not intersection #------------------------------------------------- poly = Polygon([(0,0),(0,1),(1,1),(1,0)]) line = LineString([(1,1),(2,2)]) iline = poly.intersection(line) equal(0, iline.length)
def test_angle(): ''' angle(): yz plane circle, oblique circle ''' from sphere import angle from convert_coord.cart_ll import latlon2xyz ret = angle(latlon2xyz(pi/4,0), latlon2xyz(0,0)) equal(ret, pi/4) ret = angle(latlon2xyz(pi/2,0), latlon2xyz(0,0)) equal(ret, pi/2) ret = angle(latlon2xyz(0,0), latlon2xyz(0,0)) equal(ret, 0) ret = angle(latlon2xyz(pi/4,0), latlon2xyz(-pi/4,0)) aa_equal(ret, pi/2, 15) ret = angle(latlon2xyz(pi/2,0), latlon2xyz(-pi/4,0)) aa_equal(ret, 3*pi/4, 15) ret = angle(latlon2xyz(pi/2,0), latlon2xyz(-pi/2,0)) aa_equal(ret, pi, 15)
def test_duplicate_idxs(): ''' duplicate_idxs() : normal case, latlons ''' from duplicate import duplicate_idxs # normal case xyzs = [(0,0.5,0),(-0.5,0,0),(0.5,0,0),(1,1.2,0),(0.5,0,0)] ret = duplicate_idxs(xyzs) equal(ret, [4]) xyzs = [(0,0.5,0),(-0.5,0,0),(0.5,0,0),(1,1.2,0),(0.5,0,0),(1.2,2.3,0),(-0.5,0,0)] ret = duplicate_idxs(xyzs) equal(ret, [6,4]) # error case xyzs = [(-0.69766285707571141, 1.5271630954950388, 0), \ (-0.69766285707571152, 1.5271630954950384, 0), \ (-0.78492204764598783, 1.5271630954950381, 0), \ (-0.78492204764598794, 1.5271630954950384, 0), \ (-0.78492204764598794, 1.6144295580947545, 0), \ (-0.69766285707571218, 1.6144295580947559, 0), \ (-0.69766285707571163, 1.6144295580947547, 0)] ret = duplicate_idxs(xyzs) equal(ret, [1,3,6])
def test_get_surround_idxs_2(): ''' LatlonGridRemap.get_surround_idxs(): nlat=192, nlon=384 (gaussian) ''' from cube_remap import LatlonGridRemap nlat, nlon = 192, 384 tx = 1e-5 ll = LatlonGridRemap(nlat, nlon, 'gaussian') # Near south pole lat0 = ll.tmp_lats[1] lon0 = ll.tmp_lons[7] ret_idxs = ll.get_surround_idxs(lat0-tx,lon0+tx) equal(ret_idxs, (7,-1,-1,-1)) # Near north pole lat0 = ll.tmp_lats[-2] lon0 = ll.tmp_lons[-2] ret_idxs = ll.get_surround_idxs(lat0+tx,lon0+tx) equal(ret_idxs, (nlat*nlon-1,-1,-1,-1)) # First box lat0 = ll.tmp_lats[1] lon0 = ll.tmp_lons[0] ret_idxs = ll.get_surround_idxs(lat0+tx,lon0+tx) a_equal(ret_idxs, [0,1,nlon,nlon+1]) # Last box lat0 = ll.tmp_lats[-2] lon0 = ll.tmp_lons[-2] ret_idxs = ll.get_surround_idxs(lat0-tx,lon0+tx) a_equal(ret_idxs, [(nlat-1)*nlon-1, (nlat-2)*nlon, nlat*nlon-1, (nlat-1)*nlon]) # Near Meridian lat0 = ll.tmp_lats[1] lon0 = ll.tmp_lons[-2] ret_idxs = ll.get_surround_idxs(lat0+tx,lon0+tx) a_equal(ret_idxs, [nlon-1,0,nlon*2-1,nlon])
def check_area_ratio(ncf, SCRIP=False): from util.misc.compare_float import feq num_links = len(ncf.dimensions["num_links"]) dsts = ncf.variables["dst_address"][:] srcs = ncf.variables["src_address"][:] wgts = ncf.variables["remap_matrix"][:] if SCRIP: up_size = len(ncf.dimensions["dst_grid_size"]) f = np.zeros(up_size, "f8") for i in xrange(num_links): dst, src, wgt = dsts[i] - 1, srcs[i] - 1, wgts[i, 0] f[dst] += wgt # print i, dst, src, wgt else: up_size = ncf.up_size f = np.zeros(up_size, "f8") for i in xrange(num_links): dst, src, wgt = dsts[i], srcs[i], wgts[i] f[dst] += wgt # print i, dst, src, wgt f_digits = np.ones(up_size, "i4") * (-1) num_digits = np.zeros(16, "i4") for i in xrange(up_size): for digit in xrange(15, 0, -1): if feq(f[i], 1, digit): f_digits[i] = digit num_digits[digit] += 1 break if f_digits[i] == -1: f_digits[i] = 0 num_digits[0] += 1 for digit in xrange(16): print "digit %d -> %d (%1.2f %%)" % (digit, num_digits[digit], num_digits[digit] / up_size * 100) equal(sum(num_digits), up_size)
def test_line_line(): ''' intersection between line and line ''' #------------------------------------------------- # intersection #------------------------------------------------- line1 = LineString([(0,0), (1,1)]) line2 = LineString([(1,0), (0,1)]) ist = line1.intersection(line2) equal(ist.geom_type, 'Point') a_equal([0.5,0.5], np.array(ist.coords)[0]) #------------------------------------------------- # parallel # line intersection #------------------------------------------------- line1 = LineString([(0,0), (1,1)]) line2 = LineString([(-1,-1), (0.5,0.5)]) ist = line1.intersection(line2) equal(ist.geom_type, 'LineString') a_equal([(0,0),(0.5,0.5)], np.array(ist.coords)) #------------------------------------------------- # parallel # not intersection #------------------------------------------------- line1 = LineString([(0,0), (1,1)]) line2 = LineString([(0,-1), (1,0)]) ist = line1.intersection(line2) equal(True, ist.is_empty) #------------------------------------------------- # not intersection #------------------------------------------------- line1 = LineString([(0,0), (1,1)]) line2 = LineString([(3,0), (0,3)]) ist = line1.intersection(line2) equal(True, ist.is_empty)
def test_sclopf(n): # There are some infeasibilities without line extensions for line_name in ["316", "527", "602"]: n.lines.loc[line_name, "s_nom"] = 1200 # choose the contingencies branch_outages = n.lines.index[:2] objectives = [] for pyomo in [True, False]: n.sclopf( n.snapshots[0], branch_outages=branch_outages, pyomo=pyomo, solver_name=solver_name, ) # For the PF, set the P to the optimised P n.generators_t.p_set = n.generators_t.p.copy() n.storage_units_t.p_set = n.storage_units_t.p.copy() # Check no lines are overloaded with the linear contingency analysis p0_test = n.lpf_contingency(n.snapshots[0], branch_outages=branch_outages) # check loading as per unit of s_nom in each contingency max_loading = (abs(p0_test.divide(n.passive_branches().s_nom, axis=0)).describe().loc["max"]) arr_equal(max_loading, np.ones((len(max_loading))), decimal=4) objectives.append(n.objective) equal(*objectives, decimal=1)
def compare_with_kim_rhs(myrank, nproc): ''' Compare with KIM: CubeGridMPI, CubeTensor ''' from cube_mpi import CubeGridMPI from cube_tensor import CubeTensor assert nproc==16 #--------------------------------------------------------------------- # Read reference variables from KIM #--------------------------------------------------------------------- ref_ncf = nc.Dataset('compute_and_apply_rhs/rank_%d.nc'%(myrank), 'r') ref_nelemd = len( ref_ncf.dimensions['nelemd'] ) ref_Dvv = ref_ncf.variables['Dvv'][:] ref_Dinv = ref_ncf.variables['Dinv'][:] ref_ps_v = ref_ncf.variables['ps_v'][:] ref_grad_ps = ref_ncf.variables['grad_ps'][:] #--------------------------------------------------------------------- # Compare #--------------------------------------------------------------------- cubegrid = CubeGridMPI(ne, ngq, nproc, myrank, homme_style=True) cubetensor = CubeTensor(cubegrid) # Note: Fortran array is column-major equal(ref_nelemd, cubegrid.local_nelem) aa_equal(ref_Dvv.ravel()*1e-1, cubetensor.dvvT*1e-1, 15) AI = cubetensor.AI.reshape(2,2,ngq,ngq,ref_nelemd) for ie in xrange(ref_nelemd): for gi in xrange(ngq): for gj in xrange(ngq): aa_equal(ref_Dinv[ie,gj,gi,:,:], AI[:,:,gj,gi,ie], 15)
def test_normal_vector(): ''' normal_vector(): yz plane circle, oblique circle ''' from sphere import normal_vector from convert_coord.cart_ll import latlon2xyz #--------------------------------------- # yz plane circle, +x direction #--------------------------------------- vec1 = (0, 1, 0) vec2 = (0, 1/sqrt(2), 1/sqrt(2)) nvec = normal_vector(vec1, vec2) equal(nvec, (sin(pi/4),0,0)) unit_nvec = normal_vector(vec1, vec2, normalize=True) equal(unit_nvec, (1,0,0)) #--------------------------------------- # yz plane circle, -x direction #--------------------------------------- vec1 = (0, -1, 0) vec2 = (0, 1/sqrt(2), 1/sqrt(2)) nvec = normal_vector(vec1, vec2) equal(nvec, (-sin(pi/4),0,0)) unit_nvec = normal_vector(vec1, vec2, normalize=True) equal(unit_nvec, (-1,0,0)) #--------------------------------------- # oblique circle #--------------------------------------- vec1 = (0, 0, 1) vec2 = latlon2xyz(pi/4,pi/4) nvec = normal_vector(vec1, vec2) aa_equal(nvec, latlon2xyz(0,3*pi/4,R=sin(pi/4)), 15) unit_nvec = normal_vector(vec1, vec2, normalize=True) aa_equal(unit_nvec, (-1/sqrt(2),1/sqrt(2),0), 15)
def test_lpf(n, n_r): n.lpf(snapshots=n.snapshots) equal( n.generators_t.p[n.generators.index].iloc[:2], n_r.generators_t.p[n.generators.index].iloc[:2] ) equal( n.lines_t.p0[n.lines.index].iloc[:2], n_r.lines_t.p0[n.lines.index].iloc[:2] ) equal( n.links_t.p0[n.links.index].iloc[:2], n_r.links_t.p0[n.links.index].iloc[:2] )
def test_lpf_chunks(n, n_r): for snapshot in n.snapshots[:2]: n.lpf(snapshot) n.lpf(snapshots=n.snapshots) equal( n.generators_t.p[n.generators.index],n_r.generators_t.p[n.generators.index]) equal( n.lines_t.p0[n.lines.index], n_r.lines_t.p0[n.lines.index] ) equal( n.links_t.p0[n.links.index], n_r.links_t.p0[n.links.index] )
def test_lopf_lowmem(n, n_r): status, _ = n.lopf(snapshots=n.snapshots, solver_name=solver_name, pyomo=False) assert status == 'ok' equal(n.generators_t.p.loc[:, n.generators.index], n_r.generators_t.p.loc[:, n.generators.index], decimal=2) equal(n.lines_t.p0.loc[:, n.lines.index], n_r.lines_t.p0.loc[:, n.lines.index], decimal=2) equal(n.links_t.p0.loc[:, n.links.index], n_r.links_t.p0.loc[:, n.links.index], decimal=2)
def test_lopf(n, n_r, formulation, free_memory): """ Test results were generated with GLPK; solution should be unique, so other solvers should not differ (e.g. cbc or gurobi) """ n.lopf(snapshots=n.snapshots, solver_name=solver_name, formulation=formulation, free_memory=free_memory) equal(n.generators_t.p.loc[:, n.generators.index], n_r.generators_t.p.loc[:, n.generators.index], decimal=4) equal(n.lines_t.p0.loc[:, n.lines.index], n_r.lines_t.p0.loc[:, n.lines.index], decimal=4) equal(n.links_t.p0.loc[:, n.links.index], n_r.links_t.p0.loc[:, n.links.index], decimal=4)
def test_loadarr(self): k, a = load_epi(os.path.join(pkg_dir, "data", "absolute_codes.epi")) assert k[0] == "h2az" equal(a[0][3], 1.30686752)
def test_sparsevec(self): equal(sparsevec(np.array([0, 1, 1, 1, 1, 2])), 0.22640339557688832) equal(sparsevec(np.array([1, 1, 1, 1, 1, 1])), 4.08e-10, 3)
def test_sparsemat(self): res = sparsemat(np.array([[0, 1, 1, 1, 1, 2], [1, 1, 1, 1, 1, 1]])) equal(res, 0.113201697993, 6)
def test_pf_distributed_slack(): csv_folder_name = os.path.join(os.path.dirname(__file__), "..", "examples", "scigrid-de", "scigrid-with-load-gen-trafos") network = pypsa.Network(csv_folder_name) network.set_snapshots(network.snapshots[:2]) #There are some infeasibilities without line extensions network.lines.s_max_pu = 0.7 network.lines.loc[["316", "527", "602"], "s_nom"] = 1715 network.storage_units.state_of_charge_initial = 0. network.lopf(network.snapshots, solver_name='glpk', formulation='kirchhoff') #For the PF, set the P to the optimised P network.generators_t.p_set = network.generators_t.p network.storage_units_t.p_set = network.storage_units_t.p #set all buses to PV, since we don't know what Q set points are network.generators.control = "PV" #Need some PQ buses so that Jacobian doesn't break f = network.generators[network.generators.bus == "492"] network.generators.loc[f.index, "control"] = "PQ" # by dispatch network.pf(distribute_slack=True, slack_weights='p_set') equal(network.generators_t.p_set.apply(normed, axis=1), (network.generators_t.p - network.generators_t.p_set).apply(normed, axis=1)) # by capacity network.pf(distribute_slack=True, slack_weights='p_nom') slack_shares_by_capacity = (network.generators_t.p - network.generators_t.p_set).apply(normed, axis=1) for index, row in slack_shares_by_capacity.iterrows(): equal(network.generators.p_nom.pipe(normed).fillna(0), row) # by custom weights (mirror 'capacity' via custom slack weights by bus) custom_weights = {} for sub_network in network.sub_networks.obj: buses_o = sub_network.buses_o custom_weights[sub_network.name] = sub_network.generators().groupby( 'bus').sum().p_nom.reindex(buses_o).pipe(normed).fillna(0) network.pf(distribute_slack=True, slack_weights=custom_weights) equal(slack_shares_by_capacity, (network.generators_t.p - network.generators_t.p_set).apply(normed, axis=1)) # by custom weights (mirror 'capacity' via custom slack weights by generators) custom_weights = {} for sub_network in network.sub_networks.obj: custom_weights[sub_network.name] = sub_network.generators( ).p_nom # weights do not sum up to 1 network.pf(distribute_slack=True, slack_weights=custom_weights) equal(slack_shares_by_capacity, (network.generators_t.p - network.generators_t.p_set).apply(normed, axis=1))
def test_pypower_case(): #ppopt is a dictionary with the details of the optimization routine to run ppopt = ppoption(PF_ALG=2) #choose DC or AC ppopt["PF_DC"] = False #ppc is a dictionary with details about the network, including baseMVA, branches and generators ppc = case() results, success = runpf(ppc, ppopt) #store results in a DataFrame for easy access results_df = {} #branches columns = 'bus0, bus1, r, x, b, rateA, rateB, rateC, ratio, angle, status, angmin, angmax, p0, q0, p1, q1'.split( ", ") results_df['branch'] = pd.DataFrame(data=results["branch"], columns=columns) #buses columns = [ "bus", "type", "Pd", "Qd", "Gs", "Bs", "area", "v_mag_pu", "v_ang", "v_nom", "zone", "Vmax", "Vmin" ] results_df['bus'] = pd.DataFrame(data=results["bus"], columns=columns, index=results["bus"][:, 0]) #generators columns = "bus, p, q, q_max, q_min, Vg, mBase, status, p_max, p_min, Pc1, Pc2, Qc1min, Qc1max, Qc2min, Qc2max, ramp_agc, ramp_10, ramp_30, ramp_q, apf".split( ", ") results_df['gen'] = pd.DataFrame(data=results["gen"], columns=columns) #now compute in PyPSA network = pypsa.Network() network.import_from_pypower_ppc(ppc) #PYPOWER uses PI model for transformers, whereas PyPSA defaults to #T since version 0.8.0 network.transformers.model = "pi" network.pf() #compare branch flows for c in network.iterate_components(network.passive_branch_components): for si in ["p0", "p1", "q0", "q1"]: si_pypsa = getattr(c.pnl, si).loc["now"].values si_pypower = results_df['branch'][si][c.df.original_index].values equal(si_pypsa, si_pypower) #compare generator dispatch for s in ["p", "q"]: s_pypsa = getattr(network.generators_t, s).loc["now"].values s_pypower = results_df["gen"][s].values equal(s_pypsa, s_pypower) #compare voltages v_mag_pypsa = network.buses_t.v_mag_pu.loc["now"] v_mag_pypower = results_df["bus"]["v_mag_pu"] equal(v_mag_pypsa, v_mag_pypower) v_ang_pypsa = network.buses_t.v_ang.loc["now"] pypower_slack_angle = results_df["bus"]["v_ang"][results_df["bus"]["type"] == 3].values[0] v_ang_pypower = (results_df["bus"]["v_ang"] - pypower_slack_angle) * np.pi / 180. equal(v_ang_pypsa, v_ang_pypower)
def test_pandapower_case(): # more complicated examples like # net = pandapower.networks.example_simple() # can be used once the import of e.g. switches is perfected # create empty net net = pp.create_empty_network() # create buses b1 = pp.create_bus(net, vn_kv=20.0, name="Bus 1") b2 = pp.create_bus(net, vn_kv=0.4, name="Bus 2") b3 = pp.create_bus(net, vn_kv=0.4, name="Bus 3") # create bus elements pp.create_ext_grid(net, bus=b1, vm_pu=1.02, name="Grid Connection") pp.create_load(net, bus=b3, p_mw=0.1, q_mvar=0.05, name="Load") # create branch elements pp.create_transformer(net, hv_bus=b1, lv_bus=b2, std_type="0.4 MVA 20/0.4 kV", name="Trafo") pp.create_line(net, from_bus=b2, to_bus=b3, length_km=0.1, name="Line", std_type="NAYY 4x50 SE") # because of phase angles, need to init with DC pp.runpp(net, calculate_voltage_angles=True, init="dc") n = pypsa.Network() n.import_from_pandapower_net(net) # seed PF with LPF solution because of phase angle jumps n.lpf() n.pf(use_seed=True) # use same index for everything net.res_bus.index = net.bus.name.values net.res_line.index = net.line.name.values # compare bus angles equal(n.buses_t.v_ang.loc["now"] * 180 / np.pi, net.res_bus.va_degree) # compare bus voltage magnitudes equal(n.buses_t.v_mag_pu.loc["now"], net.res_bus.vm_pu) # compare bus active power (NB: pandapower uses load signs) equal(n.buses_t.p.loc["now"], -net.res_bus.p_mw) # compare bus active power (NB: pandapower uses load signs) equal(n.buses_t.q.loc["now"], -net.res_bus.q_mvar) # compare branch flows equal(n.lines_t.p0.loc["now"], net.res_line.p_from_mw) equal(n.lines_t.p1.loc["now"], net.res_line.p_to_mw) equal(n.lines_t.q0.loc["now"], net.res_line.q_from_mvar) equal(n.lines_t.q1.loc["now"], net.res_line.q_to_mvar) equal(n.transformers_t.p0.loc["now"], net.res_trafo.p_hv_mw) equal(n.transformers_t.p1.loc["now"], net.res_trafo.p_lv_mw) equal(n.transformers_t.q0.loc["now"], net.res_trafo.q_hv_mvar) equal(n.transformers_t.q1.loc["now"], net.res_trafo.q_lv_mvar)
def test_lopf(): csv_folder_name = os.path.join(os.path.dirname(__file__), "..", "examples", "ac-dc-meshed", "ac-dc-data") n = pypsa.Network(csv_folder_name) results_folder_name = os.path.join(csv_folder_name, "results-lopf") n_r = pypsa.Network(results_folder_name) #test results were generated with GLPK; solution should be unique, #so other solvers should not differ (tested with cbc and gurobi) snapshots = n.snapshots for formulation, free_memory in product( ["angles", "cycles", "kirchhoff", "ptdf"], [{}, {"pypsa"}]): n.lopf(snapshots=snapshots, solver_name=solver_name, formulation=formulation, free_memory=free_memory) equal(n.generators_t.p.loc[:, n.generators.index], n_r.generators_t.p.loc[:, n.generators.index], decimal=4) equal(n.lines_t.p0.loc[:, n.lines.index], n_r.lines_t.p0.loc[:, n.lines.index], decimal=4) equal(n.links_t.p0.loc[:, n.links.index], n_r.links_t.p0.loc[:, n.links.index], decimal=4) if sys.version_info.major >= 3: status, cond = n.lopf(snapshots=snapshots, solver_name=solver_name, pyomo=False) assert status == 'ok' equal(n.generators_t.p.loc[:, n.generators.index], n_r.generators_t.p.loc[:, n.generators.index], decimal=2) equal(n.lines_t.p0.loc[:, n.lines.index], n_r.lines_t.p0.loc[:, n.lines.index], decimal=2) equal(n.links_t.p0.loc[:, n.links.index], n_r.links_t.p0.loc[:, n.links.index], decimal=2)
def test_single_to_multi_level_snapshots(): n = pypsa.Network(snapshots=range(2)) years = [2030, 2040] n.investment_periods = years assert isinstance(n.snapshots, pd.MultiIndex) equal(n.snapshots.levels[0], years)