示例#1
0
    def __init__(self,year,num_season,seasonobj):
        '''       
         Arguments:
        * year      * : integer
        * season    * : integer
        * seasonobj * : an instance of class season, where features of season are defined
        
        Season object can be obtained as follows:
        import season
        seasonObj = season.season()
        
        Then seasonObj defines by default seasons like this:
        Winter = 0
        Spring = 1
        Summer = 2
        Fall   = 3
        
        Example:

        req = Season_req(2012,2,seasonObj)
        print req.longname
        '''
        self.year   = year
        self.season = num_season
        ti_ref,self.longname = seasonobj.get_season_dates(num_season)

        delta_years=year - seasonobj._reference_year

        t = TimeInterval()
        t.start_time  = ti_ref.start_time + relativedelta(years=delta_years)
        t.end_time    = ti_ref.end_time   + relativedelta(years=delta_years)
        self.time_interval = t
        self.string   = str(year) + " " + self.longname[:3]
示例#2
0
 def __init__(self,year):
     self.year=year
     t = TimeInterval()
     t.start_time = datetime.datetime(year  ,1,1)
     t.end_time   = datetime.datetime(year+1,1,1)
     self.time_interval =t
     self.string    = str(year)
示例#3
0
文件: main.py 项目: tleb/zds-user-map
def main(mode):
    if not (0 <= mode <= 2):
        return print('''Available modes:
0: initialise the refresh token based on the username and password
1: initialise the data (add every marker)
2: daemon mode (watch new topics)''')

    with open(CONFIG_PATH, encoding='UTF-8') as f:
        config = yaml.safe_load(f)

    zds = ZesteDeSavoir(config['client_id'], config['client_secret'],
                        REFRESH_TOKEN_PATH, TimeInterval(0))

    osm_ti = TimeInterval(0)

    if mode == 0:
        zds._refresh_token_from_logins(input('Username: '******'id']: m for m in markers if m is not None}

        utils.save_markers(MARKERS_PATH, markers)
        utils.git_send_markers(MARKERS_PATH)

    if mode == 2:
        markers = {m['id']: m for m in utils.retrieve_markers(MARKERS_PATH)}

        while True:
            has_changed = False
            topics = list(zds.topics(True))
            topics.reverse()

            for topic in topics:
                msg = list(zds.messages(topic['id']))[-1]

                change, msg = utils.on_new_message(msg, config, markers, zds,
                                                   osm_ti)

                if change:
                    has_changed = True

                if msg is not None:
                    zds.send_message(topic['id'], msg)

            if has_changed:
                utils.save_markers(MARKERS_PATH, markers)
                utils.git_send_markers(MARKERS_PATH)

            time.sleep(config['interval'])
示例#4
0
 def __init__(self,year,month):
     self.year=year
     self.month=month
     self.string = "%d%02d" % (self.year, self.month)
     t = TimeInterval()
     t.start_time  = datetime.datetime(self.year, self.month,1)
     t.end_time    = t.start_time + relativedelta(months = 1)
     self.time_interval = t
示例#5
0
 def __init__(self,year,month,day):
     self.year   = year
     self.month  = month
     self.day    = day
     t = TimeInterval()
     t.start_time =  datetime.datetime(self.year,self.month,self.day,0)
     t.end_time   = t.start_time + datetime.timedelta(days=1)
     self.time_interval = t
     self.string  = t.start_time.strftime("%Y%m%d")
示例#6
0
 def __init__(self,year,month,day):
     self.year   = year
     self.month  = month
     self.day    = day
     centertime     = datetime.datetime(self.year,self.month,self.day,12)
     t = TimeInterval()
     t.start_time = centertime - datetime.timedelta(days=3.5)
     t.end_time   = centertime + datetime.timedelta(days=3.5)
     self.time_interval = t
     self.string  = centertime.strftime("%Y%m%d")
     self.isoweekday = centertime.isoweekday()
示例#7
0
    def __init__(self,decad):

        self.decad = decad

        q,r=divmod(decad, 10)
        assert r in [0,1]
        t = TimeInterval()
        self.startyear = decad
        self.end__year = self.startyear+9
        t.start_time = datetime.datetime(self.startyear  ,1,1,0,0,0)
        t.end_time   = datetime.datetime(self.end__year+1,1,1,0,0,0)
        self.time_interval = t
示例#8
0
def test_single_unstable_and_successfull_build(): 
    datetime_of_unstable_build = datetime(2020, 1, 1, 0, 30)    
    datetime_of_successfull_build = datetime(2020, 1, 1, 14, 30)    
    build_dto_unsuccessfull = BuildDto(123, STATUS_UNSTABLE, datetime_of_unstable_build)
    build_dto_successfull = BuildDto(124, STATUS_SUCCESS, datetime_of_successfull_build)
    expected_fail_time = TimeInterval(datetime_of_unstable_build, datetime_of_successfull_build)
    
    result = build_service.get_list_of_fail_times_from_builds([build_dto_unsuccessfull, build_dto_successfull])
    
    assert result != None
    assert len(result) == 1
    assert expected_fail_time.get_start() == result[0].get_start()
    assert expected_fail_time.get_end() == result[0].get_end()
示例#9
0
def test_single_unstable_build():    
    datetime_of_build = datetime(2020, 1, 1, 0, 30)    
    next_day = datetime.combine(datetime_of_build.date() + timedelta(days=1), datetime.min.time())
    build_service.get_datetime_today  = mock.MagicMock(return_value=next_day)
    expected_fail_time = TimeInterval(datetime_of_build, next_day)
    build_dto = BuildDto(123, STATUS_UNSTABLE, datetime_of_build)
    
    result = build_service.get_list_of_fail_times_from_builds([build_dto])
    
    assert result != None
    assert len(result) == 1
    assert expected_fail_time.get_start() == result[0].get_start()
    assert expected_fail_time.get_end() == result[0].get_end()
示例#10
0
def test_view_marginal_prices():
    print('Running Market.test_view_marginal_prices()')
    pf = 'pass'

    # Establish a test market
    test_mkt = Market

    # Create and store three TimeIntervals
    dt = datetime
    at = dt
    dur = timedelta(hours=1)
    mkt = test_mkt
    mct = dt

    ti = []  # TimeInterval.empty

    st = dt
    ti[0] = TimeInterval(at, dur, mkt, mct, st)

    st = st + dur
    ti[1] = TimeInterval(at, dur, mkt, mct, st)

    st = st + dur
    ti[2] = TimeInterval(at, dur, mkt, mct, st)

    test_mkt.timeIntervals = ti

    ## Test using a Market object
    print('- using a Market object')

    iv = []  # IntervalValue.empty
    # Create and store three marginal price values
    iv[0] = IntervalValue(test_mkt, ti[2], test_mkt,
                          MeasurementType.MarginalPrice, 3)
    iv[1] = IntervalValue(test_mkt, ti[0], test_mkt,
                          MeasurementType.MarginalPrice, 1)
    iv[2] = IntervalValue(test_mkt, ti[1], test_mkt,
                          MeasurementType.MarginalPrice, 2)
    test_mkt.marginalPrices = iv

    try:
        test_mkt.view_marginal_prices()
        print('  - function ran without errors')
    except:
        raise ('  - function encountered errors and stopped')

    # Success
    print('- the test ran to completion')
    print('Result: #s\n\n', pf)
示例#11
0
文件: Timelist.py 项目: inogs/bit.sea
def computeTimeWindow(freqString,currentDate):

    if (freqString == 'daily'):   req = requestors.Daily_req(currentDate.year,currentDate.month,currentDate.day)
    if (freqString == 'weekly'):  req = requestors.Weekly_req(currentDate.year, currentDate.month,currentDate.day)
    if (freqString == 'monthly'): req = requestors.Monthly_req(currentDate.year, currentDate.month)
    if (freqString == 'yearly'):  req = requestors.Yearly_req(currentDate.year)
    return TimeInterval.fromdatetimes(req.time_interval.start_time, req.time_interval.end_time)
示例#12
0
 def intervals(self):
     intervals = []
     intervals_names = self.rules['IntervalRules'][self.day].split(',')
     for interval_name in intervals_names:
         hours = self.rules['Intervals'][interval_name].split('-')
         intervals.append(TimeInterval(*hours))
     return intervals
示例#13
0
def test_while_in_market_lead():
    print('  Running test_while_in_market_lead().')
    print('    CASE 1: One neighbor. Its direction is not assigned.')

    test_neighbor = Neighbor()
    test_neighbor.transactive = False
    test_neighbor.upOrDown = Direction.unknown
    test_neighbor.name = 'Test_Neighbor'

    test_market = Auction()
    test_market.marketState = MarketState.MarketLead

    dt = datetime.now()
    test_interval = TimeInterval(dt,
                                 timedelta(hours=1),
                                 test_market,
                                 dt,
                                 dt)

    test_market.timeIntervals = [test_interval]

    test_agent = TransactiveNode()
    test_agent.markets = [test_market]
    test_agent.neighbors = [test_neighbor]

    assert test_market.marketState == MarketState.MarketLead

    try:
        test_market.while_in_market_lead(test_agent)
        print('    - The method ran without errors')
    except RuntimeWarning:
        print('    - ERRORS ENCOUNTERED')

    assert test_market.marketState == MarketState.MarketLead, \
                                                    'The market should not have changed from the market lead state'
    assert test_neighbor.upOrDown == Direction.downstream, \
                                                    'The undefined direction should have been assigned downstream'
    assert len(test_neighbor.scheduledPowers) == 0, \
                                              'One scheduled power should have been scheduled by the test neighbor'

    print('  CASE 2: An upstream neighbor is added.')

    upstream_neighbor = Neighbor()
    upstream_neighbor.upOrDown = Direction.upstream

    test_agent.neighbors.append(upstream_neighbor)

    assert len(test_agent.neighbors) == 2, 'There should be two neighbors'

    try:
        test_market.while_in_market_lead(test_agent)
        print('    - The method ran without errors')
    except RuntimeWarning:
        print('    - ERRORS ENCOUNTERED')

    print('  test_while_in_market_lead() ran to completion.\n')
示例#14
0
 def __init__(self,year,month,day, deltastr):
     self.year   = year
     self.month  = month
     self.day    = day
     centertime     = datetime.datetime(self.year,self.month,self.day,12)
     delta = relativedelta(10)
     exec 'delta= relativedelta(' + deltastr + ')'
     self.time_interval = TimeInterval.fromdatetimes(centertime-delta/2, centertime+delta/2)
     self.string  = centertime.strftime("%Y%m%d")
     self.deltastr = deltastr
