예제 #1
0
def main(argv):

	path = os.path.expanduser('~/Documents/data_old/OPD40cm/20130809/')
	airmasstables = ['G9348/timeairmass.dat', 'SA111773/timeairmass.dat', 'SA114750/timeairmass.dat']
	#airmasstables = ['SA114750/timeairmass.dat']
	targetRa = [21.8736111111111,19.6211111111111,22.6958333333333]
	targetDec = [2.38888888888889,0.183055555555556,1.21055555555556]
	
	sitelat =-25.3416666667
	sitelong = 3.21148148148
	#airmasstables = np.loadtxt(os.path.join(path,airmasstableslis),dtype='S',ndmin=1)
		
	T0 = 2456514.
	nightstart = 2456514.4
	nightend = 2456514.85

	timeStamp = np.linspace(nightstart,nightend,1e3)
	
	lstStamp = [_skysub.lst(time,sitelong) for time in timeStamp]

	ax = py.subplot(111)
	ylim = [0,0.5]
	
	color = ['b','r','g','y','c','m', 'k']
	
	for i in range(len(airmasstables)):
		data = np.loadtxt(os.path.join(path,airmasstables[i]),unpack=True,converters={0:datestr2JD})
		secz = np.array([_skysub.true_airmass(_skysub.secant_z(_skysub.altit(targetDec[i],lst - targetRa[i],sitelat)[0])) for lst in lstStamp])
		data[1] = np.array([_skysub.true_airmass(_skysub.secant_z(_skysub.altit(targetDec[i],_skysub.lst(time,sitelong) - targetRa[i],sitelat)[0])) for time in data[0]])

		mm = np.bitwise_and(data[1] > 0, data[1] < 3)
		py.plot(data[0][mm]-T0,np.log10(data[1][mm]),color[i]+'o')
		py.plot(data[0][mm]-T0,np.log10(data[1][mm]),color[i]+'o')
		mm = np.bitwise_and(secz > 0, secz < 3)

		py.plot(timeStamp[mm]-T0,np.log10(secz[mm]),color[i]+'-')


	py.plot([nightstart-T0,nightstart-T0],ylim,'k--',lw=1.1,alpha=1.0)
	py.plot([nightend-T0,nightend-T0],ylim,'k--',lw=1.1,alpha=1.0)
	py.ylim(ylim[1],ylim[0])
	
	a=ax.get_yticks().tolist()
	print a
	newyticks = ['%.2f'%(10**(val)) for val in a]
	print newyticks
	ax.set_yticklabels(newyticks)

	py.ylabel('airmass',size=18)
	py.xlabel('JD - %.0f'%T0,size=18)
	py.savefig(os.path.expanduser('~/Develop/SMAPs/Figures/plot_airmasses_obs.pdf'))
	py.show()
		
	return 0
예제 #2
0
	def computesky(self) :
		# computes many quantities so they're self-consistent
		sidtemp = _skysub.lst(self.jd,self.longit)
		self.sidereal = ra(sidtemp) # it behaves like an RA
		self.decimalyr = self.julian_epoch()
		self.CoordsOfDate = self.precess(self.julian_epoch())
		self.hanow = ha(self.sidereal.val - self.CoordsOfDate.ra.val)
		[self.altit,self.az,self.parang] = \
		   _skysub.altit(self.CoordsOfDate.dec.val,self.hanow.val, \
			self.lat)
		self.secz = _skysub.secant_z(self.altit)
		self.airmass = _skysub.true_airmass(self.secz)
예제 #3
0
 def computesky(self):
     # computes many quantities so they're self-consistent
     sidtemp = _skysub.lst(self.jd, self.longit)
     self.sidereal = ra(sidtemp)  # it behaves like an RA
     self.decimalyr = self.julian_epoch()
     self.CoordsOfDate = self.precess(self.julian_epoch())
     self.hanow = ha(self.sidereal.val - self.CoordsOfDate.ra.val)
     [self.altit,self.az,self.parang] = \
        _skysub.altit(self.CoordsOfDate.dec.val,self.hanow.val, \
      self.lat)
     self.secz = _skysub.secant_z(self.altit)
     self.airmass = _skysub.true_airmass(self.secz)
