Exemplo n.º 1
0
 def calcRapRperi(self, *args, **kwargs):
     """
     NAME:
        calcRapRperi
     PURPOSE:
        calculate the apocenter and pericenter radii
     INPUT:
        Either:
           a) R,vR,vT,z,vz
           b) Orbit instance: initial condition used if that's it, orbit(t)
              if there is a time given as well
     OUTPUT:
        (rperi,rap)
     HISTORY:
        2013-11-27 - Written - Bovy (IAS)
     """
     #Set up the actionAngleAxi object
     if isinstance(self._pot, list):
         thispot = [
             p.toPlanar() for p in self._pot
             if not isinstance(p, planarPotential)
         ]
         thispot.extend(
             [p for p in self._pot if isinstance(p, planarPotential)])
     elif not isinstance(self._pot, planarPotential):
         thispot = self._pot.toPlanar()
     else:
         thispot = self._pot
     aAAxi = actionAngleAxi(*args, pot=thispot, gamma=self._gamma)
     return aAAxi.calcRapRperi(**kwargs)
Exemplo n.º 2
0
 def calczmax(self,*args,**kwargs):
     """
     NAME:
        calczmax
     PURPOSE:
        calculate the maximum height
     INPUT:
        Either:
           a) R,vR,vT,z,vz
           b) Orbit instance: initial condition used if that's it, orbit(t)
              if there is a time given as well
     OUTPUT:
        zmax
     HISTORY:
        2012-06-01 - Written - Bovy (IAS)
     """
     #Set up the actionAngleAxi object
     self._parse_eval_args(*args)
     if isinstance(self._pot,list):
         thispot= [p.toPlanar() for p in self._pot]
     else:
         thispot= self._pot.toPlanar()
     if isinstance(self._pot,list):
         thisverticalpot= [p.toVertical(self._eval_R) for p in self._pot]
     else:
         thisverticalpot= self._pot.toVertical(self._eval_R)
     aAAxi= actionAngleAxi(*args,pot=thispot,
                            verticalPot=thisverticalpot,
                            gamma=self._gamma)
     return aAAxi.calczmax(**kwargs)
Exemplo n.º 3
0
 def calczmax(self,*args,**kwargs): #pragma: no cover
     """
     NAME:
        calczmax
     PURPOSE:
        calculate the maximum height
     INPUT:
        Either:
           a) R,vR,vT,z,vz
           b) Orbit instance: initial condition used if that's it, orbit(t)
              if there is a time given as well
     OUTPUT:
        zmax
     HISTORY:
        2012-06-01 - Written - Bovy (IAS)
     """
     warnings.warn("actionAngleAdiabatic.calczmax function will soon be deprecated; please contact galpy's maintainer if you require this function")
     #Set up the actionAngleAxi object
     self._parse_eval_args(*args)
     if isinstance(self._pot,list):
         thispot= [p.toPlanar() for p in self._pot]
     else:
         thispot= self._pot.toPlanar()
     if isinstance(self._pot,list):
         thisverticalpot= [p.toVertical(self._eval_R) for p in self._pot]
     else:
         thisverticalpot= self._pot.toVertical(self._eval_R)
     aAAxi= actionAngleAxi(*args,pot=thispot,
                            verticalPot=thisverticalpot,
                            gamma=self._gamma)
     return aAAxi.calczmax(**kwargs)
Exemplo n.º 4
0
 def calcRapRperi(self,*args,**kwargs):
     """
     NAME:
        calcRapRperi
     PURPOSE:
        calculate the apocenter and pericenter radii
     INPUT:
        Either:
           a) R,vR,vT,z,vz
           b) Orbit instance: initial condition used if that's it, orbit(t)
              if there is a time given as well
     OUTPUT:
        (rperi,rap)
     HISTORY:
        2013-11-27 - Written - Bovy (IAS)
     """
     #Set up the actionAngleAxi object
     if isinstance(self._pot,list):
         thispot= [p.toPlanar() for p in self._pot if not isinstance(p,planarPotential)]
         thispot.extend([p for p in self._pot if isinstance(p,planarPotential)])
     elif not isinstance(self._pot,planarPotential):
         thispot= self._pot.toPlanar()
     else:
         thispot= self._pot
     aAAxi= actionAngleAxi(*args,pot=thispot,
                            gamma=self._gamma)
     return aAAxi.calcRapRperi(**kwargs)
Exemplo n.º 5
0
 def calczmax(self, *args, **kwargs):  #pragma: no cover
     """
     NAME:
        calczmax
     PURPOSE:
        calculate the maximum height
     INPUT:
        Either:
           a) R,vR,vT,z,vz
           b) Orbit instance: initial condition used if that's it, orbit(t)
              if there is a time given as well
     OUTPUT:
        zmax
     HISTORY:
        2012-06-01 - Written - Bovy (IAS)
     """
     warnings.warn(
         "actionAngleAdiabatic.calczmax function will soon be deprecated; please contact galpy's maintainer if you require this function"
     )
     #Set up the actionAngleAxi object
     self._parse_eval_args(*args)
     if isinstance(self._pot, list):
         thispot = [p.toPlanar() for p in self._pot]
     else:
         thispot = self._pot.toPlanar()
     if isinstance(self._pot, list):
         thisverticalpot = [p.toVertical(self._eval_R) for p in self._pot]
     else:
         thisverticalpot = self._pot.toVertical(self._eval_R)
     aAAxi = actionAngleAxi(*args,
                            pot=thispot,
                            verticalPot=thisverticalpot,
                            gamma=self._gamma)
     return aAAxi.calczmax(**kwargs)
Exemplo n.º 6
0
 def calczmax(self, *args, **kwargs):
     """
     NAME:
        calczmax
     PURPOSE:
        calculate the maximum height
     INPUT:
        Either:
           a) R,vR,vT,z,vz
           b) Orbit instance: initial condition used if that's it, orbit(t)
              if there is a time given as well
     OUTPUT:
        zmax
     HISTORY:
        2012-06-01 - Written - Bovy (IAS)
     """
     #Set up the actionAngleAxi object
     self._parse_eval_args(*args)
     if isinstance(self._pot, list):
         thispot = [p.toPlanar() for p in self._pot]
     else:
         thispot = self._pot.toPlanar()
     if isinstance(self._pot, list):
         thisverticalpot = [p.toVertical(self._eval_R) for p in self._pot]
     else:
         thisverticalpot = self._pot.toVertical(self._eval_R)
     aAAxi = actionAngleAxi(*args,
                            pot=thispot,
                            verticalPot=thisverticalpot,
                            gamma=self._gamma)
     return aAAxi.calczmax(**kwargs)
