コード例 #1
0
def rankProb(ListOpt):
    List = ListOpt.copy()
    List.pop(0)
    i = 0  #for rank op
    rankOp = []
    rankOp2 = [None, None, None]

    if '--noCal' in List:
        noCalFlag = True
        List.remove('--noCal')
    else:
        noCalFlag = False

    if '--wof' in List:
        wofFlag = True
        List.remove('--wof')
    else:
        wofFlag = False

    if '--all' in List:
        allFlag = True
        List.remove('--all')
    else:
        allFlag = False

    for Arg in List:
        try:
            if int(Arg) > 0 and int(Arg) < 4:
                rankOp.append(int(Arg))
            else:
                continue
        except:
            if len(List) <= 1:
                rankOp.append(3)
            continue

    if len(rankOp) == 0:
        rankOp.append(3)
        rankOp.append(2)
    elif len(rankOp) == 1:
        if rankOp[0] == 3:
            rankOp.append(2)
        else:
            rankOp.append(3)

    rankOp = removeDuplicates(rankOp)
    #rankOp2 = [x-4 for x in rankOp]
    rankOp2 = [-2, -3]
    if len(List) == 0:
        print("error: --rank option needs an argument")
        return 0

    infoFile = List[0]
    if not os.path.isfile(infoFile):
        print("error: %s does not exist, are you in the right path?" %
              (infoFile))
        return 10000
    if not infoFile.endswith('.info'):
        print("error: %s needs a .info extension" % (infoFile))
        return 10001
    infoDict = getDictFromInfoFile(infoFile)

    for arg in List:
        if isValidSpecFile(arg):
            if arg.endswith('.info'):
                pass  #infoFile = arg
            else:
                FileName = arg

    try:
        if isValidSpecFile(FileName):
            FileExt = FileName.split('.')[-1]
    except:
        print('ERROR: Unexpected error. Not a valid file used.')
        return 110

    if noCalFlag:
        FileDict = functionDictAdv[FileExt](FileName, False)
    else:
        FileDict = functionDictAdv[FileExt](FileName)

    try:
        minRange = infoDict['Range']['start']
        maxRange = infoDict['Range']['end']
        del infoDict['Range']
    except:
        minRange, maxRange = findRangeInfoDict(infoDict)

    idxPairL = []
    for DictEle in infoDict.values():
        idxPairL.append([DictEle['start'], DictEle['end']])

    DBInfoL = []
    pathfile = os.path.realpath(__file__)
    pathfile = pathfile.rstrip('rank_prob.py')
    conexion = OpenDatabase(pathfile)

    memoLenDict = {}

    isoCountD = {}
    DBInfoL = []
    DBInfoDL = []
    tMinEL = []
    tMaxEL = []
    ProbLL = []
    DiffLL = []
    ProbDL = {}
    DiffDL = {}
    if True:
        for infoPair in infoDict.values():
            tMinEL.append(infoPair['start'])
            tMaxEL.append(infoPair['end'])
        tMinE = min(tMinEL)
        tMaxE = max(tMaxEL)
    else:
        tMinE = minRange
        tMaxE = maxRange

    myDataList = FileDict['theList']
    #print("")
    #print("Gilmore statistics\n[variables in counts]")
    fittingDict = doFittingStuff(infoDict, myDataList)
    #gaussData4Print=[]
    #fig, ax = plt.subplots()
    #for e in fittingDict:
    #a,mean,sigma,c,minIdx,maxIdx,myFWHM=fittingDict[e]
    #    a,mean,sigma,c=fittingDict[e][:-3]
    #    if a == None:
    #        print("Skipping failed fit")
    #        continue
    #    gaussData4Print.append([e,a,mean,sigma,c])

    #plt.annotate(e, xy=[mean,a])
    #myGaussRows=['#tags','a','mean','sigma','c']
    #pd.set_option('display.max_rows', None)
    #dfG = pd.DataFrame(gaussData4Print, columns = myGaussRows)

    #gilmoreDict=doGilmoreStuff(infoDict,myDataList)
    #data4print=[]
    #for e in gilmoreDict:
    #    gL=gilmoreDict[e]
    #    data4print.append(gL[0:6])
    #realXVals=myDataList[0]

    #myHStr4=['Tags','NetArea','Area+ExtBkgd','GrossInt','Background','Sigma_A']
    #pd.set_option('display.max_rows', len(data4print))#imprime todas las filas
    #df = pd.DataFrame([data for data in data4print], columns = myHStr4)
    #print(df)
    #print('\nGauss Parameters')
    #print(dfG)
    fittingDictKeys = list(fittingDict.keys())

    PeakNum = -1
    IdxRemove = []
    #idxPairL_copy=idxPairL.copy()
    for idxR in idxPairL:
        PeakNum += 1
        iEner = idxR[0]
        fEner = idxR[1]
        # DBInfoL.append(GetIntensities(conexion,iEner,fEner))
        # DBInfo = DBInfoL[-1]
        DBInfo = GetIntensities(conexion, iEner, fEner)
        DiffL, ProbL = MeanDistance(DBInfo,
                                    fittingDict[fittingDictKeys[PeakNum]])
        if DiffL == None or ProbL == None:
            continue
        else:
            IdxRemove.append(PeakNum)
            DBInfoL.append(DBInfo)
            DiffLL.append(DiffL)
            ProbLL.append(ProbL)
            DBInfoD = {}
            for e, fs, gs in zip(DBInfo, DiffL, ProbL):
                if e[-1] not in DBInfoD:
                    DBInfoD[e[-1]] = [e]
                    ProbDL[gs[0]] = [gs]
                    DiffDL[fs[0]] = [fs]
                else:
                    DBInfoD[e[-1]].append(e)
                    ProbDL[gs[0]].append(gs)
                    DiffDL[fs[0]].append(fs)
            DBInfoDL.append(DBInfoD)

            for Ele in DBInfo:
                iso = Ele[-1]
                if iso not in memoLenDict:
                    memoLenDict[iso] = [
                        len(GetIntensities(conexion, tMinE, tMaxE, iso)), 1,
                        Ele[10], [PeakNum]
                    ]
                    isoCountD[iso] = [Ele]
                else:
                    memoLenDict[iso][1] += 1
                    memoLenDict[iso][2] += Ele[10]
                    memoLenDict[iso][3].append(PeakNum)
                    isoCountD[iso].append(Ele)

    idxPairL = list(map(idxPairL.__getitem__, IdxRemove))
    memoLenDictKeys = memoLenDict.copy().keys()
    for Ele in memoLenDictKeys:
        if memoLenDict[Ele][0] == 0 or memoLenDict[Ele][2] == 0:
            del memoLenDict[Ele]
            del isoCountD[Ele]
            for DBInfoD in DBInfoDL:
                try:
                    del DBInfoD[Ele]
                except KeyError:
                    continue

    memoLenDictKeys = memoLenDict.keys()

    Ranges = []
    rankList = []

    try:
        if rankOp[0] == 1:
            myfilename = infoFile.strip('.info') + '_rank_B.txt'

        elif rankOp[0] == 2:
            myfilename = infoFile.strip('.info') + '_rank_C.txt'

        elif rankOp[0] == 3:
            myfilename = infoFile.strip('.info') + '_rank_Prob.txt'

        else:
            myfilename = infoFile.strip('.info') + '_rank_Prob.txt'
    except:
        myfilename = 'FileNameCouldNotBeRecovered.txt'

    for idxR, DBInfoD in zip(idxPairL, DBInfoDL):
        iEner = idxR[0]
        fEner = idxR[1]
        Ranges.append([iEner, fEner])
        Eg , Ig , Decay, Half , Parent, rank, rank2, rank3, ProbRank, DiffRank  = [],[],[],[],[],[],[],[],[],[]
        for Key in DBInfoD:
            #Ele = DBInfoD[Key]
            for Ele, DiffEle, ProbEle in zip(DBInfoD[Key], DiffDL[Key],
                                             ProbDL[Key]):
                Eg.append(Ele[1])
                Ig.append(round(Ele[3], 2))
                Decay.append(Ele[5])
                x = halfLifeUnit(Ele)
                if x == 0:
                    y = str(x)
                else:
                    y = str('{0:.2e}'.format(x))
                Half.append(y + ' [s] ')
                Parent.append(Ele[-1])
                rank.append(memoLenDict[Ele[-1]][1])
                rank2.append(
                    round(memoLenDict[Ele[-1]][1] / memoLenDict[Ele[-1]][0],
                          3))
                rank3.append(round(memoLenDict[Ele[-1]][2], 3))
                ProbRank.append(ProbEle[1])
                DiffRank.append(DiffEle[1])

        Eg, Ig, Decay, Half, Parent, rank3, ProbRank, DiffRank = (
            list(t) for t in zip(*sorted(zip(Eg, Ig, Decay, Half, Parent,
                                             rank3, ProbRank, DiffRank),
                                         key=itemgetter(*rankOp2),
                                         reverse=True)))

        print(
            '\nThe energy range consulted is between %.2f keV and %.2f keV.\n'
            % (iEner, fEner))

        if allFlag:
            pd.set_option('display.max_rows', None)  #imprime todas las filas
            pd.options.display.float_format = '{:,.5f}'.format
            df = pd.DataFrame(list(
                zip(Eg, Ig, Decay, Half, Parent, rank3, ProbRank, DiffRank)),
                              columns=[
                                  'Eg [keV]', 'Ig (%)', 'Decay m', 'Half Life',
                                  'Parent', 'Rank3', 'Probability', 'Distance'
                              ])  #crea  la tabla
            print(df)

        else:
            pd.set_option('display.max_rows', len(Ele))
            df = pd.DataFrame(list(
                zip(Eg, Ig, Decay, Half, Parent, rank3, ProbRank, DiffRank)),
                              columns=[
                                  'Eg [keV]', 'Ig (%)', 'Decay mode',
                                  'Half Life', 'Parent', 'Rank3',
                                  'Probability', 'Distance'
                              ])  #crea  la tabla
            print(df)

        if wofFlag:
            try:
                if allFlag:
                    WriteOutputFileRR(myfilename, df, iEner, fEner)

                else:
                    WriteOutputFileRR(myfilename, df.head(10), iEner, fEner)

            except IOError:
                print(
                    'ERROR: An unexpected error ocurrs. Data could not be saved.'
                )
                break

    if wofFlag:
        print('-----------------------------------------')
        print('The file was saved as:')
        print(myfilename)
        print('-----------------------------------------')

    return 0
