def _createChildren(self):
self._addChild(
RawDataStat(self._region, self._track,
TrackFormatReq(val='number', dense=True)))
self._addChild(
RawDataStat(self._region, self._track2,
TrackFormatReq(val='number', dense=True)))
def _createChildren(self):
self._addChild(
RawDataStat(self._region, self._track,
TrackFormatReq(interval=True, val=self._markReq)))
self._addChild(
RawDataStat(self._region, self._track2,
TrackFormatReq(dense=False, interval=True)))
def _createChildren(self):
self._addChild(RawDataStat(self._region, self._track, \
TrackFormatReq(dense=False, interval=False, \
val='category', allowOverlaps=True)))
self._addChild(RawDataStat(self._region, self._track2, \
TrackFormatReq(dense=False, interval=True, \
val='category', allowOverlaps=True)))
def _createChildren(self):
self._addChild(
RawDataStat(self._region, self._track,
TrackFormatReq(dense=True, val='char')))
self._addChild(
RawDataStat(self._region, self._track2,
TrackFormatReq(val='category')))
def _createChildren(self):
self._addChild(
RawDataStat(self._region, self._track,
TrackFormatReq(allowOverlaps=False, val='number')))
self._addChild(
RawDataStat(self._region, self._track2,
TrackFormatReq(allowOverlaps=False, dense=False)))
def _createChildren(self):
self._addChild(RawOverlapStat(self._region, self._track, self._track2))
self._addChild(
FormatSpecStat(self._region, self._track,
TrackFormatReq(dense=False, interval=True)))
self._addChild(
FormatSpecStat(self._region, self._track2,
TrackFormatReq(dense=False, interval=True)))
def _createChildren(self):
self._addChild(
RawDataStat(self._region, self._track,
TrackFormatReq(dense=False, interval=True))
) #interval=False is supported through the faster PointCountPerSegStat..
self._addChild(
RawDataStat(self._region, self._track2,
TrackFormatReq(dense=False, interval=True)))
def _createChildren(self):
self._addChild(
RawDataStat(
self._region, self._track,
TrackFormatReq(dense=False, interval=False, val='number')))
self._addChild(
RawDataStat(
self._region, self._track2,
TrackFormatReq(dense=False, interval=False, val='number')))
def _createChildren(self):
rawSegDataStat = RawDataStat(
self._region, self._track,
TrackFormatReq(interval=True, dense=False))
rawNumDataStat = RawDataStat(
self._region, self._track2,
TrackFormatReq(dense=True, val='number', interval=False))
self._addChild(rawSegDataStat)
self._addChild(rawNumDataStat)
def _createChildren(self):
rawDataStat = RawDataStat(self._region, self._track,
TrackFormatReq(dense=False, interval=False))
self._addChild(rawDataStat)
rawDataStat2 = RawDataStat(self._region, self._track2,
TrackFormatReq(dense=False, interval=True))
self._addChild(rawDataStat2)
self._binSizeStat = self._addChild(
BinSizeStat(self._region, self._track2))
def _createChildren(self):
self._addChild(
RawDataStat(self._region, self._track,
TrackFormatReq(dense=False)))
self._addChild(
RawDataStat(self._region, self._track2,
TrackFormatReq(dense=False)))
self._binSizeStat = self._addChild(
BinSizeStat(self._region, self._track2))
def testExtra(self):
tf = TrackFormat.createInstanceFromPrefixList(['start', 'a', 'b', 'c'], 'float64', 1, 'float64', 1)
self.assertTrue(tf.hasExtra(specificExtra='a'))
self.assertFalse(tf.hasExtra(specificExtra='d'))
self.assertEqual(['a','b','c'], tf.getExtraNames())
tfq = TrackFormatReq(interval=False, extra=['a','b'])
self.assertFalse(tfq.isCompatibleWith(tf))
def _assertConvertSegmentToPoint(self, targetStarts, sourceTv, converterCls):
pointFormat = TrackFormatReq(interval=False, dense=False)
self.assertTrue(converterCls.canHandle(sourceTv.trackFormat, pointFormat))
targetTv = converterCls.convert(sourceTv)
self.assertTrue(pointFormat.isCompatibleWith(targetTv.trackFormat))
self.assertEqual(targetStarts, [el.start() for el in targetTv])
for el in targetTv:
self.assertEqual(el.start() + 1, el.end())
def _createChildren(self):
self._graphNodeIdStat = self._addChild(
RawDataStat(self._region, self._track,
TrackFormatReq(interval=True, id=True, dense=True)))
#self._segmentsStat = self._addChild(RawDataStat(self._region, self._track2, TrackFormatReq(interval=False, dense=False)))
self._segmentsStat = self._addChild(
RawDataStat(
self._region, self._track2,
TrackFormatReq(interval=False, dense=False,
allowOverlaps=None)))
def testMerge(self):
mergedTFR = TrackFormatReq.merge( TrackFormatReq(dense=False), TrackFormatReq(interval=True) )
self.assertFalse(mergedTFR.isDense())
self.assertTrue(mergedTFR.isInterval())
mergedTFR = TrackFormatReq.merge( TrackFormatReq(dense=False, val='tc'), TrackFormatReq(interval=True, val='number') )
self.assertEqual(None, mergedTFR)
mergedTFR = TrackFormatReq.merge( TrackFormatReq(dense=False, weights='tc'), TrackFormatReq(interval=True, weights='number') )
self.assertEqual(None, mergedTFR)
def _createChildren(self):
self._rawOverlap = self._addChild(
RawOverlapStat(self._region, self._track, self._track2))
self._segmentCoverProportion = self._addChild(
ProportionCountStat(self._region, self._track2))
self._addChild(
FormatSpecStat(self._region, self._track,
TrackFormatReq(dense=False, interval=False)))
self._addChild(
FormatSpecStat(self._region, self._track2,
TrackFormatReq(dense=False, interval=True)))
def _init(self, scriptFn='', randomSeed=None, **kwArgs):
self._trackFormat1 = TrackFormatReq()
self._trackFormat2 = TrackFormatReq()
self._codeLines = []
if scriptFn != '':
self._parseScriptFile(scriptFn.decode('hex_codec'))
from gold.util.RandomUtil import getManualSeed, setManualSeed
if randomSeed is not None and randomSeed != 'Random' and getManualSeed(
) is None:
setManualSeed(int(randomSeed))
def testWeightTypes(self):
tf = TrackFormat.createInstanceFromPrefixList(['id', 'edges', 'weights'], 'float64', 1, 'S8', 3)
self.assertTrue(tf.isWeighted(specificWeightType='category_vector'))
self.assertFalse(tf.isWeighted(specificWeightType='number'))
self.assertEqual('Vector of categories', tf.getWeightTypeName())
self.assertEqual('Linked base pairs', tf.getFormatName())
tfq = TrackFormatReq(linked=True, weights='number')
self.assertFalse(tfq.isCompatibleWith(tf))
def testValTypes(self):
tf = TrackFormat.createInstanceFromPrefixList(['start', 'val'], 'float128', 2, 'float64', 1)
self.assertTrue(tf.isValued(specificValType='mean_sd'))
self.assertFalse(tf.isValued(specificValType='number'))
self.assertEqual('Mean and std.dev.', tf.getValTypeName())
self.assertEqual('Valued points', tf.getFormatName())
tfq = TrackFormatReq(interval=False, val='tc')
self.assertFalse(tfq.isCompatibleWith(tf))
def testExtra(self):
tf = TrackFormat.createInstanceFromPrefixList(['start', 'a', 'b', 'c'],
'float64', 1, 'float64',
1)
self.assertTrue(tf.hasExtra(specificExtra='a'))
self.assertFalse(tf.hasExtra(specificExtra='d'))
self.assertEqual(['a', 'b', 'c'], tf.getExtraNames())
tfq = TrackFormatReq(interval=False, extra=['a', 'b'])
self.assertFalse(tfq.isCompatibleWith(tf))
def _createChildren(self):
#the settings of allowOverlaps is somewhat arbitrary for now..
self._addChild(
RawDataStat(
self._region, self._track,
TrackFormatReq(dense=False, interval=True,
allowOverlaps=False)))
self._addChild(
RawDataStat(
self._region, self._track2,
TrackFormatReq(dense=False, interval=True,
allowOverlaps=False)))
def testWeightTypes(self):
tf = TrackFormat.createInstanceFromPrefixList(
['id', 'edges', 'weights'], 'float64', 1, 'S8', 3)
self.assertTrue(tf.isWeighted(specificWeightType='category_vector'))
self.assertFalse(tf.isWeighted(specificWeightType='number'))
self.assertEqual('Vector of categories', tf.getWeightTypeName())
self.assertEqual('Linked base pairs', tf.getFormatName())
tfq = TrackFormatReq(linked=True, weights='number')
self.assertFalse(tfq.isCompatibleWith(tf))
def _createChildren(self):
"Takes three tracks: "
t1, t2, t3 = self._tracks
#print 'TEMP4: ',self._kernelType
if self._kernelType == 'uniform':
from quick.statistic.StatFacades import TpRawOverlapStat
self._t2vst1 = self._addChild(
TpRawOverlapStat(self._region, t2, t1, **self._kwArgs))
self._t3vst1 = self._addChild(
SumInsideStat(self._region, t1, t3, **self._kwArgs))
elif self._kernelType == 'binSizeNormalizedV3':
#from quick.statistic.TpProportionOverlapPerBinAvgStat import TpProportionOverlapPerBinAvgStat
#from quick.statistic.MeanInsidePerBinAvgStat import MeanInsidePerBinAvgStat
from quick.statistic.AggregateOfCoveredBpsInSegmentsStat import AggregateOfCoveredBpsInSegmentsStat
from quick.statistic.AggregateOfCoverageInSegmentsStat import AggregateOfCoverageInSegmentsStat
#self._t2vst1 = self._addChild( TpProportionOverlapPerBinAvgStat(self._region, t2,t1, **self._kwArgs))
self._t2vst1 = self._addChild(
AggregateOfCoverageInSegmentsStat(self._region,
t2,
t1,
method='sum_of_mean',
**self._kwArgs))
#self._t3vst1 = self._addChild( MeanInsidePerBinAvgStat(self._region, t1,t3, **self._kwArgs))
self._t3vst1 = self._addChild(
AggregateOfCoveredBpsInSegmentsStat(self._region,
t3,
t1,
method='sum_of_mean',
**self._kwArgs))
if self._kwArgs.get('useNormalizedTestStatistic') == 'yes':
from gold.statistic.CountSegmentStat import CountSegmentStat
from gold.statistic.SumStat import SumStat
self._globalT2CoverageStat = self._addChild(
CountSegmentStat(self._region, t2, **self._kwArgs))
self._globalT3CoverageStat = self._addChild(
SumStat(self._region, t3, **self._kwArgs))
else:
#self._t2vst1 = self._addChild( KernelWeightedT1SegsInTpRawOverlapStat(self._region, t1,t2, **self._kwArgs))
self._t2vst1 = self._addChild(
KernelWeightedT1SegsInTpRawOverlapVersion2Stat(
self._globalSource, t1, t2, **self._kwArgs))
self._t3vst1 = self._addChild(
KernelWeightedSumInsideStat(self._globalSource, t3, t1,
**self._kwArgs))
self._addChild(
FormatSpecStat(self._region, t1,
TrackFormatReq(allowOverlaps=False)))
self._addChild(
FormatSpecStat(self._region, t2,
TrackFormatReq(allowOverlaps=False)))
def _createChildren(self):
kwArgs = copy(self._kwArgs)
if 'rawStatistic' in kwArgs:
del kwArgs['rawStatistic']
self._addChild(
FormatSpecStat(self._region, self._track,
TrackFormatReq(dense=False, val='category')))
self._addChild(
FormatSpecStat(self._region, self._track2,
TrackFormatReq(dense=False, val='tc')))
self._addChild(
self._rawStatistic(self._region, self._track, self._track2,
**kwArgs))
def _createChildren(self):
self._addChild(
RawDataStat(
self._region, self._track,
TrackFormatReq(val='number',
allowOverlaps=self._configuredToAllowOverlaps(
strict=False))))
self._addChild(
RawDataStat(
self._region, self._track2,
TrackFormatReq(interval=True,
allowOverlaps=self._configuredToAllowOverlaps(
strict=False))))
def testCompatibilityWithExceptions(self):
tf = TrackFormat.createInstanceFromPrefixList(['start', 'val'],
'float64', 1, 'float64',
1)
self.assertFalse(TrackFormatReq(interval=True, strand=True, val='number')\
.isCompatibleWith(tf))
self.assertFalse(TrackFormatReq(interval=True, strand=True, val='number')\
.isCompatibleWith(tf, ['interval']))
self.assertTrue(TrackFormatReq(interval=True, strand=True, val='number')\
.isCompatibleWith(tf, ['interval', 'hasStrand']))
self.assertFalse(TrackFormatReq(interval=True, strand=True, val='tc')\
.isCompatibleWith(tf, ['interval', 'hasStrand']))
def _parseScriptFile(self, scriptFn):
script = open(scriptFn)
for line in script:
if line.lower().startswith('#format1:'):
format = line.replace('#format1:', '').strip()
self._trackFormat1 = TrackFormatReq(name=format)
elif line.lower().startswith('#format2:'):
format = line.replace('#format2:', '').strip()
self._trackFormat2 = TrackFormatReq(name=format)
elif line[0] == '#':
pass
else:
self._codeLines.append(line.strip())
def testValTypes(self):
tf = TrackFormat.createInstanceFromPrefixList(['start', 'val'],
'float128', 2, 'float64',
1)
self.assertTrue(tf.isValued(specificValType='mean_sd'))
self.assertFalse(tf.isValued(specificValType='number'))
self.assertEqual('Mean and std.dev.', tf.getValTypeName())
self.assertEqual('Valued points', tf.getFormatName())
tfq = TrackFormatReq(interval=False, val='tc')
self.assertFalse(tfq.isCompatibleWith(tf))
def _createChildren(self):
self._addChild(BpLevelArrayRawDataStat(self._region, self._track))
self._addChild(BpLevelArrayRawDataStat(self._region, self._track2))
allowOverlaps = self._configuredToAllowOverlaps(
strict=False, allowReturningNone=True)
self._addChild(
FormatSpecStat(
self._region, self._track,
TrackFormatReq(dense=False, allowOverlaps=allowOverlaps)))
self._addChild(
FormatSpecStat(
self._region, self._track2,
TrackFormatReq(dense=False, allowOverlaps=allowOverlaps)))
def _createChildren(self):
from quick.statistic.StatFacades import TpRawOverlapStat
t1, t2, t3 = self._tracks
from gold.statistic.MeanInsideStat import SumInsideStat
self._t2vst1 = self._addChild(
TpRawOverlapStat(self._region, t2, t1, **self._kwArgs))
self._t3vst1 = self._addChild(
SumInsideStat(self._region, t1, t3, **self._kwArgs))
self._addChild(
FormatSpecStat(self._region, t1,
TrackFormatReq(allowOverlaps=False)))
self._addChild(
FormatSpecStat(self._region, t2,
TrackFormatReq(allowOverlaps=False)))
def _createChildren(self):
kwArgs = copy(self._kwArgs)
if 'rawStatistic' in kwArgs:
del kwArgs['rawStatistic']
track2 = self._track2 if hasattr(self, '_track2') else None
self._addChild(
FormatSpecStat(self._region, self._track,
TrackFormatReq(dense=False, val='tc')))
#self._track.formatConverters = 'Dummy' #to avoid check of tracks not being used..
#self._track2.formatConverters = 'Dummy' #to avoid check of tracks not being used..
#self._addChild( RawDataStat(self._region, self._track2, TrackFormatReq(dense=False, val='tc') ) )
self._addChild(
self._rawStatistic(
self._region, self._track, track2, **
kwArgs)) #This will actually compute, without any use for it.
self._indexOfFirstSubCatChild = len(self._children)
for subtype1 in ['0', '1']:
#for subtype2 in ['0','1']:
tn1 = self._track.trackName + [subtype1]
if not os.path.exists(createDirPath(tn1, self.getGenome())):
#logMessage('DID NOT EXIST.. '+createOrigPath(self.getGenome(),tn1))
raise IncompatibleTracksError
#else:
# logMessage('DID EXIST')
track1 = Track(tn1)
track1.formatConverters = self._track.formatConverters
#track2 = Track( self._track2.trackName + [subtype2])
#track2.formatConverters = self._track2.formatConverters
self._addChild(
self._rawStatistic(self._region, track1, track2, **kwArgs))
def _combineTrackTypeVals(self, curVal, nextVal):
try:
return self._combineEqualVals(curVal, nextVal)
except InvalidFormatError:
from gold.track.TrackFormat import TrackFormatReq
curReq = TrackFormatReq(name=curVal)
nextReq = TrackFormatReq(name=nextVal)
maxCommonCoreType = TrackFormatReq.maxCommonCoreFormat(
curReq, nextReq)
if maxCommonCoreType is not None:
return maxCommonCoreType.getFormatName().lower()
raise InvalidFormatError(
'Track types "%s" and "%s" are not possible to combine. ' %
(curVal, nextVal))
def _createChildren(self):
rawDataStat = RawDataStat(
self._region, self._track,
TrackFormatReq(dense=False,
interval=False,
allowOverlaps=(self._withOverlaps == 'yes')))
self._addChild(rawDataStat)
def _createChildren(self):
for track in self._tracks:
self._addChild(
RawDataStat(self._region, track, TrackFormatReq(dense=False),
**self._kwArgs))
self._binSizeStat = self._addChild(
BinSizeStat(self._region, self._tracks[0]))
def _createChildren(self):
self._addChild(
PointCountInsideSegsStat(self._region, self._track, self._track2))
self._addChild(CountStat(self._region, self._track2))
self._addChild(
FormatSpecStat(self._region, self._track2,
TrackFormatReq(dense=False, interval=True)))
def addFormatReq(self, requestedTrackFormat):
prevFormatReq = self._trackFormatReq
self._trackFormatReq = TrackFormatReq.merge(self._trackFormatReq, requestedTrackFormat)
if self._trackFormatReq is None:
raise IncompatibleTracksError(str(prevFormatReq ) + \
' is incompatible with additional ' + str(requestedTrackFormat))