Exemplo n.º 7
0
 def _EccZmaxRperiRap(self, *args, **kwargs):
     """
     NAME:
        EccZmaxRperiRap (_EccZmaxRperiRap)
     PURPOSE:
        evaluate the eccentricity, maximum height above the plane, peri- and apocenter for a spherical potential
     INPUT:
        Either:
           a) R,vR,vT,z,vz[,phi]:
              1) floats: phase-space value for single object (phi is optional) (each can be a Quantity)
              2) numpy.ndarray: [N] phase-space values for N objects (each can be a Quantity)
           b) Orbit instance: initial condition used if that's it, orbit(t) if there is a time given as well as the second argument
     OUTPUT:
        (e,zmax,rperi,rap)
     HISTORY:
        2017-12-22 - Written - Bovy (UofT)
     """
     if len(args) == 5:  #R,vR.vT, z, vz
         R, vR, vT, z, vz = args
     elif len(args) == 6:  #R,vR.vT, z, vz, phi
         R, vR, vT, z, vz, phi = args
     else:
         self._parse_eval_args(*args)
         R = self._eval_R
         vR = self._eval_vR
         vT = self._eval_vT
         z = self._eval_z
         vz = self._eval_vz
     if isinstance(R, float):
         R = nu.array([R])
         vR = nu.array([vR])
         vT = nu.array([vT])
         z = nu.array([z])
         vz = nu.array([vz])
     if self._c:  #pragma: no cover
         pass
     else:
         Lz = R * vT
         Lx = -z * vT
         Ly = z * vR - R * vz
         L2 = Lx * Lx + Ly * Ly + Lz * Lz
         L = nu.sqrt(L2)
         #Set up an actionAngleAxi object for EL and rap/rperi calculations
         axiR = nu.sqrt(R**2. + z**2.)
         axivT = L / axiR
         axivR = (R * vR + z * vz) / axiR
         rperi, rap = [], []
         for ii in range(len(axiR)):
             axiaA = actionAngleAxi(axiR[ii],
                                    axivR[ii],
                                    axivT[ii],
                                    pot=self._2dpot)
             trperi, trap = axiaA.calcRapRperi()
             rperi.append(trperi)
             rap.append(trap)
         rperi = nu.array(rperi)
         rap = nu.array(rap)
         return ((rap - rperi) / (rap + rperi),
                 rap * nu.sqrt(1. - Lz**2. / L2), rperi, rap)
Exemplo n.º 8
0
 def _EccZmaxRperiRap(self,*args,**kwargs):
     """
     NAME:
        EccZmaxRperiRap (_EccZmaxRperiRap)
     PURPOSE:
        evaluate the eccentricity, maximum height above the plane, peri- and apocenter for a spherical potential
     INPUT:
        Either:
           a) R,vR,vT,z,vz[,phi]:
              1) floats: phase-space value for single object (phi is optional) (each can be a Quantity)
              2) numpy.ndarray: [N] phase-space values for N objects (each can be a Quantity)
           b) Orbit instance: initial condition used if that's it, orbit(t) if there is a time given as well as the second argument
     OUTPUT:
        (e,zmax,rperi,rap)
     HISTORY:
        2017-12-22 - Written - Bovy (UofT)
     """
     if len(args) == 5: #R,vR.vT, z, vz
         R,vR,vT, z, vz= args
     elif len(args) == 6: #R,vR.vT, z, vz, phi
         R,vR,vT, z, vz, phi= args
     else:
         self._parse_eval_args(*args)
         R= self._eval_R
         vR= self._eval_vR
         vT= self._eval_vT
         z= self._eval_z
         vz= self._eval_vz
     if isinstance(R,float):
         R= nu.array([R])
         vR= nu.array([vR])
         vT= nu.array([vT])
         z= nu.array([z])
         vz= nu.array([vz])
     if self._c: #pragma: no cover
         pass
     else:
         Lz= R*vT
         Lx= -z*vT
         Ly= z*vR-R*vz
         L2= Lx*Lx+Ly*Ly+Lz*Lz
         L= nu.sqrt(L2)
         #Set up an actionAngleAxi object for EL and rap/rperi calculations
         axiR= nu.sqrt(R**2.+z**2.)
         axivT= L/axiR
         axivR= (R*vR+z*vz)/axiR
         rperi, rap= [], []
         for ii in range(len(axiR)):
             axiaA= actionAngleAxi(axiR[ii],axivR[ii],axivT[ii],
                                   pot=self._2dpot)
             trperi,trap= axiaA.calcRapRperi()
             rperi.append(trperi)
             rap.append(trap)
         rperi= nu.array(rperi)
         rap= nu.array(rap)
         return ((rap-rperi)/(rap+rperi),rap*nu.sqrt(1.-Lz**2./L2),
                 rperi,rap)