コード例 #2
0
def halfSortFun(ListOpt):
    List = ListOpt.copy()
    List.pop(0)

    if '--wof' in List:
        wofFlag = True
        List.remove('--wof')
    else:
        wofFlag = False

    if '--all' in List:
        allFlag = True
        List.remove('--all')
    else:
        allFlag = False

    if len(List) == 0:
        sys.stderr.write("error: --energyRanges option needs an argument\n")
        return 0

    infoFile = List[0]

    if not os.path.isfile(infoFile):
        sys.stderr.write(
            "error: %s does not exist, are you in the right path?\n" %
            (infoFile))
        return 100
    if not infoFile.endswith('.info'):
        sys.stderr.write("error: %s needs a .info extension\n" % (infoFile))
        return 101
    infoDict = getDictFromInfoFile(infoFile)
    minRange = infoDict['Range']['start']
    maxRange = infoDict['Range']['end']
    del infoDict['Range']

    idxPairL = []
    for DictEle in infoDict.values():
        idxPairL.append([DictEle['start'], DictEle['end']])

    DBInfoL = []
    DBInfoDL = []
    pathfile = os.path.realpath(__file__)
    if operatingSystem == 'Linux' or operatingSystem == 'Darwin':
        pathfile = pathfile.replace('/modules/halfSort.py', '')
    elif operatingSystem == 'Windows':
        pathfile = pathfile.replace('\\modules\\halfSort.py', '')

    conexion = OpenDatabase(pathfile)

    for idxR in idxPairL:
        iEner = idxR[0]
        fEner = idxR[1]
        DBInfoL.append(GetIntensities(conexion, iEner, fEner))
        DBInfo = DBInfoL[-1]
        DBInfoD = {}
        for e in DBInfo:
            #Filling dict with isotope name each isotope has only one tupple
            if e[-1] not in DBInfoD:
                DBInfoD[e[-1]] = [e]
            else:
                DBInfoD[e[-1]].append(e)

        Eg, Ig, Decay, Half, Parent = [], [], [], [], []
        for Element in DBInfoD:
            for ps in range(0, len(DBInfoD[Element]), 1):
                Eg.append(
                    str(DBInfoD[Element][ps][1]) + ' (' +
                    str(DBInfoD[Element][ps][2]) + ')')
                Ig.append(round(DBInfoD[Element][ps][3], 2))
                Decay.append(DBInfoD[Element][ps][5])
                x = halfLifeUnit(DBInfoD[Element][ps])
                if x == 0:
                    y = str(x)
                else:
                    y = str('{0:.2e}'.format(x))

                Half.append(y + ' [s] ')
                Parent.append(DBInfoD[Element][ps][-1])

        print(
            '\nThe energy range consulted is between %.2f keV and %.2f keV.\n'
            % (iEner, fEner))

        if allFlag:
            pd.set_option('display.max_rows', None)
            pd.options.display.float_format = '{:,.5f}'.format
            df = pd.DataFrame(sorted(list(zip(Eg, Ig, Decay, Half, Parent)),
                                     key=lambda x: float(x[3][:-4]),
                                     reverse=True),
                              columns=[
                                  'Eg [keV]', 'Ig (%)', 'Decay m', 'Half Life',
                                  'Parent'
                              ])  #crea  la tabla
            print(df)
        else:
            pd.set_option('display.max_rows', None)
            df = pd.DataFrame(sorted(list(zip(Eg, Ig, Decay, Half, Parent)),
                                     key=lambda x: float(x[3][:-4]),
                                     reverse=True),
                              columns=[
                                  'Eg [keV]', 'Ig (%)', 'Decay m', 'Half Life',
                                  'Parent'
                              ])  #crea  la tabla
            print(df.head(10))

        if wofFlag:
            try:
                myfilename = infoFile.strip('.info') + '_rank_C.txt'
                if allFlag:
                    WriteOutputFileRR(myfilename, df, iEner, fEner)
                else:
                    WriteOutputFileRR(myfilename, df.head(10), iEner, fEner)

                print('-----------------------------------------')
                print('The file was saved as:')
                print(myfilename)
                print('-----------------------------------------')

            except IOError:
                sys.stderr.write(
                    'ERROR: An unexpected error ocurrs. Data could not be saved.\n'
                )
                break

    return 0
コード例 #3
0
ファイル: fuzzyrank.py プロジェクト: ffavela/histoGe
def fuzzyrankFun(ListOpt):
    List = ListOpt.copy()
    List.pop(0)  
    
    if '--wof' in List:
        wofFlag = True
        List.remove('--wof')
    else:
        wofFlag = False

    if '--all' in List:
        allFlag = True
        List.remove('--all')
    else:
        allFlag = False
#####    
    if '--filter' in List:
        filterFlag = True
        List.remove('--filter')
        IntensityFilter = 5/100
    else:
        filterFlag = False
        
#####

    if '--op1' in List:
        op1Flag = True
        List.remove('--op1')
    else:
        op1Flag = False

    if len(List) == 0:
        print("error: --fuzzyRank option needs an argument")
        return 0

    infoFile=List[0]
    if not os.path.isfile(infoFile):
        print("error: %s does not exist, are you in the right path?" %(infoFile))
        return 10000
    if not infoFile.endswith('.info'):
        print("error: %s needs a .info extension" % (infoFile))
        return 10001
    infoDict=getDictFromInfoFile(infoFile)
    minRange = infoDict['Range']['start']
    maxRange = infoDict['Range']['end']
    del infoDict['Range']

    myFileDict=getMyFileDictRankAdv(List)
    
    myFilename=myFileDict['specFiles'][0]
              
    if len(myFileDict['specFiles']) > 1:
       
        print(' Error: to many files to do autopeak\n')

    #elif not myFilename.endswith('.info'):       
    else:   
        myExtension = myFilename.split(".")[-1] #verifies the file extention
        if myExtension == 'info':
            print('The file cannot be an info file.')
            return 120

    noCalFlag = False
    mySpecialDict = functionDictAdv[myExtension](myFilename,noCalFlag) #fill de dictionary
                                                                #from data file
    myDataList = mySpecialDict['theList']
    #fittingDict = doFittingStuff(infoDict,myDataList)
    gilmoreDict = doGilmoreStuff(infoDict,myDataList)
    gilmoreDictKeys = list(gilmoreDict.keys())

    idxPairL = []
    for DictEle in infoDict.values():
        ####
        if op1Flag:
            deltaEle = (DictEle['end']-DictEle['start'])*.1 #peak +/- % of the infoFile range
            meanEle = (DictEle['start']+DictEle['end'])/2
            DictEle['start'] = meanEle - deltaEle
            DictEle['end'] = meanEle + deltaEle
            idxPairL.append([DictEle['start'],DictEle['end']])
        else:
            idxPairL.append([DictEle['start'],DictEle['end']])
        ####
    #Energy range of the histogram
    
    DBInfoL = []
    pathfile = os.path.realpath(__file__)
    pathfile = pathfile.rstrip('fuzzyrank.py')
    conexion = OpenDatabase(pathfile)

    memoLenDict={}

    isoCountD = {}
    DBInfoL = []
    DBInfoDL = []
    #tMinE,tMaxE = infoDict['theList'][0],infoDict['theList'][-1]
    tMinEL = []
    tMaxEL = []
    
    if True:
        for infoPair in infoDict.values():
            tMinEL.append(infoPair['start'])
            tMaxEL.append(infoPair['end'])
        tMinE = min(tMinEL)
        tMaxE = max(tMaxEL)
    else:
        tMinE = minRange
        tMaxE = maxRange

    PeakNum = -1
    for idxR in idxPairL:
        PeakNum += 1
        iEner = idxR[0]
        fEner = idxR[1]
        #DBInfoL.append(EnergyRange(conexion,iEner,fEner))
        DBInfoL.append(GetIntensities(conexion,iEner,fEner))
        DBInfo = DBInfoL[-1]
        DBInfoD = {}
        for e in DBInfo: 
            #Filling dict with isotope name each isotope has only one tupple
            if e[-1] not in DBInfoD:
                DBInfoD[e[-1]] = [e]
            else:
                DBInfoD[e[-1]].append(e)
        DBInfoDL.append(DBInfoD)   
    
        for Ele in DBInfo:
            iso = Ele[-1]
            if iso not in memoLenDict:
                if filterFlag:
                    IntInRange = GetIntensities(conexion,tMinE,tMaxE,iso)
                    Count = 0
                    for Element in IntInRange:
                        if Element[10] >= IntensityFilter:
                            Count += 1
                    if Ele[10] >= IntensityFilter:
                        memoLenDict[iso]=[Count,1,Ele[10],[PeakNum]]
                    else:
                        memoLenDict[iso]=[Count,1,0,[PeakNum]]

                else:
                    memoLenDict[iso]=[len(GetIntensities(conexion,tMinE,tMaxE,iso)),1,Ele[10],[PeakNum]]
                
                isoCountD[iso] = [Ele]
            else:
                if filterFlag:
                    if Ele[10] >= IntensityFilter:
                        memoLenDict[iso][1] += 1 
                        memoLenDict[iso][2] += Ele[10]
                        memoLenDict[iso][3].append(PeakNum)
                        isoCountD[iso].append(Ele)
                else:
                    memoLenDict[iso][1] += 1 
                    memoLenDict[iso][2] += Ele[10]
                    memoLenDict[iso][3].append(PeakNum)
                    isoCountD[iso].append(Ele)

    memoLenDictKeys = memoLenDict.copy().keys()
    for Ele in memoLenDictKeys:
        if memoLenDict[Ele][0] == 0 or memoLenDict[Ele][2] == 0:
            del memoLenDict[Ele]
            del isoCountD[Ele]
            for DBInfoD in DBInfoDL:
                try:
                    del DBInfoD[Ele]
                except KeyError:
                    continue

    memoLenDictKeys = memoLenDict.keys()
    
    if filterFlag:
        DBInfoDLshort = []
        for DBInfoD in DBInfoDL:
            DBInfoDKeys = DBInfoD.copy().keys()
            for KeyDB in DBInfoDKeys:
                if KeyDB not in memoLenDictKeys:
                    del DBInfoD[KeyDB]
            DBInfoDLshort.append(DBInfoD)
        #DBInfoDLshortKeys = list(DBInfoDLshort.keys())
    else:
        DBInfoDLshort = DBInfoDL.copy()
    fuzzyMax = fuzzyinference(1,1,0)
    DevRankD = {}
    fuzzyRank = {}
    for Key in memoLenDictKeys:
        NetAreaTot = 0
        NormPeakIntensity = 0
        for Peak in removeDuplicates(memoLenDict[Key][3]):    
            NetAreaTot += gilmoreDict[gilmoreDictKeys[Peak]][1]
            for MultiPeak in DBInfoDLshort[Peak][Key]:
                NormPeakIntensity += MultiPeak[10]

        ECM = 0
        
        if len(removeDuplicates(memoLenDict[Key][3])) == 1:
            DevRankD[Key] = (memoLenDict[Key][0]/memoLenDict[Key][1])
            fuzzyRank[Key] = fuzzyinference(memoLenDict[Key][1]/memoLenDict[Key][0],memoLenDict[Key][2],DevRankD[Key])
        else:

            for Peak in removeDuplicates(memoLenDict[Key][3]):
                MultiPeakIntensity = 0
                for MultiPeak in DBInfoDLshort[Peak][Key]:
                    MultiPeakIntensity += MultiPeak[10]
                ECM += ((MultiPeakIntensity/NormPeakIntensity)-(gilmoreDict[gilmoreDictKeys[Peak]][1]/NetAreaTot))**2
                #ECM += ((NormPeakIntensity/MultiPeakIntensity)-(gilmoreDict[gilmoreDictKeys[Peak]][1]/NetAreaTot))**2 
            DevRankD[Key] = (memoLenDict[Key][0]/memoLenDict[Key][1])*sqrt(ECM/len(memoLenDict[Key][3]))
            fuzzyRank[Key] = fuzzyinference(memoLenDict[Key][1]/memoLenDict[Key][0],memoLenDict[Key][2],DevRankD[Key])/fuzzyMax

    Ranges = []
    for idxR, DBInfoD in zip(idxPairL,DBInfoDL):
        iEner = idxR[0]
        fEner = idxR[1]
        Ranges.append([iEner,fEner])
        Eg , Ig , Decay, Half , Parent, rank, rank2 = [],[],[],[],[],[],[]
        for Key in DBInfoD:
            #Ele = DBInfoD[Key]
            for Ele in DBInfoD[Key]:
                Eg.append(Ele[1])
                Ig.append(round(Ele[3],2))
                Decay.append(Ele[5])
                x=halfLifeUnit(Ele)
                if x == 0:
                    y = str(x)
                else:
                    y = str('{0:.2e}'.format(x))
                Half.append(y+ ' [s] ')# + str(Ele[6]) +' ' +str(Ele[7]) + ' ('+str(Ele[8])+')')
                Parent.append(Ele[-1])
                rank.append(DevRankD[Key])
                rank2.append(fuzzyRank[Key])

        print('\nThe energy range consulted is between %.2f keV and %.2f keV.\n' % (iEner,fEner))
        
        if allFlag:
            pd.set_option('display.max_rows', None) #imprime todas las filas
            df = pd.DataFrame(sorted(list(zip(Eg,Ig,Decay,Half,Parent,rank,rank2)),key=lambda x: (x[6],-x[5]),reverse=True),columns=['Eg [keV]','Ig (%)','Decay m','Half Life','Parent','Adj MSE','Membership'])#crea  la tabla
            print(df)
            #print(df.sort_values(by=['Membership'], ascending=False))
        else:
            pd.set_option('display.max_rows', 10)
            df = pd.DataFrame(sorted(list(zip(Eg,Ig,Decay,Half,Parent,rank,rank2)),key=lambda x: (x[6],-x[5]),reverse=True),columns=['Eg [keV]','Ig (%)','Decay mode','Half Life','Parent','Adj MSE','Membership'])#crea  la tabla
            print(df.head(10))
            #print(df.sort_values(by=['Membership'], ascending=False).head(10)) #print('\nOnly the first 10')
            
        if wofFlag:
            try:
                if filterFlag:
                    myfilename = infoFile.strip('.info') + '_RankFuzz_filter.txt'
                else:
                    myfilename = infoFile.strip('.info') + '_RankFuzz.txt'
                
                WriteOutputFileRR(myfilename,df,iEner,fEner)
                print('-----------------------------------------')
                print('The file was saved as:')
                print(myfilename)
                print('-----------------------------------------')
            except IOError:
                print('ERROR: An unexpected error ocurrs. Data could not be saved.')
    
    return 0
