@Mar-Co This is what I have done for the WFA. Its hard but fun. :)

def createWFAReport(simParams,simulations):
	#Create simulation report format
	reportColumns=['grossProfit','grossAverageProfit','maxProfit',
				   'grossLoss','grossAverageLoss','maxLoss',
				   'netProfit','averageNetProfit','NAR',
				   'recoveryFactor','MDDLength','MDD',
				   'wonTrade','lossTrade','tradingTime',
				   'averageTradeTime','TradeNumber','maxValue',
				   'minValue','totalCommission']
	simulationReport=pd.DataFrame(columns=reportColumns)

	#Loop Simulations to create summary
	for simulation in simulations:
		'''some Calculation is done here'''
	return simReport

def WFASplit(self,trainBy='12m',testBy='3m', loopBy='m',overlap=True):
	startDate=self.index[0]
	endDate=self.index[-1]
	if trainBy[-1] is 'm':
		trainTime=relativedelta(months=int(trainBy[:-1]))
	else:
		raise ValueError
	if testBy[-1] is 'm':
		testTime=relativedelta(months=int(testBy[:-1]))
	else:
		raise ValueError
	assert ((relativedelta(endDate,startDate)-trainTime).days) > 0

	if loopBy is 'm':
		test_starts = zip(rrule(MONTHLY, dtstart=startDate, until=endDate-trainTime,interval=int(testBy[:-1])))
	else:
		raise ValueError

	for i in test_starts:
		startD=i[0]
		endD=i[0]+trainTime
		yield (self[(self.index>=startD)&(self.index<endD)],
			  self[(self.index>=endD)&(self.index<endD+testTime)])
	return None

def runTrain(trainTestGenerator,_ind,stockName):
	WFATrainResult=[]
	for train,test in trainTestGenerator:
		logger.debug('{} Training Data:{} to {}'.format(stockName,pd.DatetimeIndex.strftime(train.head(1).index,'%Y-%m-%d'),pd.DatetimeIndex.strftime(train.tail(1).index,'%Y-%m-%d')))
		#Generate Indicator ResultSet
		trainer = bt.Cerebro(cheat_on_open=True, stdstats=False, optreturn=False)
		trainer.broker.set_cash(10000)
		#Add Commission
		IB = params['commission'](commission=0.0)
		trainer.broker.addcommissioninfo(IB)
		#Below Analyzer are used to calculate the Recovery Ratio
		trainer.addanalyzer(btanalyzers.TradeAnalyzer, _name='TradeAn')
		trainer.addanalyzer(recoveryAnalyzer,timeframe=params['analysisTimeframe'], _name='recoveryFac')
		trainer.addanalyzer(WFAAn,_name='WFAAna')
		trainer.addanalyzer(btanalyzers.TimeReturn,timeframe=bt.TimeFrame.Months,_name='TR')
		#SetBroker
		trainer.broker.set_checksubmit(False)
		#Copy for tester
		tester = deepcopy(trainer)
		#Optimize Strategy
		trainingFile='{}/WFA'
		trainer.optstrategy(trainingIdea,
							inOrOut=(params['inOrOut'],),
							selfLog=(params['selfLog'],),
							indName=(row.indicator,),
							indFormula=(_ind['formula'],),
							entryExitPara=(_ind['entryExitParameters'],),
							indOutName=(_ind['indValue'],),
							nonOptParams=(None,),
							resultLocation=(params['resultLocation'],),
							timeString=(params['timeString'],),
							market=(row.market,),
							**optt)
		trainData = bt.feeds.PandasData(dataname=train)
		# Add a subset of data.
		trainer.adddata(trainData)
		optTable = trainer.run()
		final_results_list = []
		for run in optTable:
			for x in run:
				x.params['res']=x.analyzers.WFAAna.get_analysis()
				final_results_list.append(x.params)

		_bestWFA=pd.DataFrame.from_dict(final_results_list,orient='columns').sort_values('res',ascending=False).iloc[0].to_dict()
		bestTrainParams = {key: _bestWFA[key] for key in _bestWFA if key not in ['market','inOrOut','resultLocation','selfLog','timeString','res']}
		bestTrainParams=pd.DataFrame(bestTrainParams,index=[0])
		bestTrainParams['trainStart']=train.iloc[0].name
		bestTrainParams['trainEnd']=train.iloc[-1].name
		bestTrainParams['testStart']=test.iloc[0].name
		bestTrainParams['testEnd']=test.iloc[-1].name
		WFATrainResult.append(bestTrainParams)
	WFATrainResult=pd.concat(WFATrainResult)
	return WFATrainResult