Exemplo n.º 9
0
 def _evaluate(self,*args,**kwargs):
     """
     NAME:
        _evaluate
     PURPOSE:
        evaluate the actions (jr,lz,jz)
     INPUT:
        Either:
           a) R,vR,vT,z,vz
           b) Orbit instance: initial condition used if that's it, orbit(t)
              if there is a time given as well
        scipy.integrate.quadrature keywords
        _justjr, _justjz= if True, only calculate the radial or vertical action (internal use)
     OUTPUT:
        (jr,lz,jz), where jr=[jr,jrerr], and jz=[jz,jzerr]
     HISTORY:
        2012-07-26 - Written - Bovy (IAS@MPIA)
     """
     if ((self._c and not ('c' in kwargs and not kwargs['c']))\
             or (ext_loaded and (('c' in kwargs and kwargs['c'])))) \
             and _check_c(self._pot):
         if len(args) == 5: #R,vR.vT, z, vz
             R,vR,vT, z, vz= args
         elif len(args) == 6: #R,vR.vT, z, vz, phi
             R,vR,vT, z, vz, phi= args
         else:
             self._parse_eval_args(*args)
             R= self._eval_R
             vR= self._eval_vR
             vT= self._eval_vT
             z= self._eval_z
             vz= self._eval_vz
         if isinstance(R,float):
             R= nu.array([R])
             vR= nu.array([vR])
             vT= nu.array([vT])
             z= nu.array([z])
             vz= nu.array([vz])
         Lz= R*vT
         jr, jz, err= actionAngleAdiabatic_c.actionAngleAdiabatic_c(\
             self._pot,self._gamma,R,vR,vT,z,vz)
         if err == 0:
             return (jr,Lz,jz)
         else: #pragma: no cover
             raise RuntimeError("C-code for calculation actions failed; try with c=False")
     else:
         if 'c' in kwargs and kwargs['c'] and not self._c:
             warnings.warn("C module not used because potential does not have a C implementation",galpyWarning) #pragma: no cover
         kwargs.pop('c',None)
         if (len(args) == 5 or len(args) == 6) \
                 and isinstance(args[0],nu.ndarray):
             ojr= nu.zeros((len(args[0])))
             olz= nu.zeros((len(args[0])))
             ojz= nu.zeros((len(args[0])))
             for ii in range(len(args[0])):
                 if len(args) == 5:
                     targs= (args[0][ii],args[1][ii],args[2][ii],
                             args[3][ii],args[4][ii])
                 elif len(args) == 6:
                     targs= (args[0][ii],args[1][ii],args[2][ii],
                             args[3][ii],args[4][ii],args[5][ii])
                 tjr,tlz,tjz= self(*targs,**copy.copy(kwargs))
                 ojr[ii]= tjr
                 ojz[ii]= tjz
                 olz[ii]= tlz
             return (ojr,olz,ojz)
         else:
             #Set up the actionAngleAxi object
             self._parse_eval_args(*args)
             if isinstance(self._pot,list):
                 thispot= [p.toPlanar() for p in self._pot]
             else:
                 thispot= self._pot.toPlanar()
             if isinstance(self._pot,list):
                 thisverticalpot= [p.toVertical(self._eval_R) for p in self._pot]
             else:
                 thisverticalpot= self._pot.toVertical(self._eval_R)
             aAAxi= actionAngleAxi(*args,pot=thispot,
                                    verticalPot=thisverticalpot,
                                    gamma=self._gamma)
             if kwargs.get('_justjr',False):
                 kwargs.pop('_justjr')
                 return (aAAxi.JR(**kwargs),nu.nan,nu.nan)
             elif kwargs.get('_justjz',False):
                 kwargs.pop('_justjz')
                 return (nu.nan,nu.nan,aAAxi.Jz(**kwargs))
             else:
                 return (aAAxi.JR(**kwargs),aAAxi._R*aAAxi._vT,aAAxi.Jz(**kwargs))
Exemplo n.º 10
0
 def __call__(self, *args, **kwargs):
     """
     NAME:
        __call__
     PURPOSE:
        evaluate the actions (jr,lz,jz)
     INPUT:
        Either:
           a) R,vR,vT,z,vz
           b) Orbit instance: initial condition used if that's it, orbit(t)
              if there is a time given as well
        fixed_quad= (False) if True, use n=10 fixed_quad integration
        scipy.integrate.quadrature keywords
     OUTPUT:
        (jr,lz,jz)
     HISTORY:
        2013-12-28 - Written - Bovy (IAS)
     """
     fixed_quad = kwargs.pop('fixed_quad', False)
     if len(args) == 5:  #R,vR.vT, z, vz
         R, vR, vT, z, vz = args
     elif len(args) == 6:  #R,vR.vT, z, vz, phi
         R, vR, vT, z, vz, phi = args
     else:
         meta = actionAngle(*args)
         R = meta._R
         vR = meta._vR
         vT = meta._vT
         z = meta._z
         vz = meta._vz
     if isinstance(R, float):
         R = nu.array([R])
         vR = nu.array([vR])
         vT = nu.array([vT])
         z = nu.array([z])
         vz = nu.array([vz])
     if self._c:  #pragma: no cover
         pass
     else:
         Lz = R * vT
         Lx = -z * vT
         Ly = z * vR - R * vz
         L2 = Lx * Lx + Ly * Ly + Lz * Lz
         E = evaluatePotentials(
             R, z, self._pot) + vR**2. / 2. + vT**2. / 2. + vz**2. / 2.
         L = nu.sqrt(L2)
         #Actions
         Jphi = Lz
         Jz = L - nu.fabs(Lz)
         #Jr requires some more work
         #Set up an actionAngleAxi object for EL and rap/rperi calculations
         axiR = nu.sqrt(R**2. + z**2.)
         axivT = L / axiR
         axivR = (R * vR + z * vz) / axiR
         Jr = []
         for ii in range(len(axiR)):
             axiaA = actionAngleAxi(axiR[ii],
                                    axivR[ii],
                                    axivT[ii],
                                    pot=self._2dpot)
             (rperi, rap) = axiaA.calcRapRperi()
             EL = axiaA.calcEL()
             E, L = EL
             Jr.append(self._calc_jr(rperi, rap, E, L, fixed_quad,
                                     **kwargs))
         return (nu.array(Jr), Jphi, Jz)