コード例 #4
0
def rankAdvFun(ListOpt):
    List = ListOpt.copy()
    List.pop(0)

    if '--wof' in List:
        wofFlag = True
        List.remove('--wof')
    else:
        wofFlag = False

    if '--all' in List:
        allFlag = True
        List.remove('--all')
    else:
        allFlag = False
#####
    if '--filter' in List:
        filterFlag = True
        List.remove('--filter')
        IntensityFilter = 5 / 100
    else:
        filterFlag = False

#####

    if '--op1' in List:
        op1Flag = True
        List.remove('--op1')
    else:
        op1Flag = False

    if len(List) == 0:
        sys.stderr.write("error: --energyRanges option needs an argument\n")
        return 0

    for arg in List:
        if isValidSpecFile(arg):
            if arg.endswith('.info'):
                infoFile = arg
            else:
                myFilename = arg

    try:
        if isValidSpecFile(myFilename):
            myExtension = myFilename.split('.')[-1]
    except:
        sys.stderr.write('ERROR: Unexpected error. Not a valid file used.\n')
        return 120

    if not os.path.isfile(infoFile):
        sys.stderr.write(
            "error: %s does not exist, are you in the right path?\n" %
            (infoFile))
        return 10000
    if not infoFile.endswith('.info'):
        sys.stderr.write("error: %s needs a .info extension\n" % (infoFile))
        return 10001
    infoDict = getDictFromInfoFile(infoFile)
    try:
        minRange = infoDict['Range']['start']
        maxRange = infoDict['Range']['end']
        del infoDict['Range']
    except:
        minRange, maxRange = findRangeInfoDict(infoDict)

    myFileDict = getMyFileDictRankAdv(List)

    noCalFlag = False
    mySpecialDict = functionDictAdv[myExtension](myFilename, noCalFlag)
    myDataList = mySpecialDict['theList']

    gilmoreDict = doGilmoreStuff(infoDict, myDataList)
    gilmoreDictKeys = list(gilmoreDict.keys())

    idxPairL = []
    for DictEle in infoDict.values():
        ####
        if op1Flag:
            deltaEle = (DictEle['end'] - DictEle['start']) * .1
            meanEle = (DictEle['start'] + DictEle['end']) / 2
            DictEle['start'] = meanEle - deltaEle
            DictEle['end'] = meanEle + deltaEle
            idxPairL.append([DictEle['start'], DictEle['end']])
        else:
            idxPairL.append([DictEle['start'], DictEle['end']])
        ####
    #Energy range of the histogram

    DBInfoL = []
    pathfile = os.path.realpath(__file__)
    if operatingSystem == 'Linux' or operatingSystem == 'Darwin':
        pathfile = pathfile.replace('/modules/rankAdv.py', '')
    elif operatingSystem == 'Windows':
        pathfile = pathfile.replace('\\modules\\rankAdv.py', '')

    conexion = OpenDatabase(pathfile)

    memoLenDict = {}

    isoCountD = {}
    DBInfoL = []
    DBInfoDL = []
    tMinEL = []
    tMaxEL = []

    if True:
        for infoPair in infoDict.values():
            tMinEL.append(infoPair['start'])
            tMaxEL.append(infoPair['end'])
        tMinE = min(tMinEL)
        tMaxE = max(tMaxEL)
    else:
        tMinE = minRange
        tMaxE = maxRange

    PeakNum = -1
    for idxR in idxPairL:
        PeakNum += 1
        iEner = idxR[0]
        fEner = idxR[1]
        DBInfoL.append(GetIntensities(conexion, iEner, fEner))
        DBInfo = DBInfoL[-1]
        DBInfoD = {}
        for e in DBInfo:
            #Filling dict with isotope name each isotope has only one tupple
            if e[-1] not in DBInfoD:
                DBInfoD[e[-1]] = [e]
            else:
                DBInfoD[e[-1]].append(e)
        DBInfoDL.append(DBInfoD)

        for Ele in DBInfo:
            iso = Ele[-1]
            if iso not in memoLenDict:
                if filterFlag:
                    IntInRange = GetIntensities(conexion, tMinE, tMaxE, iso)
                    Count = 0
                    for Element in IntInRange:
                        if Element[10] >= IntensityFilter:
                            Count += 1
                    if Ele[10] >= IntensityFilter:
                        memoLenDict[iso] = [Count, 1, Ele[10], [PeakNum]]
                    else:
                        memoLenDict[iso] = [Count, 1, 0, [PeakNum]]

                else:
                    memoLenDict[iso] = [
                        len(GetIntensities(conexion, tMinE, tMaxE, iso)), 1,
                        Ele[10], [PeakNum]
                    ]

                isoCountD[iso] = [Ele]
            else:
                if filterFlag:
                    if Ele[10] >= IntensityFilter:
                        memoLenDict[iso][1] += 1
                        memoLenDict[iso][2] += Ele[10]
                        memoLenDict[iso][3].append(PeakNum)
                        isoCountD[iso].append(Ele)
                else:
                    memoLenDict[iso][1] += 1
                    memoLenDict[iso][2] += Ele[10]
                    memoLenDict[iso][3].append(PeakNum)
                    isoCountD[iso].append(Ele)

    memoLenDictKeys = memoLenDict.copy().keys()
    for Ele in memoLenDictKeys:
        if memoLenDict[Ele][0] == 0 or memoLenDict[Ele][2] == 0:
            del memoLenDict[Ele]
            del isoCountD[Ele]
            for DBInfoD in DBInfoDL:
                try:
                    del DBInfoD[Ele]
                except KeyError:
                    continue

    memoLenDictKeys = memoLenDict.keys()

    if filterFlag:
        DBInfoDLshort = []
        for DBInfoD in DBInfoDL:
            DBInfoDKeys = DBInfoD.copy().keys()
            for KeyDB in DBInfoDKeys:
                if KeyDB not in memoLenDictKeys:
                    del DBInfoD[KeyDB]
            DBInfoDLshort.append(DBInfoD)

    else:
        DBInfoDLshort = DBInfoDL.copy()

    DevRankD = {}

    for Key in memoLenDictKeys:
        NetAreaTot = 0
        NormPeakIntensity = 0
        for Peak in removeDuplicates(memoLenDict[Key][3]):
            NetAreaTot += gilmoreDict[gilmoreDictKeys[Peak]][1]
            for MultiPeak in DBInfoDLshort[Peak][Key]:
                NormPeakIntensity += MultiPeak[10]

        ECM = 0

        if len(removeDuplicates(memoLenDict[Key][3])) == 1:
            DevRankD[Key] = (memoLenDict[Key][0] / memoLenDict[Key][1])
        else:

            for Peak in removeDuplicates(memoLenDict[Key][3]):
                MultiPeakIntensity = 0
                for MultiPeak in DBInfoDLshort[Peak][Key]:
                    MultiPeakIntensity += MultiPeak[10]
                ECM += (
                    (MultiPeakIntensity / NormPeakIntensity) -
                    (gilmoreDict[gilmoreDictKeys[Peak]][1] / NetAreaTot))**2

            DevRankD[Key] = (memoLenDict[Key][0] / memoLenDict[Key][1]) * sqrt(
                ECM / len(memoLenDict[Key][3]))

    Ranges = []
    for idxR, DBInfoD in zip(idxPairL, DBInfoDL):
        iEner = idxR[0]
        fEner = idxR[1]
        Ranges.append([iEner, fEner])
        Eg, Ig, Decay, Half, Parent, rank = [], [], [], [], [], []
        for Key in DBInfoD:
            for Ele in DBInfoD[Key]:
                Eg.append(Ele[1])
                Ig.append(round(Ele[3], 2))
                Decay.append(Ele[5])
                x = halfLifeUnit(Ele)
                if x == 0:
                    y = str(x)
                else:
                    y = str('{0:.2e}'.format(x))
                Half.append(y + ' [s] ')
                Parent.append(Ele[-1])
                rank.append(DevRankD[Key])

        print(
            '\nThe energy range consulted is between %.2f keV and %.2f keV.\n'
            % (iEner, fEner))

        if allFlag:
            pd.set_option('display.max_rows', None)
            if filterFlag:
                df = pd.DataFrame(sorted(list(
                    zip(Eg, Ig, Decay, Half, Parent, rank)),
                                         key=lambda x: (x[5], -x[1])),
                                  index=None,
                                  columns=[
                                      'Eg [keV]', 'Ig (%)', 'Decay m',
                                      'Half Life', 'Parent', 'Rank G Filter'
                                  ])  #crea  la tabla
            else:
                df = pd.DataFrame(sorted(list(
                    zip(Eg, Ig, Decay, Half, Parent, rank)),
                                         key=lambda x: (x[5], -x[1])),
                                  index=None,
                                  columns=[
                                      'Eg [keV]', 'Ig (%)', 'Decay m',
                                      'Half Life', 'Parent', 'Rank G'
                                  ])  #crea  la tabla

            print(df)
        else:
            pd.set_option('display.max_rows', 10)
            if filterFlag:
                df = pd.DataFrame(sorted(list(
                    zip(Eg, Ig, Decay, Half, Parent, rank)),
                                         key=lambda x: (x[5], -x[1])),
                                  index=None,
                                  columns=[
                                      'Eg [keV]', 'Ig (%)', 'Decay m',
                                      'Half Life', 'Parent', 'Rank G Filter'
                                  ])  #crea  la tabla
            else:
                df = pd.DataFrame(sorted(list(
                    zip(Eg, Ig, Decay, Half, Parent, rank)),
                                         key=lambda x: (x[5], -x[1])),
                                  index=None,
                                  columns=[
                                      'Eg [keV]', 'Ig (%)', 'Decay mode',
                                      'Half Life', 'Parent', 'Rank G'
                                  ])  #crea  la tabla
            print(df.head(10))

        if wofFlag:
            try:
                if filterFlag:
                    myfilename = infoFile.strip('.info') + '_rank_G_filter.txt'
                else:
                    myfilename = infoFile.strip('.info') + '_rank_G.txt'

                if allFlag:
                    WriteOutputFileRR(myfilename, df, iEner, fEner)

                else:
                    WriteOutputFileRR(myfilename, df.head(10), iEner, fEner)

                print('-----------------------------------------')
                print('The file was saved as:')
                print(myfilename)
                print('-----------------------------------------')
            except IOError:
                sys.stderr.write(
                    'ERROR: An unexpected error ocurrs. Data could not be saved.\n'
                )

    return 0