示例#15
0
 def set_opening_intervals(self, opening_intervals):
     if not opening_intervals:
         raise ValueError('The day must have at least one opening interval.')
     self.opening_intervals = []
     for opening_interval in opening_intervals:
         if not isinstance(opening_interval, (list, tuple)):
             raise ValueError('Interval must be a list.')
         if len(opening_interval) != 2:
             raise ValueError('Each interval must be an array containing opening and closing times.')
         self.opening_intervals.append(TimeInterval.fromString(opening_interval[0], opening_interval[1]))
     sorted(self.opening_intervals, key=lambda interval: interval.getStart())
示例#16
0
    def check_intervals(self):
        # Check or create the set of instantiated TimeIntervals in this Market

        # Create the array "steps" of time intervals that should be active.
        # steps = datetime(mkt.marketClearingTime): Hours(mkt.marketClearingInterval): datetime + Hours(mkt.futureHorizon)
        # steps = steps(steps > datetime - Hours(mkt.marketClearingInterval))
        steps = []
        cur_time = Timer.get_cur_time()
        end_time = cur_time + self.futureHorizon
        self.update_market_clearing_time(cur_time)
        step_time = self.marketClearingTime
        while step_time < end_time:
            if step_time > cur_time - self.marketClearingInterval:
                steps.append(step_time)
            step_time = step_time + self.marketClearingInterval

        # Keep only time intervals >= steps[0]
        if len(steps) > 0:
            self.timeIntervals = [ti for ti in self.timeIntervals if ti.startTime >= steps[0]]

        # Index through the needed TimeIntervals based on their start times.
        for i in range(len(steps)):
            # This is a test to semarketClearingTimee whether the interval exists.
            # Case 0: a new interval must be created
            # Case 1: There is one match, the TimeInterval exists
            # Otherwise: Duplicates exists and should be deleted.
            tis = [x for x in self.timeIntervals if x.startTime == steps[i]]
            tis_len = len(tis)

            # No match was found. Create a new TimeInterval.
            if tis_len == 0:
                # Create a new TimeInterval
                activation_time = steps[i] - self.futureHorizon
                duration = self.intervalDuration
                market_clearing_time = steps[i]
                st = steps[i]  # startTime

                ti = TimeInterval(activation_time, duration, self, market_clearing_time, st)
                self.timeIntervals.append(ti)

            # The TimeInterval already exists.
            elif tis_len == 1:
                # Find the TimeInterval and check its market state assignment.
                tis[0].assign_state(self)  # ti.assign_state(mkt)

            # Duplicate time intervals exist. Remove all but one.
            else:
                self.timeIntervals = [x for x in self.timeIntervals if x.startTime != steps[i]]
                self.timeIntervals.append(tis[0])
                tis[0].assign_state(self)
示例#17
0
 def set_opening_intervals(self, opening_intervals):
     if not opening_intervals:
         raise ValueError(
             'The day must have at least one opening interval.')
     self.opening_intervals = []
     for opening_interval in opening_intervals:
         if not isinstance(opening_interval, (list, tuple)):
             raise ValueError('Interval must be a list.')
         if len(opening_interval) != 2:
             raise ValueError(
                 'Each interval must be an array containing opening and closing times.'
             )
         self.opening_intervals.append(
             TimeInterval.fromString(opening_interval[0],
                                     opening_interval[1]))
     sorted(self.opening_intervals,
            key=lambda interval: interval.getStart())
示例#18
0
文件: season.py 项目: inogs/bit.sea
    def get_season_dates(self,season_num):
        """
        Given season number, return the range of season dates (start and end)
        and the name of season.
        """

        assert season_num  < self.numbers_season
        start_date=self.SEASON_LIST[season_num]
        if (season_num + 1) == self.numbers_season:
            end_date = self.SEASON_LIST[0] + relativedelta(years = 1)
        else:
            end_date= self.SEASON_LIST[season_num+1]
        TI = TimeInterval.fromdatetimes(start_date, end_date)

        season_name = self.SEASON_LIST_NAME[season_num]

        return TI,season_name
def test_update_vertices():
    # TEST_UPDATE_VERTICES() - test method update_vertices(), which for this
    # base class of LocalAssetModel does practically nothing and must be
    # redefined by child classes that represent flesible assets.
    print('Running LocalAssetModel.test_update_vertices()')
    pf = 'pass'

    #   Create a test Market object.
    test_market = Market

    #   Create and store a TimeInterval object.
    dt = datetime.now()  # datetime that may be used for most datetime arguments
    time_interval = TimeInterval(dt, timedelta(hours=1), test_market, dt, dt)
    test_market.timeIntervals = [time_interval]

    #   Create a test LocalAssetModel object.
    test_model = LocalAssetModel()

    #   Create and store a scheduled power IntervalValue in the active time interval.
    test_model.scheduledPowers = [
        IntervalValue(test_model, time_interval, test_market, MeasurementType.ScheduledPower, 50)]

    #   Create a LocalAsset object and its maximum and minimum powers.
    test_object = LocalAsset()
    test_object.maximumPower = 200
    test_object.minimumPower = 0

    #   Have the LocalAsset model and object cross reference one another.
    test_object.model = test_model
    test_model.object = test_object

    ## TEST 1
    print('- Test 1: Basic operation')

    test_model.update_vertices(test_market)
    print('  - the method ran without errors')

    if len(test_model.activeVertices) != 1:
        pf = 'fail'
        print('  - there is an unexpected number of active vertices')
    else:
        print('  - the expected number of active vertices was found')

    # Success.
    print('- the test ran to completion')
    print('\nResult: #s\n\n', pf)
示例#20
0
文件: Timelist.py 项目: inogs/bit.sea
    def __init__(self,datelist):
        '''
        TimeList object is created by providing a list of datetime objects
        (At least 2).
        '''
        nTimes = len(datelist)
        assert  nTimes > 1
        self.Timelist = datelist
        self.Timelist.sort()
        self.nTimes   = nTimes

        self.timeinterval = TimeInterval.fromdatetimes(self.Timelist[0], self.Timelist[-1])
        self.inputdir     = None
        self.searchstring = None
        self.filelist     = None
        self.filtervar    = None
        self.inputFrequency= self.__searchFrequency()
示例#21
0
文件: Timelist.py 项目: inogs/bit.sea
    def __generaltimeselector(self,requestor):
            SELECTION=[]
            weights  =[]

            if self.inputFrequency == "daily":
                for it, t in enumerate(self.Timelist):
                    if requestor.time_interval.contains(t):
                        SELECTION.append(it)
                        weights.append(1.)
            if self.inputFrequency in ['weekly','monthly','yearly']:
                for it, t in enumerate(self.Timelist):
                    t1 = computeTimeWindow(self.inputFrequency,t);
                    t2 = TimeInterval.fromdatetimes(requestor.time_interval.start_time, requestor.time_interval.end_time)
                    weight = t1.overlapTime(t2)
                    if (weight > 0. ) :
                        SELECTION.append(it)
                        weights.append(weight)
            return SELECTION , np.array(weights)
示例#22
0
def get_list_of_fail_times_from_builds(build_dto_list):
    fail_time_list = []
    previous_build_successfull = True
    for build_dto in build_dto_list:
        if build_dto.get_status() != "SUCCESS":
            if previous_build_successfull:
                time_interval = TimeInterval(build_dto.get_datetime())
                fail_time_list.append(time_interval)
                previous_build_successfull = False
        else:
            previous_build_successfull = True
            fail_time_list_length = len(fail_time_list)
            if fail_time_list_length > 0:
                last_unstable_entry = fail_time_list[fail_time_list_length - 1]
                last_unstable_entry.set_end(build_dto.get_datetime())

    _end_last_interval_if_unset(fail_time_list)
    return fail_time_list
示例#23
0
def test_unstable_failure_and_successfull_alternating_builds(): 
    datetime_of_unstable_build = datetime(2020, 1, 1, 0, 30)
    datetime_of_successfull_build = datetime(2020, 1, 1, 14, 30)    
    datetime_of_failed_build = datetime(2020, 1, 1, 15, 00)
    next_day = datetime.combine(datetime_of_unstable_build.date() + timedelta(days=1), datetime.min.time())
    build_service.get_datetime_today  = mock.MagicMock(return_value=next_day)    
    build_dto_unsuccessfull1 = BuildDto(123, STATUS_UNSTABLE, datetime_of_unstable_build)
    build_dto_successfull = BuildDto(124, STATUS_SUCCESS, datetime_of_successfull_build)
    build_dto_unsuccessfull2 = BuildDto(125, STATUS_FAILURE, datetime_of_failed_build)
        
    result = build_service.get_list_of_fail_times_from_builds([build_dto_unsuccessfull1, build_dto_successfull, build_dto_unsuccessfull2])
    
    expected_fail_time1 = TimeInterval(datetime_of_unstable_build, datetime_of_successfull_build)
    expected_fail_time2 = TimeInterval(datetime_of_failed_build, next_day)
    assert result != None
    assert len(result) == 2
    assert expected_fail_time1.get_start() == result[0].get_start()
    assert expected_fail_time1.get_end() == result[0].get_end()    
    assert expected_fail_time2.get_start() == result[1].get_start()
    assert expected_fail_time2.get_end() == result[1].get_end()      
示例#24
0
def test_while_in_negotiation():
    print('  Running test_while_in_negotiation().')
    print('    CASE: Normal function. Asset should schedule, and market becomes converged')

    test_asset = LocalAsset()
    default_power = 4.321
    test_asset.defaultPower = default_power

    test_market = Auction()
    test_market.converged = False
    test_market.marketState = MarketState.Negotiation

    dt = datetime.now()
    test_interval = TimeInterval(dt,
                                 timedelta(hours=1),
                                 test_market,
                                 dt,
                                 dt)

    test_market.timeIntervals = [test_interval]

    test_agent = TransactiveNode()
    test_agent.markets = [test_market]
    test_agent.localAssets = [test_asset]

    assert test_market.converged is False, 'The test market should start out not converged'
    assert test_market.marketState == MarketState.Negotiation

    try:
        test_market.while_in_negotiation(test_agent)
        print('    - The method ran without errors')
    except RuntimeWarning:
        print('    - ERRORS ENCOUNTERED')

    assert test_market.converged is True, 'The market should be converged'
    assert test_market.marketState == MarketState.Negotiation, \
            'The market should not have changed from the negotiation state'
    assert len(test_asset.scheduledPowers) == 1, 'Precisely one scheduled power should have been assigned'

    print('  test_while_in_negotiation() ran to completion.\n')
    pass