Exemplo n.º 11
0
 def actionsFreqsAngles(self, *args, **kwargs):
     """
     NAME:
        actionsFreqsAngles
     PURPOSE:
        evaluate the actions, frequencies, and angles
        (jr,lz,jz,Omegar,Omegaphi,Omegaz,ar,ap,az)
     INPUT:
        Either:
           a) R,vR,vT,z,vz
           b) Orbit instance: initial condition used if that's it, orbit(t)
              if there is a time given as well
        fixed_quad= (False) if True, use n=10 fixed_quad integration
        scipy.integrate.quadrature keywords
     OUTPUT:
         (jr,lz,jz,Omegar,Omegaphi,Omegaz,ar,aphi,az)
     HISTORY:
        2013-12-29 - Written - Bovy (IAS)
     """
     fixed_quad = kwargs.pop('fixed_quad', False)
     if len(args) == 5:  #R,vR.vT, z, vz pragma: no cover
         raise IOError("You need to provide phi when calculating angles")
     elif len(args) == 6:  #R,vR.vT, z, vz, phi
         R, vR, vT, z, vz, phi = args
     else:
         meta = actionAngle(*args)
         R = meta._R
         vR = meta._vR
         vT = meta._vT
         z = meta._z
         vz = meta._vz
         phi = meta._phi
     if isinstance(R, float):
         R = nu.array([R])
         vR = nu.array([vR])
         vT = nu.array([vT])
         z = nu.array([z])
         vz = nu.array([vz])
         phi = nu.array([phi])
     if self._c:  #pragma: no cover
         pass
     else:
         Lz = R * vT
         Lx = -z * vT
         Ly = z * vR - R * vz
         L2 = Lx * Lx + Ly * Ly + Lz * Lz
         E = evaluatePotentials(
             R, z, self._pot) + vR**2. / 2. + vT**2. / 2. + vz**2. / 2.
         L = nu.sqrt(L2)
         #Actions
         Jphi = Lz
         Jz = L - nu.fabs(Lz)
         #Jr requires some more work
         #Set up an actionAngleAxi object for EL and rap/rperi calculations
         axiR = nu.sqrt(R**2. + z**2.)
         axivT = L / axiR  #these are really spherical coords, called axi bc they go in actionAngleAxi
         axivR = (R * vR + z * vz) / axiR
         axivz = (z * vR - R * vz) / axiR
         Jr = []
         Or = []
         Op = []
         ar = []
         az = []
         #Calculate the longitude of the ascending node
         asc = self._calc_long_asc(z, R, axivz, phi, Lz, L)
         for ii in range(len(axiR)):
             axiaA = actionAngleAxi(axiR[ii],
                                    axivR[ii],
                                    axivT[ii],
                                    pot=self._2dpot)
             (rperi, rap) = axiaA.calcRapRperi()
             EL = axiaA.calcEL()
             E, L = EL
             Jr.append(self._calc_jr(rperi, rap, E, L, fixed_quad,
                                     **kwargs))
             #Radial period
             Rmean = m.exp((m.log(rperi) + m.log(rap)) / 2.)
             if Jr[-1] < 10.**-9.:  #Circular orbit
                 Or.append(epifreq(self._pot, axiR[ii]))
                 Op.append(omegac(self._pot, axiR[ii]))
             else:
                 Or.append(
                     self._calc_or(Rmean, rperi, rap, E, L, fixed_quad,
                                   **kwargs))
                 Op.append(
                     self._calc_op(Or[-1], Rmean, rperi, rap, E, L,
                                   fixed_quad, **kwargs))
             #Angles
             ar.append(
                 self._calc_angler(Or[-1], axiR[ii], Rmean, rperi, rap, E,
                                   L, axivR[ii], fixed_quad, **kwargs))
             az.append(
                 self._calc_anglez(Or[-1], Op[-1], ar[-1], z[ii], axiR[ii],
                                   Rmean, rperi, rap, E, L, Lz[ii],
                                   axivR[ii], axivz[ii], fixed_quad,
                                   **kwargs))
         Op = nu.array(Op)
         Oz = copy.copy(Op)
         Op[vT < 0.] *= -1.
         ap = copy.copy(asc)
         ar = nu.array(ar)
         az = nu.array(az)
         ap[vT < 0.] -= az[vT < 0.]
         ap[vT >= 0.] += az[vT >= 0.]
         ar = ar % (2. * nu.pi)
         ap = ap % (2. * nu.pi)
         az = az % (2. * nu.pi)
         return (nu.array(Jr), Jphi, Jz, nu.array(Or), Op, Oz, ar, ap, az)
Exemplo n.º 12
0
 def _EccZmaxRperiRap(self,*args,**kwargs):
     """
     NAME:
        EccZmaxRperiRap (_EccZmaxRperiRap)
     PURPOSE:
        evaluate the eccentricity, maximum height above the plane, peri- and apocenter in the adiabatic approximation
     INPUT:
        Either:
           a) R,vR,vT,z,vz[,phi]:
              1) floats: phase-space value for single object (phi is optional) (each can be a Quantity)
              2) numpy.ndarray: [N] phase-space values for N objects (each can be a Quantity)
           b) Orbit instance: initial condition used if that's it, orbit(t) if there is a time given as well as the second argument 
        c= (object-wide default, bool) True/False to override the object-wide setting for whether or not to use the C implementation
     OUTPUT:
        (e,zmax,rperi,rap)
     HISTORY:
        2017-12-21 - Written - Bovy (UofT)
     """
     if ((self._c and not ('c' in kwargs and not kwargs['c']))\
             or (ext_loaded and (('c' in kwargs and kwargs['c'])))) \
             and _check_c(self._pot):
         if len(args) == 5: #R,vR.vT, z, vz
             R,vR,vT, z, vz= args
         elif len(args) == 6: #R,vR.vT, z, vz, phi
             R,vR,vT, z, vz, phi= args
         else:
             self._parse_eval_args(*args)
             R= self._eval_R
             vR= self._eval_vR
             vT= self._eval_vT
             z= self._eval_z
             vz= self._eval_vz
         if isinstance(R,float):
             R= nu.array([R])
             vR= nu.array([vR])
             vT= nu.array([vT])
             z= nu.array([z])
             vz= nu.array([vz])
         rperi,Rap,zmax, err= actionAngleAdiabatic_c.actionAngleRperiRapZmaxAdiabatic_c(\
             self._pot,self._gamma,R,vR,vT,z,vz)
         if err == 0:
             rap= nu.sqrt(Rap**2.+zmax**2.)
             ecc= (rap-rperi)/(rap+rperi)
             return (ecc,zmax,rperi,rap)
         else: #pragma: no cover
             raise RuntimeError("C-code for calculation actions failed; try with c=False")
     else:
         if 'c' in kwargs and kwargs['c'] and not self._c:
             warnings.warn("C module not used because potential does not have a C implementation",galpyWarning) #pragma: no cover
         kwargs.pop('c',None)
         if (len(args) == 5 or len(args) == 6) \
                 and isinstance(args[0],nu.ndarray):
             oecc= nu.zeros((len(args[0])))
             orperi= nu.zeros((len(args[0])))
             orap= nu.zeros((len(args[0])))
             ozmax= nu.zeros((len(args[0])))
             for ii in range(len(args[0])):
                 if len(args) == 5:
                     targs= (args[0][ii],args[1][ii],args[2][ii],
                             args[3][ii],args[4][ii])
                 elif len(args) == 6:
                     targs= (args[0][ii],args[1][ii],args[2][ii],
                             args[3][ii],args[4][ii],args[5][ii])
                 tecc, tzmax, trperi,trap= self._EccZmaxRperiRap(\
                     *targs,**copy.copy(kwargs))
                 oecc[ii]= tecc
                 ozmax[ii]= tzmax
                 orperi[ii]= trperi
                 orap[ii]= trap
             return (oecc,ozmax,orperi,orap)
         else:
             #Set up the actionAngleAxi object
             self._parse_eval_args(*args)
             if isinstance(self._pot,list):
                 thispot= [p.toPlanar() for p in self._pot]
             else:
                 thispot= self._pot.toPlanar()
             if isinstance(self._pot,list):
                 thisverticalpot= [p.toVertical(self._eval_R) for p in self._pot]
             else:
                 thisverticalpot= self._pot.toVertical(self._eval_R)
             aAAxi= actionAngleAxi(*args,pot=thispot,
                                    verticalPot=thisverticalpot,
                                    gamma=self._gamma)
             rperi,Rap= aAAxi.calcRapRperi(**kwargs)
             zmax= aAAxi.calczmax(**kwargs)
             rap= nu.sqrt(Rap**2.+zmax**2.)
             return ((rap-rperi)/(rap+rperi),zmax,rperi,rap)