コード例 #5
0
def ChainRankFun(ListOpt):
    List = ListOpt.copy()
    List.pop(0)
    i = 0

    if '--wof' in List:
        wofFlag = True
        List.remove('--wof')
    else:
        wofFlag = False

    if '--all' in List:
        allFlag = True
        List.remove('--all')
    else:
        allFlag = False

    if '--peak' in List:
        addFlag = True
        List.remove('--peak')
        xId = -2
    else:
        addFlag = False
        xId = -1

    if len(List) == 0:
        sys.stderr.write("error: --Rank option needs an argument\n")
        return 0

    infoFile = List[0]
    if not os.path.isfile(infoFile):
        sys.stderr.write(
            "error: %s does not exist, are you in the right path?\n" %
            (infoFile))
        return 100
    if not infoFile.endswith('.info'):
        sys.stderr.write("error: %s needs a .info extension\n" % (infoFile))
        return 101
    infoDict = getDictFromInfoFile(infoFile)
    minRange = infoDict['Range']['start']
    maxRange = infoDict['Range']['end']
    del infoDict['Range']

    idxPairL = []
    for DictEle in infoDict.values():
        idxPairL.append([DictEle['start'], DictEle['end']])

    DBInfoL = []
    pathfile = os.path.realpath(__file__)

    if operatingSystem == 'Linux' or operatingSystem == 'Darwin':
        pathfile = pathfile.replace('/modules/chainRank.py', '')
    elif operatingSystem == 'Windows':
        pathfile = pathfile.replace('\\modules\\chainRank.py', '')

    conexion = OpenDatabase(pathfile)

    ChainDict = {}

    memoLenDict = {}
    isoPeakLL = []
    isoCountD = {}
    DBInfoL = []
    DBInfoDL = []
    tMinEL = []
    tMaxEL = []

    if True:
        for infoPair in infoDict.values():
            tMinEL.append(infoPair['start'])
            tMaxEL.append(infoPair['end'])
        tMinE = min(tMinEL)
        tMaxE = max(tMaxEL)
    else:
        tMinE = minRange
        tMaxE = maxRange

    for idxR in idxPairL:
        iEner = idxR[0]
        fEner = idxR[1]
        DBInfoL.append(GetIntensities(conexion, iEner, fEner))
        DBInfo = DBInfoL[-1]
        DBInfoD = {}
        for e in DBInfo:
            #Filling dict with isotope name each isotope has only one tupple
            DBInfoD[e[-1]] = e
        DBInfoDL.append(DBInfoD)
        isoPeakL = []
        for Ele in DBInfo:
            iso = Ele[-1]
            if [iso, 1, 0, 0] not in isoPeakL:
                isoPeakL.append([
                    iso, 1, 0, Ele[10]
                ])  #So that there is only one count of each isotope per peak
                if iso not in isoCountD:  #Considering the number of entries in the energy range of the histogram
                    if iso not in memoLenDict:
                        memoLenDict[iso] = len(
                            GetIntensities(conexion, tMinE, tMaxE, iso))
                    nInRange = memoLenDict[iso]
                    isoCountD[iso] = [0, nInRange, 0]
                isoCountD[iso][0] += 1

            MainChainIso, _ = GetChainAndChild(conexion, Ele[-1])
            if MainChainIso not in ChainDict and MainChainIso is not None:
                ChainDict[MainChainIso] = [
                    chaintoList(GetMainChain(conexion, MainChainIso)[0]),
                    [0, 0]
                ]

        isoPeakLL.append(isoPeakL)

    IgRDict = {}

    for DBInfo in DBInfoL:
        for Ele in DBInfo:
            iso = Ele[-1]
            if iso not in IgRDict:
                IgRDict[iso] = Ele[10]
            else:
                IgRDict[iso] += Ele[10]

    for isoLL in isoPeakLL:
        for isoL in isoLL:
            iso = isoL[0]
            isoC = isoCountD[iso][0]
            isoL[1] = isoC
            isoL[2] = isoC / isoCountD[iso][1]
            isoCountD[iso][2] += isoL[-1]
            isoL[3] = IgRDict[iso]

    for keyChain in ChainDict.keys():
        for chainList in ChainDict[keyChain][0]:
            try:
                ChainDict[keyChain][1][
                    0] += isoCountD[chainList][0] / isoCountD[chainList][1]
            except:
                continue

            try:
                ChainDict[keyChain][1][1] += IgRDict[chainList]
            except:
                continue

        ChainDict[keyChain][1][0] /= len(ChainDict[keyChain][0]) - 1
        ChainDict[keyChain][1][1] /= len(ChainDict[keyChain][0]) - 1

    Ranges = []
    chainRankIso = {}

    for ChainAnsestor in ChainDict:
        ChainList = ChainDict[ChainAnsestor]
        for ChainMember in ChainList[0]:
            if ChainMember not in chainRankIso:
                chainRankIso[ChainMember] = ChainList[1]

    for idxR, isoPeakL, DBInfoD in zip(idxPairL, isoPeakLL, DBInfoDL):
        iEner = idxR[0]
        fEner = idxR[1]
        Ranges.append([iEner, fEner])

        print(
            '\nThe energy range consulted is between %.2f keV and %.2f keV.\n'
            % (iEner, fEner))
        Eg , Ig , Decay, Half , Parent, rank, rank2,rank3, CR2, CR3 = [],[],[],[],[],[],[],[],[],[]
        for pInfo in isoPeakL:
            iso = pInfo[0]
            if iso not in chainRankIso:
                cr2, cr3 = [0, 0]
            else:
                cr2, cr3 = chainRankIso[iso]

            CR2.append(cr2)
            CR3.append(cr3)

            Ele = DBInfoD[iso]
            Eg.append(str(Ele[1]))  #+' ('+str(Ele[2])+')')
            Ig.append(round(Ele[3], 2))
            Decay.append(Ele[5])
            x = halfLifeUnit(Ele)
            if x == 0:
                y = str(x)
            else:
                y = str('{0:.2e}'.format(x))
            Half.append(y + ' [s] ')
            Parent.append(Ele[-1])
            rank.append(pInfo[1])
            rank2.append(round(pInfo[2], 3))
            rank3.append(round(pInfo[-1], 3))

            pd.set_option('display.max_rows', None)
            pd.options.display.float_format = '{:,.5f}'.format
            df = pd.DataFrame(sorted(list(
                zip(Eg, Ig, Decay, Half, Parent, rank, rank2, rank3, CR2,
                    CR3)),
                                     key=lambda x: (x[xId], x[1]),
                                     reverse=True),
                              columns=[
                                  'Eg [keV]', 'Ig (%)', 'Decay m', 'Half Life',
                                  'Parent', 'Rank C', 'Rank D', 'Rank E',
                                  'Rank I', 'Rank J'
                              ])  #crea  la tabla

        if allFlag:
            print(df)
        else:
            print(df.head(10))

        if wofFlag:
            try:
                if addFlag:
                    myfilename = infoFile.strip('.info') + '_rank_I.txt'
                else:
                    myfilename = infoFile.strip('.info') + '_rank_J.txt'
                if allFlag:
                    WriteOutputFileRR(myfilename, df, iEner, fEner)
                else:
                    WriteOutputFileRR(myfilename, df.head(10), iEner, fEner)

                print('-----------------------------------------')
                print('The file was saved as:')
                print(myfilename)
                print('-----------------------------------------')

            except IOError:
                sys.stderr.write(
                    'ERROR: An unexpected error ocurrs. Data could not be saved.\n'
                )
                break

    return 0
