GridLAB-D: powerflow/overheadline

00001 // $id$
00002 //  Copyright (C) 2008 Battelle Memorial Institute
00003 #ifndef _OVERHEADLINE_TEST_H
00004 #define _OVERHEADLINE_TEST_H
00005 
00006 #include "line.h"
00007 #ifndef _NO_CPPUNIT
00008 
00012 class overhead_line_tests : public test_helper
00013 {
00014     
00015     
00016 public:
00017     overhead_line_tests(){}
00022     void setUp(){
00023     }
00024 
00025     void tearDown(){
00026         local_callbacks->remove_objects();
00027     }
00028 
00038     /*void test_create(){
00039         CLASS *cl = get_class_by_name("sample");
00040         CPPUNIT_ASSERT(cl != NULL);
00041         obj = gl_create_object(cl,sizeof(sample_obj)); // Sample_obj is the name of the cpp class or struct.
00042         CPPUNIT_ASSERT(obj != NULL);
00043         
00044     }*/
00045 
00046     void test_node_create(){
00047         OBJECT* obj;
00048         CLASS *cl = get_class_by_name("node");
00049         obj = gl_create_object(cl);
00050         CPPUNIT_ASSERT(obj != NULL);
00051     }
00052 
00061     void test_overhead_line_a(){
00062         OBJECT *node1,*node2; // Node objects
00063         OBJECT *ohl1; // Overhead line object
00064         // Test values
00065         complex* node1_phA_I_test = new complex(-37.2922,60.5939);
00066         complex* node2_phA_V_test = new complex(-1017.2,2106.6);
00067 
00068         CLASS *cl = get_class_by_name("node");
00069         node1 = gl_create_object(cl);
00070         OBJECTDATA(node1,node)->create();
00071         cl = get_class_by_name("load");
00072         node2 = gl_create_object(cl);
00073         OBJECTDATA(node2,load)->create();
00074         cl = get_class_by_name("overhead_line");
00075         ohl1 = gl_create_object(cl);
00076         OBJECTDATA(ohl1,overhead_line)->create();
00077 
00078         OBJECTDATA(ohl1,overhead_line)->from = node1;
00079         OBJECTDATA(ohl1,overhead_line)->to = node2;
00080         OBJECTDATA(ohl1,overhead_line)->length = 300;
00081 
00082         // Next we set up the parameters needed for the test
00083         OBJECTDATA(ohl1,overhead_line)->phases = PHASE_A|PHASE_N;
00084         OBJECTDATA(node1,node)->phases = PHASE_A|PHASE_N;
00085         OBJECTDATA(node2,load)->phases = PHASE_A|PHASE_N;
00086         OBJECTDATA(node1,node)->voltageA = OBJECTDATA(node2,load)->voltageA = -1017.4;
00087         OBJECTDATA(node1,node)->voltageA.SetImag(2106.5);
00088         OBJECTDATA(node2,load)->voltageA.SetImag(2106.5);
00089         OBJECTDATA(node2,load)->currentA.SetReal(-37.2922);
00090         OBJECTDATA(node2,load)->currentA.SetImag(60.5939);
00091         
00092         cl = get_class_by_name("line_spacing");
00093         OBJECT *ls = gl_create_object(cl);
00094         OBJECTDATA(ls,line_spacing)->distance_AtoN = 5.0249;
00095         
00096         cl = get_class_by_name("overhead_line_conductor");
00097         OBJECT *olc_a = gl_create_object(cl);
00098         OBJECTDATA(olc_a,overhead_line_conductor)->geometric_mean_radius = .00446;
00099         OBJECTDATA(olc_a,overhead_line_conductor)->resistance = 1.12;
00100 
00101         OBJECT *olc_n = gl_create_object(cl);
00102         OBJECTDATA(olc_n,overhead_line_conductor)->geometric_mean_radius = .00446;
00103         OBJECTDATA(olc_n,overhead_line_conductor)->resistance = 1.12;
00104 
00105         // Do I need to set up the other conductors and set them to INF?
00106         cl = get_class_by_name("line_configuration");
00107         OBJECT *line_config = gl_create_object(cl);
00108         line_configuration *lc = OBJECTDATA(line_config,line_configuration);
00109         lc->line_spacing = ls;
00110         lc->phaseA_conductor = olc_a;
00111         lc->phaseB_conductor = 0;
00112         lc->phaseC_conductor = 0;
00113         lc->phaseN_conductor = olc_n;
00114         
00115         OBJECTDATA(ohl1,overhead_line)->configuration = line_config;
00116         
00117         // Now we call init on the objects
00118         CPPUNIT_ASSERT(local_callbacks->init_objects() != FAILED);
00119 
00120         // Rank?
00121         CPPUNIT_ASSERT(local_callbacks->setup_test_ranks() != FAILED);
00122 
00123         // Run the test
00124         local_callbacks->sync_all(PC_PRETOPDOWN);
00125         local_callbacks->sync_all(PC_BOTTOMUP);
00126 
00127         // Check the bottom-up pass values
00128         double rI_1 = OBJECTDATA(node1,node)->currentA.Re(); // Real part of the current at node 1
00129         double iI_1 = OBJECTDATA(node1,node)->currentA.Im(); // Imaginary part of the current at node 1
00130 
00131         // Get the percentage of the difference between the calculated value and the test value
00132         double validate_re = 1 - (rI_1 <= node1_phA_I_test->Re() ? rI_1 / node1_phA_I_test->Re() : node1_phA_I_test->Re() /rI_1);
00133         double validate_im = 1 - (iI_1 <= node1_phA_I_test->Im() ? iI_1 / node1_phA_I_test->Im() : node1_phA_I_test->Im() /iI_1);
00134 
00135         CPPUNIT_ASSERT(validate_re < VALIDATE_THRESHOLD);
00136         CPPUNIT_ASSERT(validate_im < VALIDATE_THRESHOLD);
00137 
00138         
00139         OBJECTDATA(node1,node)->voltageA = -1024.9;
00140         OBJECTDATA(node1,node)->voltageA.SetImag(2108.2);
00141         local_callbacks->sync_all(PC_POSTTOPDOWN);
00142         // check the top down values
00143 
00144         double rV_2 = OBJECTDATA(node2,load)->voltageA.Re();
00145         double iV_2 = OBJECTDATA(node2,load)->voltageA.Im();
00146 
00147         validate_re = 1 - (rV_2 <= node2_phA_V_test->Re() ? rV_2 / node2_phA_V_test->Re() : node2_phA_V_test->Re() /rV_2);
00148         validate_im = 1 - (iV_2 <= node2_phA_V_test->Im() ? iV_2 / node2_phA_V_test->Im() : node2_phA_V_test->Im() /iV_2);
00149         CPPUNIT_ASSERT(validate_re < VALIDATE_THRESHOLD);
00150         CPPUNIT_ASSERT(validate_im < VALIDATE_THRESHOLD);
00151 
00152     }
00153 
00154     void test_overhead_line_b(){
00155         OBJECT *node1,*node2; // Node objects
00156         OBJECT *ohl1; // Overhead line object
00157         //cout << "Phase B test" << endl;
00158         complex* node1_phB_I_test = new complex(-37.2922,60.5939);
00159         complex* node2_phB_V_test = new complex(-1017.2,2106.6);
00160 
00161         CLASS *cl = get_class_by_name("node");
00162         node1 = gl_create_object(cl);
00163         OBJECTDATA(node1,node)->create();
00164         cl = get_class_by_name("load");
00165         node2 = gl_create_object(cl);
00166         OBJECTDATA(node2,load)->create();
00167         cl = get_class_by_name("overhead_line");
00168         ohl1 = gl_create_object(cl);
00169         OBJECTDATA(ohl1,overhead_line)->create();
00170 
00171         OBJECTDATA(ohl1,overhead_line)->from = node1;
00172         OBJECTDATA(ohl1,overhead_line)->to = node2;
00173         OBJECTDATA(ohl1,overhead_line)->length = 300;
00174 
00175         // Next we set up the parameters needed for the test
00176         OBJECTDATA(ohl1,overhead_line)->phases = PHASE_B|PHASE_N;
00177         OBJECTDATA(node1,node)->phases = PHASE_B|PHASE_N;
00178         OBJECTDATA(node2,load)->phases = PHASE_B|PHASE_N;
00179         OBJECTDATA(node1,node)->voltageB = OBJECTDATA(node2,load)->voltageB = -1017.4;
00180         OBJECTDATA(node1,node)->voltageB.SetImag(2106.5);
00181         OBJECTDATA(node2,load)->voltageB.SetImag(2106.5);
00182         OBJECTDATA(node2,load)->currentB.SetReal(-37.2922);
00183         OBJECTDATA(node2,load)->currentB.SetImag(60.5939);
00184         
00185         cl = get_class_by_name("line_spacing");
00186         OBJECT *ls = gl_create_object(cl);
00187         OBJECTDATA(ls,line_spacing)->distance_BtoN = 5.0249;
00188         
00189         cl = get_class_by_name("overhead_line_conductor");
00190         OBJECT *olc_b = gl_create_object(cl);
00191         OBJECTDATA(olc_b,overhead_line_conductor)->geometric_mean_radius = .00446;
00192         OBJECTDATA(olc_b,overhead_line_conductor)->resistance = 1.12;
00193 
00194         OBJECT *olc_n = gl_create_object(cl);
00195         OBJECTDATA(olc_n,overhead_line_conductor)->geometric_mean_radius = .00446;
00196         OBJECTDATA(olc_n,overhead_line_conductor)->resistance = 1.12;
00197 
00198         cl = get_class_by_name("line_configuration");
00199         OBJECT *line_config = gl_create_object(cl);
00200         line_configuration *lc = OBJECTDATA(line_config,line_configuration);
00201         lc->line_spacing = ls;
00202         lc->phaseA_conductor = 0;
00203         lc->phaseB_conductor = olc_b;
00204         lc->phaseC_conductor = 0;
00205         lc->phaseN_conductor = olc_n;
00206         
00207         OBJECTDATA(ohl1,overhead_line)->configuration = line_config;
00208         
00209         
00210 
00211         // Now we call init on the objects
00212         CPPUNIT_ASSERT(local_callbacks->init_objects() != FAILED);
00213 
00214         // Rank?
00215         CPPUNIT_ASSERT(local_callbacks->setup_test_ranks() != FAILED);
00216 
00217         // Run the test
00218         local_callbacks->sync_all(PC_PRETOPDOWN);
00219         local_callbacks->sync_all(PC_BOTTOMUP);
00220         // Check the bottom-up pass values
00221         double rI_1 = OBJECTDATA(node1,node)->currentB.Re(); // Real part of the current at node 1
00222         double iI_1 = OBJECTDATA(node1,node)->currentB.Im(); // Imaginary part of the current at node 1
00223 
00224         // Get the percentage of the difference between the calculated value and the test value
00225         double validate_re = 1 - (rI_1 <= node1_phB_I_test->Re() ? rI_1 / node1_phB_I_test->Re() : node1_phB_I_test->Re() /rI_1);
00226         double validate_im = 1 - (iI_1 <= node1_phB_I_test->Im() ? iI_1 / node1_phB_I_test->Im() : node1_phB_I_test->Im() /iI_1);
00227 
00228         CPPUNIT_ASSERT(validate_re < VALIDATE_THRESHOLD);
00229         CPPUNIT_ASSERT(validate_im < VALIDATE_THRESHOLD);
00230 
00231         
00232         OBJECTDATA(node1,node)->voltageB = -1024.9;
00233         OBJECTDATA(node1,node)->voltageB.SetImag(2108.2);
00234         local_callbacks->sync_all(PC_POSTTOPDOWN);
00235         // check the top down values
00236 
00237         double rV_2 = OBJECTDATA(node2,load)->voltageB.Re();
00238         double iV_2 = OBJECTDATA(node2,load)->voltageB.Im();
00239 
00240         validate_re = 1 - (rV_2 <= node2_phB_V_test->Re() ? rV_2 / node2_phB_V_test->Re() : node2_phB_V_test->Re() /rV_2);
00241         validate_im = 1 - (iV_2 <= node2_phB_V_test->Im() ? iV_2 / node2_phB_V_test->Im() : node2_phB_V_test->Im() /iV_2);
00242         CPPUNIT_ASSERT(validate_re < VALIDATE_THRESHOLD);
00243         CPPUNIT_ASSERT(validate_im < VALIDATE_THRESHOLD);
00244 
00245     }
00246 
00247     void test_overhead_line_c(){
00248         OBJECT *node1,*node2; // Node objects
00249         OBJECT *ohl1; // Overhead line object
00250         //cout << "Phase C test" << endl;
00251         complex* node1_phC_I_test = new complex(-37.2922,60.5939);
00252         complex* node2_phC_V_test = new complex(-1017.2,2106.6);
00253 
00254         CLASS *cl = get_class_by_name("node");
00255         node1 = gl_create_object(cl);
00256         OBJECTDATA(node1,node)->create();
00257         cl = get_class_by_name("load");
00258         node2 = gl_create_object(cl);
00259         OBJECTDATA(node2,load)->create();
00260         cl = get_class_by_name("overhead_line");
00261         ohl1 = gl_create_object(cl);
00262         OBJECTDATA(ohl1,overhead_line)->create();
00263 
00264         OBJECTDATA(ohl1,overhead_line)->from = node1;
00265         OBJECTDATA(ohl1,overhead_line)->to = node2;
00266         OBJECTDATA(ohl1,overhead_line)->length = 300;
00267 
00268         // Next we set up the parameters needed for the test
00269         OBJECTDATA(ohl1,overhead_line)->phases = PHASE_C|PHASE_N;
00270         OBJECTDATA(node1,node)->phases = PHASE_C|PHASE_N;
00271         OBJECTDATA(node2,load)->phases = PHASE_C|PHASE_N;
00272         OBJECTDATA(node1,node)->voltageC = OBJECTDATA(node2,load)->voltageC = -1017.4;
00273         OBJECTDATA(node1,node)->voltageC.SetImag(2106.5);
00274         OBJECTDATA(node2,load)->voltageC.SetImag(2106.5);
00275         OBJECTDATA(node2,load)->currentC.SetReal(-37.2922);
00276         OBJECTDATA(node2,load)->currentC.SetImag(60.5939);
00277         
00278         cl = get_class_by_name("line_spacing");
00279         OBJECT *ls = gl_create_object(cl);
00280         OBJECTDATA(ls,line_spacing)->distance_CtoN = 5.0249;
00281         
00282         cl = get_class_by_name("overhead_line_conductor");
00283         OBJECT *olc_c = gl_create_object(cl);
00284         OBJECTDATA(olc_c,overhead_line_conductor)->geometric_mean_radius = .00446;
00285         OBJECTDATA(olc_c,overhead_line_conductor)->resistance = 1.12;
00286 
00287         OBJECT *olc_n = gl_create_object(cl);
00288         OBJECTDATA(olc_n,overhead_line_conductor)->geometric_mean_radius = .00446;
00289         OBJECTDATA(olc_n,overhead_line_conductor)->resistance = 1.12;
00290 
00291         cl = get_class_by_name("line_configuration");
00292         OBJECT *line_config = gl_create_object(cl);
00293         line_configuration *lc = OBJECTDATA(line_config,line_configuration);
00294         lc->line_spacing = ls;
00295         lc->phaseA_conductor = 0;
00296         lc->phaseC_conductor = olc_c;
00297         lc->phaseB_conductor = 0;
00298         lc->phaseN_conductor = olc_n;
00299         
00300         OBJECTDATA(ohl1,overhead_line)->configuration = line_config;
00301         
00302         
00303 
00304         // Now we call init on the objects
00305         CPPUNIT_ASSERT(local_callbacks->init_objects() != FAILED);
00306 
00307         // Rank?
00308         CPPUNIT_ASSERT(local_callbacks->setup_test_ranks() != FAILED);
00309 
00310         // Run the test
00311         local_callbacks->sync_all(PC_PRETOPDOWN);
00312         local_callbacks->sync_all(PC_BOTTOMUP);
00313         // Check the bottom-up pass values
00314         double rI_1 = OBJECTDATA(node1,node)->currentC.Re(); // Real part of the current at node 1
00315         double iI_1 = OBJECTDATA(node1,node)->currentC.Im(); // Imaginary part of the current at node 1
00316 
00317         // Get the percentage of the difference between the calculated value and the test value
00318         double validate_re = 1 - (rI_1 <= node1_phC_I_test->Re() ? rI_1 / node1_phC_I_test->Re() : node1_phC_I_test->Re() /rI_1);
00319         double validate_im = 1 - (iI_1 <= node1_phC_I_test->Im() ? iI_1 / node1_phC_I_test->Im() : node1_phC_I_test->Im() /iI_1);
00320 
00321         CPPUNIT_ASSERT(validate_re < VALIDATE_THRESHOLD);
00322         CPPUNIT_ASSERT(validate_im < VALIDATE_THRESHOLD);
00323 
00324         
00325         OBJECTDATA(node1,node)->voltageC = -1024.9;
00326         OBJECTDATA(node1,node)->voltageC.SetImag(2108.2);
00327         local_callbacks->sync_all(PC_POSTTOPDOWN);
00328         // check the top down values
00329 
00330         double rV_2 = OBJECTDATA(node2,load)->voltageC.Re();
00331         double iV_2 = OBJECTDATA(node2,load)->voltageC.Im();
00332 
00333         validate_re = 1 - (rV_2 <= node2_phC_V_test->Re() ? rV_2 / node2_phC_V_test->Re() : node2_phC_V_test->Re() /rV_2);
00334         validate_im = 1 - (iV_2 <= node2_phC_V_test->Im() ? iV_2 / node2_phC_V_test->Im() : node2_phC_V_test->Im() /iV_2);
00335         CPPUNIT_ASSERT(validate_re < VALIDATE_THRESHOLD);
00336         CPPUNIT_ASSERT(validate_im < VALIDATE_THRESHOLD);
00337 
00338     }
00339 
00340     void test_overhead_line_ab(){
00341         OBJECT *node1,*node2; // Node objects
00342         OBJECT *ohl1; // Overhead line object
00343         //cout << "Phase AB test" << endl;
00344         // Test values
00345         complex* node1_phA_I_test = new complex(34.73,55.192);
00346         complex* node2_phA_V_test = new complex(-1138.6,2150);
00347         complex* node1_phB_I_test = new complex(-34.73,-55.192);
00348         complex* node2_phB_V_test = new complex(-1311.7,-2101.1);
00349 
00350         CLASS *cl = get_class_by_name("node");
00351         node1 = gl_create_object(cl);
00352         OBJECTDATA(node1,node)->create();
00353         cl = get_class_by_name("load");
00354         node2 = gl_create_object(cl);
00355         OBJECTDATA(node2,load)->create();
00356         cl = get_class_by_name("overhead_line");
00357         ohl1 = gl_create_object(cl);
00358         OBJECTDATA(ohl1,overhead_line)->create();
00359 
00360         OBJECTDATA(ohl1,overhead_line)->from = node1;
00361         OBJECTDATA(ohl1,overhead_line)->to = node2;
00362         OBJECTDATA(ohl1,overhead_line)->length = 300;
00363 
00364         // Next we set up the parameters needed for the test
00365         OBJECTDATA(ohl1,overhead_line)->phases = PHASE_A|PHASE_B|PHASE_N;
00366         OBJECTDATA(node1,node)->phases = PHASE_A|PHASE_B|PHASE_N;
00367         OBJECTDATA(node2,load)->phases = PHASE_A|PHASE_B|PHASE_N;
00368         OBJECTDATA(node1,node)->voltageA = OBJECTDATA(node2,load)->voltageA = -1138.5;
00369         OBJECTDATA(node1,node)->voltageA.SetImag(2150.2);
00370         OBJECTDATA(node2,load)->voltageA.SetImag(2150.2);
00371         OBJECTDATA(node2,load)->currentA.SetReal(34.73);
00372         OBJECTDATA(node2,load)->currentA.SetImag(55.192);
00373 
00374         OBJECTDATA(node1,node)->voltageB = OBJECTDATA(node2,load)->voltageB = -1311.5;
00375         OBJECTDATA(node1,node)->voltageB.SetImag(2100.4);
00376         OBJECTDATA(node2,load)->voltageB.SetImag(2100.4);
00377         OBJECTDATA(node2,load)->currentB.SetReal(-34.73);
00378         OBJECTDATA(node2,load)->currentB.SetImag(-55.192);
00379         
00380         cl = get_class_by_name("line_spacing");
00381         OBJECT *ls = gl_create_object(cl);
00382         OBJECTDATA(ls,line_spacing)->distance_AtoN = 5.66;
00383         OBJECTDATA(ls,line_spacing)->distance_BtoN = 5.32;
00384         OBJECTDATA(ls,line_spacing)->distance_AtoB = 7;
00385         
00386         cl = get_class_by_name("overhead_line_conductor");
00387         OBJECT *olc_a = gl_create_object(cl);
00388         OBJECTDATA(olc_a,overhead_line_conductor)->geometric_mean_radius = .00446;
00389         OBJECTDATA(olc_a,overhead_line_conductor)->resistance = 1.12;
00390 
00391         OBJECT *olc_b = gl_create_object(cl);
00392         OBJECTDATA(olc_b,overhead_line_conductor)->geometric_mean_radius = .00446;
00393         OBJECTDATA(olc_b,overhead_line_conductor)->resistance = 1.12;
00394 
00395         OBJECT *olc_n = gl_create_object(cl);
00396         OBJECTDATA(olc_n,overhead_line_conductor)->geometric_mean_radius = .00446;
00397         OBJECTDATA(olc_n,overhead_line_conductor)->resistance = 1.12;
00398 
00399         // Do I need to set up the other conductors and set them to INF?
00400         cl = get_class_by_name("line_configuration");
00401         OBJECT *line_config = gl_create_object(cl);
00402         line_configuration *lc = OBJECTDATA(line_config,line_configuration);
00403         lc->line_spacing = ls;
00404         lc->phaseA_conductor = olc_a;
00405         lc->phaseB_conductor = olc_b;
00406         lc->phaseC_conductor = 0;
00407         lc->phaseN_conductor = olc_n;
00408         
00409         OBJECTDATA(ohl1,overhead_line)->configuration = line_config;
00410         
00411         // Now we call init on the objects
00412         CPPUNIT_ASSERT(local_callbacks->init_objects() != FAILED);
00413 
00414         // Rank?
00415         CPPUNIT_ASSERT(local_callbacks->setup_test_ranks() != FAILED);
00416 
00417         // Run the test
00418         local_callbacks->sync_all(PC_PRETOPDOWN);
00419         local_callbacks->sync_all(PC_BOTTOMUP);
00420 
00421         // Check the bottom-up pass values
00422         double rI_1 = OBJECTDATA(node1,node)->currentA.Re(); // Real part of the current at node 1
00423         double iI_1 = OBJECTDATA(node1,node)->currentA.Im(); // Imaginary part of the current at node 1
00424 
00425         // Get the percentage of the difference between the calculated value and the test value
00426         double validate_re = 1 - (rI_1 <= node1_phA_I_test->Re() ? rI_1 / node1_phA_I_test->Re() : node1_phA_I_test->Re() /rI_1);
00427         double validate_im = 1 - (iI_1 <= node1_phA_I_test->Im() ? iI_1 / node1_phA_I_test->Im() : node1_phA_I_test->Im() /iI_1);
00428 
00429         CPPUNIT_ASSERT(validate_re < VALIDATE_THRESHOLD);
00430         CPPUNIT_ASSERT(validate_im < VALIDATE_THRESHOLD);
00431 
00432         
00433         OBJECTDATA(node1,node)->voltageA = -1139.2;
00434         OBJECTDATA(node1,node)->voltageA.SetImag(2155.2);
00435         OBJECTDATA(node1,node)->voltageB = -1311.1;
00436         OBJECTDATA(node1,node)->voltageB.SetImag(-2106.3);
00437         local_callbacks->sync_all(PC_POSTTOPDOWN);
00438         // check the top down values
00439 
00440         double rV_2 = OBJECTDATA(node2,load)->voltageA.Re();
00441         double iV_2 = OBJECTDATA(node2,load)->voltageA.Im();
00442 
00443         validate_re = 1 - (rV_2 <= node2_phA_V_test->Re() ? rV_2 / node2_phA_V_test->Re() : node2_phA_V_test->Re() /rV_2);
00444         validate_im = 1 - (iV_2 <= node2_phA_V_test->Im() ? iV_2 / node2_phA_V_test->Im() : node2_phA_V_test->Im() /iV_2);
00445         CPPUNIT_ASSERT(validate_re < VALIDATE_THRESHOLD);
00446         CPPUNIT_ASSERT(validate_im < VALIDATE_THRESHOLD);
00447 
00448         rV_2 = OBJECTDATA(node2,load)->voltageB.Re();
00449         iV_2 = OBJECTDATA(node2,load)->voltageB.Im();
00450 
00451         validate_re = 1 - (rV_2 <= node2_phB_V_test->Re() ? rV_2 / node2_phB_V_test->Re() : node2_phB_V_test->Re() /rV_2);
00452         validate_im = 1 - (iV_2 <= node2_phB_V_test->Im() ? iV_2 / node2_phB_V_test->Im() : node2_phB_V_test->Im() /iV_2);
00453         CPPUNIT_ASSERT(validate_re < VALIDATE_THRESHOLD);
00454         CPPUNIT_ASSERT(validate_im < VALIDATE_THRESHOLD);
00455 
00456     }
00457 
00458     void test_overhead_line_ac(){
00459         OBJECT *node1,*node2; // Node objects
00460         OBJECT *ohl1; // Overhead line object
00461         //cout << "Phase AC test" << endl;
00462         // Test values
00463         complex* node1_phA_I_test = new complex(48.931,-39.794);
00464         complex* node2_phA_V_test = new complex(2362.9,-220.14);
00465         complex* node1_phC_I_test = new complex(-37.292,60.594);
00466         complex* node2_phC_V_test = new complex(-1024.6,2108.3);
00467 
00468 
00469         CLASS *cl = get_class_by_name("node");
00470         node1 = gl_create_object(cl);
00471         OBJECTDATA(node1,node)->create();
00472         cl = get_class_by_name("load");
00473         node2 = gl_create_object(cl);
00474         OBJECTDATA(node2,load)->create();
00475         cl = get_class_by_name("overhead_line");
00476         ohl1 = gl_create_object(cl);
00477         OBJECTDATA(ohl1,overhead_line)->create();
00478 
00479         OBJECTDATA(ohl1,overhead_line)->from = node1;
00480         OBJECTDATA(ohl1,overhead_line)->to = node2;
00481         OBJECTDATA(ohl1,overhead_line)->length = 300;
00482 
00483         // Next we set up the parameters needed for the test
00484         OBJECTDATA(ohl1,overhead_line)->phases = PHASE_A|PHASE_C|PHASE_N;
00485         OBJECTDATA(node1,node)->phases = PHASE_A|PHASE_C|PHASE_N;
00486         OBJECTDATA(node2,load)->phases = PHASE_A|PHASE_C|PHASE_N;
00487         OBJECTDATA(node1,node)->voltageA = OBJECTDATA(node2,load)->voltageA = 2362.7;
00488         OBJECTDATA(node1,node)->voltageA.SetImag(-220.02);
00489         OBJECTDATA(node2,load)->voltageA.SetImag(-220.02);
00490         OBJECTDATA(node2,load)->currentA.SetReal(48.931);
00491         OBJECTDATA(node2,load)->currentA.SetImag(-39.794);
00492 
00493         OBJECTDATA(node1,node)->voltageC = OBJECTDATA(node2,load)->voltageC = -1024.7;
00494         OBJECTDATA(node1,node)->voltageC.SetImag(2108.3);
00495         OBJECTDATA(node2,load)->voltageC.SetImag(2108.3);
00496         OBJECTDATA(node2,load)->currentC.SetReal(-37.292);
00497         OBJECTDATA(node2,load)->currentC.SetImag(60.594);
00498 
00499 
00500         
00501         cl = get_class_by_name("line_spacing");
00502         OBJECT *ls = gl_create_object(cl);
00503         OBJECTDATA(ls,line_spacing)->distance_AtoN = 5.66;
00504         OBJECTDATA(ls,line_spacing)->distance_CtoN = 5.32;
00505         OBJECTDATA(ls,line_spacing)->distance_AtoC = 7;
00506         
00507         cl = get_class_by_name("overhead_line_conductor");
00508         OBJECT *olc_a = gl_create_object(cl);
00509         OBJECTDATA(olc_a,overhead_line_conductor)->geometric_mean_radius = .00446;
00510         OBJECTDATA(olc_a,overhead_line_conductor)->resistance = 1.12;
00511 
00512         OBJECT *olc_c = gl_create_object(cl);
00513         OBJECTDATA(olc_c,overhead_line_conductor)->geometric_mean_radius = .00446;
00514         OBJECTDATA(olc_c,overhead_line_conductor)->resistance = 1.12;
00515 
00516         OBJECT *olc_n = gl_create_object(cl);
00517         OBJECTDATA(olc_n,overhead_line_conductor)->geometric_mean_radius = .00446;
00518         OBJECTDATA(olc_n,overhead_line_conductor)->resistance = 1.12;
00519 
00520 
00521         // Do I need to set up the other conductors and set them to INF?
00522         cl = get_class_by_name("line_configuration");
00523         OBJECT *line_config = gl_create_object(cl);
00524         line_configuration *lc = OBJECTDATA(line_config,line_configuration);
00525         lc->line_spacing = ls;
00526         lc->phaseA_conductor = olc_a;
00527         lc->phaseB_conductor = 0;
00528         lc->phaseC_conductor = olc_c;
00529         lc->phaseN_conductor = olc_n;
00530         
00531         OBJECTDATA(ohl1,overhead_line)->configuration = line_config;
00532         
00533         // Now we call init on the objects
00534         CPPUNIT_ASSERT(local_callbacks->init_objects() != FAILED);
00535 
00536         // Rank?
00537         CPPUNIT_ASSERT(local_callbacks->setup_test_ranks() != FAILED);
00538 
00539         // Run the test
00540         local_callbacks->sync_all(PC_PRETOPDOWN);
00541         local_callbacks->sync_all(PC_BOTTOMUP);
00542 
00543         // Check the bottom-up pass values
00544         double rI_1 = OBJECTDATA(node1,node)->currentA.Re(); // Real part of the current at node 1
00545         double iI_1 = OBJECTDATA(node1,node)->currentA.Im(); // Imaginary part of the current at node 1
00546 
00547         // Get the percentage of the difference between the calculated value and the test value
00548         double validate_re = 1 - (rI_1 <= node1_phA_I_test->Re() ? rI_1 / node1_phA_I_test->Re() : node1_phA_I_test->Re() /rI_1);
00549         double validate_im = 1 - (iI_1 <= node1_phA_I_test->Im() ? iI_1 / node1_phA_I_test->Im() : node1_phA_I_test->Im() /iI_1);
00550 
00551         CPPUNIT_ASSERT(validate_re < VALIDATE_THRESHOLD);
00552         CPPUNIT_ASSERT(validate_im < VALIDATE_THRESHOLD);
00553 
00554         
00555         OBJECTDATA(node1,node)->voltageA = 2367.6;
00556         OBJECTDATA(node1,node)->voltageA.SetImag(-219.64);
00557         OBJECTDATA(node1,node)->voltageC = -1030.4;
00558         OBJECTDATA(node1,node)->voltageC.SetImag(2110.9);
00559         local_callbacks->sync_all(PC_POSTTOPDOWN);
00560         // check the top down values
00561 
00562         double rV_2 = OBJECTDATA(node2,load)->voltageA.Re();
00563         double iV_2 = OBJECTDATA(node2,load)->voltageA.Im();
00564 
00565         validate_re = 1 - (rV_2 <= node2_phA_V_test->Re() ? rV_2 / node2_phA_V_test->Re() : node2_phA_V_test->Re() /rV_2);
00566         validate_im = 1 - (iV_2 <= node2_phA_V_test->Im() ? iV_2 / node2_phA_V_test->Im() : node2_phA_V_test->Im() /iV_2);
00567         CPPUNIT_ASSERT(validate_re < VALIDATE_THRESHOLD);
00568         CPPUNIT_ASSERT(validate_im < VALIDATE_THRESHOLD);
00569 
00570         rV_2 = OBJECTDATA(node2,load)->voltageC.Re();
00571         iV_2 = OBJECTDATA(node2,load)->voltageC.Im();
00572 
00573         validate_re = 1 - (rV_2 <= node2_phC_V_test->Re() ? rV_2 / node2_phC_V_test->Re() : node2_phC_V_test->Re() /rV_2);
00574         validate_im = 1 - (iV_2 <= node2_phC_V_test->Im() ? iV_2 / node2_phC_V_test->Im() : node2_phC_V_test->Im() /iV_2);
00575         CPPUNIT_ASSERT(validate_re < VALIDATE_THRESHOLD);
00576         CPPUNIT_ASSERT(validate_im < VALIDATE_THRESHOLD);
00577 
00578     }
00579 
00580     void test_overhead_line_bc(){
00581         OBJECT *node1,*node2; // Node objects
00582         OBJECT *ohl1; // Overhead line object
00583         //cout << "Phase BC test" << endl;
00584         // Test values
00585         complex* node1_phB_I_test = new complex(-34.73,-55.192);
00586         complex* node2_phB_V_test = new complex(-1311.7,-2101.1);
00587         complex* node1_phC_I_test = new complex(34.73,55.192);
00588         complex* node2_phC_V_test = new complex(-1138.6,2150);
00589 
00590 
00591         CLASS *cl = get_class_by_name("node");
00592         node1 = gl_create_object(cl);
00593         OBJECTDATA(node1,node)->create();
00594         cl = get_class_by_name("load");
00595         node2 = gl_create_object(cl);
00596         OBJECTDATA(node2,load)->create();
00597         cl = get_class_by_name("overhead_line");
00598         ohl1 = gl_create_object(cl);
00599         OBJECTDATA(ohl1,overhead_line)->create();
00600 
00601         OBJECTDATA(ohl1,overhead_line)->from = node1;
00602         OBJECTDATA(ohl1,overhead_line)->to = node2;
00603         OBJECTDATA(ohl1,overhead_line)->length = 300;
00604 
00605         // Next we set up the parameters needed for the test
00606         OBJECTDATA(ohl1,overhead_line)->phases = PHASE_B|PHASE_C|PHASE_N;
00607         OBJECTDATA(node1,node)->phases = PHASE_B|PHASE_C|PHASE_N;
00608         OBJECTDATA(node2,load)->phases = PHASE_B|PHASE_C|PHASE_N;
00609         OBJECTDATA(node1,node)->voltageB = OBJECTDATA(node2,load)->voltageB = -1311.5;
00610         OBJECTDATA(node1,node)->voltageB.SetImag(-2100.4);
00611         OBJECTDATA(node2,load)->voltageB.SetImag(-2100.4);
00612         OBJECTDATA(node2,load)->currentB.SetReal(-34.73);
00613         OBJECTDATA(node2,load)->currentB.SetImag(-55.192);
00614 
00615         OBJECTDATA(node1,node)->voltageC = OBJECTDATA(node2,load)->voltageC = -1138.5;
00616         OBJECTDATA(node1,node)->voltageC.SetImag(2150.2);
00617         OBJECTDATA(node2,load)->voltageC.SetImag(2150.2);
00618         OBJECTDATA(node2,load)->currentC.SetReal(34.73);
00619         OBJECTDATA(node2,load)->currentC.SetImag(55.192);
00620 
00621 
00622         
00623         cl = get_class_by_name("line_spacing");
00624         OBJECT *ls = gl_create_object(cl);
00625         OBJECTDATA(ls,line_spacing)->distance_BtoN = 5.32;
00626         OBJECTDATA(ls,line_spacing)->distance_CtoN = 5.66;
00627         OBJECTDATA(ls,line_spacing)->distance_BtoC = 7;
00628         
00629         cl = get_class_by_name("overhead_line_conductor");
00630         OBJECT *olc_b = gl_create_object(cl);
00631         OBJECTDATA(olc_b,overhead_line_conductor)->geometric_mean_radius = .00446;
00632         OBJECTDATA(olc_b,overhead_line_conductor)->resistance = 1.12;
00633 
00634         OBJECT *olc_c = gl_create_object(cl);
00635         OBJECTDATA(olc_c,overhead_line_conductor)->geometric_mean_radius = .00446;
00636         OBJECTDATA(olc_c,overhead_line_conductor)->resistance = 1.12;
00637 
00638         OBJECT *olc_n = gl_create_object(cl);
00639         OBJECTDATA(olc_n,overhead_line_conductor)->geometric_mean_radius = .00446;
00640         OBJECTDATA(olc_n,overhead_line_conductor)->resistance = 1.12;
00641 
00642 
00643         // Do I need to set up the other conductors and set them to INF?
00644         cl = get_class_by_name("line_configuration");
00645         OBJECT *line_config = gl_create_object(cl);
00646         line_configuration *lc = OBJECTDATA(line_config,line_configuration);
00647         lc->line_spacing = ls;
00648         lc->phaseA_conductor = 0;
00649         lc->phaseB_conductor = olc_b;
00650         lc->phaseC_conductor = olc_c;
00651         lc->phaseN_conductor = olc_n;
00652         
00653         OBJECTDATA(ohl1,overhead_line)->configuration = line_config;
00654         
00655         // Now we call init on the objects
00656         CPPUNIT_ASSERT(local_callbacks->init_objects() != FAILED);
00657 
00658         // Rank?
00659         CPPUNIT_ASSERT(local_callbacks->setup_test_ranks() != FAILED);
00660 
00661         // Run the test
00662         local_callbacks->sync_all(PC_PRETOPDOWN);
00663         local_callbacks->sync_all(PC_BOTTOMUP);
00664 
00665         // Check the bottom-up pass values
00666         double rI_1 = OBJECTDATA(node1,node)->currentB.Re(); // Real part of the current at node 1
00667         double iI_1 = OBJECTDATA(node1,node)->currentB.Im(); // Imaginary part of the current at node 1
00668 
00669         // Get the percentage of the difference between the calculated value and the test value
00670         double validate_re = 1 - (rI_1 <= node1_phB_I_test->Re() ? rI_1 / node1_phB_I_test->Re() : node1_phB_I_test->Re() /rI_1);
00671         double validate_im = 1 - (iI_1 <= node1_phB_I_test->Im() ? iI_1 / node1_phB_I_test->Im() : node1_phB_I_test->Im() /iI_1);
00672 
00673         CPPUNIT_ASSERT(validate_re < VALIDATE_THRESHOLD);
00674         CPPUNIT_ASSERT(validate_im < VALIDATE_THRESHOLD);
00675 
00676         
00677         OBJECTDATA(node1,node)->voltageB = -1311.1;
00678         OBJECTDATA(node1,node)->voltageB.SetImag(-2106.3);
00679         OBJECTDATA(node1,node)->voltageC = -1139.2;
00680         OBJECTDATA(node1,node)->voltageC.SetImag(2155.2);
00681         local_callbacks->sync_all(PC_POSTTOPDOWN);
00682         // check the top down values
00683 
00684         double rV_2 = OBJECTDATA(node2,load)->voltageB.Re();
00685         double iV_2 = OBJECTDATA(node2,load)->voltageB.Im();
00686 
00687         validate_re = 1 - (rV_2 <= node2_phB_V_test->Re() ? rV_2 / node2_phB_V_test->Re() : node2_phB_V_test->Re() /rV_2);
00688         validate_im = 1 - (iV_2 <= node2_phB_V_test->Im() ? iV_2 / node2_phB_V_test->Im() : node2_phB_V_test->Im() /iV_2);
00689         CPPUNIT_ASSERT(validate_re < VALIDATE_THRESHOLD);
00690         CPPUNIT_ASSERT(validate_im < VALIDATE_THRESHOLD);
00691 
00692         rV_2 = OBJECTDATA(node2,load)->voltageC.Re();
00693         iV_2 = OBJECTDATA(node2,load)->voltageC.Im();
00694 
00695         validate_re = 1 - (rV_2 <= node2_phC_V_test->Re() ? rV_2 / node2_phC_V_test->Re() : node2_phC_V_test->Re() /rV_2);
00696         validate_im = 1 - (iV_2 <= node2_phC_V_test->Im() ? iV_2 / node2_phC_V_test->Im() : node2_phC_V_test->Im() /iV_2);
00697         CPPUNIT_ASSERT(validate_re < VALIDATE_THRESHOLD);
00698         CPPUNIT_ASSERT(validate_im < VALIDATE_THRESHOLD);
00699 
00700     }
00701 
00702     void test_overhead_line_abc_delta(){
00703         OBJECT *node1,*node2; // Node objects
00704         OBJECT *ohl1; // Overhead line object
00705         //cout << "Phase ABC_Delta test" << endl;
00706         // Test values
00707         complex* node1_phA_I_test = new complex(108.4,-47.132);
00708         complex* node2_phA_V_test = new complex(7171.2,-17.944);
00709 
00710         complex* node1_phB_I_test = new complex(-111.34,-100.96);
00711         complex* node2_phB_V_test = new complex(-3613.5,-6200.6);
00712 
00713         complex* node1_phC_I_test = new complex(2.847,148.27);
00714         complex* node2_phC_V_test = new complex(-3563.5,6220.9);
00715 //----------------------------------------------------------------------
00716 
00717         CLASS *cl = get_class_by_name("node");
00718         node1 = gl_create_object(cl);
00719         OBJECTDATA(node1,node)->create();
00720         cl = get_class_by_name("load");
00721         node2 = gl_create_object(cl);
00722         OBJECTDATA(node2,load)->create();
00723         cl = get_class_by_name("overhead_line");
00724         ohl1 = gl_create_object(cl);
00725         OBJECTDATA(ohl1,overhead_line)->create();
00726 
00727         OBJECTDATA(ohl1,overhead_line)->from = node1;
00728         OBJECTDATA(ohl1,overhead_line)->to = node2;
00729         OBJECTDATA(ohl1,overhead_line)->length = 2000;
00730 
00731         // Next we set up the parameters needed for the test
00732         OBJECTDATA(ohl1,overhead_line)->phases = PHASE_A|PHASE_B|PHASE_C;
00733         OBJECTDATA(node1,node)->phases = PHASE_A|PHASE_B|PHASE_C;
00734         OBJECTDATA(node2,load)->phases = PHASE_A|PHASE_B|PHASE_C;
00735         OBJECTDATA(node1,node)->voltageA = OBJECTDATA(node2,load)->voltageA = 7943.2;
00736         OBJECTDATA(node1,node)->voltageA.SetImag(458);
00737         OBJECTDATA(node2,load)->voltageA.SetImag(458);
00738         OBJECTDATA(node2,load)->currentA.SetReal(108.4);
00739         OBJECTDATA(node2,load)->currentA.SetImag(-47.132);
00740 
00741         OBJECTDATA(node1,node)->voltageB = OBJECTDATA(node2,load)->voltageB = -2916.9;
00742         OBJECTDATA(node1,node)->voltageB.SetImag(-6740.4);
00743         OBJECTDATA(node2,load)->voltageB.SetImag(-6740.4);
00744         OBJECTDATA(node2,load)->currentB.SetReal(-111.34);
00745         OBJECTDATA(node2,load)->currentB.SetImag(-100.96);
00746 
00747         OBJECTDATA(node1,node)->voltageC = OBJECTDATA(node2,load)->voltageC = -3879.1;
00748         OBJECTDATA(node1,node)->voltageC.SetImag(6585.4);
00749         OBJECTDATA(node2,load)->voltageC.SetImag(6585.4);
00750         OBJECTDATA(node2,load)->currentC.SetReal(2.847);
00751         OBJECTDATA(node2,load)->currentC.SetImag(148.27);
00752         
00753         cl = get_class_by_name("line_spacing");
00754         OBJECT *ls = gl_create_object(cl);
00755         OBJECTDATA(ls,line_spacing)->distance_AtoN = 0;
00756         OBJECTDATA(ls,line_spacing)->distance_BtoN = 0;
00757         OBJECTDATA(ls,line_spacing)->distance_CtoN = 0;
00758         OBJECTDATA(ls,line_spacing)->distance_AtoB = 2.5;
00759         OBJECTDATA(ls,line_spacing)->distance_BtoC = 4.5;
00760         OBJECTDATA(ls,line_spacing)->distance_AtoC = 7;
00761         
00762         cl = get_class_by_name("overhead_line_conductor");
00763         OBJECT *olc_a = gl_create_object(cl);
00764         OBJECTDATA(olc_a,overhead_line_conductor)->geometric_mean_radius = .0244;
00765         OBJECTDATA(olc_a,overhead_line_conductor)->resistance = .278;
00766 
00767         OBJECT *olc_b = gl_create_object(cl);
00768         OBJECTDATA(olc_b,overhead_line_conductor)->geometric_mean_radius = .0244;
00769         OBJECTDATA(olc_b,overhead_line_conductor)->resistance = .278;
00770 
00771         OBJECT *olc_c = gl_create_object(cl);
00772         OBJECTDATA(olc_c,overhead_line_conductor)->geometric_mean_radius = .0244;
00773         OBJECTDATA(olc_c,overhead_line_conductor)->resistance = .278;
00774 
00775         /*
00776         OBJECT *olc_n = gl_create_object(cl,sizeof(overhead_line_conductor));
00777         OBJECTDATA(olc_n,overhead_line_conductor)->geometric_mean_radius = 0;
00778         OBJECTDATA(olc_n,overhead_line_conductor)->resistance = 1.12;
00779         */
00780 
00781         // Do I need to set up the other conductors and set them to INF?
00782         cl = get_class_by_name("line_configuration");
00783         OBJECT *line_config = gl_create_object(cl);
00784         line_configuration *lc = OBJECTDATA(line_config,line_configuration);
00785         lc->line_spacing = ls;
00786         lc->phaseA_conductor = olc_a;
00787         lc->phaseB_conductor = olc_b;
00788         lc->phaseC_conductor = olc_c;
00789         lc->phaseN_conductor = 0;
00790         
00791         OBJECTDATA(ohl1,overhead_line)->configuration = line_config;
00792         
00793         // Now we call init on the objects
00794         CPPUNIT_ASSERT(local_callbacks->init_objects() != FAILED);
00795 
00796         // Rank?
00797         CPPUNIT_ASSERT(local_callbacks->setup_test_ranks() != FAILED);
00798 
00799         // Run the test
00800         local_callbacks->sync_all(PC_PRETOPDOWN);
00801         local_callbacks->sync_all(PC_BOTTOMUP);
00802 
00803         // Check the bottom-up pass values
00804         double rI_1 = OBJECTDATA(node1,node)->currentA.Re(); // Real part of the current at node 1
00805         double iI_1 = OBJECTDATA(node1,node)->currentA.Im(); // Imaginary part of the current at node 1
00806 
00807         // Get the percentage of the difference between the calculated value and the test value
00808         double validate_re = 1 - (rI_1 <= node1_phA_I_test->Re() ? rI_1 / node1_phA_I_test->Re() : node1_phA_I_test->Re() /rI_1);
00809         double validate_im = 1 - (iI_1 <= node1_phA_I_test->Im() ? iI_1 / node1_phA_I_test->Im() : node1_phA_I_test->Im() /iI_1);
00810 
00811         CPPUNIT_ASSERT(validate_re < VALIDATE_THRESHOLD);
00812         CPPUNIT_ASSERT(validate_im < VALIDATE_THRESHOLD);
00813 
00814         
00815         OBJECTDATA(node1,node)->voltageA = 7199.6;
00816         OBJECTDATA(node1,node)->voltageA.SetImag(0);
00817         OBJECTDATA(node1,node)->voltageB = -3599.8;
00818         OBJECTDATA(node1,node)->voltageB.SetImag(-6235);
00819         OBJECTDATA(node1,node)->voltageC = -3599.8;
00820         OBJECTDATA(node1,node)->voltageC.SetImag(6235);
00821 
00822         local_callbacks->sync_all(PC_POSTTOPDOWN);
00823         // check the top down values
00824 
00825         double rV_2 = OBJECTDATA(node2,load)->voltageA.Re();
00826         double iV_2 = OBJECTDATA(node2,load)->voltageA.Im();
00827 
00828         validate_re = 1 - (rV_2 <= node2_phA_V_test->Re() ? rV_2 / node2_phA_V_test->Re() : node2_phA_V_test->Re() /rV_2);
00829         validate_im = 1 - (iV_2 <= node2_phA_V_test->Im() ? iV_2 / node2_phA_V_test->Im() : node2_phA_V_test->Im() /iV_2);
00830         CPPUNIT_ASSERT(validate_re < VALIDATE_THRESHOLD);
00831         CPPUNIT_ASSERT(validate_im < VALIDATE_THRESHOLD);
00832 
00833         rV_2 = OBJECTDATA(node2,load)->voltageB.Re();
00834         iV_2 = OBJECTDATA(node2,load)->voltageB.Im();
00835 
00836         validate_re = 1 - (rV_2 <= node2_phB_V_test->Re() ? rV_2 / node2_phB_V_test->Re() : node2_phB_V_test->Re() /rV_2);
00837         validate_im = 1 - (iV_2 <= node2_phB_V_test->Im() ? iV_2 / node2_phB_V_test->Im() : node2_phB_V_test->Im() /iV_2);
00838         CPPUNIT_ASSERT(validate_re < VALIDATE_THRESHOLD);
00839         CPPUNIT_ASSERT(validate_im < VALIDATE_THRESHOLD);
00840 
00841         rV_2 = OBJECTDATA(node2,load)->voltageC.Re();
00842         iV_2 = OBJECTDATA(node2,load)->voltageC.Im();
00843 
00844         validate_re = 1 - (rV_2 <= node2_phC_V_test->Re() ? rV_2 / node2_phC_V_test->Re() : node2_phC_V_test->Re() /rV_2);
00845         validate_im = 1 - (iV_2 <= node2_phC_V_test->Im() ? iV_2 / node2_phC_V_test->Im() : node2_phC_V_test->Im() /iV_2);
00846         CPPUNIT_ASSERT(validate_re < VALIDATE_THRESHOLD);
00847         CPPUNIT_ASSERT(validate_im < VALIDATE_THRESHOLD);
00848 
00849     }
00850 
00851     void test_overhead_line_abcn(){
00852         OBJECT *node1,*node2; // Node objects
00853         OBJECT *ohl1; // Overhead line object
00854         //cout << "Phase ABC_WYE test" << endl;
00855         // Test values
00856         complex* node1_phA_I_test = new complex(64.315,-49.78);
00857         complex* node2_phA_V_test = new complex(2441.9,-108.49);
00858 
00859         complex* node1_phB_I_test = new complex(-57.095,-21.814);
00860         complex* node2_phB_V_test = new complex(-1315.5,-2124.3);
00861 
00862         complex* node1_phC_I_test = new complex(10.383,61.845);
00863         complex* node2_phC_V_test = new complex(-1136.9,2155.1);
00864 //----------------------------------------------------------------------
00865 
00866         CLASS *cl = get_class_by_name("node");
00867         node1 = gl_create_object(cl);
00868         OBJECTDATA(node1,node)->create();
00869         cl = get_class_by_name("load");
00870         node2 = gl_create_object(cl);
00871         OBJECTDATA(node2,load)->create();
00872         cl = get_class_by_name("overhead_line");
00873         ohl1 = gl_create_object(cl);
00874         OBJECTDATA(ohl1,overhead_line)->create();
00875 
00876         OBJECTDATA(ohl1,overhead_line)->from = node1;
00877         OBJECTDATA(ohl1,overhead_line)->to = node2;
00878         OBJECTDATA(ohl1,overhead_line)->length = 500;
00879 
00880         // Next we set up the parameters needed for the test
00881         OBJECTDATA(ohl1,overhead_line)->phases = PHASE_ABCN;
00882         OBJECTDATA(node1,node)->phases = PHASE_ABCN;
00883         OBJECTDATA(node2,load)->phases = PHASE_ABCN;
00884         OBJECTDATA(node1,node)->voltageA = OBJECTDATA(node2,load)->voltageA = 2442.6;
00885         OBJECTDATA(node1,node)->voltageA.SetImag(-109.21);
00886         OBJECTDATA(node2,load)->voltageA.SetImag(-109.21);
00887         OBJECTDATA(node2,load)->currentA.SetReal(64.315);
00888         OBJECTDATA(node2,load)->currentA.SetImag(-49.78);
00889 
00890         OBJECTDATA(node1,node)->voltageB = OBJECTDATA(node2,load)->voltageB = -1315.1;
00891         OBJECTDATA(node1,node)->voltageB.SetImag(-2123.6);
00892         OBJECTDATA(node2,load)->voltageB.SetImag(-2123.6);
00893         OBJECTDATA(node2,load)->currentB.SetReal(-57.095);
00894         OBJECTDATA(node2,load)->currentB.SetImag(-21.814);
00895 
00896         OBJECTDATA(node1,node)->voltageC = OBJECTDATA(node2,load)->voltageC = -1137.7;
00897         OBJECTDATA(node1,node)->voltageC.SetImag(2156);
00898         OBJECTDATA(node2,load)->voltageC.SetImag(2156);
00899         OBJECTDATA(node2,load)->currentC.SetReal(10.383);
00900         OBJECTDATA(node2,load)->currentC.SetImag(61.845);
00901         
00902         cl = get_class_by_name("line_spacing");
00903         OBJECT *ls = gl_create_object(cl);
00904         OBJECTDATA(ls,line_spacing)->distance_AtoN = 4.12;
00905         OBJECTDATA(ls,line_spacing)->distance_BtoN = 5.32;
00906         OBJECTDATA(ls,line_spacing)->distance_CtoN = 5.66;
00907         OBJECTDATA(ls,line_spacing)->distance_AtoB = 2.5;
00908         OBJECTDATA(ls,line_spacing)->distance_BtoC = 7;
00909         OBJECTDATA(ls,line_spacing)->distance_AtoC = 4.5;
00910         
00911         cl = get_class_by_name("overhead_line_conductor");
00912         OBJECT *olc_a = gl_create_object(cl);
00913         OBJECTDATA(olc_a,overhead_line_conductor)->geometric_mean_radius = .0081;
00914         OBJECTDATA(olc_a,overhead_line_conductor)->resistance = .592;
00915 
00916         OBJECT *olc_b = gl_create_object(cl);
00917         OBJECTDATA(olc_b,overhead_line_conductor)->geometric_mean_radius = .0081;
00918         OBJECTDATA(olc_b,overhead_line_conductor)->resistance = .592;
00919 
00920         OBJECT *olc_c = gl_create_object(cl);
00921         OBJECTDATA(olc_c,overhead_line_conductor)->geometric_mean_radius = .0081;
00922         OBJECTDATA(olc_c,overhead_line_conductor)->resistance = .592;
00923 
00924         OBJECT *olc_n = gl_create_object(cl);
00925         OBJECTDATA(olc_n,overhead_line_conductor)->geometric_mean_radius = .0081;
00926         OBJECTDATA(olc_n,overhead_line_conductor)->resistance = .592;
00927         
00928 
00929         // Do I need to set up the other conductors and set them to INF?
00930         cl = get_class_by_name("line_configuration");
00931         OBJECT *line_config = gl_create_object(cl);
00932         line_configuration *lc = OBJECTDATA(line_config,line_configuration);
00933         lc->line_spacing = ls;
00934         lc->phaseA_conductor = olc_a;
00935         lc->phaseB_conductor = olc_b;
00936         lc->phaseC_conductor = olc_c;
00937         lc->phaseN_conductor = olc_n;
00938         
00939         OBJECTDATA(ohl1,overhead_line)->configuration = line_config;
00940         
00941         // Now we call init on the objects
00942         CPPUNIT_ASSERT(local_callbacks->init_objects() != FAILED);
00943 
00944         // Rank?
00945         CPPUNIT_ASSERT(local_callbacks->setup_test_ranks() != FAILED);
00946 
00947         // Run the test
00948         local_callbacks->sync_all(PC_PRETOPDOWN);
00949         local_callbacks->sync_all(PC_BOTTOMUP);
00950 
00951         // Check the bottom-up pass values
00952         double rI_1 = OBJECTDATA(node1,node)->currentA.Re(); // Real part of the current at node 1
00953         double iI_1 = OBJECTDATA(node1,node)->currentA.Im(); // Imaginary part of the current at node 1
00954 
00955         // Get the percentage of the difference between the calculated value and the test value
00956         double validate_re = 1 - (rI_1 <= node1_phA_I_test->Re() ? rI_1 / node1_phA_I_test->Re() : node1_phA_I_test->Re() /rI_1);
00957         double validate_im = 1 - (iI_1 <= node1_phA_I_test->Im() ? iI_1 / node1_phA_I_test->Im() : node1_phA_I_test->Im() /iI_1);
00958 
00959         CPPUNIT_ASSERT(validate_re < VALIDATE_THRESHOLD);
00960         CPPUNIT_ASSERT(validate_im < VALIDATE_THRESHOLD);
00961 
00962         
00963         OBJECTDATA(node1,node)->voltageA = 2449.9;
00964         OBJECTDATA(node1,node)->voltageA.SetImag(-106.54);
00965         OBJECTDATA(node1,node)->voltageB = -1315.8;
00966         OBJECTDATA(node1,node)->voltageB.SetImag(-2128.8);
00967         OBJECTDATA(node1,node)->voltageC = -1140.3;
00968         OBJECTDATA(node1,node)->voltageC.SetImag(2160.1);
00969 
00970         local_callbacks->sync_all(PC_POSTTOPDOWN);
00971         // check the top down values
00972 
00973         double rV_2 = OBJECTDATA(node2,load)->voltageA.Re();
00974         double iV_2 = OBJECTDATA(node2,load)->voltageA.Im();
00975 
00976         validate_re = 1 - (rV_2 <= node2_phA_V_test->Re() ? rV_2 / node2_phA_V_test->Re() : node2_phA_V_test->Re() /rV_2);
00977         validate_im = 1 - (iV_2 <= node2_phA_V_test->Im() ? iV_2 / node2_phA_V_test->Im() : node2_phA_V_test->Im() /iV_2);
00978         CPPUNIT_ASSERT(validate_re < VALIDATE_THRESHOLD);
00979         CPPUNIT_ASSERT(validate_im < VALIDATE_THRESHOLD);
00980 
00981         rV_2 = OBJECTDATA(node2,load)->voltageB.Re();
00982         iV_2 = OBJECTDATA(node2,load)->voltageB.Im();
00983 
00984         validate_re = 1 - (rV_2 <= node2_phB_V_test->Re() ? rV_2 / node2_phB_V_test->Re() : node2_phB_V_test->Re() /rV_2);
00985         validate_im = 1 - (iV_2 <= node2_phB_V_test->Im() ? iV_2 / node2_phB_V_test->Im() : node2_phB_V_test->Im() /iV_2);
00986         CPPUNIT_ASSERT(validate_re < VALIDATE_THRESHOLD);
00987         CPPUNIT_ASSERT(validate_im < VALIDATE_THRESHOLD);
00988 
00989         rV_2 = OBJECTDATA(node2,load)->voltageC.Re();
00990         iV_2 = OBJECTDATA(node2,load)->voltageC.Im();
00991 
00992         validate_re = 1 - (rV_2 <= node2_phC_V_test->Re() ? rV_2 / node2_phC_V_test->Re() : node2_phC_V_test->Re() /rV_2);
00993         validate_im = 1 - (iV_2 <= node2_phC_V_test->Im() ? iV_2 / node2_phC_V_test->Im() : node2_phC_V_test->Im() /iV_2);
00994         CPPUNIT_ASSERT(validate_re < VALIDATE_THRESHOLD);
00995         CPPUNIT_ASSERT(validate_im < VALIDATE_THRESHOLD);
00996 
00997     }
00998 
00999     /*
01000      * This section creates the suite() method that will be used by the
01001      * CPPUnit testrunner to execute the tests that we have registered.
01002      * This section needs to be in the .h file
01003      */
01004     CPPUNIT_TEST_SUITE(overhead_line_tests);
01005     /*
01006      * For each test method defined above, we should have a separate
01007      * CPPUNIT_TEST() line.
01008      */
01009     CPPUNIT_TEST(test_overhead_line_a);
01010     CPPUNIT_TEST(test_overhead_line_b);
01011     CPPUNIT_TEST(test_overhead_line_c);
01012     CPPUNIT_TEST(test_overhead_line_ab);
01013     CPPUNIT_TEST(test_overhead_line_ac);
01014     CPPUNIT_TEST(test_overhead_line_bc);
01015     CPPUNIT_TEST(test_overhead_line_abc_delta);
01016     CPPUNIT_TEST(test_overhead_line_abcn);
01017     CPPUNIT_TEST_SUITE_END();
01018 
01019     
01020 };
01021 #endif
01022 #endif
powerflow/overheadline_test.h