Exemplo n.º 13
0
 def _EccZmaxRperiRap(self, *args, **kwargs):
     """
     NAME:
        EccZmaxRperiRap (_EccZmaxRperiRap)
     PURPOSE:
        evaluate the eccentricity, maximum height above the plane, peri- and apocenter in the adiabatic approximation
     INPUT:
        Either:
           a) R,vR,vT,z,vz[,phi]:
              1) floats: phase-space value for single object (phi is optional) (each can be a Quantity)
              2) numpy.ndarray: [N] phase-space values for N objects (each can be a Quantity)
           b) Orbit instance: initial condition used if that's it, orbit(t) if there is a time given as well as the second argument 
        c= (object-wide default, bool) True/False to override the object-wide setting for whether or not to use the C implementation
     OUTPUT:
        (e,zmax,rperi,rap)
     HISTORY:
        2017-12-21 - Written - Bovy (UofT)
     """
     if ((self._c and not ('c' in kwargs and not kwargs['c']))\
             or (ext_loaded and (('c' in kwargs and kwargs['c'])))) \
             and _check_c(self._pot):
         if len(args) == 5:  #R,vR.vT, z, vz
             R, vR, vT, z, vz = args
         elif len(args) == 6:  #R,vR.vT, z, vz, phi
             R, vR, vT, z, vz, phi = args
         else:
             self._parse_eval_args(*args)
             R = self._eval_R
             vR = self._eval_vR
             vT = self._eval_vT
             z = self._eval_z
             vz = self._eval_vz
         if isinstance(R, float):
             R = nu.array([R])
             vR = nu.array([vR])
             vT = nu.array([vT])
             z = nu.array([z])
             vz = nu.array([vz])
         rperi,Rap,zmax, err= actionAngleAdiabatic_c.actionAngleRperiRapZmaxAdiabatic_c(\
             self._pot,self._gamma,R,vR,vT,z,vz)
         if err == 0:
             rap = nu.sqrt(Rap**2. + zmax**2.)
             ecc = (rap - rperi) / (rap + rperi)
             return (ecc, zmax, rperi, rap)
         else:  #pragma: no cover
             raise RuntimeError(
                 "C-code for calculation actions failed; try with c=False")
     else:
         if 'c' in kwargs and kwargs['c'] and not self._c:
             warnings.warn(
                 "C module not used because potential does not have a C implementation",
                 galpyWarning)  #pragma: no cover
         kwargs.pop('c', None)
         if (len(args) == 5 or len(args) == 6) \
                 and isinstance(args[0],nu.ndarray):
             oecc = nu.zeros((len(args[0])))
             orperi = nu.zeros((len(args[0])))
             orap = nu.zeros((len(args[0])))
             ozmax = nu.zeros((len(args[0])))
             for ii in range(len(args[0])):
                 if len(args) == 5:
                     targs = (args[0][ii], args[1][ii], args[2][ii],
                              args[3][ii], args[4][ii])
                 elif len(args) == 6:
                     targs = (args[0][ii], args[1][ii], args[2][ii],
                              args[3][ii], args[4][ii], args[5][ii])
                 tecc, tzmax, trperi,trap= self._EccZmaxRperiRap(\
                     *targs,**copy.copy(kwargs))
                 oecc[ii] = tecc
                 ozmax[ii] = tzmax
                 orperi[ii] = trperi
                 orap[ii] = trap
             return (oecc, ozmax, orperi, orap)
         else:
             #Set up the actionAngleAxi object
             self._parse_eval_args(*args)
             if isinstance(self._pot, list):
                 thispot = [p.toPlanar() for p in self._pot]
             else:
                 thispot = self._pot.toPlanar()
             if isinstance(self._pot, list):
                 thisverticalpot = [
                     p.toVertical(self._eval_R) for p in self._pot
                 ]
             else:
                 thisverticalpot = self._pot.toVertical(self._eval_R)
             aAAxi = actionAngleAxi(*args,
                                    pot=thispot,
                                    verticalPot=thisverticalpot,
                                    gamma=self._gamma)
             rperi, Rap = aAAxi.calcRapRperi(**kwargs)
             zmax = aAAxi.calczmax(**kwargs)
             rap = nu.sqrt(Rap**2. + zmax**2.)
             return ((rap - rperi) / (rap + rperi), zmax, rperi, rap)
