Ejemplo n.º 1
0
    def findoffBB(self, t, plane, MADTwiss, betalist):

        print "METHOD => Starting to calculate off-momentum beta-beat"

        self.bpms = intersect(t)
        self.bpms = modelIntersect(self.bpms, MADTwiss)
        MADTwiss.chrombeat()

        self.slope = {}
        self.slopeE = {}
        self.slopeM = {}

        dpplist = []

        for i in range(len(betalist)):  #### for sorting

            dpplist.append(betalist[i]['DPP'])

        dpplist.sort()

        #if dpplist[0]>dpplist[1]
        #dpplist.reverse()

        for i in range(len(self.bpms)):

            bn = upper(self.bpms[i][1])
            check = 0
            slopei = 0.0
            slopeiM = 0.0
            beta = []
            k = 0

            for k in range(len(dpplist)):
                count = 0
                for j in range(len(betalist)):

                    if dpplist[k] == betalist[j]['DPP']:

                        if count == 0:

                            beta.append(betalist[j][bn][0])
                        count = 1

            [slope, offset, R, slope_error,
             offset_error] = linreg.linreg(dpplist, beta)

            a = FIT(dpplist, beta, 1, 1e-15)
            #print ' list '+str(dpplist)
            coef, error = a.linreg()

            if plane == 'H':
                slopeiM = MADTwiss.dbx[MADTwiss.indx[upper(bn)]]
            else:
                slopeiM = MADTwiss.dby[MADTwiss.indx[upper(bn)]]

            #self.slope[bn]=coef[0]
            self.slope[bn] = coef[0] / 100
            #self.slopeE[bn]=error[0]
            self.slopeE[bn] = error[0] / 100
            self.slopeM[bn] = slopeiM
Ejemplo n.º 2
0
    def findoffPhase(self, t, plane, MADTwiss, phaselist):

        print "METHOD => Start calculating off-momentum phase"

        # t is collection of twiss files
        dpplist = []
        for i in range(len(phaselist)):  #### for sorting

            dpplist.append(phaselist[i]['DPP'])
        dpplist.sort()

        if len(t) < 2:
            print " Not enough files \n ... I cannot work like this! => sys.exit()"
            sys.exit()

        self.bpms = intersect(t)
        self.bpms = modelIntersect(self.bpms, MADTwiss)

        self.slope = {}
        self.slopeE = {}
        self.slopeM = {}

        print "The lenght of the bpms " + str(len(self.bpms))

        for i in range(len(self.bpms)):
            print i
            if i == len(self.bpms) - 1:
                bn = upper(self.bpms[i][1])
                print bn
                print "hereeeeeee"
                bn2 = upper(self.bpms[0][1])
            else:
                bn = upper(self.bpms[i][1])
                bn2 = upper(self.bpms[i + 1][1])

            phase = []

            if plane == 'H':
                slopeMp = MADTwiss.DMUX[MADTwiss.indx[bn2]] - MADTwiss.DMUX[
                    MADTwiss.indx[bn]]
            else:
                slopeMp = MADTwiss.DMUY[MADTwiss.indx[bn2]] - MADTwiss.DMUY[
                    MADTwiss.indx[bn]]

            for k in range(len(dpplist)):
                count = 0
                for j in range(len(phaselist)):

                    if dpplist[k] == phaselist[j]['DPP']:

                        if count == 0:

                            phase.append(phaselist[j][bn][0])

                        count = 1

            a = FIT(dpplist, phase, 1, 1e-15)
            coef, error = a.linreg()

            self.slope[bn] = coef[0]
            self.slopeE[bn] = error[0]
            self.slopeM[bn] = slopeMp
    def findoffPhase(self,t,plane,MADTwiss,phaselist):

        print "METHOD => Start calculating off-momentum phase"

        # t is collection of twiss files
        dpplist=[]
        for i in range(len(phaselist)): #### for sorting

            dpplist.append(phaselist[i]['DPP'])
        dpplist.sort()

        if len(t)<2:
            print " Not enough files \n ... I cannot work like this! => sys.exit()"
            sys.exit()

        self.bpms=intersect(t)
        self.bpms=modelIntersect(self.bpms, MADTwiss)
         
        self.slope={}
        self.slopeE={}
        self.slopeM={}

        print "The lenght of the bpms "+str(len(self.bpms))

        for i in range(len(self.bpms)):
            print i
            if i==len(self.bpms)-1:
                bn=upper(self.bpms[i][1])
                print bn
                print "hereeeeeee"
                bn2=upper(self.bpms[0][1])
            else:
                bn=upper(self.bpms[i][1])
                bn2=upper(self.bpms[i+1][1])
                
            phase=[]

            if plane=='H':
                slopeMp=MADTwiss.DMUX[MADTwiss.indx[bn2]]-MADTwiss.DMUX[MADTwiss.indx[bn]]	
            else:
                slopeMp=MADTwiss.DMUY[MADTwiss.indx[bn2]]-MADTwiss.DMUY[MADTwiss.indx[bn]]
       

            for k in range(len(dpplist)):
                count=0
                for j in range(len(phaselist)):

                    if dpplist[k]==phaselist[j]['DPP']:

                        if count==0:
                       
                            phase.append(phaselist[j][bn][0])
                            
                        count=1
                        
            a=FIT(dpplist,phase,1,1e-15)
            coef,error=a.linreg()

            self.slope[bn]=coef[0]
            self.slopeE[bn]=error[0]
            self.slopeM[bn]=slopeMp
    def findoffBB(self,t,plane,MADTwiss,betalist):

        print "METHOD => Starting to calculate off-momentum beta-beat"

        
	self.bpms=intersect(t)
	self.bpms=modelIntersect(self.bpms, MADTwiss)
	MADTwiss.chrombeat()

	self.slope={}
        self.slopeE={}
	self.slopeM={}

        dpplist=[]

        for i in range(len(betalist)): #### for sorting

            dpplist.append(betalist[i]['DPP'])

        
        dpplist.sort()
        
        #if dpplist[0]>dpplist[1]
        #dpplist.reverse()

        
	for i in range(len(self.bpms)):
            
            bn=upper(self.bpms[i][1])
            check=0
            slopei=0.0
            slopeiM=0.0
            beta=[]
            k=0
            

            for k in range(len(dpplist)):
                count=0
                for j in range(len(betalist)):
                    
                    if dpplist[k]==betalist[j]['DPP']:

                        if count==0:
                        
                            beta.append(betalist[j][bn][0])
                        count=1
                        
          
                  
            [slope, offset, R, slope_error, offset_error]=linreg.linreg(dpplist,beta)
           
            a=FIT(dpplist,beta,1,1e-15)
            #print ' list '+str(dpplist)
            coef,error=a.linreg()             
			
            if plane=='H':
                slopeiM=MADTwiss.dbx[MADTwiss.indx[upper(bn)]]
            else:
                slopeiM=MADTwiss.dby[MADTwiss.indx[upper(bn)]]
	
            #self.slope[bn]=coef[0]
            self.slope[bn]=coef[0]/100
            #self.slopeE[bn]=error[0]
            self.slopeE[bn]=error[0]/100
            self.slopeM[bn]=slopeiM