コード例 #6
0
ファイル: rank.py プロジェクト: ffavela/histoGe
def rankFun(ListOpt):
    List = ListOpt.copy()
    List.pop(0)
    i = 0  #for rank op
    rankOp = []

    if '--wof' in List:
        wofFlag = True
        List.remove('--wof')
    else:
        wofFlag = False

    if '--all' in List:
        allFlag = True
        List.remove('--all')
    else:
        allFlag = False

    if 'and' in List:
        addFlag = True
        List.remove('and')
    else:
        addFlag = False

    for Arg in List:
        try:
            rankOp.append(int(Arg))
            if rankOp[i] > 0 and rankOp[i] < 4:

                if type(rankOp[i]) == int:
                    i += 1

            #break
        except:
            rankOp.append(3)
            continue

    if len(List) == 0:
        print("error: --Rank option needs an argument")
        return 0

    infoFile = List[0]
    if not os.path.isfile(infoFile):
        print("error: %s does not exist, are you in the right path?" %
              (infoFile))
        return 100
    if not infoFile.endswith('.info'):
        print("error: %s needs a .info extension" % (infoFile))
        return 101
    infoDict = getDictFromInfoFile(infoFile)
    minRange = infoDict['Range']['start']
    maxRange = infoDict['Range']['end']
    del infoDict['Range']

    idxPairL = []
    for DictEle in infoDict.values():

        if addFlag:
            if rankOp[2] == 1:
                rankSort = 'Rank'

                idxPairL.append([DictEle['start'], DictEle['end']])

            elif rankOp[2] == 2:
                rankSort = 'Rank2'

                idxPairL.append([DictEle['start'], DictEle['end']])

            elif rankOp[2] == 3:
                rankSort = 'Rank3'

                idxPairL.append([DictEle['start'], DictEle['end']])

            else:
                idxPairL.append([DictEle['start'], DictEle['end']])
                print(
                    'theres n|o rank op {}, please try an option between 1 and 3'
                    .format(rankOp))
                break
        else:
            rankSort = 'Rank3'

            idxPairL.append([DictEle['start'], DictEle['end']])

    DBInfoL = []
    pathfile = os.path.realpath(__file__)
    pathfile = pathfile.rstrip('rank.py')
    conexion = OpenDatabase(pathfile)

    memoLenDict = {}
    isoPeakLL = []
    isoCountD = {}
    DBInfoL = []
    DBInfoDL = []
    #tMinE,tMaxE = infoDict['theList'][0],infoDict['theList'][-1]
    tMinEL = []
    tMaxEL = []

    if True:
        for infoPair in infoDict.values():
            tMinEL.append(infoPair['start'])
            tMaxEL.append(infoPair['end'])
        tMinE = min(tMinEL)
        tMaxE = max(tMaxEL)
    else:
        tMinE = minRange
        tMaxE = maxRange

    for idxR in idxPairL:
        iEner = idxR[0]
        fEner = idxR[1]
        #DBInfoL.append(EnergyRange(conexion,iEner,fEner))
        DBInfoL.append(GetIntensities(conexion, iEner, fEner))
        DBInfo = DBInfoL[-1]
        DBInfoD = {}
        for e in DBInfo:
            #Filling dict with isotope name each isotope has only one tupple
            DBInfoD[e[-1]] = e
        DBInfoDL.append(DBInfoD)
        isoPeakL = []
        for Ele in DBInfo:
            iso = Ele[-1]
            if [iso, 1, 0, 0] not in isoPeakL:
                isoPeakL.append([
                    iso, 1, 0, Ele[10]
                ])  #So that there is only one count of each isotope per peak
                if iso not in isoCountD:  #Considering the number of entries in the energy range of the histogram
                    if iso not in memoLenDict:
                        #memoLenDict[iso]=len(EnergyRange(conexion,tMinE,tMaxE,iso))
                        memoLenDict[iso] = len(
                            GetIntensities(conexion, tMinE, tMaxE, iso))
                    nInRange = memoLenDict[iso]
                    isoCountD[iso] = [0, nInRange, 0]
                isoCountD[iso][0] += 1
        isoPeakLL.append(isoPeakL)

    IgRDict = {}

    for DBInfo in DBInfoL:
        for Ele in DBInfo:
            iso = Ele[-1]
            if iso not in IgRDict:
                IgRDict[iso] = Ele[10]
            else:
                IgRDict[iso] += Ele[10]

    for isoLL in isoPeakLL:
        for isoL in isoLL:
            iso = isoL[0]
            isoC = isoCountD[iso][0]
            isoL[1] = isoC
            isoL[2] = isoC / isoCountD[iso][1]
            isoCountD[iso][2] += isoL[-1]
            isoL[3] = IgRDict[iso]

        if addFlag:
            isoLL.sort(key=lambda x: x[rankOp[1]],
                       reverse=True)  # Main Sort of RANK HGE
        else:
            if i:
                isoLL.sort(key=lambda x: x[rankOp[1]],
                           reverse=True)  # Main Sort of RANK HGE
            else:
                isoLL.sort(key=lambda x: x[rankOp[0]],
                           reverse=True)  # Main Sort of RANK HGE

    Ranges = []
    for idxR, isoPeakL, DBInfoD in zip(idxPairL, isoPeakLL, DBInfoDL):
        iEner = idxR[0]
        fEner = idxR[1]
        Ranges.append([iEner, fEner])

        print(
            '\nThe energy range consulted is between %.2f keV and %.2f keV.\n'
            % (iEner, fEner))
        Eg , Ig , Decay, Half , Parent, rank, rank2,rank3 = [],[],[],[],[],[],[],[]
        for pInfo in isoPeakL:
            iso = pInfo[0]
            Ele = DBInfoD[iso]
            Eg.append(str(Ele[1]) + ' (' + str(Ele[2]) + ')')
            Ig.append(round(Ele[3],
                            2))  #+' ('+str(Ele[4])+')') #Normalized Intensity
            Decay.append(Ele[5])
            #Half.append(str(Ele[6])+' '+Ele[7]+' ('+str(Ele[8])+')')
            x = halfLifeUnit(Ele)
            if x == 0:
                y = str(x)
            else:
                y = str('{0:.2e}'.format(x))
            Half.append(
                y + ' [s] '
            )  # + str(Ele[6]) +' ' +str(Ele[7]) + ' ('+str(Ele[8])+')')
            Parent.append(Ele[-1])
            rank.append(pInfo[1])
            rank2.append(round(pInfo[2], 3))
            rank3.append(round(pInfo[-1], 3))

        if allFlag:
            pd.set_option('display.max_rows', None)  #imprime todas las filas
            pd.options.display.float_format = '{:,.5f}'.format
            df = pd.DataFrame(list(
                zip(Eg, Ig, Decay, Half, Parent, rank, rank2, rank3)),
                              columns=[
                                  'Eg [keV]', 'Ig (%)', 'Decay m', 'Half Life',
                                  'Parent', 'Rank', 'Rank2', 'Rank3'
                              ])  #crea  la tabla
            if addFlag:
                print(df.sort_values(by=[rankSort], ascending=False))
            else:
                print(df)  #.sort_values(by=['Rank2'], ascending=False))
        else:
            pd.set_option('display.max_rows', len(Ele))
            df = pd.DataFrame(
                list(zip(Eg, Ig, Decay, Half, Parent, rank, rank2, rank3)),
                columns=[
                    'Eg [keV]', 'Ig (%)', 'Decay mode', 'Half Life', 'Parent',
                    'Rank', 'Rank2', 'Rank3'
                ])  #crea  la tabla
            if addFlag:
                print(df.head(10).sort_values(
                    by=[rankSort],
                    ascending=False))  #print('\nOnly the first 10')
            else:
                print(
                    df.head(10)
                )  #.sort_values(by=[rankSort], ascending=False)) #print('\nOnly the first 10')

        if wofFlag:
            try:
                if rankOp[1] == 1:
                    myfilename = infoFile.strip('.info') + '_rank_B.txt'

                elif rankOp[1] == 2:
                    myfilename = infoFile.strip('.info') + '_rank_C.txt'

                elif rankOp[1] == 3:
                    myfilename = infoFile.strip('.info') + '_rank_D.txt'

                else:
                    myfilename = infoFile.strip('.info') + '_rank_D.txt'

                if allFlag:
                    if addFlag:
                        WriteOutputFileRR(
                            myfilename,
                            df.sort_values(by=[rankSort], ascending=False),
                            iEner, fEner)
                    else:
                        WriteOutputFileRR(myfilename, df, iEner, fEner)
                else:
                    if addFlag:
                        WriteOutputFileRR(
                            myfilename,
                            df.head(10).sort_values(by=[rankSort],
                                                    ascending=False), iEner,
                            fEner)
                    else:
                        WriteOutputFileRR(myfilename, df.head(10), iEner,
                                          fEner)

                print('-----------------------------------------')
                print('The file was saved as:')
                print(myfilename)
                print('-----------------------------------------')

            except IOError:
                print(
                    'ERROR: An unexpected error ocurrs. Data could not be saved.'
                )
                break

    return 0