예제 #4
0
파일: tao.py 프로젝트: tribeiro/SMAPS
	def selectStandardTargets(self,nstars=3,nairmass=3):
		'''
		Based on configuration parameters, select 'nstars' standard stars to run scheduler on a specified Julian Day. Ideally you 
		will select standard stars before your science targets so not to have a full queue. Usually standard stars are observed 
		more than once a night at different airmasses. The user can control this parameter with nairmass and the script will try
		to take care of the rest. 
		'''

		session = Session()
		
		# First of all, standard stars can be obsered multiple times in sucessive nights. I will mark all
		# stars an unscheduled.
		targets = session.query(Targets).filter(Targets.scheduled == True).filter(Targets.type == self.stdFlag)
		for target in targets:
			target.scheduled = False
			session.commit()
		
		# [To be done] Reject objects that are close to the moon

		# Selecting standard stars is not only searching for the higher in that time but select stars than can be observed at 3
		# or more (nairmass) different airmasses. It is also important to select stars with different colors (but this will be
		# taken care in the future).

		if nairmass*nstars > len(self.obsTimeBins):
			self.log.warning('Requesting more stars/observations than it will be possible to schedule. Decreasing number of requests to fit in the night.')
			nstars = len(self.obsTimeBins)/nairmass

		obsStandars = np.zeros(len(self.obsTimeBins))-1 # first selection of observable standards

		for tbin,time in enumerate(self.obsTimeBins):

			if self.obsTimeMask[tbin] < 1.0:
				# 1 - Select objects from database that where not scheduled yet (standard stars may be repited)
				#     that fits our observing night
				targets = session.query(Targets).filter(Targets.scheduled == 0).filter(Targets.type == self.stdFlag)
			
				lst = _skysub.lst(time,self.sitelong) #*360./24.
				alt = np.array([_skysub.altit(target.targetDec,lst - target.targetRa,self.sitelat)[0] for target in targets])
				stg = alt.argmax()

				self.log.info('Selecting %s'%(targets[stg]))
				
				# Marking target as schedule
				tst = session.query(Targets).filter(Targets.id == targets[stg].id)

				for t in tst:
					t.scheduled = True
					session.commit()
					obsStandars[tbin] = t.id
				
			else:
				self.log.info('Bin already filled up with observations. Skipping...')

		if len(obsStandars[obsStandars >= 0]) < nstars:
			self.log.warning('Could not find %i suitable standard stars in catalog. Only %i where found.'%(nstars,len(obsStandars[obsStandars >= 0])))
		#
		# Unmarking potential targets as scheduled
		#
		for id in obsStandars[obsStandars >= 0]:
			target = session.query(Targets).filter(Targets.id == id)
			for t in target:
				t.scheduled = False
				session.commit()
				
			tbin+=1
		#
		# Preparing a grid of altitudes for each target for each observing window
		#
		amGrid = np.zeros(len(obsStandars)*len(obsStandars)).reshape(len(obsStandars),len(obsStandars))

		for i in np.arange(len(obsStandars))[obsStandars >= 0]:
			target = session.query(Targets).filter(Targets.id == obsStandars[i])[0]
			for j in range(len(obsStandars)):
				lst = _skysub.lst(self.obsTimeBins[j],self.sitelong)
				amGrid[i][j] = _skysub.true_airmass(_skysub.secant_z(_skysub.altit(target.targetDec,lst - target.targetRa,self.sitelat)[0]))
				if amGrid[i][j] < 0:
					amGrid [i][j] = 99.
		#
		# Build a grid mask that specifies the position in time each target should be observed. This means that, when
		# selecting a single target we ocuppy more than one, non consecutive, position in the night. This grid shows where are these
		# positions.
		#
		obsMask = np.zeros(len(obsStandars)*len(obsStandars),dtype=np.bool).reshape(len(obsStandars),len(obsStandars))

		for i in np.arange(len(obsStandars))[obsStandars >= 0]:
			amObs = np.linspace(amGrid[i].min(),self.stdMaxAirmass,nairmass) # requested aimasses
			dam = np.mean(np.abs(amGrid[i][amGrid[i]<self.stdMaxAirmass][1:] - amGrid[i][amGrid[i]<self.stdMaxAirmass][:-1])) # how much airmass changes in average
			for j,am in enumerate(amObs):
				# Mark positions where target is at	specified airmass
				if j == 0:
					obsMask[i] = np.bitwise_or(obsMask[i],amGrid[i] == am)
				else:
					obsMask[i] = np.bitwise_or(obsMask[i],np.bitwise_and(amGrid[i]>am-dam,amGrid[i]<am+dam))

			#print amGrid[i][np.where(obsMask[i])]
		#
		# Now it is time to actually select the targets. It will start with the first target and then try the others
		# until it find enough standard stars, as specified by the user.
		#
		# Para cada bin em tempo, varro o bin em massa de ar por coisas observaveis. Se acho um, vejo se posso agendar
		# os outros bins. Se sim, marco o alvo para observacao, se nao, passo para o proximo. Repito ate completar a
		# lista de alvos
		#

		obsMaskTimeGrid = np.zeros(len(obsStandars),dtype=np.bool)
		nrequests = 0
		reqId = np.zeros(nstars,dtype=np.int)-1
		for tbin,time in enumerate(self.obsTimeBins[:-1]):
			# Evaluates if time slots are all available. If yes, mark orbservation and ocuppy slots.
			if ( (not obsMaskTimeGrid[obsMask[tbin]].any()) and (len(amGrid[tbin][obsMask[tbin]])>=nairmass) ):
				obsMaskTimeGrid = np.bitwise_or(obsMaskTimeGrid,obsMask[tbin])
				reqId[nrequests] = tbin
				nrequests += 1
			if nrequests >= nstars:
				break

		# Finally, requesting observations

		for id in reqId[reqId >= 0]:
			target = session.query(Targets).filter(Targets.id == obsStandars[id])[0]
			secz = amGrid[id][obsMask[id]]
			seczreq = np.zeros(nairmass,dtype=np.bool)
			amObs = np.linspace(amGrid[id].min(),self.stdMaxAirmass,nairmass) # requested aimasses
			for i,obstime in enumerate(self.obsTimeBins[obsMask[id]]):
				sindex = np.abs(amObs-secz[i]).argmin()
				if not seczreq[sindex]:
					self.log.info('Requesting observations of %s @airmass=%4.2f @mjd=%.3f...'%(target.name,secz[i],obstime-2400000.5))
					seczreq[sindex] = True
					target.scheduled = True
					session.commit()
					self.addObservation(target,obstime)
					self.obsTimeMask[obsMask[id]] = 1.0
			#print self.obsTimeBins[obsMask[id]]
			#print

		#print i
		return 0 #targets