示例#25
0
def test_view_net_curve():
    print('Running Market.test_view_net_curve()')
    pf = 'pass'

    # Establish a test market
    test_mkt = Market()

    # Create and store one TimeInterval
    dt = datetime(2018, 1, 1, 12, 0, 0)
    at = dt
    dur = timedelta(hours=1)
    mkt = test_mkt
    mct = dt
    st = dt
    ti = [TimeInterval(at, dur, mkt, mct, st)]

    test_mkt.timeIntervals = ti

    ## Test using a Market object
    print('- using a Market object')

    # Create and store three active vertices
    v = [Vertex(0.01, 0, -1), Vertex(0.02, 0, 1), Vertex(0.03, 0, 1)]
    iv = [
        IntervalValue(test_mkt, ti[0], test_mkt, MeasurementType.ActiveVertex,
                      v[2]),
        IntervalValue(test_mkt, ti[0], test_mkt, MeasurementType.ActiveVertex,
                      v[0]),
        IntervalValue(test_mkt, ti[0], test_mkt, MeasurementType.ActiveVertex,
                      v[1])
    ]
    test_mkt.activeVertices = [iv]

    test_mkt.view_net_curve(0)
    print('  - function ran without errors')

    # Success
    print('- the test ran to completion')
    print('Result: #s\n\n', pf)
def test_update_dc_threshold():
    print('Running BulkSupplier_dc.test_update_dc_threshold()')
    pf = 'pass'

    ## Basic configuration for tests:
    # Create a test object and initialize demand-realted properties
    test_obj = BulkSupplier_dc()
    test_obj.demandMonth = datetime.now().month  # month(datetime)
    test_obj.demandThreshold = 1000

    # Create a test market   
    test_mkt = Market()

    # Create and store two time intervals
    dt = datetime.now()
    at = dt
    dur = timedelta(hours=1)  # Hours(1)
    mkt = test_mkt
    mct = dt
    st = dt
    ti = [TimeInterval(at, dur, mkt, mct, st)]
    st = st + dur
    ti.append(TimeInterval(at, dur, mkt, mct, st))
    test_mkt.timeIntervals = ti

    ##  Test case when there is no MeterPoint object  
    test_obj.demandThreshold = 1000
    test_obj.demandMonth = datetime.now().month  # month(datetime)
    test_obj.meterPoints = []  # MeterPoint.empty

    # Create and store a couple scheduled powers
    # iv(1) = IntervalValue(test_obj, ti[0], test_mkt, MeasurementType.ScheduledPower, 900)
    # iv(2) = IntervalValue(test_obj, ti[1], test_mkt, MeasurementType.ScheduledPower, 900)
    iv = [
        IntervalValue(test_obj, ti[0], test_mkt, MeasurementType.ScheduledPower, 900),
        IntervalValue(test_obj, ti[1], test_mkt, MeasurementType.ScheduledPower, 900)
    ]
    test_obj.scheduledPowers = iv

    try:
        test_obj.update_dc_threshold(test_mkt)
        print('- the method ran without errors')
    except:
        pf = 'fail'
        print('- the method encountered errors when called')

    if test_obj.demandThreshold != 1000:
        pf = 'fail'
        print('- the method inferred the wrong demand threshold value')
    else:
        print('- the method properly kept the old demand threshold value with no meter')

    iv = [
        IntervalValue(test_obj, ti[0], test_mkt, MeasurementType.ScheduledPower, 1100),
        IntervalValue(test_obj, ti[1], test_mkt, MeasurementType.ScheduledPower, 900)
    ]
    test_obj.scheduledPowers = iv

    try:
        test_obj.update_dc_threshold(test_mkt)
        print('- the method ran without errors when there is no meter')
    except:
        pf = 'fail'
        print('- the method encountered errors when there is no meter')

    if test_obj.demandThreshold != 1100:
        pf = 'fail'
        print('- the method did not update the inferred demand threshold value')
    else:
        print('- the method properly updated the demand threshold value with no meter')

    ## Test with an appropriate MeterPoint meter
    # Create and store a MeterPoint test object
    test_mtr = MeterPoint()
    test_mtr.measurementType = MeasurementType.AverageDemandkW
    test_mtr.currentMeasurement = 900
    test_obj.meterPoints = [test_mtr]

    # Reconfigure the test object for this test:
    iv = [
        IntervalValue(test_obj, ti[0], test_mkt, MeasurementType.ScheduledPower, 900),
        IntervalValue(test_obj, ti[1], test_mkt, MeasurementType.ScheduledPower, 900)
    ]
    test_obj.scheduledPowers = iv

    test_obj.demandThreshold = 1000
    test_obj.demandMonth = datetime.now().month

    # Run the test. Confirm it runs.
    try:
        test_obj.update_dc_threshold(test_mkt)
        print('- the method ran without errors when there is a meter')
    except:
        pf = 'fail'
        print('- the method encountered errors when there is a meter')

    # Check that the old threshold is correctly retained.
    if test_obj.demandThreshold != 1000:
        pf = 'fail'
        print('- the method failed to keep the correct demand threshold value when there is a meter')
    else:
        print('- the method properly kept the old demand threshold value when there is a meter')

    # Reconfigure the test object with a lower current threshold
    iv = [
        IntervalValue(test_obj, ti[0], test_mkt, MeasurementType.ScheduledPower, 900),
        IntervalValue(test_obj, ti[1], test_mkt, MeasurementType.ScheduledPower, 900)
    ]
    test_obj.scheduledPowers = iv
    test_obj.demandThreshold = 800

    # Run the test.
    test_obj.update_dc_threshold(test_mkt)

    # Check that a new, higher demand threshold was set.
    if test_obj.demandThreshold != 900:
        pf = 'fail'
        print(['- the method failed to update the demand threshold value when there is a meter'])
    else:
        print('- the method properly updated the demand threshold value when there is a meter')

    ## Test rollover to new month
    # Configure the test object
    test_obj.demandMonth = dt + relativedelta.relativedelta(months=-1)  # month(datetime - days(31))  # prior month
    test_obj.demandThreshold = 1000
    test_obj.scheduledPowers[0].value = 900
    test_obj.scheduledPowers[1].value = 900
    test_obj.meterPoints = []  # MeterPoint.empty

    # Run the test
    test_obj.update_dc_threshold(test_mkt)

    # See if the demand threshold was reset at the new month.
    if test_obj.demandThreshold != 0.8 * 1000:
        pf = 'fail'
        print('- the method did not reduce the threshold properly in a new month')
    else:
        print('- the method reduced the threshold properly in a new month')

    # Success
    print('- the test ran to completion')
    print('Result: #s\n\n', pf)
示例#27
0
def test_production():
    from local_asset_model import LocalAssetModel
    from market import Market

    print('Running test_production()')
    pf = 'pass'

    #   Create a test object
    test_object = LocalAssetModel()

    #   Create a test market
    test_market = Market()

    #   Create several active vertices av
    av = [
        Vertex(0.0200, 5.00, 0.0),
        Vertex(0.0200, 7.00, 100.0),
        Vertex(0.0250, 9.25, 200.0)
    ]

    # Create a time interval ti
    dt = datetime.now()
    at = dt
    #   NOTE: Function Hours() corrects the behavior of Matlab hours().
    dur = timedelta(hours=1)
    mkt = test_market
    mct = dt
    st = dt
    ti = TimeInterval(at, dur, mkt, mct, st)

    # Assign activeVertices, which are IntervalValues
    test_object.activeVertices = [
        IntervalValue(test_object, ti, test_market,
                      MeasurementType.ActiveVertex, av[0]),
        IntervalValue(test_object, ti, test_market,
                      MeasurementType.ActiveVertex, av[1]),
        IntervalValue(test_object, ti, test_market,
                      MeasurementType.ActiveVertex, av[2])
    ]

    ## CASE: Various marginal prices when there is more than one vertex
    test_prices = [-0.010, 0.000, 0.020, 0.0225, 0.030]

    p = [0] * len(test_prices)  #zeros(1, length(test_prices))
    for i in range(len(test_prices)):  #for i = 1:length(test_prices)
        p[i] = production(test_object, test_prices[i], ti)

    print('- the function ran without errors')

    # p(1) = 0: below first vertex
    # p(2) = 0: below first vertex
    # p(3) = 100: at first vertex, which has identical marginal price as second
    # p(4) = 150: interpolate between vertices
    # p(5) = 200: exceeds last vertex

    #if ~all(abs(p - [0, 0, 100, 150, 200]) < 0.001):
    expected = [0, 0, 100, 150, 200]
    if not all([p[i] - expected[i] < 0.001 for i in range(len(p))]):
        pf = 'fail'
        raise Exception('- the production cost was incorrectly calculated')
    else:
        print('- the production cost was correctly calculated')

    ## CASE: One vertex (inelastic case, a constant)
    test_object.activeVertices = [
        IntervalValue(test_object, ti, test_market,
                      MeasurementType.ActiveVertex, av[2])
    ]

    for i in range(5):
        p[i] = production(test_object, test_prices[i], ti)

    #if ~all(p == 200 * ones(1, length(p))):
    if not all(x == 200 for x in p):
        pf = 'fail'
        raise Exception(
            'the vertex power should be assigned when there is one vertex')
    else:
        print('- the correct power was assigned when there is one vertex')

    ## CASE: No active vertices (error case):
    test_object.activeVertices = []

    try:
        p = production(test_object, test_prices[4], ti)
        pf = 'fail'
        raise Exception(
            '- an error should have occurred with no active vertices')
    except:
        print('- with no vertices, system returned with warnings, as expected')

    #   Success
    print('- the test function ran to completion')
    print('Result: #s\n\n', pf)
