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_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)
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)
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