예제 #5
0
    def selectStandardTargets(self, nstars=3, nairmass=3):
        '''
		Based on configuration parameters, select 'nstars' standard stars to run scheduler on a specified Julian Day. Ideally you 
		will select standard stars before your science targets so not to have a full queue. Usually standard stars are observed 
		more than once a night at different airmasses. The user can control this parameter with nairmass and the script will try
		to take care of the rest. 
		'''

        session = Session()

        # First of all, standard stars can be obsered multiple times in sucessive nights. I will mark all
        # stars an unscheduled.
        targets = session.query(Targets).filter(
            Targets.scheduled == True).filter(Targets.type == self.stdFlag)
        for target in targets:
            target.scheduled = False
            session.commit()

        # [To be done] Reject objects that are close to the moon

        # Selecting standard stars is not only searching for the higher in that time but select stars than can be observed at 3
        # or more (nairmass) different airmasses. It is also important to select stars with different colors (but this will be
        # taken care in the future).

        if nairmass * nstars > len(self.obsTimeBins):
            log.warning(
                'Requesting more stars/observations than it will be possible to schedule. Decreasing number of requests to fit in the night.'
            )
            nstars = len(self.obsTimeBins) / nairmass

        obsStandars = np.zeros(len(
            self.obsTimeBins)) - 1  # first selection of observable standards

        for tbin, time in enumerate(self.obsTimeBins):

            if self.obsTimeMask[tbin] < 1.0:
                # 1 - Select objects from database that where not scheduled yet (standard stars may be repited)
                #     that fits our observing night
                targets = session.query(Targets).filter(
                    Targets.scheduled == 0).filter(
                        Targets.type == self.stdFlag)

                lst = _skysub.lst(time, self.sitelong)  #*360./24.
                alt = np.array([
                    _skysub.altit(target.targetDec, lst - target.targetRa,
                                  self.sitelat)[0] for target in targets
                ])
                stg = alt.argmax()

                log.info('Selecting %s' % (targets[stg]))

                # Marking target as schedule
                tst = session.query(Targets).filter(
                    Targets.id == targets[stg].id)

                for t in tst:
                    t.scheduled = True
                    session.commit()
                    obsStandars[tbin] = t.id

            else:
                log.info(
                    'Bin already filled up with observations. Skipping...')

        if len(obsStandars[obsStandars >= 0]) < nstars:
            log.warning(
                'Could not find %i suitable standard stars in catalog. Only %i where found.'
                % (nstars, len(obsStandars[obsStandars >= 0])))
        #
        # Unmarking potential targets as scheduled
        #
        for id in obsStandars[obsStandars >= 0]:
            target = session.query(Targets).filter(Targets.id == id)
            for t in target:
                t.scheduled = False
                session.commit()

            tbin += 1
        #
        # Preparing a grid of altitudes for each target for each observing window
        #
        amGrid = np.zeros(len(obsStandars) * len(obsStandars)).reshape(
            len(obsStandars), len(obsStandars))

        for i in np.arange(len(obsStandars))[obsStandars >= 0]:
            target = session.query(Targets).filter(
                Targets.id == obsStandars[i])[0]
            for j in range(len(obsStandars)):
                lst = _skysub.lst(self.obsTimeBins[j], self.sitelong)
                amGrid[i][j] = _skysub.true_airmass(
                    _skysub.secant_z(
                        _skysub.altit(target.targetDec, lst - target.targetRa,
                                      self.sitelat)[0]))
                if amGrid[i][j] < 0:
                    amGrid[i][j] = 99.
        #
        # Build a grid mask that specifies the position in time each target should be observed. This means that, when
        # selecting a single target we ocuppy more than one, non consecutive, position in the night. This grid shows where are these
        # positions.
        #
        obsMask = np.zeros(len(obsStandars) * len(obsStandars),
                           dtype=np.bool).reshape(len(obsStandars),
                                                  len(obsStandars))

        for i in np.arange(len(obsStandars))[obsStandars >= 0]:
            amObs = np.linspace(amGrid[i].min(), self.stdMaxAirmass,
                                nairmass)  # requested aimasses
            dam = np.mean(
                np.abs(amGrid[i][amGrid[i] < self.stdMaxAirmass][1:] -
                       amGrid[i][amGrid[i] < self.stdMaxAirmass][:-1])
            )  # how much airmass changes in average
            for j, am in enumerate(amObs):
                # Mark positions where target is at	specified airmass
                if j == 0:
                    obsMask[i] = np.bitwise_or(obsMask[i], amGrid[i] == am)
                else:
                    obsMask[i] = np.bitwise_or(
                        obsMask[i],
                        np.bitwise_and(amGrid[i] > am - dam,
                                       amGrid[i] < am + dam))

            #print amGrid[i][np.where(obsMask[i])]
        #
        # Now it is time to actually select the targets. It will start with the first target and then try the others
        # until it find enough standard stars, as specified by the user.
        #
        # Para cada bin em tempo, varro o bin em massa de ar por coisas observaveis. Se acho um, vejo se posso agendar
        # os outros bins. Se sim, marco o alvo para observacao, se nao, passo para o proximo. Repito ate completar a
        # lista de alvos
        #

        obsMaskTimeGrid = np.zeros(len(obsStandars), dtype=np.bool)
        nrequests = 0
        reqId = np.zeros(nstars, dtype=np.int) - 1
        for tbin, time in enumerate(self.obsTimeBins[:-1]):
            # Evaluates if time slots are all available. If yes, mark orbservation and ocuppy slots.
            if ((not obsMaskTimeGrid[obsMask[tbin]].any())
                    and (len(amGrid[tbin][obsMask[tbin]]) >= nairmass)):
                obsMaskTimeGrid = np.bitwise_or(obsMaskTimeGrid, obsMask[tbin])
                reqId[nrequests] = tbin
                nrequests += 1
            if nrequests >= nstars:
                break

        # Finally, requesting observations

        for id in reqId[reqId >= 0]:
            target = session.query(Targets).filter(
                Targets.id == obsStandars[id])[0]
            secz = amGrid[id][obsMask[id]]
            seczreq = np.zeros(nairmass, dtype=np.bool)
            amObs = np.linspace(amGrid[id].min(), self.stdMaxAirmass,
                                nairmass)  # requested aimasses
            for i, obstime in enumerate(self.obsTimeBins[obsMask[id]]):
                sindex = np.abs(amObs - secz[i]).argmin()
                if not seczreq[sindex]:
                    log.info(
                        'Requesting observations of %s @airmass=%4.2f @mjd=%.3f...'
                        % (target.name, secz[i], obstime - 2400000.5))
                    seczreq[sindex] = True
                    target.scheduled = True
                    session.commit()
                    self.addObservation(target, obstime)
                    self.obsTimeMask[obsMask[id]] = 1.0
            #print self.obsTimeBins[obsMask[id]]
            #print

        #print i
        return 0  #targets