def runTest(params, WFATrainResult,_ind,datafeed,stockName):
	#Generate Indicator ResultSet
	tester = bt.Cerebro(cheat_on_open=True)
	tester.broker.set_cash(10000)
	#Add Commission
	IB = params['commission'](commission=0.0)
	tester.broker.addcommissioninfo(IB)
	#SetBroker
	tester.broker.set_checksubmit(False)
	logger.debug('{} Start Testing'.format(stockName))
	OneSimHandler=logging.FileHandler(filename='{}/simulation/{}_{}_test.log'.format(params['resultLocation'], str(stockName),str(row.indicator)))
	OneSimHandler.setLevel(logging.DEBUG)
	OneSimHandler.setFormatter(logging.Formatter("%(asctime)s:%(relativeCreated)d - %(message)s"))
	oneLogger.addHandler(OneSimHandler)
	tester.addstrategy(trainingIdea,
			inOrOut=params['inOrOut'],
			selfLog=params['selfLog'],
			indName=row.indicator,
			indFormula=_ind['formula'],
			entryExitPara=_ind['entryExitParameters'],
			indOutName=_ind['indValue'],
			nonOptParams=None,
			resultLocation=params['resultLocation'],
			timeString=params['timeString'],
			market=market,
			WFATestParams=WFATrainResult)
	data=bt.feeds.PandasData(dataname=datafeed)
	tester.adddata(data,name=stockName)
	#Add analyzers for Tester
	tester.addanalyzer(btanalyzers.DrawDown, _name='MDD')
	tester.addanalyzer(btanalyzers.TradeAnalyzer, _name='TradeAn')
	tester.addanalyzer(btanalyzers.SQN, _name='SQN')
	tester.addanalyzer(recoveryAnalyzer,timeframe=params['analysisTimeframe'], _name='recoveryFac')
	tester.addanalyzer(ITDDAnalyzer,_name='ITDD')
	tester.addanalyzer(simpleAn,_name='simpleAna')
	tester.addanalyzer(btanalyzers.TimeReturn,timeframe=bt.TimeFrame.Months,_name='TR')
	# Run and Return Cerebro
	cere=tester.run()[0]

	_report=cere.analyzers.simpleAna.writeAnalysis(bnhReturn)
	oneLogger.removeHandler(OneSimHandler)
	if params['plotGraph']:
		plotSimGraph(tester,params,stockName,row.indicator)
	return _report

if __name__ == "__main__":
	session='WinsWFAProd'
	stockList, indicatorDict, params = jsonConfigMap(session)
	params['timeString']='0621_113833'
	params['topResult']=pd.read_csv('{}{}/consoReport.csv'.format(params['resultLocation'],params['timeString']),index_col=0)
	params['resultLocation']+=params['timeString']+'/WFA'
	simulations=[]

	try:
	#Create Folder
		shutil.rmtree(params['resultLocation'])
	except FileNotFoundError :
		pass
	except PermissionError:
		pass
	os.makedirs(params['resultLocation'],exist_ok=True)
	for element in ['order','trade','mr','ohlc','simulation','bestTrain','graph']:
		os.makedirs(params['resultLocation']+'/'+element,exist_ok=True)
	#Create master Log
	handler = logging.FileHandler(filename='{}/Master.log'.format(params['resultLocation']))
	handler.setFormatter(logging.Formatter('%(asctime)s:%(name)s - %(levelname)s {}- %(message)s'))
	logger = logging.getLogger()
	logger.setLevel(logging.DEBUG)
	logger.addHandler(handler)
	#Create OptReport Log
	reportHandler = logging.FileHandler(filename='{}/optReport.csv'.format(params['resultLocation']))
	reportHandler.setFormatter(logging.Formatter('%(message)s'))
	reportHandler.setLevel(logging.INFO)
	reportLogger=logging.getLogger('report')
	reportLogger.addHandler(reportHandler)
	simResultColumns=['stockName','market','indicator',
					'grossProfit','grossAverageProfit','maxProfit',
					'grossLoss','grossAverageLoss','maxLoss',
					'netProfit','averageNetProfit','NAR','profitFactor',
					'recoveryFactor','MDDLength','MDD',
					'selfMDD','winRate','tradingTimeRatio',
					'averageTradingBar','tradeNumber','maxValue',
					'minValue','initialv','totalCommission',
					'barNumber','expectancy100','bnhReturn','bnhRatio']
	reportLogger.info(str(simResultColumns).strip("[]").replace("'","").replace(" ",""))

	#Create Simulation Log
	oneLogger=logging.getLogger('oneLogger')
	oneLogger.propagate=False
	postHandler=logging.StreamHandler()
	postHandler.setLevel(logging.INFO)
	if params['selfLog']:
		oneLogger.setLevel(logging.DEBUG)
	else:
		oneLogger.setLevel(logging.INFO)
	oneLogger.addHandler(postHandler)
	#Record Start Time
	startTime=time.time()
	for row in params['topResult'].itertuples():
		simParams=pd.DataFrame(columns=['startTime','endTime','Parameter'])
		indicator=indicatorDict[row.indicator]
		stockName=row.stockName
		market=row.market
		try:
			optt = eval(indicator['optParam'])
		except:
			logger.info('{}: Indicator does not have WFA parameters and skipped'.format(row.indicator))
			continue
		datafeed=feeder(stockName, market,params)
		bnhReturn=round(datafeed.iloc[-1]['close'] - datafeed.iloc[0]['open'],2)
		#Extract Feeder from Data to save time for multi-simulation
		print('Start WFA for {}-{} from {} to {}'.format(stockName,row.indicator,datafeed.iloc[0].name,datafeed.iloc[-1].name))
		trainTestGenerator=WFASplit(datafeed,trainBy='8m',testBy='8m',loopBy='m')
		_ind=indicatorDict[row.indicator]
		#Training
		WFATrainResult=runTrain(trainTestGenerator,_ind,stockName)
		WFATrainResult=pd.DataFrame.from_records(WFATrainResult)
		WFATrainResult.to_csv('{}/bestTrain/{}_{}_train.csv'.format(params['resultLocation'],stockName,row.indicator),index=False)
		#TESTING
		_report=runTest(params, WFATrainResult,_ind, datafeed,stockName)
		#Consolidate T
		if _report[0] is not None:
			reportLogger.info(str(_report).strip("[]").strip(" ").replace(" ","").replace("'",""))
			simulations.append(_report)