示例#28
0
def test_prod_cost_from_formula():
    from local_asset_model import LocalAssetModel
    from market import Market

    print('Running test_prod_cost_from_formula()')
    pf = 'pass'

    #   Create a test object
    test_object = LocalAssetModel()

    #   Create a test market
    test_market = Market()

    #   Create and store the object's cost parameters
    test_object.costParameters = [4, 3, 2]

    #   Create and store three hourly TimeIntervals
    #   Modified to use the TimeInterval constructor.
    dt = datetime.now()
    at = dt
    dur = timedelta(hours=1)
    mkt = test_market
    mct = dt

    st = dt
    ti = [TimeInterval(at, dur, mkt, mct, st)]

    st = st + dur
    ti.append(TimeInterval(at, dur, mkt, mct, st))

    st = st + dur
    ti.append(TimeInterval(at, dur, mkt, mct, st))

    test_market.timeIntervals = ti

    # Create and store three corresponding scheduled powers
    iv = [
        IntervalValue(test_object, ti[0], test_market,
                      MeasurementType.ScheduledPower, 100),
        IntervalValue(test_object, ti[1], test_market,
                      MeasurementType.ScheduledPower, 200),
        IntervalValue(test_object, ti[2], test_market,
                      MeasurementType.ScheduledPower, 300)
    ]
    test_object.scheduledPowers = iv

    #   Run the test
    pc = [0] * 3
    for i in range(3):
        pc[i] = prod_cost_from_formula(test_object, ti[i])

    # pc(1) = 4 + 3 * 100 + 0.5 * 2 * 100^2 = 10304
    # pc(2) = 4 + 3 * 200 + 0.5 * 2 * 200^2 = 40604
    # pc(3) = 4 + 3 * 300 + 0.5 * 2 * 300^2 = 90904

    #if all(pc ~=[10304, 40604, 90904])
    expected = [10304, 40604, 90904]
    if all([pc[i] != expected[i] for i in range(len(pc))]):
        pf = 'fail'
        raise Exception('- production cost was incorrectly calculated')
    else:
        print('- production cost was correctly calculated')

    #   Success
    print('- the test ran to completion')
    print('Result: #s\n\n', pf)
示例#29
0
文件: Timelist.py 项目: inogs/bit.sea
    def select(self,requestor):
        '''
        Method for time aggregation
        indexes, weights = select(requestor)
        Returned values:
         - a list of indexes (integers) indicating to access selected times (or files)
         - a numpy array of weights


        '''

        if isinstance(requestor,requestors.Daily_req):
            # hourly values are treated as instantaneous values, not time averages
            assert self.inputFrequency in ["hourly","daily"] # it does not matter how many hours
            SELECTION=[]
            weights = []
            for it,t in enumerate(self.Timelist):
                if requestor.time_interval.contains(t):
                    SELECTION.append(it)
                    weights.append(1.)
            return SELECTION , np.array(weights)


        if isinstance(requestor, requestors.Monthly_req):
            SELECTION=[]
            weights = []

            if self.inputFrequency == 'daily':
                for it, t in enumerate(self.Timelist):
                    if (t.year==requestor.year) & (t.month==requestor.month):
                        SELECTION.append(it)
                        weights.append(1.)
            if self.inputFrequency == 'weekly':
                for it,t in enumerate(self.Timelist):
                    t1 = computeTimeWindow("weekly",t);
                    t2 = TimeInterval.fromdatetimes(requestor.time_interval.start_time, requestor.time_interval.end_time)
                    weight = t1.overlapTime(t2);
                    if (weight > 0. ) :
                        SELECTION.append(it)
                        weights.append(weight)
            if self.inputFrequency == 'monthly':
                #print "Not time aggregation"
                for it,t in enumerate(self.Timelist):
                    if requestor.time_interval.contains(t):
                        SELECTION.append(it)
                        weights.append(1.)
            return SELECTION , np.array(weights)


        if isinstance(requestor, requestors.Weekly_req):
            assert self.inputFrequency != "monthly"
            assert self.inputFrequency != "weekly"

            SELECTION=[]
            weights  =[]

            if self.inputFrequency == "daily":
                for it,t in enumerate(self.Timelist):
                    if requestor.time_interval.contains(t):
                        SELECTION.append(it)
                        weights.append(1.)
            return SELECTION , np.array(weights)

        if isinstance(requestor, requestors.Interval_req):
            return self.__generaltimeselector(requestor)

        if isinstance(requestor, requestors.Season_req):
            return self.__generaltimeselector(requestor)

        if isinstance(requestor, requestors.Yearly_req):
            return self.__generaltimeselector(requestor)

        if isinstance(requestor, requestors.Decadal_req):
            return self.__generaltimeselector(requestor)
        if isinstance(requestor, requestors.Generic_req):
            return self.__generaltimeselector(requestor)

        if isinstance(requestor, requestors.Clim_day):
            assert self.inputFrequency == 'daily'
            SELECTION=[]
            weights  =[]
            for it,t in enumerate(self.Timelist):
                if (t.month == requestor.month) & (t.day == requestor.day):
                    SELECTION.append(it)
                    weights.append(1.)
            return SELECTION , np.array(weights)


        if isinstance(requestor,requestors.Clim_month):
            SELECTION = []
            weights   = []
            YEARLIST=self.getYearlist()
            for year_req in YEARLIST:
                req = requestors.Monthly_req(year_req.year, requestor.month)
                s,w = self.select(req)
                SELECTION.extend(s)
                weights.extend(w)

            return SELECTION , np.array(weights)

        if isinstance(requestor,requestors.Clim_season):
            SELECTION = []
            weights   = []
            YEARLIST=self.getYearlist()
            for year_req in YEARLIST:
                req = requestors.Season_req(year_req.year, requestor.season,seasonobj)
                s,w = self.select(req)
                SELECTION.extend(s)
                weights.extend(w)
            return SELECTION , np.array(weights)
def test_schedule_engagement():
    # TEST_SCHEDULE_ENGAGEMENT() - tests a LocalAssetModel method called
    # schedule_engagment()

    print('Running LocalAssetModel.test_schedule_engagement()')

    pf = 'pass'

    #   Establish test market
    test_mkt = Market()

    #   Establish test market with two distinct active time intervals
    # Note: This changed 1/29/18 due to new TimeInterval constructor
    dt = datetime.now()
    at = dt
    #   NOTE: def Hours() corrects behavior of Matlab hours().
    dur = timedelta(hours=1)
    mkt = test_mkt
    mct = dt
    st = datetime.combine(date.today(), time())  # datetime(date)

    ti = [TimeInterval(at, dur, mkt, mct, st)]

    st = ti[0].startTime + dur
    ti.append(TimeInterval(at, dur, mkt, mct, st))

    #   store time intervals
    test_mkt.timeIntervals = ti

    #   Establish test object that is a LocalAssetModel
    test_object = LocalAssetModel()

    #   Run the first test case.
    test_object.schedule_engagement(test_mkt)

    #   Were the right number of engagement schedule values created?
    if len(test_object.engagementSchedule) != 2:
        pf = 'fail'
        raise Exception('- the method did not store the engagement schedule')
    else:
        print('- the method stored the right number of results')

    # Where the correct scheduled engagement values stored?
    if len([x.value for x in test_object.engagementSchedule if x.value != 1]) > 0:
        pf = 'fail'
        raise Exception('- the stored engagement schedule was not as expected')
    else:
        print('- the result values were as expected')

    # Create and store another active time interval.
    st = ti[1].startTime + dur
    ti.append(TimeInterval(at, dur, mkt, mct, st))

    #   Re-store time intervals
    test_mkt.timeIntervals = ti

    #   Run next test case.
    test_object.schedule_engagement(test_mkt)

    #   Was the new time interval used?
    if len(test_object.engagementSchedule) != 3:
        pf = 'fail'
        raise Exception('- the method apparently failed to create a new engagement')
    else:
        print('- the method created and stored new values')

    # Were the existing time interval values reassigned properly?
    # if any([test_object.engagementSchedule.value] != true * ones(1, 3)):
    if any([x.value != 1 for x in test_object.engagementSchedule]):
        pf = 'fail'
        raise Exception('- the existing list was not augmented as expected')

    # Success.
    print('- the test ran to completion')
    print('\nResult: #s\n\n', pf)
示例#31
0
def test_are_different2():
    from transactive_record import TransactiveRecord

    print('Running test_production()')
    pf = 'pass'

    # Create a time interval ti
    dt = datetime.now()
    at = dt
    dur = timedelta(hours=1)
    mkt = None
    mct = dt
    st = dt
    ti = TimeInterval(at, dur, mkt, mct, st)

    transactive_records = [
        TransactiveRecord(ti, 0, 0.5, 100),
        TransactiveRecord(ti, 0, 0.5, 105),
        TransactiveRecord(ti, 1, 0.022, -0.0),
        TransactiveRecord(ti, 2, 0.022, 16400),
        TransactiveRecord(ti, 2, 0.023, 16400)
    ]

    # CASE 0: SIGNAL SETS DIFFER IN NUMBERS OF RECORDS
    print('Case 0: Signals have different record counts.')
    prepped_records = [transactive_records[0]]
    sent_records = [transactive_records[0], transactive_records[1]]
    threshold = 0.02
    response = False

    try:
        response = are_different2(prepped_records, sent_records, threshold)
        print('  The method ran without errors')
    except Exception as ex:
        pf = 'fail'
        print(ex.message)

    if not response:
        pf = 'fail'
        print('  The method said the signals are the same which is wrong')
    else:
        print('  The method correctly said the signals differ')

    # CASE 1: No flexibility. One signal each. Powers of Records 0 match.
    print(
        'Case 1: No flexibility. One signal each. Powers of Records 0 match.')
    prepped_records = [transactive_records[0]]
    sent_records = [transactive_records[0]]
    threshold = 0.02

    try:
        response = are_different2(prepped_records, sent_records, threshold)
        print('  The method ran without errors')
    except:
        pf = 'fail'
        print('  The method encountered errors and stopped')

    if response:
        pf = 'fail'
        print('  The method said the signals were different which is wrong')
    else:
        print('  The method correctly said the signals were the same')

    # CASE 2 - No flexibiltiy. One signal each. Powers of Records 0 do not
    # match.
    print(
        'Case 2: No flexibility. One signal each. Powers of Records 0 do NOT match.'
    )
    prepped_records = [transactive_records[0]]
    sent_records = [transactive_records[1]]
    threshold = 0.02

    try:
        response = are_different2(prepped_records, sent_records, threshold)
        print('  The method ran without errors')
    except:
        pf = 'fail'
        print('  The method encountered errors and stopped')

    if not response:
        pf = 'fail'
        print('  The method said the signals were the same which is wrong')
    else:
        print('  The method correctly said the signals differ')

    # CASE 3 - (Hung's case) Flexibility, but identical signals.
    #NOTE: Hung had found a case where powers had become zero, causing logic
    #problems. Code has been revised to avoid this possiblity.
    print('Case 3: Flexibility. Signals are identical')
    prepped_records = [transactive_records[2], transactive_records[3]]
    sent_records = [transactive_records[2], transactive_records[3]]
    threshold = 0.02

    try:
        response = are_different2(prepped_records, sent_records, threshold)
        print('  The method ran without errors')
    except:
        pf = 'fail'
        print('  The method encountered errors and stopped')

    if response:
        pf = 'fail'
        print('  The method said the signals differ which is wrong')
    else:
        print('  The method correctly said the signals are the same')

    # CASE 4 - Flexibility, but different signals.
    print('Case 4: Flexibility. Signals are different')
    prepped_records = [transactive_records[2], transactive_records[3]]
    sent_records = [
        transactive_records[2], transactive_records[3], transactive_records[4]
    ]
    threshold = 0.02

    try:
        response = are_different2(prepped_records, sent_records, threshold)
        print('  The method ran without errors')
    except:
        pf = 'fail'
        print('  The method encountered errors and stopped')

    if not response:
        pf = 'fail'
        print('  The method said the signals are the same which is wrong')
    else:
        print('  The method correctly said the signals differ')

    # Success
    print('- the test ran to completion')
    print('Result: {}\n\n'.format(pf))