Exemplo n.º 14
0
 def _evaluate(self,*args,**kwargs):
     """
     NAME:
        __call__ (_evaluate)
     PURPOSE:
        evaluate the actions (jr,lz,jz)
     INPUT:
        Either:
           a) R,vR,vT,z,vz[,phi]:
              1) floats: phase-space value for single object (phi is optional) (each can be a Quantity)
              2) numpy.ndarray: [N] phase-space values for N objects (each can be a Quantity)
           b) Orbit instance: initial condition used if that's it, orbit(t) if there is a time given as well as the second argument
        fixed_quad= (False) if True, use n=10 fixed_quad integration
        scipy.integrate.quadrature or .fixed_quad keywords
     OUTPUT:
        (jr,lz,jz)
     HISTORY:
        2013-12-28 - Written - Bovy (IAS)
     """
     fixed_quad= kwargs.pop('fixed_quad',False)
     if len(args) == 5: #R,vR.vT, z, vz
         R,vR,vT, z, vz= args
     elif len(args) == 6: #R,vR.vT, z, vz, phi
         R,vR,vT, z, vz, phi= args
     else:
         self._parse_eval_args(*args)
         R= self._eval_R
         vR= self._eval_vR
         vT= self._eval_vT
         z= self._eval_z
         vz= self._eval_vz
     if isinstance(R,float):
         R= nu.array([R])
         vR= nu.array([vR])
         vT= nu.array([vT])
         z= nu.array([z])
         vz= nu.array([vz])
     if self._c: #pragma: no cover
         pass
     else:
         Lz= R*vT
         Lx= -z*vT
         Ly= z*vR-R*vz
         L2= Lx*Lx+Ly*Ly+Lz*Lz
         E= _evaluatePotentials(self._pot,R,z)\
             +vR**2./2.+vT**2./2.+vz**2./2.
         L= nu.sqrt(L2)
         #Actions
         Jphi= Lz
         Jz= L-nu.fabs(Lz)
         #Jr requires some more work
         #Set up an actionAngleAxi object for EL and rap/rperi calculations
         axiR= nu.sqrt(R**2.+z**2.)
         axivT= L/axiR
         axivR= (R*vR+z*vz)/axiR
         Jr= []
         for ii in range(len(axiR)):
             axiaA= actionAngleAxi(axiR[ii],axivR[ii],axivT[ii],
                                   pot=self._2dpot)
             (rperi,rap)= axiaA.calcRapRperi()
             EL= axiaA.calcEL()
             E, L= EL
             Jr.append(self._calc_jr(rperi,rap,E,L,fixed_quad,**kwargs))
         return (nu.array(Jr),Jphi,Jz)
Exemplo n.º 15
0
 def _actionsFreqsAngles(self,*args,**kwargs):
     """
     NAME:
        actionsFreqsAngles (_actionsFreqsAngles)
     PURPOSE:
        evaluate the actions, frequencies, and angles
        (jr,lz,jz,Omegar,Omegaphi,Omegaz,ar,ap,az)
     INPUT:
        Either:
           a) R,vR,vT,z,vz[,phi]:
              1) floats: phase-space value for single object (phi is optional) (each can be a Quantity)
              2) numpy.ndarray: [N] phase-space values for N objects (each can be a Quantity)
           b) Orbit instance: initial condition used if that's it, orbit(t) if there is a time given as well as the second argument
        fixed_quad= (False) if True, use n=10 fixed_quad integration
        scipy.integrate.quadrature or .fixed_quad keywords
     OUTPUT:
         (jr,lz,jz,Omegar,Omegaphi,Omegaz,ar,aphi,az)
     HISTORY:
        2013-12-29 - Written - Bovy (IAS)
     """
     fixed_quad= kwargs.pop('fixed_quad',False)
     if len(args) == 5: #R,vR.vT, z, vz pragma: no cover
         raise IOError("You need to provide phi when calculating angles")
     elif len(args) == 6: #R,vR.vT, z, vz, phi
         R,vR,vT, z, vz, phi= args
     else:
         self._parse_eval_args(*args)
         R= self._eval_R
         vR= self._eval_vR
         vT= self._eval_vT
         z= self._eval_z
         vz= self._eval_vz
         phi= self._eval_phi
     if isinstance(R,float):
         R= nu.array([R])
         vR= nu.array([vR])
         vT= nu.array([vT])
         z= nu.array([z])
         vz= nu.array([vz])
         phi= nu.array([phi])
     if self._c: #pragma: no cover
         pass
     else:
         Lz= R*vT
         Lx= -z*vT
         Ly= z*vR-R*vz
         L2= Lx*Lx+Ly*Ly+Lz*Lz
         E= _evaluatePotentials(self._pot,R,z)+vR**2./2.+vT**2./2.+vz**2./2.
         L= nu.sqrt(L2)
         #Actions
         Jphi= Lz
         Jz= L-nu.fabs(Lz)
         #Jr requires some more work
         #Set up an actionAngleAxi object for EL and rap/rperi calculations
         axiR= nu.sqrt(R**2.+z**2.)
         axivT= L/axiR #these are really spherical coords, called axi bc they go in actionAngleAxi
         axivR= (R*vR+z*vz)/axiR
         axivz= (z*vR-R*vz)/axiR
         Jr= []
         Or= []
         Op= []
         ar= []
         az= []
         #Calculate the longitude of the ascending node
         asc= self._calc_long_asc(z,R,axivz,phi,Lz,L)
         for ii in range(len(axiR)):
             axiaA= actionAngleAxi(axiR[ii],axivR[ii],axivT[ii],
                                   pot=self._2dpot)
             (rperi,rap)= axiaA.calcRapRperi()
             EL= axiaA.calcEL()
             E, L= EL
             Jr.append(self._calc_jr(rperi,rap,E,L,fixed_quad,**kwargs))
             #Radial period
             Rmean= m.exp((m.log(rperi)+m.log(rap))/2.)
             if Jr[-1] < 10.**-9.: #Circular orbit
                 Or.append(epifreq(self._pot,axiR[ii],use_physical=False))
                 Op.append(omegac(self._pot,axiR[ii],use_physical=False))
             else:
                 Or.append(self._calc_or(Rmean,rperi,rap,E,L,fixed_quad,**kwargs))
                 Op.append(self._calc_op(Or[-1],Rmean,rperi,rap,E,L,fixed_quad,**kwargs))
             #Angles
             ar.append(self._calc_angler(Or[-1],axiR[ii],Rmean,rperi,rap,
                                         E,L,axivR[ii],fixed_quad,**kwargs))
             az.append(self._calc_anglez(Or[-1],Op[-1],ar[-1],
                                         z[ii],axiR[ii],
                                         Rmean,rperi,rap,E,L,Lz[ii],
                                         axivR[ii],axivz[ii],
                                         fixed_quad,**kwargs))
         Op= nu.array(Op)
         Oz= copy.copy(Op)
         Op[vT < 0.]*= -1.
         ap= copy.copy(asc)
         ar= nu.array(ar)
         az= nu.array(az)
         ap[vT < 0.]-= az[vT < 0.]
         ap[vT >= 0.]+= az[vT >= 0.]
         ar= ar % (2.*nu.pi)
         ap= ap % (2.*nu.pi)
         az= az % (2.*nu.pi)
         return (nu.array(Jr),Jphi,Jz,nu.array(Or),Op,Oz,
                 ar,ap,az)