コード例 #7
0
ファイル: energy.py プロジェクト: ffavela/histoGe
def energyFun(ListOpt):
    List = ListOpt.copy()
    List.pop(0)

    if '--wof' in List:
        wofFlag = True
        List.remove('--wof')
    else:
        wofFlag = False

    if '--all' in List:
        allFlag = True
        List.remove('--all')
    else:
        allFlag = False

    if len(List) == 0:
        print("error: --energyRanges option needs an argument")
        return 0

    infoFile = List[0]
    if not os.path.isfile(infoFile):
        print("error: %s does not exist, are you in the right path?" %
              (infoFile))
        return False
    if not infoFile.endswith('.info'):
        print("error: %s needs a .info extension" % (infoFile))
        return False
    infoDict = getDictFromInfoFile(infoFile)
    del infoDict['Range']
    idxPairL = []
    for DictEle in infoDict.values():
        idxPairL.append([DictEle['start'], DictEle['end']])
    #Energy range of the histogram

    DBInfoL = []
    pathfile = os.path.realpath(__file__)
    pathfile = pathfile.strip('energy.py')
    conexion = OpenDatabase(pathfile)
    for idxR in idxPairL:
        iEner = idxR[0]
        fEner = idxR[1]
        DBInfoL.append(EnergyRange(conexion, iEner, fEner))
        DBInfo = DBInfoL[-1]

        print(
            '\nThe energy range consulted is between %.2f keV and %.2f keV.\n'
            % (iEner, fEner))
        Eg, Ig, Decay, Half, Parent = [], [], [], [], []
        for Ele in DBInfo:
            Eg.append(str(Ele[1]) + ' (' + str(Ele[2]) + ')')
            Ig.append(str(Ele[3]) + ' (' + str(Ele[4]) + ')')
            Decay.append(Ele[5])
            Half.append(halfLifeUnit(Ele))
            Parent.append(Ele[10])

        if allFlag:
            pd.set_option('display.max_rows', None)
        else:
            pd.set_option('display.max_rows', len(Ele))

        df = pd.DataFrame(list(zip(Eg, Ig, Decay, Half, Parent)),
                          columns=[
                              'Eg [keV]', 'Ig (%)', 'Decay mode',
                              'Half Life (s)', 'Parent'
                          ])
        if allFlag:
            print(df)
        else:
            print(df.head(10))

        if wofFlag:
            try:
                myfilename = infoFile.strip('.info') + '_energyRanges.txt'
                WriteOutputFileRR(myfilename, df, iEner, fEner)
                print('-----------------------------------------')
                print('The file was saved as:')
                print(myfilename)
                print('-----------------------------------------')
            except IOError:
                print(
                    'ERROR: An unexpected error ocurrs. Data could not be saved.'
                )

    CloseDatabase(conexion)
    return 0
コード例 #8
0
def rankImp(ListOpt):
    List = ListOpt.copy()
    List.pop(0)
    i = 0  #for rank op
    rankOp = []
    rankOp2 = [None, None, None]
    if '--wof' in List:
        wofFlag = True
        List.remove('--wof')
    else:
        wofFlag = False

    if '--all' in List:
        allFlag = True
        List.remove('--all')
    else:
        allFlag = False

    for Arg in List:
        try:
            #if int(Arg) > 0 and int(Arg) < 4:
            if Arg == 'D':
                #rankOp.append(int(Arg))
                rankOp.append(1)

            elif Arg == 'E':
                #rankOp.append(int(Arg))
                rankOp.append(2)

            elif Arg == 'F':
                #rankOp.append(int(Arg))
                rankOp.append(3)
            else:
                continue
        except:
            if len(List) <= 1:
                rankOp.append(3)
            continue

    if len(rankOp) == 0:
        rankOp.append(3)
        rankOp.append(2)
        rankOp.append(1)
    elif len(rankOp) == 1:
        if rankOp[0] == 3:
            rankOp.append(2)
            rankOp.append(1)
        elif rankOp[0] == 2:
            rankOp.append(3)
            rankOp.append(1)
        elif rankOp[0] == 1:
            rankOp.append(3)
            rankOp.append(2)

    rankOp = removeDuplicates(rankOp)
    rankOp2 = [x - 4 for x in rankOp]
    rankOp2.append(1)

    if len(List) == 0:
        sys.stderr.write("error: --rank option needs an argument")
        return 0

    infoFile = List[0]
    if not os.path.isfile(infoFile):
        sys.stderr.write(
            "error: %s does not exist, are you in the right path?" %
            (infoFile))
        return 10000
    if not infoFile.endswith('.info'):
        sys.stderr.write("error: %s needs a .info extension" % (infoFile))
        return 10001
    infoDict = getDictFromInfoFile(infoFile)

    try:
        minRange = infoDict['Range']['start']
        maxRange = infoDict['Range']['end']
        del infoDict['Range']
    except:
        minRange, maxRange = findRangeInfoDict(infoDict)

    idxPairL = []
    for DictEle in infoDict.values():
        idxPairL.append([DictEle['start'], DictEle['end']])

    DBInfoL = []
    pathfile = os.path.realpath(__file__)
    if operatingSystem == 'Linux' or operatingSystem == 'Darwin':
        pathfile = pathfile.replace('/modules/rank_imp.py', '')
    elif operatingSystem == 'Windows':
        pathfile = pathfile.replace('\\modules\\rank_imp.py', '')

    conexion = OpenDatabase(pathfile)

    memoLenDict = {}

    isoCountD = {}
    DBInfoL = []
    DBInfoDL = []
    tMinEL = []
    tMaxEL = []

    if True:
        for infoPair in infoDict.values():
            tMinEL.append(infoPair['start'])
            tMaxEL.append(infoPair['end'])
        tMinE = min(tMinEL)
        tMaxE = max(tMaxEL)
    else:
        tMinE = minRange
        tMaxE = maxRange

    PeakNum = -1
    for idxR in idxPairL:
        PeakNum += 1
        iEner = idxR[0]
        fEner = idxR[1]
        DBInfoL.append(GetIntensities(conexion, iEner, fEner))
        DBInfo = DBInfoL[-1]
        DBInfoD = {}
        for e in DBInfo:
            if e[-1] not in DBInfoD:
                DBInfoD[e[-1]] = [e]
            else:
                DBInfoD[e[-1]].append(e)
        DBInfoDL.append(DBInfoD)

        for Ele in DBInfo:
            iso = Ele[-1]
            if iso not in memoLenDict:
                memoLenDict[iso] = [
                    len(GetIntensities(conexion, tMinE, tMaxE, iso)), 1,
                    Ele[10], [PeakNum]
                ]

                isoCountD[iso] = [Ele]
            else:
                memoLenDict[iso][1] += 1
                memoLenDict[iso][2] += Ele[10]
                memoLenDict[iso][3].append(PeakNum)
                isoCountD[iso].append(Ele)

    memoLenDictKeys = memoLenDict.copy().keys()
    for Ele in memoLenDictKeys:
        if memoLenDict[Ele][0] == 0 or memoLenDict[Ele][2] == 0:
            del memoLenDict[Ele]
            del isoCountD[Ele]
            for DBInfoD in DBInfoDL:
                try:
                    del DBInfoD[Ele]
                except KeyError:
                    continue

    memoLenDictKeys = memoLenDict.keys()

    Ranges = []
    rankList = []

    try:
        if rankOp[0] == 1:
            myfilename = infoFile.strip('.info') + '_rank_D.txt'

        elif rankOp[0] == 2:
            myfilename = infoFile.strip('.info') + '_rank_E.txt'

        elif rankOp[0] == 3:
            myfilename = infoFile.strip('.info') + '_rank_F.txt'

        else:
            myfilename = infoFile.strip('.info') + '_rank_F.txt'
    except:
        myfilename = 'FileNameCouldNotBeRecovered.txt'

    for idxR, DBInfoD in zip(idxPairL, DBInfoDL):
        iEner = idxR[0]
        fEner = idxR[1]
        Ranges.append([iEner, fEner])
        Eg , Ig , Decay, Half , Parent, rank, rank2,rank3 = [],[],[],[],[],[],[],[]
        for Key in DBInfoD:
            for Ele in DBInfoD[Key]:
                Eg.append(Ele[1])
                Ig.append(round(Ele[3], 2))
                Decay.append(Ele[5])
                x = halfLifeUnit(Ele)
                if x == 0:
                    y = str(x)
                else:
                    y = str('{0:.2e}'.format(x))
                Half.append(y + ' [s] ')
                Parent.append(Ele[-1])
                rank.append(memoLenDict[Ele[-1]][1])
                rank2.append(
                    round(memoLenDict[Ele[-1]][1] / memoLenDict[Ele[-1]][0],
                          3))
                rank3.append(round(memoLenDict[Ele[-1]][2], 3))

        Eg, Ig, Decay, Half, Parent, rank, rank2, rank3 = (
            list(t) for t in zip(
                *sorted(zip(Eg, Ig, Decay, Half, Parent, rank, rank2, rank3),
                        key=itemgetter(*rankOp2),
                        reverse=True)))

        print(
            '\nThe energy range consulted is between %.2f keV and %.2f keV.\n'
            % (iEner, fEner))

        if allFlag:
            pd.set_option('display.max_rows', None)
            pd.options.display.float_format = '{:,.5f}'.format
            df = pd.DataFrame(list(
                zip(Eg, Ig, Decay, Half, Parent, rank, rank2, rank3)),
                              columns=[
                                  'Eg [keV]', 'Ig (%)', 'Decay m', 'Half Life',
                                  'Parent', 'Rank D', 'Rank E', 'Rank F'
                              ])  #crea  la tabla
            print(df)

        else:
            pd.set_option('display.max_rows', len(Ele))
            df = pd.DataFrame(
                list(zip(Eg, Ig, Decay, Half, Parent, rank, rank2, rank3)),
                columns=[
                    'Eg [keV]', 'Ig (%)', 'Decay mode', 'Half Life', 'Parent',
                    'Rank D', 'Rank E', 'Rank F'
                ])  #crea  la tabla
            print(df.head(10))

        if wofFlag:
            try:
                if allFlag:
                    WriteOutputFileRR(myfilename, df, iEner, fEner)

                else:
                    WriteOutputFileRR(myfilename, df.head(10), iEner, fEner)

            except IOError:
                sys.stderr.write(
                    'ERROR: An unexpected error ocurrs. Data could not be saved.'
                )
                break

    if wofFlag:
        print('-----------------------------------------')
        print('The file was saved as:')
        print(myfilename)
        print('-----------------------------------------')

    return 0