示例#32
0
def test_update_costs():
    print('Running AbstractModel.test_update_costs()')

    pf = 'pass'

    #   Create a test market test_mkt
    test_mkt = Market()

    #   Create a sample time interval ti
    dt = datetime.now()
    at = dt
    #   NOTE: Function Hours() corrects behavior of Matlab hours().
    dur = timedelta(hours=1)
    mkt = test_mkt
    mct = dt
    st = datetime.combine(date.today(), time()) + timedelta(hours=20)
    ti = TimeInterval(at, dur, mkt, mct, st)

    #   Save the time interval
    test_mkt.timeIntervals = [ti]

    #   Assign a marginal price in the time interval
    test_mkt.check_marginal_prices()

    #   Create a Neighbor test object and give it a default maximum power value
    test_obj = Neighbor()
    #     test_obj.maximumPower = 100

    #   Create a corresponding NeighborModel
    test_mdl = NeighborModel()

    #   Make sure that the model and object cross-reference one another
    test_obj.model = test_mdl
    test_mdl.object = test_obj

    test_mdl.scheduledPowers = [
        IntervalValue(test_mdl, ti, test_mkt, MeasurementType.ScheduledPower,
                      100)
    ]
    test_mdl.activeVertices = [
        IntervalValue(test_mdl, ti, test_mkt, MeasurementType.ActiveVertex,
                      Vertex(0.05, 0, 100))
    ]

    #   Run a test with a NeighborModel object
    print('- running test with a NeighborModel:')
    try:
        test_mdl.update_costs(test_mkt)
        print('  - the method encountered no errors')
    except:
        pf = 'fail'
        raise '  - the method did not run without errors'

    if len(test_mdl.productionCosts) != 1:
        pf = 'fail'
        raise '  - the method did not store a production cost'
    else:
        print('  - the method calculated and stored a production cost')

    if len(test_mdl.dualCosts) != 1:
        pf = 'fail'
        raise '  - the method did not store a dual cost'
    else:
        print('  - the method stored a dual cost')

    if test_mdl.totalProductionCost != sum(
        [x.value for x in test_mdl.productionCosts]):
        pf = 'fail'
        raise '  - the method did not store a total production cost'
    else:
        print('  - the method stored an total production cost')

    if test_mdl.totalDualCost != sum([x.value for x in test_mdl.dualCosts]):
        pf = 'fail'
        raise '  - the method did not store a total dual cost'
    else:
        print('  - the method stored an total dual cost')

    # Run a test again with a LocalAssetModel object
    test_obj = LocalAsset()
    #     test_obj.maximumPower = 100
    test_mdl = LocalAssetModel()
    test_obj.model = test_mdl
    test_mdl.object = test_obj

    test_mdl.scheduledPowers = [
        IntervalValue(test_mdl, ti, test_mkt, MeasurementType.ScheduledPower,
                      100)
    ]
    test_mdl.activeVertices = [
        IntervalValue(test_mdl, ti, test_mkt, MeasurementType.ActiveVertex,
                      Vertex(0.05, 0, 100))
    ]

    print('- running test with a LocalAssetModel:')

    try:
        test_mdl.update_costs(test_mkt)
        print('  - the method encountered no errors')
    except:
        pf = 'fail'
        raise '  - the method did not run without errors'

    if len(test_mdl.productionCosts) != 1:
        pf = 'fail'
        raise '  - the method did not store a production cost'
    else:
        print('  - the method calculated and stored a production cost')

    if len(test_mdl.dualCosts) != 1:
        pf = 'fail'
        raise '  - the method did not store a dual cost'
    else:
        print('  - the method stored a dual cost')

    if test_mdl.totalProductionCost != sum(
        [x.value for x in test_mdl.productionCosts]):
        pf = 'fail'
        raise '  - the method did not store a total production cost'
    else:
        print('  - the method stored an total production cost')

    if test_mdl.totalDualCost != sum([x.value for x in test_mdl.dualCosts]):
        pf = 'fail'
        raise '  - the method did not store a total dual cost'
    else:
        print('  - the method stored an total dual cost')

    # Success
    print('- the test ran to completion')
    print('Result: %s', pf)
def test_calculate_reserve_margin():
    # TEST_LAM_CALCULATE_RESERVE_MARGIN() - a LocalAssetModel ("LAM") class
    # method NOTE: Reserve margins are introduced but not fully integrated into
    # code in early template versions.
    # CASES:
    # 1. uses hard maximum if no active vertices exist
    # 2. vertices exist
    # 2.1 uses maximum vertex power if it is less than hard power constraint
    # 2.2 uses hard constraint if it is less than maximum vertex power
    # 2.3 upper flex power is greater than scheduled power assigns correct
    # positive reserve margin
    # 2.4 upperflex power less than scheduled power assigns zero value to
    # reserve margin.

    print('Running LocalAssetModel.test_calculate_reserve_margin()')

    pf = 'pass'

    # Establish test market
    test_mkt = Market()

    # Establish test market with an active time interval
    # Note: modified 1/29/18 due to new TimeInterval constructor
    dt = datetime.now()
    at = dt
    # NOTE: def Hours() corrects behavior of Matlab hours().
    dur = timedelta(hours=1)
    mkt = test_mkt
    mct = dt
    # st = datetime(date)
    st = datetime.combine(date.today(), time())

    ti = TimeInterval(at, dur, mkt, mct, st)

    # Store time interval
    test_mkt.timeIntervals = [ti]

    # Establish a test object that is a LocalAsset with assigned maximum power
    test_object = LocalAsset()
    test_object.maximumPower = 100

    # Establish test object that is a LocalAssetModel
    test_model = LocalAssetModel()
    test_model.scheduledPowers = [
        IntervalValue(test_model, ti, test_mkt, MeasurementType.ScheduledPower, 0.0)]

    # Allow object and model to cross-reference one another.
    test_object.model = test_model
    test_model.object = test_object

    # Run the first test case.
    test_model.calculate_reserve_margin(test_mkt)
    print('- method ran without errors')

    if len(test_model.reserveMargins) != 1:
        raise Exception('- an unexpected number of results were stored')
    else:
        print('- one reserve margin was stored, as expected')

    if test_model.reserveMargins[0].value != test_object.maximumPower:
        pf = 'fail'
        raise Exception('- the method did not use the available maximum power')
    else:
        print('- the method used maximum power value, as expected')

    # create some vertices and store them
    iv = [
        IntervalValue(test_model, ti, test_mkt, MeasurementType.Vertex, Vertex(0, 0, -10)),
        IntervalValue(test_model, ti, test_mkt, MeasurementType.Vertex, Vertex(0, 0, 10))
    ]
    test_model.activeVertices = iv

    # run test with maximum power greater than maximum vertex
    test_object.maximumPower = 100
    test_model.calculate_reserve_margin(test_mkt)

    if test_model.reserveMargins[0].value != 10:
        pf = 'fail'
        raise Exception('- the method should have used vertex for comparison')
    else:
        print('- the method correctly chose to use the vertex power')

    # run test with maximum power less than maximum vertex
    test_object.maximumPower = 5
    test_model.calculate_reserve_margin(test_mkt)

    if test_model.reserveMargins[0].value != 5:
        pf = 'fail'
        raise Exception('- method should have used maximum power for comparison')
    else:
        print('- the method properly chose to use the maximum power')

    # run test with scheduled power greater than maximum vertex
    test_model.scheduledPowers[0].value = 20
    test_object.maximumPower = 500
    test_model.calculate_reserve_margin(test_mkt)

    if test_model.reserveMargins[0].value != 0:
        pf = 'fail'
        raise Exception('- method should have assigned zero for a neg. result')
    else:
        print('- the method properly assigned 0 for a negative result')

    # Success.
    print('- the test ran to completion')
    print('\nResult: #s\n\n', pf)
def test_update_production_costs():
    # TEST_UPDATE_PRODUCTION_COSTS() - test method update_production_costs()
    # that calculates production costs from active vertices and scheduled
    # powers.
    # NOTE: This test is virtually identical to the NeighborModel test of the
    # same name.
    print('Running LocalAssetModel.test_update_production_costs()')
    pf = 'pass'

    #   Create a test Market object.
    test_market = Market

    #   Create and store a TimeInterval object.
    dt = datetime.now()  # datetime that may be used for most datetime arguments
    time_interval = TimeInterval(dt, timedelta(hours=1), test_market, dt, dt)
    test_market.timeIntervals = [time_interval]

    #   Create a test LocalAssetModel object.
    test_model = LocalAssetModel()

    #   Create and store a scheduled power IntervalValue in the active time
    #   interval.
    test_model.scheduledPowers = [
        IntervalValue(test_model, time_interval, test_market, MeasurementType.ScheduledPower, 50)]

    #   Create and store some active vertices IntervalValue objects in the
    #   active time interval.
    vertices = [
        Vertex(0.1, 1000, 0),
        Vertex(0.2, 1015, 100)
    ]
    interval_values = [
        IntervalValue(test_model, time_interval, test_market, MeasurementType.ActiveVertex, vertices[0]),
        IntervalValue(test_model, time_interval, test_market, MeasurementType.ActiveVertex, vertices[1])
    ]
    test_model.activeVertices = interval_values

    # TEST 1
    print('- Test 1: First calculation of a production cost')

    test_model.update_production_costs(test_market)
    print('  - the method ran without errors')

    if len(test_model.productionCosts) != 1:
        pf = 'fail'
        print('  - the wrong number of production costs was created')
    else:
        print('  - the right number of production cost values was created')

    production_cost = test_model.productionCosts[0].value

    if float(production_cost) != float(1007.5):
        pf = 'fail'
        print('  - an unexpected production cost value was found')
    else:
        print('  - the expected production cost value was found')

    # TEST 2
    print('- Test 2: Reassignment of an existing production cost')

    #   Configure the test by modifying the scheduled power value.
    test_model.scheduledPowers[0].value = 150

    test_model.update_production_costs(test_market)
    print('  - the method ran without errors')

    if len(test_model.productionCosts) != 1:
        pf = 'fail'
        print('  - the wrong number of productions was created')
    else:
        print('  - the right number of production cost values was created')

    production_cost = test_model.productionCosts[0].value

    if float(production_cost) != float(1015):
        pf = 'fail'
        print('  - an unexpected dual cost value was found')
    else:
        print('  - the expected dual cost value was found')

    # Success.
    print('- the test ran to completion')
    print('\nResult: #s\n\n', pf)