Exemplo n.º 16
0
 def _actionsFreqs(self,*args,**kwargs):
     """
     NAME:
        actionsFreqs (_actionsFreqs)
     PURPOSE:
        evaluate the actions and frequencies (jr,lz,jz,Omegar,Omegaphi,Omegaz)
     INPUT:
        Either:
           a) R,vR,vT,z,vz[,phi]:
              1) floats: phase-space value for single object (phi is optional) (each can be a Quantity)
              2) numpy.ndarray: [N] phase-space values for N objects (each can be a Quantity)
           b) Orbit instance: initial condition used if that's it, orbit(t) if there is a time given as well as the second argument
        fixed_quad= (False) if True, use n=10 fixed_quad integration
        scipy.integrate.quadrature or .fixed_quad keywords
     OUTPUT:
         (jr,lz,jz,Omegar,Omegaphi,Omegaz)
     HISTORY:
        2013-12-28 - Written - Bovy (IAS)
     """
     fixed_quad= kwargs.pop('fixed_quad',False)
     if len(args) == 5: #R,vR.vT, z, vz
         R,vR,vT, z, vz= args
     elif len(args) == 6: #R,vR.vT, z, vz, phi
         R,vR,vT, z, vz, phi= args
     else:
         self._parse_eval_args(*args)
         R= self._eval_R
         vR= self._eval_vR
         vT= self._eval_vT
         z= self._eval_z
         vz= self._eval_vz
     if isinstance(R,float):
         R= nu.array([R])
         vR= nu.array([vR])
         vT= nu.array([vT])
         z= nu.array([z])
         vz= nu.array([vz])
     if self._c: #pragma: no cover
         pass
     else:
         Lz= R*vT
         Lx= -z*vT
         Ly= z*vR-R*vz
         L2= Lx*Lx+Ly*Ly+Lz*Lz
         E= _evaluatePotentials(self._pot,R,z)+vR**2./2.+vT**2./2.+vz**2./2.
         L= nu.sqrt(L2)
         #Actions
         Jphi= Lz
         Jz= L-nu.fabs(Lz)
         #Jr requires some more work
         #Set up an actionAngleAxi object for EL and rap/rperi calculations
         axiR= nu.sqrt(R**2.+z**2.)
         axivT= L/axiR
         axivR= (R*vR+z*vz)/axiR
         Jr= []
         Or= []
         Op= []
         for ii in range(len(axiR)):
             axiaA= actionAngleAxi(axiR[ii],axivR[ii],axivT[ii],
                                   pot=self._2dpot)
             (rperi,rap)= axiaA.calcRapRperi()
             EL= axiaA.calcEL()
             E, L= EL
             Jr.append(self._calc_jr(rperi,rap,E,L,fixed_quad,**kwargs))
             #Radial period
             if Jr[-1] < 10.**-9.: #Circular orbit
                 Or.append(epifreq(self._pot,axiR[ii],use_physical=False))
                 Op.append(omegac(self._pot,axiR[ii],use_physical=False))
                 continue
             Rmean= m.exp((m.log(rperi)+m.log(rap))/2.)
             Or.append(self._calc_or(Rmean,rperi,rap,E,L,fixed_quad,**kwargs))
             Op.append(self._calc_op(Or[-1],Rmean,rperi,rap,E,L,fixed_quad,**kwargs))
         Op= nu.array(Op)
         Oz= copy.copy(Op)
         Op[vT < 0.]*= -1.
         return (nu.array(Jr),Jphi,Jz,nu.array(Or),Op,Oz)