コード例 #9
0
def rankDist(ListOpt):
    List = ListOpt.copy()
    List.pop(0)  
    i = 0 #for rank op
    rankOp = []
    rankOp2 = [None,None,None]
    
    if '--noCal' in List:
        noCalFlag = True
        List.remove('--noCal')
    else:
        noCalFlag = False
    
    if '--wof' in List:
        wofFlag = True
        List.remove('--wof')
    else:
        wofFlag = False

    if '--all' in List:
        allFlag = True
        List.remove('--all')
    else:
        allFlag = False

    for Arg in List:
        try:
            if int(Arg) > 0 and int(Arg) < 4:
                rankOp.append(int(Arg))
            else:
                continue
        except:
            if len(List) <= 1:
                rankOp.append(3)
            continue
    
    if len(rankOp) == 0:
        rankOp.append(3)
        rankOp.append(2) 
    elif len(rankOp) == 1:
        if rankOp[0] == 3:
            rankOp.append(2)
        else:
            rankOp.append(3)

    rankOp = removeDuplicates(rankOp)    
    rankOp2 = [-1,-3,1]
    if len(List) == 0:
        sys.stderr.write("error: --rank option needs an argument\n")
        return 0

    for arg in List:
        if isValidSpecFile(arg):
            if arg.endswith('.info'):
                infoFile = arg
            else:
                FileName = arg
    
    try:
        if isValidSpecFile(FileName):
            FileExt = FileName.split('.')[-1]
    except:
        sys.stderr.write('ERROR: Unexpected error. Not a valid file used.\n')
        return 110

    if not os.path.isfile(infoFile):
        sys.stderr.write("error: %s does not exist, are you in the right path?\n" %(infoFile))
        return 10000
    if not infoFile.endswith('.info'):
        sys.stderr.write("error: %s needs a .info extension\n" % (infoFile))
        return 10001
    infoDict=getDictFromInfoFile(infoFile)
    
    if noCalFlag:
        FileDict = functionDictAdv[FileExt](FileName,False)
    else:
        FileDict = functionDictAdv[FileExt](FileName)

    try:
        minRange = infoDict['Range']['start']
        maxRange = infoDict['Range']['end']
        del infoDict['Range']
    except:
        minRange, maxRange = findRangeInfoDict(infoDict)
    
    idxPairL = []
    for DictEle in infoDict.values():
        idxPairL.append([DictEle['start'],DictEle['end']])

    DBInfoL = []
    pathfile = os.path.realpath(__file__)
    if operatingSystem == 'Linux' or operatingSystem == 'Darwin':
        pathfile = pathfile.replace('/modules/rank_dist.py','')
    elif operatingSystem == 'Windows':
        pathfile = pathfile.replace('\\modules\\rank_dist.py','')

    conexion = OpenDatabase(pathfile)

    memoLenDict={}

    isoCountD = {}
    DBInfoL = []
    DBInfoDL = []
    ProbDL = []
    DiffDL = []
    tMinEL = []
    tMaxEL = []
    ProbLL = []
    DiffLL = []
    if True:
        for infoPair in infoDict.values():
            tMinEL.append(infoPair['start'])
            tMaxEL.append(infoPair['end'])
        tMinE = min(tMinEL)
        tMaxE = max(tMaxEL)
    else:
        tMinE = minRange
        tMaxE = maxRange

    myDataList = FileDict['theList']
    
    fittingDict=doFittingStuff(infoDict,myDataList)
    fittingDictKeys = list(fittingDict.keys())

    PeakNum = -1
    IdxRemove=[]
    
    for idxR in idxPairL:
        PeakNum += 1
        iEner = idxR[0]
        fEner = idxR[1]
        DBInfo = GetIntensities(conexion,iEner,fEner)
        DiffL, ProbL = MeanDistance(DBInfo,fittingDict[fittingDictKeys[PeakNum]])
        if DiffL == None or ProbL == None:
            continue
        else:
            IdxRemove.append(PeakNum)
            DBInfoL.append(DBInfo)
            DiffLL.append(DiffL)
            ProbLL.append(ProbL)
            DBInfoD = {}
            ProbD= {}
            DiffD = {}
            for e,fs,gs in zip(DBInfo,DiffL,ProbL): 
                if e[-1] not in DBInfoD:
                    DBInfoD[e[-1]] = [e]
                    ProbD[gs[0]] = [gs]
                    DiffD[fs[0]] = [fs]
                else:
                    DBInfoD[e[-1]].append(e)
                    ProbD[gs[0]].append(gs)
                    DiffD[fs[0]].append(fs)
            DBInfoDL.append(DBInfoD)   
            ProbDL.append(ProbD)
            DiffDL.append(DiffD)

            for Ele in DBInfo:
                iso = Ele[-1]
                if iso not in memoLenDict:
                    memoLenDict[iso]=[len(GetIntensities(conexion,tMinE,tMaxE,iso)),1,Ele[10],[PeakNum]]
                    isoCountD[iso] = [Ele]
                else:
                    memoLenDict[iso][1] += 1 
                    memoLenDict[iso][2] += Ele[10]
                    memoLenDict[iso][3].append(PeakNum)
                    isoCountD[iso].append(Ele)
    
    idxPairL=list(map(idxPairL.__getitem__,IdxRemove))
    memoLenDictKeys = memoLenDict.copy().keys()
    for Ele in memoLenDictKeys:
        if memoLenDict[Ele][0] == 0 or memoLenDict[Ele][2] == 0:
            del memoLenDict[Ele]
            del isoCountD[Ele]
            for DBInfoD in DBInfoDL:
                try:
                    del DBInfoD[Ele]
                except KeyError:
                    continue

    memoLenDictKeys = memoLenDict.keys()

    Ranges = []
    rankList = []

    try:
        if rankOp[0] == 1:
            myfilename = infoFile.strip('.info') + '_rank_B.txt'
        
        elif rankOp[0] == 2:
            myfilename = infoFile.strip('.info') + '_rank_C.txt'
        
        elif rankOp[0] == 3:
            myfilename = infoFile.strip('.info') + '_rank_A.txt'

        else:
            myfilename = infoFile.strip('.info') + '_rank_A.txt'
    except:
        myfilename = 'FileNameCouldNotBeRecovered.txt'

    for idxR,DBInfoD,DiffD,ProbD in zip(idxPairL,DBInfoDL,DiffDL,ProbDL):
        iEner = idxR[0]
        fEner = idxR[1]
        Ranges.append([iEner,fEner])
        Eg , Ig , Decay, Half , Parent, rank, rank2, rank3, ProbRank, DiffRank  = [],[],[],[],[],[],[],[],[],[]
        for Key in DBInfoD:
            #Ele = DBInfoD[Key]
            for Ele,DiffEle,ProbEle in zip(DBInfoD[Key],DiffD[Key],ProbD[Key]):
                Eg.append(Ele[1])
                Ig.append(round(Ele[3],2))
                Decay.append(Ele[5])
                x=halfLifeUnit(Ele)
                if x == 0:
                    y = str(x)
                else:
                    y = str('{0:.2e}'.format(x))
                Half.append(y+ ' [s] ')
                Parent.append(Ele[-1])
                rank.append(memoLenDict[Ele[-1]][1])
                rank2.append(round(memoLenDict[Ele[-1]][1]/memoLenDict[Ele[-1]][0],3))
                rank3.append(round(memoLenDict[Ele[-1]][2],3))
                ProbRank.append(ProbEle[1])
                DiffRank.append(DiffEle[1])

        print('\nThe energy range consulted is between %.2f keV and %.2f keV.\n' % (iEner,fEner))
        
        if allFlag:
            pd.set_option('display.max_rows', None) #imprime todas las filas
            pd.options.display.float_format = '{:,.5f}'.format
            df = pd.DataFrame(list(zip(Eg,Ig,Decay,Half,Parent,rank3,ProbRank,DiffRank)),columns=['Eg [keV]','Ig (%)','Decay m','Half Life','Parent','Rank F','Probability','Distance'])#crea  la tabla
            df = df.sort_values(by=['Distance','Rank F','Ig (%)'],ascending=[True,False,False],ignore_index=True)
            print(df)
            
        else:
            pd.set_option('display.max_rows', len(Ele))
            df = pd.DataFrame(list(zip(Eg,Ig,Decay,Half,Parent,rank3,ProbRank,DiffRank)),columns=['Eg [keV]','Ig (%)','Decay mode','Half Life','Parent','Rank F','Probability','Distance'])#crea  la tabla
            df = df.sort_values(by=['Distance','Rank F','Ig (%)'],ascending=[True,False,False],ignore_index=True)
            print(df.head(n=10))
            
        if wofFlag:
            try:
                if allFlag:
                    WriteOutputFileRR(myfilename,df,iEner,fEner)
                    
                else:
                    WriteOutputFileRR(myfilename,df.head(10),iEner,fEner)    
            
            except IOError:
                sys.stderr.write('ERROR: An unexpected error ocurrs. Data could not be saved.\n')
                break
    
    if wofFlag:
        print('-----------------------------------------')
        print('The file was saved as:')
        print(myfilename)
        print('-----------------------------------------')  

    return 0