def test_update_dual_costs():
    # TEST_UPDATE_DUAL_COSTS() - test method update_dual_costs() that creates
    # or revises the dual costs in active time intervals using active vertices,
    # scheduled powers, and marginal prices.
    # NOTE: This test is virtually identical to the NeighborModel test of the
    # same name.
    print('Running LocalAssetModel.test_update_dual_costs()')
    pf = 'pass'

    #   Create a test Market object.
    test_market = Market()

    #   Create and store a TimeInterval object.
    dt = datetime.now()  # datetime that may be used for most datetime arguments
    time_interval = TimeInterval(dt, timedelta(hours=1), test_market, dt, dt)
    test_market.timeIntervals = [time_interval]

    #   Create and store a marginal price IntervalValue object.
    test_market.marginalPrices = [
        IntervalValue(test_market, time_interval, test_market, MeasurementType.MarginalPrice, 0.1)]

    #   Create a test LocalAssetModel object.
    test_model = LocalAssetModel()

    #   Create and store a scheduled power IntervalValue in the active time
    #   interval.
    test_model.scheduledPowers = [
        IntervalValue(test_model, time_interval, test_market, MeasurementType.ScheduledPower, 100)]

    #   Create and store a production cost IntervalValue object in the active
    #   time interval.
    test_model.productionCosts = [
        IntervalValue(test_model, time_interval, test_market, MeasurementType.ProductionCost, 1000)]

    # TEST 1
    print('- Test 1: First calculation of a dual cost')

    test_model.update_dual_costs(test_market)
    print('  - the method ran without errors')

    if len(test_model.dualCosts) != 1:
        pf = 'fail'
        print('  - the wrong number of dual cost values was created')
    else:
        print('  - the right number of dual cost values was created')

    dual_cost = test_model.dualCosts[0].value

    if dual_cost != (1000 - 100 * 0.1):
        pf = 'fail'
        print('  - an unexpected dual cost value was found')
    else:
        print('  - the expected dual cost value was found')

    # TEST 2
    print('- Test 2: Reassignment of an existing dual cost')

    #   Configure the test by modifying the marginal price value.
    test_market.marginalPrices[0].value = 0.2

    test_model.update_dual_costs(test_market)
    print('  - the method ran without errors')

    if len(test_model.dualCosts) != 1:
        pf = 'fail'
        print('  - the wrong number of dual cost values was created')
    else:
        print('  - the right number of dual cost values was created')

    dual_cost = test_model.dualCosts[0].value

    if dual_cost != (1000 - 100 * 0.2):
        pf = 'fail'
        print('  - an unexpected dual cost value was found')
    else:
        print('  - the expected dual cost value was found')

    # Success.
    print('- the test ran to completion')
    print('\nResult: #s\n\n', pf)
def test_schedule_power():
    # TEST_SCHEDULE_POWER() - tests a LocalAssetModel method called
    # schedule_power().

    print('Running LocalAssetModel.test_schedule_power()')

    pf = 'pass'

    #   Establish test market
    test_mkt = Market

    #   Establish test market with two distinct active time intervals
    # Note: This changed 1/29/19 due to new TimeInterval constructor
    dt = datetime.now()
    at = dt
    #   NOTE: def Hours() corrects behavior of Matlab hours().
    dur = timedelta(hours=1)
    mkt = test_mkt
    mct = dt
    st = datetime.combine(date.today(), time())  # datetime(date)

    ti = [TimeInterval(at, dur, mkt, mct, st)]
    st = ti[0].startTime + dur
    ti.append(TimeInterval(at, dur, mkt, mct, st))

    #   Store time intervals
    test_mkt.timeIntervals = ti

    #   Establish test object that is a LocalAssetModel with a default power
    #   property.
    test_object = LocalAssetModel()
    test_object.defaultPower = 3.14159

    #   Run the first test case.
    test_object.schedule_power(test_mkt)

    #   Were the right number of schduled power values created?
    if len(test_object.scheduledPowers) != 2:
        pf = 'fail'
        raise Exception('- the method did not store the right number of results')
    else:
        print('- the method stored the right number of results')

    # Where the correct scheduled power valules stored?
    # if any([test_object.scheduledPowers.value] != test_object.defaultPower * ones(1, 2))
    if any([x.value != test_object.defaultPower for x in test_object.scheduledPowers]):
        pf = 'fail'
        raise Exception('- the stored scheduled powers were not as expected')
    else:
        print('- the result value was as expected')

    # Change the default power.
    test_object.defaultPower = 6

    #   Create and store another active time interval.
    st = ti[1].startTime + dur
    ti.append(TimeInterval(at, dur, mkt, mct, st))

    #   Re-store time intervals
    test_mkt.timeIntervals = ti

    #   Run next test case.
    test_object.schedule_power(test_mkt)

    #   Was the new time interval used?
    if len(test_object.scheduledPowers) != 3:
        pf = 'fail'
        raise Exception('- the method failed to create a new scheduled power')

    # Were the existing time intervals reassigned properly?
    # if any([test_object.scheduledPowers.value] != test_object.defaultPower * ones(1, 3))
    if any([x.value != test_object.defaultPower for x in test_object.scheduledPowers]):
        pf = 'fail'
        raise Exception('- existing scheduled powers were not reassigned properly')

    # Success.
    print('- the test ran to completion')
    print('\nResult: #s\n\n', pf)
示例#37
0
    def test_schedule_power(cls):
        print('Running test_schedule_power()')
        pf = 'pass'

        # Create a test Market object.
        test_mkt = Market()

        # Create and store a couple TimeInterval objects at a known date and
        # time.
        dt = datetime(2017, 11, 1, 12, 0, 0)  # Wednesday Nov. 1, 2017 at noon
        at = dt
        dur = timedelta(hours=1)
        mkt = test_mkt
        mct = dt
        st = dt
        test_intervals = [TimeInterval(at, dur, mkt, mct, st)]

        st = st + dur  # 1p on the same day
        test_intervals.append(TimeInterval(at, dur, mkt, mct, st))

        test_mkt.timeIntervals = test_intervals

        # Create a test TemperatureForecastModel object and give it some
        # temperature values in the test TimeIntervals.
        # test_forecast = TemperatureForecastModel
        # # The information type should be specified so the test object will
        # # correctly identivy it.
        # test_forecast.informationType = 'temperature'
        # # test_forecast.update_information(test_mkt)
        # test_forecast.predictedValues(1) = IntervalValue(test_forecast, test_intervals(1), test_mkt, 'Temperature', 20)  # Heating regime
        # test_forecast.predictedValues(2) = IntervalValue(test_forecast, test_intervals(2), test_mkt, 'Temperature', 100)  # Cooling regime
        # test_obj.informationServiceModels = {test_forecast}
        # Create a OpenLoopRichlandLoadPredictor test object.
        test_forecast = TemperatureForecastModel()
        test_forecast.informationType = 'temperature'
        test_forecast.predictedValues = [
            IntervalValue(test_forecast, test_intervals[0], test_mkt,
                          MeasurementType.Temperature, 20),
            # Heating regime
            IntervalValue(test_forecast, test_intervals[1], test_mkt,
                          MeasurementType.Temperature, 100)
            # Cooling regime
        ]
        test_obj = OpenLoopRichlandLoadPredictor(test_forecast)

        # Manually evaluate from the lookup table and the above categorical inputs
        # DOW = Wed. ==>
        Intercept1 = 146119
        Intercept2 = 18836
        Intercept3 = -124095
        Factor1 = -1375
        Factor2 = 1048
        Temperature1 = 20
        Temperature2 = 100

        LOAD = [
            -(Intercept1 + Intercept2 + Factor1 * Temperature1),
            -(Intercept1 + Intercept3 + Factor2 * Temperature2)
        ]

        try:
            test_obj.schedule_power(test_mkt)
            print('- the method ran without errors')
        except:
            pf = 'fail'
            _log.warning('- the method had errors when called')

        #if any(abs([test_obj.scheduledPowers(1: 2).value] - [LOAD])) > 5
        if any([
                abs(test_obj.scheduledPowers[i].value - LOAD[i]) > 5
                for i in range(len(test_obj.scheduledPowers))
        ]):
            pf = 'fail'
            _log.warning('- the calculated powers were not as expected')
        else:
            print('- the calculated powers were as expected')

        # Success
        print('- the test ran to completion')
        print('Result: #s\n\n', pf)
示例#38
0
def test_prod_cost_from_vertices():
    from local_asset_model import LocalAssetModel

    # TEST_PROD_COST_FROM_VERTICES - tests function prod_cost_from_vertices()
    print('Running test_prod_cost_from_vertices()')
    pf = 'pass'

    # Create a test object
    test_object = LocalAssetModel

    # Create a test market
    test_market = Market

    # Create several active vertices av
    av = [Vertex(0.02, 5, 0), Vertex(0.02, 7, 100), Vertex(0.025, 9.25, 200)]

    # Create a time interval
    dt = datetime.now()
    at = dt
    #   NOTE: Function Hours() corrects behavior of Matlab function hours().
    dur = timedelta(hours=1)
    mkt = test_market
    mct = dt
    st = dt
    ti = TimeInterval(at, dur, mkt, mct, st)

    # Create and store the activeVertices, which are IntervalValues
    test_object.activeVertices = [
        IntervalValue(test_object, ti, test_market,
                      MeasurementType.ActiveVertex, av[0]),
        IntervalValue(test_object, ti, test_market,
                      MeasurementType.ActiveVertex, av[1]),
        IntervalValue(test_object, ti, test_market,
                      MeasurementType.ActiveVertex, av[2])
    ]

    ## CASE: Various signed powers when there is more than one vertex
    test_powers = [-50, 0, 50, 150, 250]
    pc = []
    for p in test_powers:
        pc.append(prod_cost_from_vertices(test_object, ti, p))

    # pc(1) = 0: value is always 0 for power < 0
    # pc(2) = 5.0: assign cost from first vertex
    # pc(3) = 6.0: interpolate between vertices
    # pc(4) = 8.125: interpolate between vertices
    # pc(5) = 9.25: use last vertex cost if power > last vertex power

    #if ~all(pc == [0, 5.0, 6.0, 8.125, 9.25])
    expected = [0, 5.0, 6.0, 8.125, 9.25]
    if not all([pc[i] == expected[i] for i in range(len(pc))]):
        pf = 'fail'
        raise Exception('- the production cost was incorrectly calculated')
    else:
        print('- the production cost was correctly calculated')

    ## CASE: One vertex (inelastic case, a constant)
    test_object.activeVertices = [
        IntervalValue(test_object, ti, test_market,
                      MeasurementType.ActiveVertex, av[0])
    ]

    #pc[i] = prod_cost_from_vertices(test_object, ti, test_powers[i])
    pc = []
    for p in test_powers:
        pc.append(prod_cost_from_vertices(test_object, ti, p))

    expected = [0.0, 5.0, 5.0, 5.0, 5.0]
    #if ~all(pc == [0.0, 5.0, 5.0, 5.0, 5.0])
    if not all([pc[i] == expected[i] for i in range(len(pc))]):
        pf = 'fail'
        raise Exception(
            '- made an incorrect assignment when there is one vertex')
    else:
        print('- made a correct assignment when there is one vertex')

    ## CASE: No active vertices (error case):
    test_object.activeVertices = []

    #print('off', 'all')
    try:
        pc = prod_cost_from_vertices(test_object, ti, test_powers[4])
        pf = 'fail'
        #print('on', 'all')
        raise Exception(
            '- the function should have warned and continued when there were no active vertices'
        )
    except:
        print(
            '- the function returned gracefully when there were no active vertices'
        )
        #print('on', 'all')

    #   Success
    print('- the test function ran to completion')
    print('Result: #s\n\n', pf)