#After simulations
	simulations=pd.DataFrame(simulations)
	reportColumns=['stockName','market','indicator',
					'grossProfit','grossAverageProfit','maxProfit',
					'grossLoss','grossAverageLoss','maxLoss',
					'netProfit','averageNetProfit','NAR',
					'profitFactor','recoveryFactor','MDDLength',
					'selfMDD','winRate','tradingTimeRatio',
					'averageTradingBar','tradeNumber','maxValue',
					'minValue','initialv','totalCommission',
					'barNumber','expectancy100','bnhReturn',
					'bnhRatio']
	simulations.columns=reportColumns
	consoResult=cr.scoring(simulations)
	consoResult=consoResult.sort_values(['res'],ascending=False)
	consoResult.sort_values('res').to_csv('{}/optReport.csv'.format(params['resultLocation']),index=False)

	timeRequired=time.time()-startTime
	print('timeRequired={:.2f}s'.format(timeRequired))

Credit to CAR25 by Howard Bandy. I think Howard provides a good way to measure the required fraction (sizing) for any stock simulation.
I have created the monte carlos as Howard Bandy mentioned in his book. Hope it helps BT-ers as a quick start to have the Monte Carlos simulation. :)

Figures as follow:
I have randomly distributed the trade and set the data started as 1-1-1990. It will need some entry and exit price in your previous trade record as reference point. It will adjust the monte['fraction'] according to the simulated DD90 value.

Code as follow:

def runOneMonte(_,row,consoFeeds,monte,params):
	stockName,exchange,indName=row[:3]
	cerebro = bt.Cerebro()
	cerebro.broker.setcash(100000)
	simParams={'stockName':stockName,'exchange':exchange,'indicator':indName}
	#analyzer
	cerebro.addanalyzer(continueITDDAnalyzer,_name='contITDD')
	#addCommission
	IB = params['commission'](commission=0.0)
	cerebro.broker.addcommissioninfo(IB)
	#SetBroker
	cerebro.broker.set_checksubmit(False)

	#Shuffle and reindex Data
	#random.seed(1)
	datas=list(itertools.chain.from_iterable(itertools.repeat(consoFeeds,max(int(monte['tradeTime']/len(consoFeeds)),1))))
	shuffledDatas=random.sample(datas, len(datas))
	barlen = sum(len(f)-1 for f in shuffledDatas)
	consoFeed=pd.concat(shuffledDatas)
	mcIndex=pd.date_range(start=datetime.datetime.strptime('1990-01-01','%Y-%m-%d'),periods=len(consoFeed),freq='D')
	consoFeed.set_index(mcIndex,drop=True,inplace=True)
	_feed=bt.feeds.PandasData(dataname=consoFeed[['open','high','low','close','volume']])
	cerebro.adddata(_feed,name=stockName)
	tradeFeed = consoFeed[['BuyPrice','SellPrice']]
	cerebro.addstrategy(sizingStra, monte['fraction'],tradeFeed)
	cerebro.strats[0][0][0].contITDDSet={'ITDD':0,'ITDDLength':0,'initV':100000,'peak':float('-inf'),'ddlen':-1,'dd':0}
	strategies=cerebro.run()
	contITDDSet=strategies[0].analyzers.contITDD.get_analysis()
	contITDDSet['CARReturn']=(cerebro.broker.getvalue()/contITDDSet['initV'] - 1)*100*252/barlen
	return contITDDSet

def calculateDD90(row,params,monte,consoFeeds,q,loopRound=6):
	stockName=row.Index
	masterLogger=logging.getLogger('Master')
	loopTime=0
	while loopTime<loopRound:
		_prevFraction=0
		_loopCount=0
		if params['numMulti'] >1:
			print('{}-{}: Start Pooling with Monte fraction:{}'.format(stockName,row.indicator, monte['fraction']))
			pool = multiprocessing.Pool(params['numMulti'], worker_init, [q])
			#Run 1000 monte carlos
			startTime=datetime.datetime.now()
			with pool as p:
				simResSet=pd.DataFrame.from_dict(pool.starmap(runOneMonte,zip(range(0,monte['NumberSim']),itertools.repeat(list(row)),itertools.repeat(consoFeeds),itertools.repeat(monte),itertools.repeat(params))))
			pool.close()
			pool.join()
			timeRequired=datetime.datetime.now()-startTime
			print('{}-{}: Loop Time required for runOneMonte:{}'.format(stockName,row.indicator,timeRequired))
		else:
			print('{}:Start Single Thread Simulation'.format(stockName))
			simResSet = pd.DataFrame([runOneMonte(i,list(row), consoFeeds,monte,params) for i in range(0,monte['NumberSim'])])
		DD90 = np.quantile(simResSet['ITDD'] , 0.9, interpolation='nearest')
		DD90 = simResSet[simResSet['ITDD']==DD90].to_dict(orient='records')[0]
		print('{}-{}:Test Result: Fraction ={}, DD90={}, CAR25={}'.format(stockName,row.indicator,monte['fraction']*100,DD90['ITDD'],DD90['CARReturn']))
		if abs(monte['drawdownLimit'] - DD90['ITDD']) < monte['accuracyTolerance'] or abs(monte['fraction'] - _prevFraction) < 0.01 or _loopCount >5:
			return DD90
		else:
			_prevFraction = monte['fraction']
			_loopCount+=1
			monte['fraction']=monte['fraction']*monte['drawdownLimit']/(DD90['ITDD'])
			if monte['fraction']>1 :
				print('Overwhelming sizing Occurred')
				return DD90
		loopTime+=1
	return DD90

