def test_count_cycles(series, cycles, counts, approx): result = rainflow.count_cycles(series) if approx: expected = [(pytest.approx(rng), count) for rng, count in counts] else: expected = counts assert result == expected
def test_rainflow_counting(self): self.assertEqual( rainflow.count_cycles(self.series), self.cycles, ) self.assertEqual( rainflow.count_cycles(self.series[1:-1], left=True, right=True), self.cycles, ) self.assertEqual( rainflow.count_cycles(self.series[1:], left=True), self.cycles, ) self.assertEqual( rainflow.count_cycles(self.series[:-1], right=True), self.cycles, )
def test_count_cycles_series_with_zero_derivatives(series, cycles, counts, approx): series = list(itertools.chain.from_iterable([x, x] for x in series)) result = rainflow.count_cycles(series) if approx: expected = [(pytest.approx(rng), count) for rng, count in counts] else: expected = counts assert result == expected
def calc_degradation(self, opt_period, start_dttm, end_dttm): """ calculate degradation percent based on yearly degradation and cycle degradation Args: opt_period: the index of the optimization that occurred before calling this function, None if no optimization problem has been solved yet start_dttm (DateTime): Start timestamp to calculate degradation. ie. the first datetime in the optimization problem end_dttm (DateTime): End timestamp to calculate degradation. ie. the last datetime in the optimization problem A percent that represented the energy capacity degradation """ # time difference between time stamps converted into years multiplied by yearly degrate rate if self.incl_cycle_degrade: # calculate degradation due to cycling iff energy values are given if opt_period is not None: energy_series = self.variables.loc[start_dttm:end_dttm, 'ene'] # use rainflow counting algorithm to get cycle counts cycle_counts = rainflow.count_cycles(energy_series, ndigits=4) # sort cycle counts into user inputed cycle life bins digitized_cycles = np.searchsorted( self.cycle_life['Cycle Depth Upper Limit'], [min(i[0] / self.ene_max_rated, 1) for i in cycle_counts], side='left') # sum up number of cycles for all cycle counts in each bin cycle_sum = self.cycle_life.loc[:, :] cycle_sum.loc[:, 'cycles'] = 0 for i in range(len(cycle_counts)): cycle_sum.loc[digitized_cycles[i], 'cycles'] += cycle_counts[i][1] # sum across bins to get total degrade percent # 1/cycle life value is degrade percent for each cycle cycle_degrade = np.dot(1 / cycle_sum['Cycle Life Value'], cycle_sum.cycles) else: cycle_degrade = 0 # add the degradation due to time passing and cycling for total degradation degrade_percent = cycle_degrade # record the degradation if opt_period: # the total degradation after optimization OPT_PERIOD must also take into account the # degradation that occurred before the battery was in operation (which we saved as SELF.DEGRADE_PERC) self.degrade_data.loc[ opt_period, 'degrade_perc'] = degrade_percent + self.degrade_perc else: # if this calculation is done pre-optimization loop, then save this value as an attribute # self.degrade_perc = degrade_percent + self.degrade_perc self.degrade_perc = degrade_percent
def test_rainflow_nbins(self): self.assertEqual( rainflow.count_cycles(self.series, left=True, right=True, nbins=1), self.cycles_nbins_1, ) self.assertEqual( rainflow.count_cycles(self.series, left=True, right=True, nbins=2), self.cycles_nbins_2, ) self.assertEqual( rainflow.count_cycles(self.series, left=True, right=True, nbins=5), self.cycles_nbins_5, ) self.assertEqual( rainflow.count_cycles(self.series, left=True, right=True, nbins=9), self.cycles_nbins_9, ) self.assertEqual( rainflow.count_cycles(self.series, left=True, right=True, nbins=10), self.cycles_nbins_10, )
def test_count_cycles_binsize(): series = TEST_CASE_1[0] assert rainflow.count_cycles(series, binsize=10) == [(10, 4.0)] assert rainflow.count_cycles(series, binsize=9) == [(9, 4.0)] assert rainflow.count_cycles(series, binsize=5) == [ (5, 2.0), (10, 2.0), ] assert rainflow.count_cycles(series, binsize=3) == [ (3, 0.5), (6, 2.0), (9, 1.5), ] assert rainflow.count_cycles(series, binsize=2) == [ (2, 0.0), (4, 2.0), (6, 0.5), (8, 1.0), (10, 0.5), ] assert rainflow.count_cycles(series, binsize=1) == [ (1, 0.0), (2, 0.0), (3, 0.5), (4, 1.5), (5, 0.0), (6, 0.5), (7, 0.0), (8, 1.0), (9, 0.5), ]
def test_rainflow_binsize(self): self.assertEqual( rainflow.count_cycles(self.series, left=True, right=True, binsize=1), self.cycles_binsize_1, ) self.assertEqual( rainflow.count_cycles(self.series, left=True, right=True, binsize=2), self.cycles_binsize_2, ) self.assertEqual( rainflow.count_cycles(self.series, left=True, right=True, binsize=3), self.cycles_binsize_3, ) self.assertEqual( rainflow.count_cycles(self.series, left=True, right=True, binsize=5), self.cycles_binsize_5, ) self.assertEqual( rainflow.count_cycles(self.series, left=True, right=True, binsize=9), self.cycles_binsize_9, ) self.assertEqual( rainflow.count_cycles(self.series, left=True, right=True, binsize=10), self.cycles_binsize_10, )
def test_num_bins(): # This test checks for a bug reported in issue #60 where the # returned number of bins was different than the nbins argument # due to floating point accuracy. series = [ 0, 3517.860166127188, -3093.4966492094213, 0, ] nbins = 100 result = rainflow.count_cycles(series, nbins=nbins) assert len(result) == nbins
def calDel(y_raw, m, life, t, T): if t < 8766: t = 8766 f = 1e7 / (life * t * 3600) y = np.asarray(y_raw, dtype='float64') counts = rainflow.count_cycles(y) s = 0 for count in counts: s += count[1] * np.power(count[0], m) load = np.power(s / (T * f), 1 / m) / 1000 # Unit: kNm return load
def test_count_cycles_nbins(): series = TEST_CASE_1[0] assert rainflow.count_cycles(series, nbins=1) == [(9, 4.0)] assert rainflow.count_cycles(series, nbins=2) == [ (4.5, 2.0), (9.0, 2.0), ] assert rainflow.count_cycles(series, nbins=5) == [ (1.8, 0.0), (3.6, 0.5), (5.4, 1.5), (7.2, 0.5), (9.0, 1.5), ] assert rainflow.count_cycles(series, nbins=9) == [ (1.0, 0.0), (2.0, 0.0), (3.0, 0.5), (4.0, 1.5), (5.0, 0.0), (6.0, 0.5), (7.0, 0.0), (8.0, 1.0), (9.0, 0.5), ] assert rainflow.count_cycles(series, nbins=10) == [ (0.9, 0.0), (1.8, 0.0), (2.7, 0.0), (3.6, 0.5), (4.5, 1.5), (5.4, 0.0), (6.3, 0.5), (7.2, 0.0), (8.1, 1.0), (9.0, 0.5), ]
def test_count_cycles_binsize_case_3(): series = TEST_CASE_3[0] result = rainflow.count_cycles(series, binsize=0.2) expected = [(pytest.approx(rng), count) for rng, count in [ (0.2, 4.0), (0.4, 0.0), (0.6, 0.0), (0.8, 1.0), (1.0, 0.0), (1.2, 0.0), (1.4, 0.0), (1.6, 0.0), (1.8, 2.0), (2.0, 2.5), ]] assert result == expected
def test_count_cycles_exclusive_arguments(): series = TEST_CASE_1[0] with pytest.raises(ValueError): rainflow.count_cycles(series, nbins=1, binsize=1) with pytest.raises(ValueError): rainflow.count_cycles(series, nbins=1, ndigits=1) with pytest.raises(ValueError): rainflow.count_cycles(series, binsize=1, ndigits=1)
def get_cycle_data(self,asset_id,addresses,variable,filter,range_unit,temperature,startdate,enddate): """ Returns cycle data on chain as specified by 'variable' between start and end dates """ out = {} out["x"] = [] out["y"] = [] out["full_cycle_equivalent"] = 0 data = self.get_chain_data(asset_id,addresses,variable,filter,range_unit,temperature,startdate,enddate) try: cycles = rainflow.count_cycles(data["y"], binsize=10.0) sum = 0.0 for i in range(len(cycles)): out["x"].append("Cycle {}-{}%".format(cycles[i][0]-10,cycles[i][0])) out["y"].append(cycles[i][1]) sum += self.full_cycle_equivalent(cycles[i]) out["full_cycle_equivalent"] = round(100*sum)/100 except: pass return out
def test_series_with_zero_derivatives(self): series = itertools.chain(*([x, x] for x in self.series)) self.assertEqual(rainflow.count_cycles(series), self.cycles)
import rainflow import pandas as pd import numpy as np import math as m import matplotlib.pyplot as plt import glob path = r"C:\Users\Joe\PycharmProjects\rainflow\excel\*.csv" appended_data = pd.DataFrame() for fname in glob.glob(path): data = pd.read_csv(fname) #print(data) appended_data = appended_data.append(data, ignore_index=True) #print(appended_data.head) y = appended_data.to_numpy() y = np.reshape(y, (1, len(y))) y = y[0] print(y) result = rainflow.count_cycles(y) print(result)
def test_rainflow_ndigits(self): series = [x + 0.01 * random.random() for x in self.series] self.assertNotEqual(rainflow.count_cycles(series), self.cycles) self.assertEqual(rainflow.count_cycles(series, ndigits=1), self.cycles)
def test_rainflow_counting(self): self.assertEqual(rainflow.count_cycles(self.series), self.cycles)
import pandas as pd df = pd.read_csv('tags\V_2215_Outlet_Pressure_MPa.csv') print(df.head()) print(df.columns) df['SCTM:22V15CP1:PI22498.PNT'] = pd.to_numeric( df['SCTM:22V15CP1:PI22498.PNT'], errors='coerce') data = df["SCTM:22V15CP1:PI22498.PNT"].tolist() #print(data) def getKey(item): return item[0] import rainflow rfcycles = rainflow.count_cycles(data) res = rainflow.count_cycles(data[:]) count = 0 for x in res: if x[0] >= 3.2: count += x[1] print('pressure cycle count is') print(count)
def test_count_cycles_ndigits(series, cycles, counts): series = [x + 0.01 * random.random() for x in series] assert rainflow.count_cycles(series) != counts assert rainflow.count_cycles(series, ndigits=1) == counts
def test_count_cycles(series, cycles, counts): result = rainflow.count_cycles(series) assert result == counts
def test_count_cycles_series_with_zero_derivatives(series, cycles, counts): series = list(itertools.chain.from_iterable([x, x] for x in series)) assert rainflow.count_cycles(series) == counts