def driveSelector(DRIVE, TYPE): # Split Drive ############################################################# if DRIVE == 'SD': if TYPE == 'ECO': aggD = monet.generateAggregationDictionary( ["WA", "H", "R", "B", "C", "WB"], gsd.SD_ECO) yRange = 12500 * 2 colors = COLEN elif TYPE == 'HLT': aggD = monet.generateAggregationDictionary(["H*", "O-", "Total"], gsd.SD_HLT) yRange = 12500 colors = COLHN elif TYPE == 'TRS': aggD = monet.generateAggregationDictionary(["C*", "O-", "Total"], gsd.SD_TRS) yRange = 12500 colors = COLTN elif TYPE == 'WLD': aggD = monet.generateAggregationDictionary(["O-", "W*", "Total"], gsd.SD_WLD) yRange = 12500 colors = COLWN # Return values ########################################################### return {'gDict': aggD, 'yRange': yRange, 'colors': colors}
def aggregateDataFromPath(path, aggregationDictionary): filenames = monet.readExperimentFilenames(path) landscapeSumData = monet.sumLandscapePopulationsFromFiles( filenames, male=True, female=True, dataType=float ) aggData = monet.aggregateGenotypesInNode(landscapeSumData, aggregationDictionary) return aggData
def exportPreTracesParallel(exIx, STYLE, PT_IMG, border=True, borderColor='#322E2D', borderWidth=1, autoAspect=False, xpNum=0, digs=3, vLines=[0, 0], hLines=[0], popScaler=1, sampRate=1): monet.printProgress(exIx[0], xpNum, digs) repFilePath = exIx[1][1] repDta = pkl.load(repFilePath) name = path.splitext(repFilePath.split('/')[-1])[0][:-4] monet.exportTracesPlot(repDta, name, STYLE, PT_IMG, wopPrint=False, autoAspect=autoAspect, border=border, borderColor=borderColor, borderWidth=borderWidth, sampRate=sampRate) return None
def calcQuantWOP(srpPrb, meanRef, thresholds, gIx, quantile=.95): """ Calculates the mean window of protection for the quantile response of two populations. Args: srpPrb (dict): SRP population of the probe population. meanRef (np.array): Mean population of the reference population thresholds (list): List of ratios to use as thresholds. gIx (int): Index of the genotype of interest's location quantile (float): Quantile for the thresholds calculation cmprOp(function): Operation to compare against (less than, greater than, etcetera). Returns: list: Returns the time at which the condition is met at a given quantile level. """ prb = srpPrb['landscapes'] smpNum = len(prb) (wopArr, ttiArr, ttoArr) = [np.empty((smpNum, len(thresholds))) for i in range(3)] for s in range(smpNum): refPop = meanRef['population'] ratioOI = monet.getPopRatio(prb[s], refPop, gIx) thsArray = monet.comparePopToThresh(ratioOI, thresholds, cmprOp=op.lt) thsDays = monet.thresholdMet(thsArray) wopArr[s] = [len(i) for i in thsDays] ttiArr[s] = [min(i) for i in thsDays] ttoArr[s] = [max(i) for i in thsDays] (quantWOP, quantTTI, quantTTO) = [ np.nanquantile(i, quantile, axis=0) for i in [wopArr, ttiArr, ttoArr] ] return (quantWOP, quantTTI, quantTTO)
def exportPstTracesParallel( exIx, expsNum, STABLE_T, THS, QNT, STYLE, PT_IMG, border=True, borderColor='#322E2D', borderWidth=1, labelPos=(.7, .9), xpsNum=0, digs=3, autoAspect=False, popScaler=1, wopPrint=True, cptPrint=True, poePrint=True, mnfPrint=True, ticksHide=True, transparent=True, sampRate=1, labelspacing=.1 ): (ix, repFile, tti, tto, wop, mnf, _, poe, cpt) = exIx repDta = pkl.load(repFile) # Print to terminal ------------------------------------------------------- padi = str(ix+1).zfill(digs) fmtStr = '{}+ File: {}/{}' print(fmtStr.format(monet.CBBL, padi, expsNum, monet.CEND), end='\r') # Traces ------------------------------------------------------------------ pop = repDta['landscapes'][0][STABLE_T][-1] # STYLE['yRange'] = (0, pop*popScaler) monet.exportTracesPlot( repDta, repFile.split('/')[-1][:-6]+str(QNT), STYLE, PT_IMG, vLines=[tti, tto, 0], hLines=[mnf*pop], labelPos=labelPos, border=border, borderColor=borderColor, borderWidth=borderWidth, autoAspect=autoAspect, popScaler=popScaler, wop=wop, wopPrint=wopPrint, cpt=cpt, cptPrint=cptPrint, poe=poe, poePrint=poePrint, mnf=mnf, mnfPrint=mnfPrint, ticksHide=ticksHide, transparent=True, sampRate=sampRate, labelspacing=labelspacing ) return None
def readExperimentFilenames(experimentPath, sexFilenameIdentifiers={ "male": "", "female": "" }, exclusionPattern=None): defaultIdentifiers = {"male": ["M_", "ADM"], "female": ["F_", "AF1"]} maleFiles = [] if 'male' in sexFilenameIdentifiers: maleFiles = monet.getFileExperimentList(experimentPath, sexFilenameIdentifiers['male']) if not maleFiles: for i in defaultIdentifiers['male']: fileList = monet.getFileExperimentList(experimentPath, i) if fileList: maleFiles = fileList break femaleFiles = [] if 'female' in sexFilenameIdentifiers: femaleFiles = monet.getFileExperimentList( experimentPath, sexFilenameIdentifiers['female']) if not femaleFiles: for i in defaultIdentifiers['female']: fileList = monet.getFileExperimentList(experimentPath, i) if fileList: femaleFiles = fileList break if exclusionPattern is not None: maleFiles = [i for i in maleFiles if exclusionPattern(i)] femaleFiles = [i for i in femaleFiles if exclusionPattern(i)] return {"male": maleFiles, "female": femaleFiles}
def exportTracesPlot( tS, nS, STYLE, PATH_IMG, append='', vLines=[0, 0], hLines=[0], labelPos=(.7, .9), autoAspect=False, border=True, borderColor='#8184a7AA', borderWidth=2, popScaler=1, wop=0, wopPrint=True, cpt=0, cptPrint=False, poe=0, poePrint=False, transparent=False ): if transparent: plt.rcParams.update({ "figure.facecolor": (1.0, 0.0, 0.0, 0.0), "axes.facecolor": (0.0, 1.0, 0.0, 0.0), "savefig.facecolor": (0.0, 0.0, 1.0, 0.0), }) figArr = monet.plotNodeTraces(tS, STYLE) axTemp = figArr[0].get_axes()[0] STYLE['yRange'] = (STYLE['yRange'][0], STYLE['yRange'][1] * popScaler) axTemp.set_xlim(STYLE['xRange'][0], STYLE['xRange'][1]) axTemp.set_ylim(STYLE['yRange'][0], STYLE['yRange'][1]) if autoAspect: axTemp.set_aspect(aspect=monet.scaleAspect(STYLE["aspect"], STYLE)) else: axTemp.set_aspect(aspect=STYLE["aspect"]) # axTemp.axes.xaxis.set_ticklabels() # axTemp.axes.yaxis.set_ticklabels() axTemp.axes.xaxis.set_visible(True) axTemp.axes.yaxis.set_visible(True) # axTemp.set_axis_off() axTemp.grid(which='major', axis='y', lw=.5, ls='-', alpha=0.0, color=(0, 0, 0)) axTemp.grid(which='major', axis='x', lw=.5, ls='-', alpha=0.0, color=(0, 0, 0)) if wop==True: axTemp.axvspan(vLines[0], vLines[1], alpha=0.15, facecolor='#3687ff', zorder=-5) for vline in vLines[2:]: axTemp.axvline(vline, alpha=.5, zorder=10, ls='-', lw=.1, color='#000000') #axTemp.tick_params(color=(0, 0, 0, 0.5)) axTemp.tick_params(left=False, labelleft=False, bottom=False, labelbottom=False) # extent = axTemp.get_tightbbox(figArr[0]).transformed(figArr[0].dpi_scale_trans.inverted()) if border: axTemp.set_axis_on() plt.setp(axTemp.spines.values(), color=borderColor) pad = 0.025 for axis in ['top','bottom','left','right']: axTemp.spines[axis].set_linewidth(borderWidth) else: pad = 0 figArr[0].savefig( "{}/{}.{}".format(PATH_IMG, nS, STYLE['format']), dpi=STYLE['dpi'], facecolor=None, orientation='portrait', format=STYLE['format'], transparent=transparent, bbox_inches='tight', pad_inches=pad ) plt.clf() plt.cla() plt.close('all') plt.gcf() return None
def setupFolder(USR, DRV, exp, HD_IND): (PT_ROT, PT_IMG, PT_DTA, PT_PRE, PT_OUT) = selectPath(USR, DRV, exp) PT_IMG = PT_IMG[:-1]+'Pst/' fldrName = '{}_{}/'.format(*HD_IND) PT_IMG_XP = PT_IMG+fldrName monet.makeFolder(PT_IMG) monet.makeFolder(PT_IMG_XP) return (PT_ROT, PT_IMG_XP, PT_DTA, PT_PRE, PT_OUT)
def plotAndSaveLandscapeReps(landscapeReps, ssDay, path): figsArray = plots.plotLandscapeDataRepetitions(landscapeReps, style, ssDay, yRangeFixed) for i in range(0, len(figsArray)): figsArray[i].get_axes()[0].set_xlim(0, xRange) figsArray[i].get_axes()[0].set_ylim(0, yRangeFixed) monet.quickSaveFigure(figsArray[i], path, dpi=750) plt.close()
def getExpPaths(PATH_DATA): (expDirsMean, expDirsTrac) = ( monet.listDirectoriesWithPathWithinAPath(PATH_DATA + 'ANALYZED/'), monet.listDirectoriesWithPathWithinAPath(PATH_DATA + 'TRACES/') ) expDirsMean.sort() expDirsTrac.sort() return (expDirsMean, expDirsTrac)
def loadSummedMeanResponse(aFiles, GDICT, MALE, FEMALE): print(aux.CBLU, end='\r') # print('\t Loading mean response...'+aux.PADC, end='\r') landData = monet.loadLandscapeData(aFiles, male=MALE, female=FEMALE) # print('\t Aggregating mean response...'+aux.PADC, end='\r') aggDataM = monet.aggregateGenotypesInLandscape(landData, GDICT) aggDataM['landscape'] = sum(aggDataM['landscape']) print(aux.CEND, end='\r') return aggDataM
def getExpPaths(PATH_DATA): (expDirsMean, expDirsTrac) = (monet.listDirectoriesWithPathWithinAPath(PATH_DATA + 'analyzed/'), monet.listDirectoriesWithPathWithinAPath(PATH_DATA + 'traces/')) expDirsMean.sort() expDirsTrac.sort() return (expDirsMean, [i + '/' for i in expDirsTrac])
def plotAndSaveStack(aggData, ssDay, ffString, ffStringH, path): figB = plots.plotMeanGenotypeStack(aggData, styleS, ssDay, 2 * yRange) figB.get_axes()[0].set_xlim(0, xRange) figB.get_axes()[0].set_ylim(0, 2 * yRange) figB.get_axes()[0].set_title("[tSS: " + str(ssDay) + "] :: [" + ffString + "] :: [" + ffStringH + "]", fontsize=5) monet.quickSaveFigure(figB, path, dpi=1024, format="pdf") plt.close()
def preProcessSubLandscape(pop, landReps, fName, drive, nodesAggLst, nodeAggIx, MF=(True, True), cmpr='bz2', SUM=True, AGG=True, SPA=True, REP=True, SRP=True): """ Preprocesses a subset of the landscape Args: pop (list): Files list element aggregated by landscape subset landReps (dict): Landscape repetitions (spatial from monet.loadAndAggregateLandscapeDataRepetitions) fName (str): Filename (including path) drive (dict): Gene-drive dictionary nodesAggLst (lst): List of lists containing the indices of the nodes to be aggregated together nodeAggIx (int): Current list to process (from the nodeAggLst) MF (bool tuple): Male and Female boolean selectors cmpr (str): Compression algorithm to be used by compress-python SUM (bool): Population summed and gene-aggregated into one node AGG (bool): Population gene-aggregated in their own nodes SPA (bool): Genetic landscape (gene-aggregated) REP (bool): Garbage gene-aggregated data SRP (bool): Summed into one garbage gene-aggregated data Returns: None """ if SUM: sumData = monet.sumLandscapePopulationsFromFiles(pop, MF[0], MF[1]) sumAgg = monet.aggregateGenotypesInNode(sumData, drive) pkl.dump(sumAgg, fName + '_sum', compression=cmpr) if AGG: aggData = monet.loadAndAggregateLandscapeData(pop, drive, MF[0], MF[1]) pkl.dump(aggData, fName + '_agg', compression=cmpr) if SPA: geneSpaTemp = monet.getGenotypeArraysFromLandscape(aggData) pkl.dump(geneSpaTemp, fName + '_spa', compression=cmpr) if REP or SRP: fLandReps = monet.filterAggregateGarbageByIndex( landReps, nodesAggLst[nodeAggIx]) pkl.dump(fLandReps, fName + '_rep', compression=cmpr) if SRP: fRepsSum = [sum(i) for i in fLandReps['landscapes']] fRepsDict = { 'genotypes': fLandReps['genotypes'], 'landscapes': fRepsSum } pkl.dump(fRepsDict, fName + '_srp', compression=cmpr) return None
def calcDaysCrosses(aggregatedNodesData, thresholds, ssPops, gIx): chngDays = [] for j in range(len(aggregatedNodesData['landscape'])): nodePop = aggregatedNodesData['landscape'][j] thrsBool = monet.comparePopToThresholds(nodePop, gIx, [0, 1], thresholds, refPop=ssPops[j]) chngDays.append(monet.getConditionChangeDays(thrsBool)) return chngDays
def selectVersionPath(MGV, PT_DTA): if MGV == 'v2': (expDirsMean, expDirsTrac) = monet.getExpPaths(PT_DTA, mean='analyzed/', reps='traces/') else: (expDirsMean, expDirsTrac) = monet.getExpPaths(PT_DTA, mean='ANALYZED/', reps='GARBAGE/') return (expDirsMean, expDirsTrac)
def getAggDataSSDay(pathsRoot, i): pathSample = pathsRoot[i] + "/" experimentString = pathSample.split("/")[-2] filenames = monet.readExperimentFilenames(pathSample) landscapeSumData = monet.sumLandscapePopulationsFromFiles(filenames, male=True, female=True, dataType=float) aggData = monet.aggregateGenotypesInNode(landscapeSumData, aggregationDictionary) ssDay = aux.reachedSteadtStateAtDay(aggData, .01) return aggData, ssDay, experimentString
def getLandscapeReps(i): pathsRoot = monet.listDirectoriesWithPathWithinAPath(pathRoot + pathExt + "ANALYZED/") aggData, ssDay, _ = getAggDataSSDay(pathsRoot, i) ####################################################################### pathsRoot = monet.listDirectoriesWithPathWithinAPath(pathRoot + pathExt + "GARBAGE/") pathSample = pathsRoot[i] experimentString = pathSample.split("/")[-1] paths = monet.listDirectoriesWithPathWithinAPath(pathSample + "/") landscapeReps = monet.loadAndAggregateLandscapeDataRepetitions( paths, aggregationDictionary, male=False, female=True, dataType=float) return landscapeReps, ssDay, experimentString
def driveSelector(DRIVE, HEALTH, pathRoot): if DRIVE == 1: (pathExt, pathO) = ("SplitDrive/2019_10_12_GARBAGE/", 'SD') if HEALTH is True: aggregationDictionary = monet.generateAggregationDictionary( ["H", "Other", "Total"], [[4, 5, 6, 11, 14, 15, 16, 21, 24, 25, 26], [ 0, 1, 2, 3, 7, 8, 9, 10, 12, 13, 17, 18, 19, 20, 22, 23, 27, 28, 29 ], [ 4, 5, 6, 11, 14, 15, 16, 21, 24, 25, 26, 0, 1, 2, 3, 7, 8, 9, 10, 12, 13, 17, 18, 19, 20, 22, 23, 27, 28, 29 ]]) else: aggregationDictionary = monet.generateAggregationDictionary( ["H", "B", "R", "W", "C", "Total"], [[1, 4, 4, 5, 6, 11, 14, 14, 15, 16, 21, 24, 24, 25, 26], [3, 6, 8, 9, 9, 13, 16, 18, 19, 19, 23, 26, 28, 29, 29], [2, 5, 7, 7, 8, 12, 15, 17, 17, 18, 22, 25, 27, 27, 28], [ 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 10, 11, 11, 12, 12, 13, 13, 14, 15, 16, 17, 18, 19, 20, 20, 21, 22, 23 ], [ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29 ], [ 1, 4, 4, 5, 6, 11, 14, 14, 15, 16, 21, 24, 24, 25, 26, 3, 6, 8, 9, 9, 13, 16, 18, 19, 19, 23, 26, 28, 29, 29, 2, 5, 7, 7, 8, 12, 15, 17, 17, 18, 22, 25, 27, 27, 28, 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 10, 11, 11, 12, 12, 13, 13, 14, 15, 16, 17, 18, 19, 20, 20, 21, 22, 23, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29 ]]) if HEALTH is True: prepend = "H" else: prepend = "E" if pathRoot != '': pathsRoot = monet.listDirectoriesWithPathWithinAPath(pathRoot + pathExt) else: pathsRoot = '' return [pathsRoot, aggregationDictionary, prepend, pathO]
def calculateGeneTemporal(filenames): landscapeSumData = monet.sumLandscapePopulationsFromFiles( filenames, male=True, female=False, dataType=float ) genotypes = landscapeSumData["genotypes"] aggregationDictionary = monet.autoGenerateGenotypesDictionary( ["W", "H", "R", "B"], genotypes ) aggData = monet.aggregateGenotypesInNode( landscapeSumData, aggregationDictionary ) return aggData
def driveParameters(TYPE, popSize): if TYPE == 'ECO': aggD = monet.generateAggregationDictionary(*CRS_ECO) yRange = popSize elif TYPE == 'HLT': aggD = monet.generateAggregationDictionary(*CRS_HLT) yRange = popSize / 4 elif TYPE == 'TRS': aggD = monet.generateAggregationDictionary(*CRS_TRS) yRange = popSize elif TYPE == 'WLD': aggD = monet.generateAggregationDictionary(*CRS_WLD) yRange = popSize return (aggD, yRange, 'SplitDrive-YG')
def driveParameters(TYPE, popSize): if TYPE == 'ECO': aggD = monet.generateAggregationDictionary(*ASD_ECO) yRange = popSize elif TYPE == 'HLT': aggD = monet.generateAggregationDictionary(*ASD_HLT) yRange = popSize / 2 elif TYPE == 'TRS': aggD = monet.generateAggregationDictionary(*ASD_TRS) yRange = popSize / 2 elif TYPE == 'WLD': aggD = monet.generateAggregationDictionary(*ASD_WLD) yRange = popSize return (aggD, yRange, 'autosomal')
def driveParameters(TYPE, popSize): if TYPE == 'ECO': aggD = monet.generateAggregationDictionary(*YXS_ECO) yRange = popSize elif TYPE == 'HLT': aggD = monet.generateAggregationDictionary(*YXS_HLT) yRange = popSize / 2 elif TYPE == 'TRS': aggD = monet.generateAggregationDictionary(*YXS_TRS) yRange = popSize / 2 elif TYPE == 'WLD': aggD = monet.generateAggregationDictionary(*YXS_WLD) yRange = popSize return (aggD, yRange, 'yLinked')
def driveParameters(TYPE, popSize): if TYPE == 'ECO': aggD = monet.generateAggregationDictionary(*FMS_ECO) yRange = popSize * 4 elif TYPE == 'HLT': aggD = monet.generateAggregationDictionary(*FMS_HLT) yRange = popSize elif TYPE == 'TRS': aggD = monet.generateAggregationDictionary(*FMS_TRS) yRange = popSize / 2 elif TYPE == 'WLD': aggD = monet.generateAggregationDictionary(*FMS_WLD) yRange = popSize / 2 return (aggD, yRange, 'ifegenia_5')
def driveParameters(TYPE, popSize): if TYPE == 'ECO': aggD = monet.generateAggregationDictionary(*LDR_ECO) yRange = popSize*2 elif TYPE == 'HLT': aggD = monet.generateAggregationDictionary(*LDR_HLT) yRange = popSize/2 elif TYPE == 'TRS': aggD = monet.generateAggregationDictionary(*LDR_TRS) yRange = popSize/2 elif TYPE == 'WLD': aggD = monet.generateAggregationDictionary(*LDR_WLD) yRange = popSize/2 return (aggD, yRange, 'LDR')
def HelperFunction(i, xpNum, digs, fLists, STYLE, PT_IMG): print(msg.format(str(i+1).zfill(digs), str(xpNum).zfill(digs)), end='\r') (sumDta, repDta) = [pkl.load(file) for file in (fLists[i])] name = fLists[i][0].split('/')[-1].split('.')[0][:-4][11:] # Export plots -------------------------------------------------------- fun.exportTracesPlot(repDta, name, STYLE, PT_IMG, append='TRA') cl = [i[:-2]+'cc' for i in CLR] if i == xpNum - 1: monet.exportGeneLegend( sumDta['genotypes'], cl, PT_IMG+'/plt_{}.png'.format(AOI), 500 ) tE = datetime.now() print('* Analyzed ({}/{}) '.format(xpNum, xpNum), end='\n') print(monet.PAD)
def preProcessParallel(exIx, expNum, drive, analysisOI='HLT', prePath='./', nodesAggLst=[[0]], fNameFmt='{}/{}-{}_', MF=(True, True), cmpr='bz2', nodeDigits=4, SUM=True, AGG=False, SPA=False, REP=False, SRP=True, sexFilenameIdentifiers={ "male": "M_", "female": "F_" }): (ix, expDirsMean, expDirsTrac) = exIx monet.printProgress(ix + 1, expNum, nodeDigits) (pathMean, pathTraces) = (expDirsMean, expDirsTrac + '/') expName = pathMean.split('/')[-1] fNameFmt = '{}/{}-{}_'.format(prePath, expName, analysisOI) # Iterate through experiment files and skip errors (unsafe but logs) try: monet.preProcessLandscape( pathMean, pathTraces, expName, drive, prePath, analysisOI=analysisOI, nodesAggLst=nodesAggLst, fNameFmt=fNameFmt, MF=MF, cmpr=cmpr, nodeDigits=nodeDigits, SUM=SUM, AGG=AGG, SPA=SPA, REP=REP, SRP=SRP, sexFilenameIdentifiers=sexFilenameIdentifiers) except: file = open("preProcess.log", "a") file.write(expName + '\n') file.close() return None
def calculateGeneSpatiotemporals(filenames): landscapeData = monet.loadLandscapeData(filenames, dataType=float) genotypes = landscapeData["genotypes"] aggregationDictionary = monet.autoGenerateGenotypesDictionary( ["W", "H", "R", "B"], genotypes ) aggregatedNodesData = monet.aggregateGenotypesInLandscape( landscapeData, aggregationDictionary ) geneSpatiotemporals = monet.getGenotypeArraysFromLandscape( aggregatedNodesData ) return geneSpatiotemporals
def exportTracesPlot(tS, nS, STYLE, PATH_IMG, append='', vLines=[0]): figArr = monet.plotLandscapeDataRepetitions(tS, STYLE) axTemp = figArr[0].get_axes()[0] axTemp.set_aspect(aspect=STYLE["aspect"]) axTemp.set_xlim(STYLE['xRange'][0], STYLE['xRange'][1]) axTemp.set_ylim(STYLE['yRange'][0], STYLE['yRange'][1]) axTemp.vlines(vLines, 0, 1, transform=axTemp.get_xaxis_transform(), colors='#FF007FA5', linestyles='dashed', linewidth=.25) axTemp.tick_params(color=(0, 0, 0, 0.5)) figArr[0].savefig("{}/{}-{}.png".format(PATH_IMG, nS, append), dpi=STYLE['dpi'], facecolor=None, edgecolor='w', orientation='portrait', papertype=None, format='png', transparent=True, bbox_inches='tight', pad_inches=.01) plt.close('all') return True
def selectPath(USR, DRV, EXP): if USR == 'srv': PATH_ROOT = '/RAID5/marshallShare/SplitDrive_Suppression/{}/{}/'.format( DRV, EXP) elif USR == 'srv2': PATH_ROOT = '/RAID5/marshallShare/SplitDrive_Suppression/theoretical/{}/{}/'.format( DRV, EXP) elif USR == 'srvA': PATH_ROOT = '/RAID5/marshallShare/SplitDrive_Suppression/realized1/{}/{}/'.format( DRV, EXP) elif USR == 'srvB': PATH_ROOT = '/RAID5/marshallShare/SplitDrive_Suppression/realized3/{}/{}/'.format( DRV, EXP) elif USR == 'srvC': PATH_ROOT = '/RAID5/marshallShare/SplitDrive_Suppression/realized7/{}/{}/'.format( DRV, EXP) elif USR == 'dsk': PATH_ROOT = '/home/chipdelmal/Documents/WorkSims/SDP/{}/{}/'.format( DRV, EXP) elif USR == 'lab': PATH_ROOT = '/Volumes/marshallShare/SplitDrive_Suppression/theoretical/{}/{}/'.format( DRV, EXP) (PATH_IMG, PATH_DATA) = ('{}img/'.format(PATH_ROOT), '{}'.format(PATH_ROOT)) PATH_PRE = PATH_DATA + 'PREPROCESS/' PATH_OUT = PATH_DATA + 'POSTPROCESS/' PATH_MTR = PATH_DATA + 'SUMMARY/' fldrList = [PATH_ROOT, PATH_IMG, PATH_DATA, PATH_PRE, PATH_OUT, PATH_MTR] [monet.makeFolder(i) for i in fldrList] return (PATH_ROOT, PATH_IMG, PATH_DATA, PATH_PRE, PATH_OUT, PATH_MTR)