예제 #6
0
파일: mkqueue.py 프로젝트: tribeiro/SMAPS
	def selectStandardTargets(self,flag,nstars=3,nairmass=3):
		'''
		Based on configuration parameters, select 'nstars' standard stars to run scheduler on a specified Julian Day. Ideally you 
		will select standard stars before your science targets so not to have a full queue. Usually standard stars are observed 
		more than once a night at different airmasses. The user can control this parameter with nairmass and the script will try
		to take care of the rest. 
		'''

		session = Session()
		
		# query project information
		projQuery = session.query(Projects).filter(Projects.flag == flag)
		
		totobstime = 0.
		
		# Calculate total observation time
		
		for block in projQuery:
			totobstime += block.exptime
		totobstime /= 86400.0
		# First of all, standard stars can be observed multiple times in sucessive nights. I will mark all
		# stars as unscheduled.
		
		targets = session.query(Targets).filter(Targets.scheduled == True).filter(Targets.type == flag)
		for target in targets:
			target.scheduled = False
			session.commit()
		
		# [To be done] Reject objects that are close to the moon
		# [To be done] Apply all sorts of rejections

		# Selecting standard stars is not only searching for the higher in that time but select stars than can be observed at 3
		# or more (nairmass) different airmasses. It is also important to select stars with different colors (but this will be
		# taken care in the future).

		if nairmass*nstars > len(self.obsTimeBins):
			self.log.warning('Requesting more stars/observations than it will be possible to schedule. Decreasing number of requests to fit in the night.')
			nstars = len(self.obsTimeBins)/nairmass


		# Build a grid of desired times for higher airmass observation of each standard star.
		
		stdObsTimeBin = np.arange(10,len(self.obsTimeBins)-10,(len(self.obsTimeBins)-10)/nstars)
		obsStandars = np.zeros(nstars)
		print stdObsTimeBin
		
		# selecting the closest bin without observation

		stdObsTimeBin,status = self.findSuitableTimeBin(stdObsTimeBin)
		
		if status != 0:
			raise Exception('Could not find suitable time to start observations! Try cleaning queue.')
			
		print stdObsTimeBin
		
		site = Site()

		calclst = lambda time: np.sum(np.array([float(tt) / 60.**i for i,tt in enumerate(str(site._getEphem(datetimeFromJD(time)).sidereal_time()).split(':'))]))
		nightlst = np.array([calclst(obstime) for obstime in self.obsTimeBins])


		for i,tbin in enumerate(stdObsTimeBin):
		
			# selecting the closest bin without observation
			closestcleanbin = tbin
			while self.obsTimeMask[closestcleanbin] > 0.0:
				closestcleanbin += 1
			if i+1 < len(stdObsTimeBin):
				if closestcleanbin > stdObsTimeBin[i+1]:
					raise Exception('Could not find suitable place to start observations of standard star. Try cleaning queue.')
			
			time = self.obsTimeBins[closestcleanbin]

			# 1 - Select objects from database that where not scheduled yet (standard stars may be repited)
			#     that fits our observing night

			#targetSched = False

			# Will try until a good match is obtained
			#while( not targetSched ):
			targets = session.query(Targets).filter(Targets.scheduled == 0).filter(Targets.type == flag)
			if len(targets[:]) > 0:

				#ephem = site._getEphem(datetimeFromJD(time))
				
				lst = calclst(time) #np.sum(np.array([float(tt) / 60.**i for i,tt in enumerate(str(ephem.sidereal_time()).split(':'))]))
				sitelat = np.sum(np.array([float(tt) / 60.**i for i,tt in enumerate(str(site['latitude']).split(':'))]))
				alt = np.array([_skysub.altit(target.targetDec,lst - target.targetRa,sitelat)[0] for target in targets])
				
				stg = alt.argmax()

				print('Selecting %s'%(targets[stg]))
				
				# Marking target as schedule
				tst = session.query(Targets).filter(Targets.id == targets[stg].id)
				
				# Build airmass table for object
				objsecz = np.array([_skysub.true_airmass(_skysub.secant_z(_skysub.altit(targets[stg].targetDec,nlst - targets[stg].targetRa,sitelat)[0])) for nlst in nightlst])
				# Build desired airmass table
				#obsairmass = np.linspace(_skysub.true_airmass(_skysub.secant_z(alt[stg])),projQuery[0].maxairmass,nairmass)
				obsairmass = np.logspace(np.log10(np.min(objsecz[objsecz > 0])),np.log10(projQuery[0].maxairmass),nairmass)
				np.savetxt('airmass_%04i.dat'%(stg),X=zip(self.obsTimeBins,objsecz))
				# Build mask with scheduled airmasses
				#mask = np.zeros(len(objsecz),dtype=bool) == 1
				pltobstime,pltobsairmass = np.array([]),np.array([])
				# Try scheduling observations on all airmasses
				for airmass in obsairmass:
				
					# Get times where the object is close to the desired airmass and there are no observations scheduled
					timeobsmask = np.bitwise_and(self.obsTimeMask < 1.0,np.abs(objsecz - airmass) < self.tolairmass)
					# Check that there are times available
					if not timeobsmask.any():
						#raise Exception('No time available for scheduling observations of standard star %s at airmass %.3f'%(targets[stg],airmass))
						self.log.warning('No time available for scheduling observations of standard star %s at airmass %.3f'%(targets[stg],airmass))
					# Start trying to schedule observations
					indexes = np.arange(len(self.obsTimeMask))[timeobsmask] #np.bitwise_and(self.obsTimeMask, timeobsmask)
					
					obsSched = False


					
					for index in indexes:
						print('[%.3f] - Time bin available for observation of standard star at airmass %.3f'%(self.obsTimeBins[index], airmass))
						print '- Require %i extra time bins'%(totobstime/self.tbin)
						if (self.obsTimeMask[index:index+totobstime/self.tbin] < 1.0).all():
							print 'Observation fit in this block.'
							self.obsTimeMask[index:index+totobstime/self.tbin] = 1.0
							self.log.info('Requesting observations of %s @airmass=%4.2f @mjd=%.3f...'%(target.name,airmass,self.obsTimeBins[index]-2400000.5))
							
							pltobstime = np.append(pltobstime,self.obsTimeBins[index:index+totobstime/self.tbin])
							pltobsairmass = np.append(pltobsairmass, objsecz[index:index+totobstime/self.tbin])
							

							#for nblock,ii in enumerate(range(index,int(index+totobstime/self.tbin),1)):
							self.addObservation(targets[stg],self.obsTimeBins[index],projQuery)
							break
					np.savetxt('obsairmass_%04i.dat'%stg,X = zip(pltobstime,pltobsairmass))

						#self.obsTimeMask[index] = 1.0
						#for iobsbins in range(index+1,index+int(totobstime/self.tbin)):
							#print '[%i] - require extra time bin'%(iobsbins)
							#if self.obsTimeMask[iobsbins] < 1.0:
							#	self.obsTimeMask[iobsbins] = 1.0
							#else:
							#	raise Exception('Time bin [%i/%i] not available for observation of standard star at airmass %.3f'%(iobsbins,len(self.obsTimeMask),airmass))
						#else:
							#raise Exception('Time bin not available for observation of standard star at airmass %.3f'%(airmass))

				for t in tst:
					t.scheduled = True
					session.commit()
					obsStandars[i] = t.id
			else:
				self.log.warning('No suitable standard star for jd:%.3f in database...'%(time))
				return 0

		return 0
		
		if len(obsStandars[obsStandars >= 0]) < nstars:
			self.log.warning('Could not find %i suitable standard stars in catalog. Only %i where found.'%(nstars,len(obsStandars[obsStandars >= 0])))

		obsStandars = np.zeros(len(self.obsTimeBins))-1 # first selection of observable standards
		
		for tbin,time in enumerate(self.obsTimeBins):

			if self.obsTimeMask[tbin] < 1.0:
				# 1 - Select objects from database that where not scheduled yet (standard stars may be repited)
				#     that fits our observing night
				targets = session.query(Targets).filter(Targets.scheduled == 0).filter(Targets.type == flag)
				
				if len(targets[:]) > 0:

					ephem = site._getEphem(datetimeFromJD(time))
					
					lst = np.sum(np.array([float(tt) / 60.**i for i,tt in enumerate(str(ephem.sidereal_time()).split(':'))]))
					sitelat = np.sum(np.array([float(tt) / 60.**i for i,tt in enumerate(str(site['latitude']).split(':'))]))
					secz = np.array([_skysub.secant_z(_skysub.altit(target.targetDec,lst - target.targetRa,sitelat)[0]) for target in targets])
					
					stg = secz.argmax()

					self.log.info('Selecting %s'%(targets[stg]))
					
					# Marking target as schedule
					tst = session.query(Targets).filter(Targets.id == targets[stg].id)

					for t in tst:
						t.scheduled = True
						session.commit()
						obsStandars[tbin] = t.id
				else:
					print('No suitable target for jd:%.3f in database...'%(time))
					break

			else:
				self.log.info('Bin already filled up with observations. Skipping...')

		if len(obsStandars[obsStandars >= 0]) < nstars:
			self.log.warning('Could not find %i suitable standard stars in catalog. Only %i where found.'%(nstars,len(obsStandars[obsStandars >= 0])))
		#
		# Unmarking potential targets as scheduled
		#
		for id in obsStandars[obsStandars >= 0]:
			target = session.query(Targets).filter(Targets.id == id)
			for t in target:
				t.scheduled = False
				session.commit()
				
			tbin+=1
		#
		# Preparing a grid of altitudes for each target for each observing window
		#
		amGrid = np.zeros(len(obsStandars)*len(obsStandars)).reshape(len(obsStandars),len(obsStandars))

		for i in np.arange(len(obsStandars))[obsStandars >= 0]:
			target = session.query(Targets).filter(Targets.id == obsStandars[i])[0]
			for j in range(len(obsStandars)):
				lst = _skysub.lst(self.obsTimeBins[j],self.sitelong)
				amGrid[i][j] = _skysub.true_airmass(_skysub.secant_z(_skysub.altit(target.targetDec,lst - target.targetRa,self.sitelat)[0]))
				if amGrid[i][j] < 0:
					amGrid [i][j] = 99.
		#
		# Build a grid mask that specifies the position in time each target should be observed. This means that, when
		# selecting a single target we ocuppy more than one, non consecutive, position in the night. This grid shows where are these
		# positions.
		#
		obsMask = np.zeros(len(obsStandars)*len(obsStandars),dtype=np.bool).reshape(len(obsStandars),len(obsStandars))

		for i in np.arange(len(obsStandars))[obsStandars >= 0]:
			amObs = np.linspace(amGrid[i].min(),self.stdMaxAirmass,nairmass) # requested aimasses
			dam = np.mean(np.abs(amGrid[i][amGrid[i]<self.stdMaxAirmass][1:] - amGrid[i][amGrid[i]<self.stdMaxAirmass][:-1])) # how much airmass changes in average
			for j,am in enumerate(amObs):
				# Mark positions where target is at	specified airmass
				if j == 0:
					obsMask[i] = np.bitwise_or(obsMask[i],amGrid[i] == am)
				else:
					obsMask[i] = np.bitwise_or(obsMask[i],np.bitwise_and(amGrid[i]>am-dam,amGrid[i]<am+dam))

			#print amGrid[i][np.where(obsMask[i])]
		#
		# Now it is time to actually select the targets. It will start with the first target and then try the others
		# until it find enough standard stars, as specified by the user.
		#
		# Para cada bin em tempo, varro o bin em massa de ar por coisas observaveis. Se acho um, vejo se posso agendar
		# os outros bins. Se sim, marco o alvo para observacao, se nao, passo para o proximo. Repito ate completar a
		# lista de alvos
		#

		obsMaskTimeGrid = np.zeros(len(obsStandars),dtype=np.bool)
		nrequests = 0
		reqId = np.zeros(nstars,dtype=np.int)-1
		for tbin,time in enumerate(self.obsTimeBins[:-1]):
			# Evaluates if time slots are all available. If yes, mark orbservation and ocuppy slots.
			if ( (not obsMaskTimeGrid[obsMask[tbin]].any()) and (len(amGrid[tbin][obsMask[tbin]])>=nairmass) ):
				obsMaskTimeGrid = np.bitwise_or(obsMaskTimeGrid,obsMask[tbin])
				reqId[nrequests] = tbin
				nrequests += 1
			if nrequests >= nstars:
				break

		# Finally, requesting observations

		for id in reqId[reqId >= 0]:
			target = session.query(Targets).filter(Targets.id == obsStandars[id])[0]
			secz = amGrid[id][obsMask[id]]
			seczreq = np.zeros(nairmass,dtype=np.bool)
			amObs = np.linspace(amGrid[id].min(),self.stdMaxAirmass,nairmass) # requested aimasses
			for i,obstime in enumerate(self.obsTimeBins[obsMask[id]]):
				sindex = np.abs(amObs-secz[i]).argmin()
				if not seczreq[sindex]:
					self.log.info('Requesting observations of %s @airmass=%4.2f @mjd=%.3f...'%(target.name,secz[i],obstime-2400000.5))
					seczreq[sindex] = True
					target.scheduled = True
					session.commit()
					self.addObservation(target,obstime)
					self.obsTimeMask[obsMask[id]] = 1.0
			#print self.obsTimeBins[obsMask[id]]
			#print

		#print i
		return 0 #targets