示例#39
0
def test_update_dc_threshold():
    print('Running BulkSupplier_dc.test_update_dc_threshold()')

    # Basic configuration for tests:
    # Create a test object and initialize demand-related properties
    test_obj = BulkSupplier_dc()
    test_obj.demandMonth = datetime.now().month  # month(datetime)
    test_obj.demandThreshold = 1000

    # Create a test market
    test_mkt = Market()

    # Create and store two time intervals
    dt = datetime.now()
    at = dt
    dur = timedelta(hours=1)  # Hours(1)
    mkt = test_mkt
    mct = dt
    st = dt
    ti = [TimeInterval(at, dur, mkt, mct, st)]
    st = st + dur
    ti.append(TimeInterval(at, dur, mkt, mct, st))
    test_mkt.timeIntervals = ti

    #  Test case when there is no MeterPoint object
    test_obj.demandThreshold = 1000
    test_obj.demandMonth = datetime.now().month  # month(datetime)
    test_obj.meterPoints = []  # MeterPoint.empty

    # Create and store a couple scheduled powers
    # iv(1) = IntervalValue(test_obj, ti[0], test_mkt, MeasurementType.ScheduledPower, 900)
    # iv(2) = IntervalValue(test_obj, ti[1], test_mkt, MeasurementType.ScheduledPower, 900)
    iv = [
        IntervalValue(test_obj, ti[0], test_mkt, MeasurementType.ScheduledPower, 900),
        IntervalValue(test_obj, ti[1], test_mkt, MeasurementType.ScheduledPower, 900)
    ]
    test_obj.scheduledPowers = iv

    try:
        test_obj.update_dc_threshold(test_mkt)
        print('- the method ran without errors')
    except RuntimeWarning:
        print('- the method encountered errors when called')

    assert test_obj.demandThreshold == 1000, '- the method inferred the wrong demand threshold value'

    iv = [
        IntervalValue(test_obj, ti[0], test_mkt, MeasurementType.ScheduledPower, 1100),
        IntervalValue(test_obj, ti[1], test_mkt, MeasurementType.ScheduledPower, 900)
    ]
    test_obj.scheduledPowers = iv

    try:
        test_obj.update_dc_threshold(test_mkt)
        print('- the method ran without errors when there is no meter')
    except RuntimeWarning:
        print('- the method encountered errors when there is no meter')

    assert test_obj.demandThreshold == 1100, '- the method did not update the inferred demand threshold value'

    # Test with an appropriate MeterPoint meter
    # Create and store a MeterPoint test object
    test_mtr = MeterPoint()
    test_mtr.measurementType = MeasurementType.AverageDemandkW
    test_mtr.currentMeasurement = 900
    test_obj.meterPoints = [test_mtr]

    # Reconfigure the test object for this test:
    iv = [
        IntervalValue(test_obj, ti[0], test_mkt, MeasurementType.ScheduledPower, 900),
        IntervalValue(test_obj, ti[1], test_mkt, MeasurementType.ScheduledPower, 900)
    ]
    test_obj.scheduledPowers = iv

    test_obj.demandThreshold = 1000
    test_obj.demandMonth = datetime.now().month

    # Run the test. Confirm it runs.
    try:
        test_obj.update_dc_threshold(test_mkt)
        print('- the method ran without errors when there is a meter')
    except RuntimeWarning:
        print('- the method encountered errors when there is a meter')

    # Check that the old threshold is correctly retained.
    assert test_obj.demandThreshold == 1000, \
                            '- the method failed to keep the correct demand threshold value when there is a meter'

    # Reconfigure the test object with a lower current threshold
    iv = [
        IntervalValue(test_obj, ti[0], test_mkt, MeasurementType.ScheduledPower, 900),
        IntervalValue(test_obj, ti[1], test_mkt, MeasurementType.ScheduledPower, 900)]
    test_obj.scheduledPowers = iv
    test_obj.demandThreshold = 800

    # Run the test.
    test_obj.update_dc_threshold(test_mkt)

    # Check that a new, higher demand threshold was set.
    assert test_obj.demandThreshold == 900, \
                                    '- the method failed to update the demand threshold value when there is a meter'

    # Test rollover to new month
    # Configure the test object
    last_month = dt.month - 1
    if last_month == 0:
        last_month = 12
    test_obj.demandMonth = last_month  # month(datetime - days(31))  # prior month
    test_obj.demandThreshold = 1000
    test_obj.scheduledPowers[0].value = 900
    test_obj.scheduledPowers[1].value = 900
    test_obj.meterPoints = []  # MeterPoint.empty
    test_obj.demandThresholdCoef = 0.8

    # Run the test
    try:
        test_obj.update_dc_threshold(test_mkt)
        print('  - The method ran without errors')
    except RuntimeWarning:
        print('  - ERRORS ENCOUNTERED')

    # See if the demand threshold was reset at the new month.
    assert test_obj.demandThreshold == test_obj.demandThresholdCoef * 1000, \
        '- the method did not reduce the threshold properly in a new month'

    # Success
    print('test_update_dc_threshold() ran to completion.\n')
