powerflow/overheadline_test.h

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