コード例 #10
0
def ChainRankFun(ListOpt):
    List = ListOpt.copy()
    List.pop(0)
    i = 0  #for rank op
    #rankOp = []

    if '--wof' in List:
        wofFlag = True
        List.remove('--wof')
    else:
        wofFlag = False

    if '--all' in List:
        allFlag = True
        List.remove('--all')
    else:
        allFlag = False

    if '--peak' in List:
        addFlag = True
        List.remove('--peak')
        xId = -2
    else:
        addFlag = False
        xId = -1

    # for Arg in List:
    #     try:
    #         rankOp.append(int(Arg))
    #         if rankOp[i] > 0 and rankOp[i] < 4:

    #             if type(rankOp[i]) == int:
    #                 i += 1

    #         #break
    #     except:
    #         rankOp.append(3)
    #         continue

    if len(List) == 0:
        print("error: --Rank option needs an argument")
        return 0

    infoFile = List[0]
    if not os.path.isfile(infoFile):
        print("error: %s does not exist, are you in the right path?" %
              (infoFile))
        return 100
    if not infoFile.endswith('.info'):
        print("error: %s needs a .info extension" % (infoFile))
        return 101
    infoDict = getDictFromInfoFile(infoFile)
    minRange = infoDict['Range']['start']
    maxRange = infoDict['Range']['end']
    del infoDict['Range']

    idxPairL = []
    for DictEle in infoDict.values():

        # if addFlag :
        #     if rankOp[2] == 1:
        #         rankSort = 'Rank'

        #         idxPairL.append([DictEle['start'],DictEle['end']])

        #     elif rankOp[2] == 2:
        #         rankSort = 'Rank2'

        #         idxPairL.append([DictEle['start'],DictEle['end']])

        #     elif rankOp[2] == 3:
        #         rankSort = 'Rank3'

        #         idxPairL.append([DictEle['start'],DictEle['end']])

        #     else:
        #         idxPairL.append([DictEle['start'],DictEle['end']])
        #         print('theres n|o rank op {}, please try an option between 1 and 3'.format(rankOp))
        #         break
        # else:
        #     rankSort = 'Rank3'

        idxPairL.append([DictEle['start'], DictEle['end']])

    DBInfoL = []
    pathfile = os.path.realpath(__file__)
    pathfile = pathfile.rstrip('chainRank.py')
    conexion = OpenDatabase(pathfile)

    ChainDict = {}

    memoLenDict = {}
    isoPeakLL = []
    isoCountD = {}
    DBInfoL = []
    DBInfoDL = []
    #tMinE,tMaxE = infoDict['theList'][0],infoDict['theList'][-1]
    tMinEL = []
    tMaxEL = []

    if True:
        for infoPair in infoDict.values():
            tMinEL.append(infoPair['start'])
            tMaxEL.append(infoPair['end'])
        tMinE = min(tMinEL)
        tMaxE = max(tMaxEL)
    else:
        tMinE = minRange
        tMaxE = maxRange

    for idxR in idxPairL:
        iEner = idxR[0]
        fEner = idxR[1]
        #DBInfoL.append(EnergyRange(conexion,iEner,fEner))
        DBInfoL.append(GetIntensities(conexion, iEner, fEner))
        DBInfo = DBInfoL[-1]
        DBInfoD = {}
        for e in DBInfo:
            #Filling dict with isotope name each isotope has only one tupple
            DBInfoD[e[-1]] = e
        DBInfoDL.append(DBInfoD)
        isoPeakL = []
        for Ele in DBInfo:
            iso = Ele[-1]
            if [iso, 1, 0, 0] not in isoPeakL:
                isoPeakL.append([
                    iso, 1, 0, Ele[10]
                ])  #So that there is only one count of each isotope per peak
                if iso not in isoCountD:  #Considering the number of entries in the energy range of the histogram
                    if iso not in memoLenDict:
                        #memoLenDict[iso]=len(EnergyRange(conexion,tMinE,tMaxE,iso))
                        memoLenDict[iso] = len(
                            GetIntensities(conexion, tMinE, tMaxE, iso))
                    nInRange = memoLenDict[iso]
                    isoCountD[iso] = [0, nInRange, 0]
                isoCountD[iso][0] += 1

            MainChainIso, _ = GetChainAndChild(conexion, Ele[-1])
            if MainChainIso not in ChainDict and MainChainIso is not None:
                ChainDict[MainChainIso] = [
                    chaintoList(GetMainChain(conexion, MainChainIso)[0]),
                    [0, 0]
                ]

        isoPeakLL.append(isoPeakL)

    IgRDict = {}

    for DBInfo in DBInfoL:
        for Ele in DBInfo:
            iso = Ele[-1]
            if iso not in IgRDict:
                IgRDict[iso] = Ele[10]
            else:
                IgRDict[iso] += Ele[10]

    for isoLL in isoPeakLL:
        for isoL in isoLL:
            iso = isoL[0]
            isoC = isoCountD[iso][0]
            isoL[1] = isoC
            isoL[2] = isoC / isoCountD[iso][1]
            isoCountD[iso][2] += isoL[-1]
            isoL[3] = IgRDict[iso]

    for keyChain in ChainDict.keys():
        for chainList in ChainDict[keyChain][0]:
            try:
                ChainDict[keyChain][1][
                    0] += isoCountD[chainList][0] / isoCountD[chainList][1]
            except:
                continue

            try:
                ChainDict[keyChain][1][1] += IgRDict[chainList]
            except:
                continue

        ChainDict[keyChain][1][0] /= len(ChainDict[keyChain][0]) - 1
        ChainDict[keyChain][1][1] /= len(ChainDict[keyChain][0]) - 1

        # if addFlag:
        #     isoLL.sort(key = lambda x: x[rankOp[1]],reverse = True) # Main Sort of RANK HGE
        # else:
        #     if i:
        #         isoLL.sort(key = lambda x: x[rankOp[1]],reverse = True) # Main Sort of RANK HGE
        #     else:
        #         isoLL.sort(key = lambda x: x[rankOp[0]],reverse = True) # Main Sort of RANK HGE

    Ranges = []
    chainRankIso = {}

    for ChainAnsestor in ChainDict:
        ChainList = ChainDict[ChainAnsestor]
        for ChainMember in ChainList[0]:
            if ChainMember not in chainRankIso:
                chainRankIso[ChainMember] = ChainList[1]

    for idxR, isoPeakL, DBInfoD in zip(idxPairL, isoPeakLL, DBInfoDL):
        iEner = idxR[0]
        fEner = idxR[1]
        Ranges.append([iEner, fEner])

        print(
            '\nThe energy range consulted is between %.2f keV and %.2f keV.\n'
            % (iEner, fEner))
        Eg , Ig , Decay, Half , Parent, rank, rank2,rank3, CR2, CR3 = [],[],[],[],[],[],[],[],[],[]
        for pInfo in isoPeakL:
            iso = pInfo[0]
            if iso not in chainRankIso:
                cr2, cr3 = [0, 0]
            else:
                cr2, cr3 = chainRankIso[iso]

            CR2.append(cr2)
            CR3.append(cr3)

            Ele = DBInfoD[iso]
            Eg.append(str(Ele[1]) + ' (' + str(Ele[2]) + ')')
            Ig.append(round(Ele[3],
                            2))  #+' ('+str(Ele[4])+')') #Normalized Intensity
            Decay.append(Ele[5])
            #Half.append(str(Ele[6])+' '+Ele[7]+' ('+str(Ele[8])+')')
            x = halfLifeUnit(Ele)
            if x == 0:
                y = str(x)
            else:
                y = str('{0:.2e}'.format(x))
            Half.append(
                y + ' [s] '
            )  # + str(Ele[6]) +' ' +str(Ele[7]) + ' ('+str(Ele[8])+')')
            Parent.append(Ele[-1])
            rank.append(pInfo[1])
            rank2.append(round(pInfo[2], 3))
            rank3.append(round(pInfo[-1], 3))

            pd.set_option('display.max_rows', None)  #imprime todas las filas
            pd.options.display.float_format = '{:,.5f}'.format
            df = pd.DataFrame(sorted(list(
                zip(Eg, Ig, Decay, Half, Parent, rank, rank2, rank3, CR2,
                    CR3)),
                                     key=lambda x: x[xId],
                                     reverse=True),
                              columns=[
                                  'Eg [keV]', 'Ig (%)', 'Decay m', 'Half Life',
                                  'Parent', 'Rank', 'Rank2', 'Rank3', 'CR2',
                                  'CR3'
                              ])  #crea  la tabla

        if allFlag:
            print(df)
        else:
            print(df.head(10))

        if wofFlag:
            try:
                if addFlag:
                    myfilename = infoFile.strip(
                        '.info') + '_Rank_Hdecay_Chain.txt'
                else:
                    myfilename = infoFile.strip(
                        '.info') + '_Rank_Gdecay_Chain.txt'
                if allFlag:
                    WriteOutputFileRR(myfilename, df, iEner, fEner)
                else:
                    WriteOutputFileRR(myfilename, df.head(10), iEner, fEner)

                print('-----------------------------------------')
                print('The file was saved as:')
                print(myfilename)
                print('-----------------------------------------')

            except IOError:
                print(
                    'ERROR: An unexpected error ocurrs. Data could not be saved.'
                )
                break

    return 0


# def ChainRankFun(ListOpt):
#     List = ListOpt.copy()
#     List.pop(0)

#     if '--wof' in List:
#         wofFlag = True
#         List.remove('--wof')
#     else:
#         wofFlag = False

#     if '--all' in List:
#         allFlag = True
#         List.remove('--all')
#     else:
#         allFlag = False

#     if len(List) == 0:
#         print("error: --chainRank option needs an argument")
#         return 3500

#     infoFile=List[0]
#     if not os.path.isfile(infoFile):
#         print("error: %s does not exist, are you in the right path?" %(infoFile))
#         return 3501
#     if not infoFile.endswith('.info'):
#         print("error: %s needs a .info extension" % (infoFile))
#         return 3502

#     infoDict=getDictFromInfoFile(infoFile)
#     minRange = infoDict['Range']['start']
#     maxRange = infoDict['Range']['end']
#     #del infoDict['Range']

#     pathfile = os.path.realpath(__file__)
#     pathfile = pathfile.strip('chainRank.py')
#     conexion = OpenDatabase(pathfile)

#     ChainDict = {}

#     memoLenDict={}
#     isoPeakLL = []
#     isoCountD = {}
#     DBInfoL = []
#     DBInfoDL = []
#     #tMinE,tMaxE = infoDict['theList'][0],infoDict['theList'][-1]
#     tMinEL = []
#     tMaxEL = []
#     idxPairL = []

#     for DictEle in infoDict.values():
#         idxPairL.append([DictEle['start'],DictEle['end']])

#     if True:
#         for infoPair in infoDict.values():
#             tMinEL.append(infoPair['start'])
#             tMaxEL.append(infoPair['end'])
#         tMinE = min(tMinEL)
#         tMaxE = max(tMaxEL)
#     else:
#         tMinE = minRange
#         tMaxE = maxRange

#     for idxR in idxPairL:
#         iEner = idxR[0]
#         fEner = idxR[1]
#         #DBInfoL.append(EnergyRange(conexion,iEner,fEner))
#         DBInfoL.append(GetIntensities(conexion,iEner,fEner))
#         DBInfo = DBInfoL[-1]
#         DBInfoD = {}
#         for e in DBInfo:
#             #Filling dict with isotope name each isotope has only one tupple
#             DBInfoD[e[-1]] = e
#         DBInfoDL.append(DBInfoD)
#         isoPeakL = []
#         for Ele in DBInfo:
#             MainChainIso, _ = GetChainAndChild(conexion,Ele[-1])
#             if MainChainIso not in ChainDict and MainChainIso is not None:
#                 ChainDict[MainChainIso] = [chaintoList(GetMainChain(conexion,MainChainIso)[0]),0]

#             pass

#         #     iso = Ele[-1]
#         #     if [iso,1,0,0] not in isoPeakL:
#         #         isoPeakL.append([iso,1,0,Ele[10]]) #So that there is only one count of each isotope per peak
#         #         if iso not in isoCountD: #Considering the number of entries in the energy range of the histogram
#         #             if iso not in memoLenDict:
#         #                 #memoLenDict[iso]=len(EnergyRange(conexion,tMinE,tMaxE,iso))
#         #                 memoLenDict[iso]=len(GetIntensities(conexion,tMinE,tMaxE,iso))
#         #             nInRange=memoLenDict[iso]
#         #             isoCountD[iso] = [0,nInRange,0]
#         #         isoCountD[iso][0] += 1
#         # isoPeakLL.append(isoPeakL)

#     # for Isotope in List:
#     #     MainChainIso,Child = GetChainAndChild(conexion,Isotope)
#     #     if MainChainIso == None or Child == None:

#     #         print('Isotope: ' + Isotope + ' -- Parent: ' + 'None' + ' --Child: ' + 'None' +  '\n')
#     #         print('There is not enough information in the database or the isotope ' + Isotope + ' do not have Child or parents isotopes. \n')

#     #     else:

#     #         MainChain = GetMainChain(conexion,MainChainIso)
#     #         if '+' in MainChain:
#     #             AuxStr = MainChain.split('+')[1]
#     #             Parentiso = AuxStr.split('#')[0]
#     #         else:
#     #             Parentiso = MainChain[0].split('#')[0]

#     #         print('Isotope: ' + Isotope + ' -- Parent: ' + Parentiso + ' --Child: ' + Child + '\n')

#     CloseDatabase(conexion)
#     return 0