powerflow/test.h

#ifndef _POWERFLOW_TEST_H
#define _POWERFLOW_TEST_H
#define VALIDATE_THRESHOLD .0002

#include "gridlabd.h"

#ifndef _NO_CPPUNIT

#include "test_framework.h"

#include "test_callbacks.h"
// Include any module specific headers needed for testing.

#include "node.h"
#include "link.h"

class powerflow_test_helper : public test_helper
{
protected:
    static void test_powerflow_link(class link *test_link, double tolerance,
            set phases1, set phases2, const complex bs_V2_in[3],
            const complex bs_I2_in[3], const complex bs_I1_out[3],
            const complex fs_V1_in[3], const complex fs_I2_in[3],
            const complex fs_V2_out[3])
    {   
        node *src_node = create_object<node>("node");
        load *load_node = create_object<load>("load");

        src_node->phases = phases1;
        load_node->phases = phases2;
        load_node->phaseA_V = bs_V2_in[0];
        load_node->phaseB_V = bs_V2_in[1];
        load_node->phaseC_V = bs_V2_in[2];
        load_node->phaseA_I = bs_I2_in[0];
        load_node->phaseB_I = bs_I2_in[1];
        load_node->phaseC_I = bs_I2_in[2];

        test_link->from = GETOBJECT(src_node);
        test_link->to = GETOBJECT(load_node);

        // Now we call init on the objects
        CPPUNIT_ASSERT(local_callbacks->init_objects() != FAILED);

        // Rank?
        CPPUNIT_ASSERT(local_callbacks->setup_test_ranks() != FAILED);

        // Run the test
        CPPUNIT_ASSERT(local_callbacks->sync_all(PC_PRETOPDOWN) != FAILED);
        CPPUNIT_ASSERT(local_callbacks->sync_all(PC_BOTTOMUP) != FAILED);

        CPPUNIT_ASSERT((src_node->get_phaseA_I_in() - bs_I1_out[0]).IsZero(tolerance));
        CPPUNIT_ASSERT((src_node->get_phaseB_I_in() - bs_I1_out[1]).IsZero(tolerance));
        CPPUNIT_ASSERT((src_node->get_phaseC_I_in() - bs_I1_out[2]).IsZero(tolerance));

        src_node->phaseA_V = fs_V1_in[0];
        src_node->phaseB_V = fs_V1_in[1];
        src_node->phaseC_V = fs_V1_in[2];
        load_node->phaseA_I = fs_I2_in[0];
        load_node->phaseB_I = fs_I2_in[1];
        load_node->phaseC_I = fs_I2_in[2];

        CPPUNIT_ASSERT(local_callbacks->sync_all(PC_POSTTOPDOWN) != FAILED);
        // check the top down values

        CPPUNIT_ASSERT((load_node->phaseA_V - fs_V2_out[0]).IsZero(tolerance));
        CPPUNIT_ASSERT((load_node->phaseB_V - fs_V2_out[1]).IsZero(tolerance));
        CPPUNIT_ASSERT((load_node->phaseC_V - fs_V2_out[2]).IsZero(tolerance));
    }
};


#include "regulator_test.h"
#include "transformer_test.h"
#include "overheadline_test.h"
#include "undergroundline_test.h"
#include "relay_test.h"
#include "meter_test.h"
#include "triplexline_test.h"


//using namespace std;

/*
 * Registers the test suite with the CPPUnit registration factory.  In most
 * cases, this is all that is required for it to be included and run by the
 * module_test method in test.cpp.
 */
CPPUNIT_TEST_SUITE_REGISTRATION(overhead_line_tests);
CPPUNIT_TEST_SUITE_REGISTRATION(transformer_tests);
CPPUNIT_TEST_SUITE_REGISTRATION(undergroundline_tests);
CPPUNIT_TEST_SUITE_REGISTRATION(regulator_tests);
CPPUNIT_TEST_SUITE_REGISTRATION(relay_tests);
CPPUNIT_TEST_SUITE_REGISTRATION(meter_tests);
//CPPUNIT_TEST_SUITE_REGISTRATION(triplex_line_tests);


#endif
#endif

---

GridLAB-D^TM Version 1.0

An open-source project initiated by the US Department of Energy