Exemplo n.º 17
0
 def _evaluate(self, *args, **kwargs):
     """
     NAME:
        _evaluate
     PURPOSE:
        evaluate the actions (jr,lz,jz)
     INPUT:
        Either:
           a) R,vR,vT,z,vz
           b) Orbit instance: initial condition used if that's it, orbit(t)
              if there is a time given as well
        scipy.integrate.quadrature keywords
        _justjr, _justjz= if True, only calculate the radial or vertical action (internal use)
     OUTPUT:
        (jr,lz,jz), where jr=[jr,jrerr], and jz=[jz,jzerr]
     HISTORY:
        2012-07-26 - Written - Bovy (IAS@MPIA)
     """
     if ((self._c and not ('c' in kwargs and not kwargs['c']))\
             or (ext_loaded and (('c' in kwargs and kwargs['c'])))) \
             and _check_c(self._pot):
         if len(args) == 5:  #R,vR.vT, z, vz
             R, vR, vT, z, vz = args
         elif len(args) == 6:  #R,vR.vT, z, vz, phi
             R, vR, vT, z, vz, phi = args
         else:
             self._parse_eval_args(*args)
             R = self._eval_R
             vR = self._eval_vR
             vT = self._eval_vT
             z = self._eval_z
             vz = self._eval_vz
         if isinstance(R, float):
             R = nu.array([R])
             vR = nu.array([vR])
             vT = nu.array([vT])
             z = nu.array([z])
             vz = nu.array([vz])
         Lz = R * vT
         jr, jz, err= actionAngleAdiabatic_c.actionAngleAdiabatic_c(\
             self._pot,self._gamma,R,vR,vT,z,vz)
         if err == 0:
             return (jr, Lz, jz)
         else:  #pragma: no cover
             raise RuntimeError(
                 "C-code for calculation actions failed; try with c=False")
     else:
         if 'c' in kwargs and kwargs['c'] and not self._c:
             warnings.warn(
                 "C module not used because potential does not have a C implementation",
                 galpyWarning)  #pragma: no cover
         kwargs.pop('c', None)
         if (len(args) == 5 or len(args) == 6) \
                 and isinstance(args[0],nu.ndarray):
             ojr = nu.zeros((len(args[0])))
             olz = nu.zeros((len(args[0])))
             ojz = nu.zeros((len(args[0])))
             for ii in range(len(args[0])):
                 if len(args) == 5:
                     targs = (args[0][ii], args[1][ii], args[2][ii],
                              args[3][ii], args[4][ii])
                 elif len(args) == 6:
                     targs = (args[0][ii], args[1][ii], args[2][ii],
                              args[3][ii], args[4][ii], args[5][ii])
                 tjr, tlz, tjz = self(*targs, **copy.copy(kwargs))
                 ojr[ii] = tjr
                 ojz[ii] = tjz
                 olz[ii] = tlz
             return (ojr, olz, ojz)
         else:
             #Set up the actionAngleAxi object
             self._parse_eval_args(*args)
             if isinstance(self._pot, list):
                 thispot = [p.toPlanar() for p in self._pot]
             else:
                 thispot = self._pot.toPlanar()
             if isinstance(self._pot, list):
                 thisverticalpot = [
                     p.toVertical(self._eval_R) for p in self._pot
                 ]
             else:
                 thisverticalpot = self._pot.toVertical(self._eval_R)
             aAAxi = actionAngleAxi(*args,
                                    pot=thispot,
                                    verticalPot=thisverticalpot,
                                    gamma=self._gamma)
             if kwargs.get('_justjr', False):
                 kwargs.pop('_justjr')
                 return (aAAxi.JR(**kwargs), nu.nan, nu.nan)
             elif kwargs.get('_justjz', False):
                 kwargs.pop('_justjz')
                 return (nu.nan, nu.nan, aAAxi.Jz(**kwargs))
             else:
                 return (aAAxi.JR(**kwargs), aAAxi._R * aAAxi._vT,
                         aAAxi.Jz(**kwargs))
Exemplo n.º 18
0
 def actionsFreqs(self, *args, **kwargs):
     """
     NAME:
        actionsFreqs
     PURPOSE:
        evaluate the actions and frequencies (jr,lz,jz,Omegar,Omegaphi,Omegaz)
     INPUT:
        Either:
           a) R,vR,vT,z,vz
           b) Orbit instance: initial condition used if that's it, orbit(t)
              if there is a time given as well
        fixed_quad= (False) if True, use n=10 fixed_quad integration
        scipy.integrate.quadrature keywords
     OUTPUT:
         (jr,lz,jz,Omegar,Omegaphi,Omegaz)
     HISTORY:
        2013-12-28 - Written - Bovy (IAS)
     """
     fixed_quad = kwargs.pop('fixed_quad', False)
     if len(args) == 5:  #R,vR.vT, z, vz
         R, vR, vT, z, vz = args
     elif len(args) == 6:  #R,vR.vT, z, vz, phi
         R, vR, vT, z, vz, phi = args
     else:
         meta = actionAngle(*args)
         R = meta._R
         vR = meta._vR
         vT = meta._vT
         z = meta._z
         vz = meta._vz
     if isinstance(R, float):
         R = nu.array([R])
         vR = nu.array([vR])
         vT = nu.array([vT])
         z = nu.array([z])
         vz = nu.array([vz])
     if self._c:  #pragma: no cover
         pass
     else:
         Lz = R * vT
         Lx = -z * vT
         Ly = z * vR - R * vz
         L2 = Lx * Lx + Ly * Ly + Lz * Lz
         E = evaluatePotentials(
             R, z, self._pot) + vR**2. / 2. + vT**2. / 2. + vz**2. / 2.
         L = nu.sqrt(L2)
         #Actions
         Jphi = Lz
         Jz = L - nu.fabs(Lz)
         #Jr requires some more work
         #Set up an actionAngleAxi object for EL and rap/rperi calculations
         axiR = nu.sqrt(R**2. + z**2.)
         axivT = L / axiR
         axivR = (R * vR + z * vz) / axiR
         Jr = []
         Or = []
         Op = []
         for ii in range(len(axiR)):
             axiaA = actionAngleAxi(axiR[ii],
                                    axivR[ii],
                                    axivT[ii],
                                    pot=self._2dpot)
             (rperi, rap) = axiaA.calcRapRperi()
             EL = axiaA.calcEL()
             E, L = EL
             Jr.append(self._calc_jr(rperi, rap, E, L, fixed_quad,
                                     **kwargs))
             #Radial period
             if Jr[-1] < 10.**-9.:  #Circular orbit
                 Or.append(epifreq(self._pot, axiR[ii]))
                 Op.append(omegac(self._pot, axiR[ii]))
                 continue
             Rmean = m.exp((m.log(rperi) + m.log(rap)) / 2.)
             Or.append(
                 self._calc_or(Rmean, rperi, rap, E, L, fixed_quad,
                               **kwargs))
             Op.append(
                 self._calc_op(Or[-1], Rmean, rperi, rap, E, L, fixed_quad,
                               **kwargs))
         Op = nu.array(Op)
         Oz = copy.copy(Op)
         Op[vT < 0.] *= -1.
         return (nu.array(Jr), Jphi, Jz, nu.array(Or), Op, Oz)