def setMonte(row,params,monte):
	#Read Order time and Trade Price and prepare the feeds, dont follow below script as it is minimized
	consoFeeds=[]
	for record in records:
		consoFeeds.append(consoFeed)

	#Multi-processing
	_stockStartTime=datetime.datetime.now()
	DD90=calculateDD90(row,params,monte,consoFeeds,q)
	timeRequired=datetime.datetime.now()-_stockStartTime
	print('{}: Total Loop Time required:{}\n================================='.format(row.Index,timeRequired))
	DD90.update({'fraction':monte['fraction'],'stockName':row.Index,'exchange':row.exchange,'indicator':row.indicator})
	return DD90

Re: JSON data sources

Hi @backtrader ,

Just a follow up on this wonderful idea mixing backtrader+ influxDB +Grafana using Analyzer, here's what I did:

Pre-req:

1.You setup the grafana/influxdb connection, basic stuff like installed Json/influxdb-python blah blah blah.
2. You created a influxdb client and passed to strategy using params
(i.e. self.strategy.params['client'] <==this is the influxdb client object
3. You already created a database called "simulation" to store the simulation result.
4. For the Grafana OHLC bar please take reference here

Feel free to discuss and let me know if you have any great idea on it.
(Btw InfluxDB will have a high cardinality issue if talking about recording a lot of ohlc simulations, talking about 10k~ up with 16gb ram will be overflow, im thinking should i remove the candlestick instead...)

from __future__ import (absolute_import, division, print_function,
					unicode_literals)

import backtrader as bt
import pandas as pd
from influxdb import DataFrameClient

class GrafanaAn(bt.Analyzer):

def create_analysis(self):
	self.tradeBegV=0
	self.tradeEndV=0

def notify_trade(self, trade):
	t=self.datas[0].datetime.date(0).strftime('%Y-%m-%dT%H:%M:%SZ')
	if trade.justopened:
		self.tradeBegV=self.strategy.broker.getvalue()
		self.tradeBegTime=t
		self.tradeBegP=float(trade.price)
		self.tradeSize=float(trade.size)
		#Send a buy indicator to Grafana
		jsonBody=[{"measurement":"portfolio",
					"tags":{
					"stock":self.data._name,
					"market":self.strategy.params['market'],
					"ind":self.strategy.indName
					},
					"time":t,
					"fields":{
						"BuyPrice":float(trade.price),
						"Size":float(trade.size),
				}
				  }]
		ar=self.strategy.params['client'].write_points(jsonBody,database='simulation')
		assert ar
	elif trade.status == trade.Closed:
		self.tradeEndV = self.strategy.broker.getvalue()
		ret=(self.tradeEndV/self.tradeBegV-1)*100
		t=self.datas[0].datetime.date(0).strftime('%Y-%m-%dT%H:%M:%SZ')
		jsonBody=[{"measurement":"trade",
					"tags":{
					"stock":self.data._name,
					"market":self.strategy.params['market'],
					"ind":self.strategy.indName
					},
					"time":t,
					"fields":{
						"commission":float(trade.commission),
						"return":float(ret),
						"pnl":float(trade.pnl),
						"pnlcomm":float(trade.pnlcomm),
						"tradingTime":int(trade.barlen),
						"beginTime":self.tradeBegTime,
						"endTime":t
					}
				  }]
		ar=self.strategy.params['client'].write_points(jsonBody,database='simulation')
		assert ar
		jsonBody=[{"measurement":"portfolio",
					"tags":{
					"stock":self.data._name,
					"market":self.strategy.params['market'],
					"ind":self.strategy.indName
					},
					"time":t,
					"fields":{
						"SellPrice":float(trade.pnl/self.tradeSize+self.tradeBegP),
						"Size":float(trade.size),
				}
				  }]
		ar=self.strategy.params['client'].write_points(jsonBody,database='simulation')
		assert ar
		
def start(self):
	self._i=0
	self._dict={}

def next(self):
	_value=self.strategy.broker.getvalue()
	_pos=self.strategy.getposition().size
	self._dict[self._i]={'portv':_value,'pos':_pos}
	self._i+=1
	#for k,ind in self.strategy.ind.items():

def stop(self):
	portVFrame=pd.DataFrame.from_dict(self._dict,"index")
	portVFrame.columns=['portv','pos']
	priceFrame=self.data._dataname
	portVFrame.set_index(priceFrame.index,inplace=True)
	priceFrame['portv']=portVFrame['portv']
	priceFrame['pos']=portVFrame['pos']
	priceFrame=priceFrame.astype(float)
	client=DataFrameClient(database='simulation')
	ar=client.write_points(priceFrame,"portfolio",{"ind":self.strategy.indName,"market":self.strategy.params['market'],"stock":self.data._name},database='simulation')
	assert ar
	#Print Monthly return
	_mr=self.strategy.analyzers.TR.get_analysis()
	MonthlyReport=pd.DataFrame.from_dict(_mr,"index")
	ar=client.write_points(MonthlyReport,"monthlyReturn",{"ind":self.strategy.indName,"market":self.strategy.params['market'],"stock":self.data._name},database='simulation')
	assert ar

def get_analysis(self):
	return None

'''

Data - Multiple Timeframes
Quoting from above article: The data with the smallest timeframe (and thus the larger number of bars) must be the 1st one to be added to the Cerebro instance

The reason your strategy using daily (data0) instead of intraday (data1) because you inputted the daily bar first. Try input intraday (data1) first then resample back to daily (data0), this should solve your problem.

Here's the Super Smoother and generic filter class based on John F. Ehlers book. Applicable to all common indicators for filtering/smoothing. Tested the modified RSI against the graph in the book and works fine.

Feel free to create and share new indicators or discuss effectiveness below.

Supersmoother

class genericSuperSmoother(bt.Indicator):
    '''P.49
    a=e(−1.414*3.14159 / Period)
    b=2 * a * Cos(1.414 * 180 / Period)
    c2=b
    c3=−a * a
    c1=1 − c2 − c3
    Output=c1 * (Input + Input[1]) / 2 + c2 * Output[1] + c3 * Output[2]
    '''
    lines=('outputLine','inputLine')
    params=(
            ('inputLine',None),
            ('smoothingPeriod',60),
            )
    plotinfo=dict(subplot=True)
    plotlines=dict(
        inputLine=dict(_plotskip=True)
    )

    def __init__(self):
        super(genericSuperSmoother, self).__init__()
        self.l.inputLine=self.p.inputLine
        a=math.exp(-1.414*math.pi/self.p.smoothingPeriod)
        b=2*a*math.cos(math.radians(1.414*180/self.p.smoothingPeriod))
        self.p.c2=b
        self.p.c3=-a*a
        self.p.c1=1-self.p.c2-self.p.c3

    def nextstart(self):
        self.l.outputLine[0]=self.l.outputLine[-1]=self.l.outputLine[-2]=0
    def next(self):
        self.l.outputLine[0]=self.p.c1*(self.l.inputLine[0]+self.l.inputLine[-1])/2+self.p.c2*self.l.outputLine[-1]+self.p.c3*self.l.outputLine[-2]

Filtering (I called Tuning below)

class genericTuningClass(bt.Indicator):
    '''
    The generic tuning
    '''
    lines=('outputLine','inputLine')
    params=(
            ('filterType', 'twoPoleHighPass'),
            ('inputLine','self.data.close'),
            ('K', 1),
            ('bandwidth',0),
            ('period',60),
            )
    plotinfo=dict(subplot=True)
    plotlines=dict(
        inputLine=dict(_plotskip=True)
        )

    def __init__(self):
        super(genericTuningClass, self).__init__()
        self.addminperiod(self.p.period)
        self.l.inputLine=eval(self.p.inputLine)
        filterType=self.p.filterType
        radianMapping={'singlePole':math.radians(360/self.p.period),
        'twoPoleHighPass':math.radians(0.707*360/self.p.period),
        'twoPoleLowPass':math.radians(1.414*360/self.p.period)}
        try:
            radianSetting=radianMapping[self.p.filterType]
        except:
            if self.p.K ==1 and self.p.bandwidth ==0:
                raise TypeError
            radianSetting=math.radians(self.p.K * self.p.bandwidth * 360/self.p.period)
        alphaValue=(math.cos(radianSetting)+math.sin(radianSetting)-1)/math.cos(radianSetting)
        lambdaValue=math.cos(math.radians(360/self.p.period))
        sigmaValue=(1/math.cos(math.radians(360*self.p.bandwidth/self.p.period)))-math.sqrt((1/math.cos(math.radians(360*self.p.bandwidth/self.p.period)))**2-1)
        #P.28 - Below filter set are value for 'b0','b1','b2','a1','a2' ('a0'=1 so skipped)
        FilterSet={'EMA':{'b0':alphaValue,
                          'b1':0,
                          'b2':0,
                          'a1':-(1-alphaValue),
                          'a2':0},
                    'twoPoleLowPass':{'b0':alphaValue**2,
                                    'b1':0,
                                    'b2':0,
                                    'a1':-2*(1-alphaValue),
                                    'a2':0},
                    #High Pass Plus has b1=-(1+alpha/2) instead of -1(1-alpha/2)
                    'highPassPlus':{'b0':(1+alphaValue/2),
                                    'b1':-(1+alphaValue/2),
                                    'b2':0,
                                    'a1':-(1-alphaValue),
                                    'a2':0},
                    'highPass':{'b0':(1-alphaValue/2),
                                    'b1':-(1-alphaValue/2),
                                    'b2':0,
                                    'a1':-(1-alphaValue),
                                    'a2':0},
                    'twoPoleHighPass':{'b0':(1-alphaValue/2)**2,
                                    'b1':-2*(1-alphaValue/2)**2,
                                    'b2':(1-alphaValue/2)**2,
                                    'a1':-2*(1-alphaValue),
                                    'a2':(1-alphaValue)**2},
                    'bandPass':{'b0':(1-sigmaValue)/2,
                                    'b1':0,
                                    'b2':-(1-sigmaValue)/2,
                                    'a1':-lambdaValue*(1+sigmaValue),
                                    'a2':sigmaValue},
                    'bandStop':{'b0':(1+sigmaValue)/2,
                                    'b1':-2*lambdaValue*(1+sigmaValue)/2,
                                    'b2':(1+sigmaValue)/2,
                                    'a1':-lambdaValue*(1+sigmaValue),
                                    'a2':sigmaValue}}
        self.p.paramsSet=FilterSet[filterType]
        if (self.p.filterType=='bandPass' or self.p.filterType=='bandStop') and (sigmaValue==0 or lambdaValue==0):
            raise IndexError

    def nextstart(self):
        #Seed Recursive value
        self.l.outputLine[0]=self.l.outputLine[-1]=0

    def next(self):
        #Formula=b0*input+b1*input[-1]+b2*input[-2]-a1*output[-1]-a2*output[-2]
        self.l.outputLine[0]= self.p.paramsSet['b0']*self.l.inputLine[0] \
                                +self.p.paramsSet['b1']*self.l.inputLine[-1] \
                                +self.p.paramsSet['b2']*self.l.inputLine[-2] \
                                -self.p.paramsSet['a1']*self.l.outputLine[-1]\
                                -self.p.paramsSet['a2']*self.l.outputLine[-2]
        ''' #For debug purpose only
        print('b0:{:.2f}, i0:{:.2f}, b1:{:.2f}, i1:{:.2f}, b2:{:.2f}, i2:{:.2f}, a1:{:.2f}, o1:{:.2f}, a2:{:.2f}, o2:{:.2f}. Output:{:.2f}'.format(
                            self.p.paramsSet['b0'],self.l.inputLine[0],
                            self.p.paramsSet['b1'],self.l.inputLine[-1],
                            self.p.paramsSet['b2'],self.l.inputLine[-2],
                            self.p.paramsSet['a1'],self.l.outputLine[-1],
                            self.p.paramsSet['a2'],self.l.outputLine[-2],
                            self.l.outputLine[0]))
        '''

Example modified RSI

class modifiedRSI(bt.Indicator):
    lines=('modifiedRSI',)
    params=(('period',10),
    ('HPperiod',48),
    ('smoothingPeriod',10),
    )
    plotinfo=dict(subplot=True)
    plotlines=dict(
    modifiedRSI=dict(_fill_gt=(70, 'red'),
                    _fill_lt=(30, 'green')),
        )
    def _plotinit(self):
        self.plotinfo.plotyhlines=[10,30,70,90]

    def __init__(self):
        self.l.HPclose=genericTuningClass(filterType='twoPoleHighPass',inputLine='self.data.close',period=self.p.HPperiod)
        self.l.smoothHPClose=genericSuperSmoother(inputLine=self.l.HPclose,smoothingPeriod=self.p.smoothingPeriod)
        self.l.upDay = bt.ind.UpDay(self.l.smoothHPClose)
        self.l.downDay = bt.ind.DownDay(self.l.smoothHPClose)
        self.l.upSum = bt.ind.SumN(self.l.upDay, period=self.p.period)
        self.l.downSum = bt.ind.SumN(self.l.downDay, period=self.p.period)
        self.l.denom=self.l.upSum+self.l.downSum
        self.l.modRSI = 100*self.l.upSum/self.l.denom
        self.l.modifiedRSI=genericSuperSmoother(inputLine=self.l.modRSI,smoothingPeriod=self.p.smoothingPeriod)

@Jakob-Schütte

yes, and better use self.p.period instead of a hardcode value 14.
super call related to inheritance, tbh i'm not sure for details.

@Mariano-Volpedo

Great strategy! Tried to replace with moving average and more on __init__ instead of next.
The results swift to 60-63 instead of ~55. Not sure is it because of any calculation error....

    def __init__(self):
        self.l.m = bt.ind.MovAv.Simple(self.data.close, period=self.p.period) #replace with median
        self.l.nl=bt.And(self.data.close>self.l.m,self.data.close>self.data.close(-1))
        self.l.nh=bt.And(self.data.close<self.l.m,self.data.close<self.data.close(-1))
        self.l.upSum = bt.ind.SumN(self.l.nl, period=self.p.period)
        self.l.downSum = bt.ind.SumN(self.l.nh, period=self.p.period)
        self.l.mmi= 100.0 * (self.l.upSum+self.l.downSum)/(self.p.period - 1)

@Mariano-Volpedo

Great strategy! Tried to replace with moving average and more on __init__ instead of next.
The results swift to 60-63 instead of ~55. Not sure is it because of any calculation error....

    def __init__(self):
        self.l.m = bt.ind.MovAv.Simple(self.data.close, period=self.p.period) #replace with median
        self.l.nl=bt.And(self.data.close>self.l.m,self.data.close>self.data.close(-1))
        self.l.nh=bt.And(self.data.close<self.l.m,self.data.close<self.data.close(-1))
        self.l.upSum = bt.ind.SumN(self.l.nl, period=self.p.period)
        self.l.downSum = bt.ind.SumN(self.l.nh, period=self.p.period)
        self.l.mmi= 100.0 * (self.l.upSum+self.l.downSum)/(self.p.period - 1)

@RandomTrader88

https://community.backtrader.com/topic/872/plot-with-logarithmic-y-axis/3

@Princeton-Wong

Basic idea behind is applying electric signal processing filter technique on any indicators to identify trend in a better way, that will filters out unwanted trend periods (either too long or too short) or try to auto-identify the correct trend period (I havent covered in here though).

@chewbacca
maybe a if in next can do?

if self.datas[0].datetime.datetime.hour==9 and self.datas[0].datetime.datetime.minute==1:
    self.buy()```

@Jakob-Schütte

yes, and better use self.p.period instead of a hardcode value 14.
super call related to inheritance, tbh i'm not sure for details.

Here's the Super Smoother and generic filter class based on John F. Ehlers book. Applicable to all common indicators for filtering/smoothing. Tested the modified RSI against the graph in the book and works fine.

Feel free to create and share new indicators or discuss effectiveness below.

Supersmoother

class genericSuperSmoother(bt.Indicator):
    '''P.49
    a=e(−1.414*3.14159 / Period)
    b=2 * a * Cos(1.414 * 180 / Period)
    c2=b
    c3=−a * a
    c1=1 − c2 − c3
    Output=c1 * (Input + Input[1]) / 2 + c2 * Output[1] + c3 * Output[2]
    '''
    lines=('outputLine','inputLine')
    params=(
            ('inputLine',None),
            ('smoothingPeriod',60),
            )
    plotinfo=dict(subplot=True)
    plotlines=dict(
        inputLine=dict(_plotskip=True)
    )

    def __init__(self):
        super(genericSuperSmoother, self).__init__()
        self.l.inputLine=self.p.inputLine
        a=math.exp(-1.414*math.pi/self.p.smoothingPeriod)
        b=2*a*math.cos(math.radians(1.414*180/self.p.smoothingPeriod))
        self.p.c2=b
        self.p.c3=-a*a
        self.p.c1=1-self.p.c2-self.p.c3

    def nextstart(self):
        self.l.outputLine[0]=self.l.outputLine[-1]=self.l.outputLine[-2]=0
    def next(self):
        self.l.outputLine[0]=self.p.c1*(self.l.inputLine[0]+self.l.inputLine[-1])/2+self.p.c2*self.l.outputLine[-1]+self.p.c3*self.l.outputLine[-2]

Filtering (I called Tuning below)

class genericTuningClass(bt.Indicator):
    '''
    The generic tuning
    '''
    lines=('outputLine','inputLine')
    params=(
            ('filterType', 'twoPoleHighPass'),
            ('inputLine','self.data.close'),
            ('K', 1),
            ('bandwidth',0),
            ('period',60),
            )
    plotinfo=dict(subplot=True)
    plotlines=dict(
        inputLine=dict(_plotskip=True)
        )

    def __init__(self):
        super(genericTuningClass, self).__init__()
        self.addminperiod(self.p.period)
        self.l.inputLine=eval(self.p.inputLine)
        filterType=self.p.filterType
        radianMapping={'singlePole':math.radians(360/self.p.period),
        'twoPoleHighPass':math.radians(0.707*360/self.p.period),
        'twoPoleLowPass':math.radians(1.414*360/self.p.period)}
        try:
            radianSetting=radianMapping[self.p.filterType]
        except:
            if self.p.K ==1 and self.p.bandwidth ==0:
                raise TypeError
            radianSetting=math.radians(self.p.K * self.p.bandwidth * 360/self.p.period)
        alphaValue=(math.cos(radianSetting)+math.sin(radianSetting)-1)/math.cos(radianSetting)
        lambdaValue=math.cos(math.radians(360/self.p.period))
        sigmaValue=(1/math.cos(math.radians(360*self.p.bandwidth/self.p.period)))-math.sqrt((1/math.cos(math.radians(360*self.p.bandwidth/self.p.period)))**2-1)
        #P.28 - Below filter set are value for 'b0','b1','b2','a1','a2' ('a0'=1 so skipped)
        FilterSet={'EMA':{'b0':alphaValue,
                          'b1':0,
                          'b2':0,
                          'a1':-(1-alphaValue),
                          'a2':0},
                    'twoPoleLowPass':{'b0':alphaValue**2,
                                    'b1':0,
                                    'b2':0,
                                    'a1':-2*(1-alphaValue),
                                    'a2':0},
                    #High Pass Plus has b1=-(1+alpha/2) instead of -1(1-alpha/2)
                    'highPassPlus':{'b0':(1+alphaValue/2),
                                    'b1':-(1+alphaValue/2),
                                    'b2':0,
                                    'a1':-(1-alphaValue),
                                    'a2':0},
                    'highPass':{'b0':(1-alphaValue/2),
                                    'b1':-(1-alphaValue/2),
                                    'b2':0,
                                    'a1':-(1-alphaValue),
                                    'a2':0},
                    'twoPoleHighPass':{'b0':(1-alphaValue/2)**2,
                                    'b1':-2*(1-alphaValue/2)**2,
                                    'b2':(1-alphaValue/2)**2,
                                    'a1':-2*(1-alphaValue),
                                    'a2':(1-alphaValue)**2},
                    'bandPass':{'b0':(1-sigmaValue)/2,
                                    'b1':0,
                                    'b2':-(1-sigmaValue)/2,
                                    'a1':-lambdaValue*(1+sigmaValue),
                                    'a2':sigmaValue},
                    'bandStop':{'b0':(1+sigmaValue)/2,
                                    'b1':-2*lambdaValue*(1+sigmaValue)/2,
                                    'b2':(1+sigmaValue)/2,
                                    'a1':-lambdaValue*(1+sigmaValue),
                                    'a2':sigmaValue}}
        self.p.paramsSet=FilterSet[filterType]
        if (self.p.filterType=='bandPass' or self.p.filterType=='bandStop') and (sigmaValue==0 or lambdaValue==0):
            raise IndexError

    def nextstart(self):
        #Seed Recursive value
        self.l.outputLine[0]=self.l.outputLine[-1]=0

    def next(self):
        #Formula=b0*input+b1*input[-1]+b2*input[-2]-a1*output[-1]-a2*output[-2]
        self.l.outputLine[0]= self.p.paramsSet['b0']*self.l.inputLine[0] \
                                +self.p.paramsSet['b1']*self.l.inputLine[-1] \
                                +self.p.paramsSet['b2']*self.l.inputLine[-2] \
                                -self.p.paramsSet['a1']*self.l.outputLine[-1]\
                                -self.p.paramsSet['a2']*self.l.outputLine[-2]
        ''' #For debug purpose only
        print('b0:{:.2f}, i0:{:.2f}, b1:{:.2f}, i1:{:.2f}, b2:{:.2f}, i2:{:.2f}, a1:{:.2f}, o1:{:.2f}, a2:{:.2f}, o2:{:.2f}. Output:{:.2f}'.format(
                            self.p.paramsSet['b0'],self.l.inputLine[0],
                            self.p.paramsSet['b1'],self.l.inputLine[-1],
                            self.p.paramsSet['b2'],self.l.inputLine[-2],
                            self.p.paramsSet['a1'],self.l.outputLine[-1],
                            self.p.paramsSet['a2'],self.l.outputLine[-2],
                            self.l.outputLine[0]))
        '''

Example modified RSI

class modifiedRSI(bt.Indicator):
    lines=('modifiedRSI',)
    params=(('period',10),
    ('HPperiod',48),
    ('smoothingPeriod',10),
    )
    plotinfo=dict(subplot=True)
    plotlines=dict(
    modifiedRSI=dict(_fill_gt=(70, 'red'),
                    _fill_lt=(30, 'green')),
        )
    def _plotinit(self):
        self.plotinfo.plotyhlines=[10,30,70,90]

    def __init__(self):
        self.l.HPclose=genericTuningClass(filterType='twoPoleHighPass',inputLine='self.data.close',period=self.p.HPperiod)
        self.l.smoothHPClose=genericSuperSmoother(inputLine=self.l.HPclose,smoothingPeriod=self.p.smoothingPeriod)
        self.l.upDay = bt.ind.UpDay(self.l.smoothHPClose)
        self.l.downDay = bt.ind.DownDay(self.l.smoothHPClose)
        self.l.upSum = bt.ind.SumN(self.l.upDay, period=self.p.period)
        self.l.downSum = bt.ind.SumN(self.l.downDay, period=self.p.period)
        self.l.denom=self.l.upSum+self.l.downSum
        self.l.modRSI = 100*self.l.upSum/self.l.denom
        self.l.modifiedRSI=genericSuperSmoother(inputLine=self.l.modRSI,smoothingPeriod=self.p.smoothingPeriod)

Data - Multiple Timeframes
Quoting from above article: The data with the smallest timeframe (and thus the larger number of bars) must be the 1st one to be added to the Cerebro instance

The reason your strategy using daily (data0) instead of intraday (data1) because you inputted the daily bar first. Try input intraday (data1) first then resample back to daily (data0), this should solve your problem.

@barton05 said in Problem with my custom Indicator, UIcerIndex:

self.l.sqAvg = bt.ind.SumN(self.l.perDrawdown,period=self.p.period)**2/14

should be changed to:

self.l.sqAvg = bt.ind.SumN(self.l.perDrawdown,period=self.p.period)**2/self.p.period

Referencing RSI in backtrader and simplfied the design a bit, see if it helps

import backtrader as bt

class RVI(bt.Indicator):
    lines = ('rvi','upDaySTD','downDaySTD')
    params = (('period', 14),
    ('movav', bt.ind.MovAv.Smoothed),
    ('upperband', 70.0),
    ('lowerband', 30.0),
    ('safehigh', 100.0),
    ('safelow', 50.0),
    )

    plotinfo = dict(subplot=True)
    plotlines = dict(
        upDaySTD=dict(_plotskip=True),
        downDaySTD=dict(_plotskip=True),
    )

    def _plotinit(self):
        self.plotinfo.plotyhlines = [self.p.upperband, self.p.lowerband]

    def __init__(self):
        super(RVI, self).__init__()
        self.lines.upDaySTD=bt.If(self.data-self.data(-1)<0,bt.ind.StdDev(self.data, period=self.p.period),0)
        self.lines.downDaySTD=bt.If(self.data-self.data(-1)>0,bt.ind.StdDev(self.data, period=self.p.period),0)
        maup = self.p.movav(self.lines.upDaySTD, period=self.p.period)
        madown = self.p.movav(self.lines.downDaySTD, period=self.p.period)
        highrs = self._rscalc(self.p.safehigh)
        lowrs = self._rscalc(self.p.safelow)
        rv = bt.ind.DivZeroByZero(maup, madown, highrs, lowrs)
        self.l.rvi = 100.0 - 100.0 / (1.0 + rv)

    def _rscalc(self, rsi):
        try:
            rs = (-100.0 / (rsi - 100.0)) - 1.0
        except ZeroDivisionError:
            return float('inf')
        return rs

Maybe dont need to reinvent the wheel? Using bt.talib.CDL3WHITESOLDIERS and bt.talib.CDL3BLACKCROWS should work.