示例#40
0
def test_sum_vertices():
    print('Running Market.test_sum_vertices()')
    pf = 'pass'

    # Create a test myTransactiveNode object.
    test_node = myTransactiveNode()

    # Create a test Market object.
    test_market = Market()

    # List the test market with the test_node.
    test_node.markets = test_market

    # Create and store a time interval to work with.
    dt = datetime.now()
    at = dt
    dur = timedelta(hours=1)
    mkt = test_market
    mct = dt
    st = dt
    time_interval = TimeInterval(at, dur, mkt, mct, st)
    test_market.timeIntervals = [time_interval]

    # Create test LocalAsset and LocalAssetModel objects
    test_asset = LocalAsset()
    test_asset_model = LocalAssetModel()

    # Add the test_asset to the test node list.
    test_node.localAssets = [test_asset]

    # Have the test asset and its model cross reference one another.
    test_asset.model = test_asset_model
    test_asset_model.object = test_asset

    # Create and store an active Vertex or two for the test asset
    test_vertex = [Vertex(0.2, 0, -110), Vertex(0.2, 0, -90)]
    interval_values = [
        IntervalValue(test_node, time_interval, test_market,
                      MeasurementType.ActiveVertex, test_vertex[0]),
        IntervalValue(test_node, time_interval, test_market,
                      MeasurementType.ActiveVertex, test_vertex[1])
    ]
    test_asset_model.activeVertices = [interval_values[0], interval_values[1]
                                       ]  # interval_value(1:2)

    # Create test Neighbor and NeighborModel objects.
    test_neighbor = Neighbor()
    test_neighbor_model = NeighborModel()

    # Add the test neighbor to the test node list.
    test_node.neighbors = [test_neighbor]

    # Have the test neighbor and its model cross reference one another.
    test_neighbor.model = test_neighbor_model
    test_neighbor.model.object = test_neighbor

    # Create and store an active Vertex or two for the test neighbor
    test_vertex.append(Vertex(0.1, 0, 0))
    test_vertex.append(Vertex(0.3, 0, 200))
    interval_values.append(
        IntervalValue(test_node, time_interval, test_market,
                      MeasurementType.ActiveVertex, test_vertex[2]))
    interval_values.append(
        IntervalValue(test_node, time_interval, test_market,
                      MeasurementType.ActiveVertex, test_vertex[3]))
    test_neighbor_model.activeVertices = [
        interval_values[2], interval_values[3]
    ]

    ## Case 1
    print('- Case 1: Basic case with interleaved vertices')

    # Run the test.
    try:
        vertices = test_market.sum_vertices(test_node, time_interval)
        print('  - the method ran without errors')
    except:
        pf = 'fail'
        print('  - the method had errors when called and stopped')

    if len(vertices) != 4:
        pf = 'fail'
        print('  - an unexpected number of vertices was returned')
    else:
        print('  - the expected number of vertices was returned')

    powers = [x.power for x in vertices]

    # if any(~ismember(single(powers), single([-110.0000, -10.0000, 10.0000, 110.0000])))
    if len([
            x for x in powers
            if round(x, 4) not in [-110.0000, -10.0000, 10.0000, 110.0000]
    ]) > 0:
        pf = 'fail'
        print('  - the vertex powers were not as expected')
    else:
        print('  - the vertex powers were as expected')

    marginal_prices = [round(x.marginalPrice, 4) for x in vertices]

    # if any(~ismember(single(marginal_prices), single([0.1000, 0.2000, 0.3000])))
    if len([
            x for x in marginal_prices
            if round(x, 4) not in [0.1000, 0.2000, 0.3000]
    ]) > 0:
        pf = 'fail'
        print('  - the vertex powers were not as expected')
    else:
        print('  - the vertex marginal prices were as expected')

    ## CASE 2: NEIGHBOR MODEL TO BE EXCLUDED
    # This case is needed when a demand or supply curve must be created for a
    # transactive Neighbor object. The active vertices of the target Neighbor
    # must be excluded, leaving a residual supply or demand curve against which
    # the Neighbor may plan.
    print('- Case 2: Exclude test Neighbor model')

    # Run the test.
    try:
        # [vertices] = test_market.sum_vertices(test_node, time_interval, test_neighbor_model)
        vertices = test_market.sum_vertices(test_node, time_interval,
                                            test_neighbor_model)
        print('  - the method ran without errors')
    except:
        pf = 'fail'
        print('  - the method encountered errors and stopped')

    if len(vertices) != 2:
        pf = 'fail'
        print('  - an unexpected number of vertices was returned')
    else:
        print('  - the expected number of vertices was returned')

    powers = [round(x.power, 4) for x in vertices]

    # if any(~ismember(single(powers), single([-110.0000, -90.0000])))
    if len([x for x in powers if x not in [-110.0000, -90.0000]]) > 0:
        pf = 'fail'
        print('  - the vertex powers were not as expected')
    else:
        print('  - the vertex powers were as expected')

    marginal_prices = [x.marginalPrice for x in vertices]

    # if any(~ismember(single(marginal_prices), single([0.2000])))
    if len([x for x in marginal_prices if round(x, 4) not in [0.2000]]) > 0:
        pf = 'fail'
        print('  - the vertex powers were not as expected')
    else:
        print('  - the vertex marginal prices were as expected')

    ## CASE 3: CONSTANT SHOULD NOT CREATE NEW NET VERTEX
    print('- Case 3: Include a constant vertex. No net vertex should be added')

    # Change the test asset to NOT have any flexibility. A constant should
    # not introduce a net vertex at a constant's marginal price. Marginal
    # price is NOT meaningful for an inelastic device.
    test_asset_model.activeVertices = [interval_values[0]]

    # Run the test.
    try:
        # [vertices] = test_market.sum_vertices(test_node, time_interval)
        vertices = test_market.sum_vertices(test_node, time_interval)
        print('  - the method ran without errors')
    except:
        pf = 'fail'
        print('  - the method encountered errors and stopped')

    #%[180907DJH: THIS TEST IS CORRECTED. THE NEIGHBOR HAS TWO VERTICES. ADDING
    #AN ASSET WITH ONE VERTEX (NO FLEXIBILITY) SHOULD NOT CHANGE THE NUMBER OF
    #ACTIVE VERTICES, SO THE CORRECTED TEST CONFIRMS TWO VERTICES. THE CODE HAS
    #BEEN CORRECTED ACCORDINGLY.]
    if len(vertices) != 2:
        pf = 'fail'
        print('  - an unexpected number of vertices was returned')
    else:
        print('  - the expected number of vertices was returned')

    powers = [x.power for x in vertices]

    # if any(~ismember(single(powers), single([-110.0000, 90])))
    if len([x for x in powers if round(x, 4) not in [-110.0000, 90]]) > 0:
        pf = 'fail'
        print('  - the vertex powers were not as expected')
    else:
        print('  - the vertex powers were as expected')

    marginal_prices = [x.marginalPrice for x in vertices]

    # if any(~ismember(single(marginal_prices), single([0.1000, 0.3000, Inf])))
    if len([
            x for x in marginal_prices if round(x, 4) not in
        [0.1000, 0.3000, float("inf")]
    ]) > 0:
        pf = 'fail'
        print('  - the vertex powers were not as expected')
    else:
        print('  - the vertex marginal prices were as expected')

    # CASE 4: More than two vertices at any marginal price
    print('- Case 4: More than two vertices at same marginal price')

    # Move the two active vertices of the test asset to be at the same
    # marginal price as one of the neighbor active vertices.
    test_vertex = [Vertex(0.1, 0, -110), Vertex(0.1, 0, -90)]
    interval_values = [
        IntervalValue(test_node, time_interval, test_market,
                      MeasurementType.ActiveVertex, test_vertex[0]),
        IntervalValue(test_node, time_interval, test_market,
                      MeasurementType.ActiveVertex, test_vertex[1])
    ]
    test_asset_model.activeVertices = [interval_values[0], interval_values[1]
                                       ]  # interval_value(1:2)

    # Run the test.
    try:
        vertices = test_market.sum_vertices(test_node, time_interval)
        print('  - the method ran without errors')
    except:
        pf = 'fail'
        print('  - the method encountered errors and stopped')

    if len(vertices) != 3:
        pf = 'fail'
        print('  - an unexpected number of vertices was returned')
    else:
        print('  - the expected number of vertices was returned')

    powers = [x.power for x in vertices]

    # if any(~ismember(single(powers), single([-110.0000, -90.0000, 110.0000])))
    if len([
            x for x in powers
            if round(x, 4) not in [-110.0000, -90.0000, 110.0000]
    ]) > 0:
        pf = 'fail'
        print('  - the vertex powers were not as expected')
    else:
        print('  - the vertex powers were as expected')

    marginal_prices = [x.marginalPrice for x in vertices]

    # if any(~ismember(single(marginal_prices), single([0.1000, 0.3000])))
    if len([x for x in marginal_prices if round(x, 4) not in [0.1000, 0.3000]
            ]) > 0:
        pf = 'fail'
        print('  - the vertex powers were not as expected')
    else:
        print('  - the vertex marginal prices were as expected')

    # Success
    print('- the test ran to completion')
    print('Result: #s\n\n', pf)
示例#41
0
def test_schedule():
    print('Running Market.test_schedule()')
    print('WARNING: This test may be affected by NeighborModel.schedule()')
    print('WARNING: This test may be affected by NeighborModel.schedule()')
    pf = 'pass'

    # Establish a myTransactiveNode object
    mtn = myTransactiveNode()

    # Establish a test market
    test_mkt = Market()

    # Create and store one TimeInterval
    dt = datetime(2018, 1, 1, 12, 0, 0)  # Noon Jan 1, 2018
    at = dt
    dur = timedelta(hours=1)
    mkt = test_mkt
    mct = dt
    st = dt
    ti = TimeInterval(at, dur, mkt, mct, st)

    test_mkt.timeIntervals = [ti]

    # Create and store a marginal price in the active interval.
    test_mkt.marginalPrices = [
        IntervalValue(test_mkt, ti, test_mkt, MeasurementType.MarginalPrice,
                      0.01)
    ]

    print('- configuring a test Neighbor and its NeighborModel')
    # Create a test object that is a Neighbor
    test_obj1 = Neighbor()
    test_obj1.maximumPower = 100

    # Create the corresponding model that is a NeighborModel
    test_mdl1 = NeighborModel()
    test_mdl1.defaultPower = 10

    test_obj1.model = test_mdl1
    test_mdl1.object = test_obj1

    mtn.neighbors = [test_obj1]

    print('- configuring a test LocalAsset and its LocalAssetModel')
    # Create a test object that is a Local Asset
    test_obj2 = LocalAsset
    test_obj2.maximumPower = 100

    # Create the corresponding model that is a LocalAssetModel
    test_mdl2 = LocalAssetModel()
    test_mdl2.defaultPower = 10

    test_obj2.model = test_mdl2
    test_mdl2.object = test_obj2

    mtn.localAssets = [test_obj2]

    try:
        test_mkt.schedule(mtn)
        print('- method ran without errors')
    except:
        raise ('- method did not run due to errors')

    if len(test_mdl1.scheduledPowers) != 1:
        raise (
            '- the wrong numbers of scheduled powers were stored for the Neighbor'
        )
    else:
        print(
            '- the right number of scheduled powers were stored for the Neighbor'
        )

    if len(test_mdl2.scheduledPowers) != 1:
        raise (
            '- the wrong numbers of scheduled powers were stored for the LocalAsset'
        )
    else:
        print(
            '- the right number of scheduled powers were stored for the LocalAsset'
        )

    # Success
    print('- the test ran to completion')
    print('Result: #s\n\n', pf)
示例#42
0
def test_schedule():
    print('Running AbstractModel.test_schedule()')
    pf = 'pass'

    #   Create a test market test_mkt
    test_mkt = Market()

    #   Create a sample time interval ti
    dt = datetime.now()
    at = dt
    # NOTE: Function Hours() corrects behavior of Matlab hours().
    dur = timedelta(hours=1)
    mkt = test_mkt
    mct = dt
    # NOTE: Function Hours() corrects behavior of Matlab hours().
    st = datetime.combine(date.today(), time()) + timedelta(hours=20)
    ti = TimeInterval(at, dur, mkt, mct, st)

    #   Save the time interval
    test_mkt.timeIntervals = [ti]

    #   Assign a marginal price in the time interval
    test_mkt.check_marginal_prices()

    #   Create a Neighbor test object and give it a default maximum power value
    test_obj = Neighbor()
    test_obj.maximumPower = 100

    #   Create a corresponding NeighborModel
    test_mdl = NeighborModel()

    #   Make sure that the model and object cross-reference one another
    test_obj.model = test_mdl
    test_mdl.object = test_obj

    #   Run a test with a NeighborModel object
    print('- running test with a NeighborModel:')

    test_mdl.schedule(test_mkt)
    print('  - the method encountered no errors')

    if len(test_mdl.scheduledPowers) != 1:
        pf = 'fail'
        raise '  - the method did not store a scheduled power'
    else:
        print('  - the method calculated and stored a scheduled power')

    if len(test_mdl.reserveMargins) != 1:
        pf = 'fail'
        raise '  - the method did not store a reserve margin'
    else:
        print('  - the method stored a reserve margin')

    if len(test_mdl.activeVertices) != 1:
        pf = 'fail'
        raise '  - the method did not store an active vertex'
    else:
        print('  - the method stored an active vertex')

    # Run a test again with a LocalAssetModel object
    test_obj = LocalAsset()
    test_obj.maximumPower = 100
    test_mdl = LocalAssetModel()
    test_obj.model = test_mdl
    test_mdl.object = test_obj

    print('- running test with a LocalAssetModel:')

    test_mdl.schedule(test_mkt)
    print('  - the method encountered no errors')

    if len(test_mdl.scheduledPowers) != 1:
        pf = 'fail'
        raise '  - the method did not store a scheduled power'
    else:
        print('  - the method calculated and stored a scheduled power')

    if len(test_mdl.reserveMargins) != 1:
        pf = 'fail'
        raise '  - the method did not store a reserve margin'
    else:
        print('  - the method stored a reserve margin')

    if len(test_mdl.activeVertices) != 1:
        pf = 'fail'
        raise '  - the method did not store an active vertex'
    else:
        print('  - the method stored an active vertex')

    # Success
    print('- the test ran to completion')
    print('Result: %s', pf)