def flatCommand(self, wf):
""" Returns the command to give to the actuators to level
the wf considered
"""
tt = Timestamp.now()
fitsFileName = os.path.join(Flattenig._storageFolder(), tt)
self._logger.info('Calculation of the flat command')
circular_mask = self._roi._circularMaskForSegmentCreator()
mask_no_edge_actuators = np.ma.mask_or(wf.mask, circular_mask)
normal_mask = np.ma.mask_or(wf.mask, self._an.getMasterMask())
super_mask = np.ma.mask_or(mask_no_edge_actuators,
self._an.getMasterMask())
wf_masked = np.ma.masked_array(wf.data, mask=super_mask)
pyfits.writeto(os.path.join(fitsFileName, 'imgstart.fits'),
wf_masked.data)
pyfits.append(os.path.join(fitsFileName, 'imgstart.fits'),
wf_masked.mask.astype(int))
self._an.setDetectorMask(wf_masked.mask | self._an.getMasterMask())
rec = self._an.getReconstructor()
amp = -np.dot(rec, wf_masked.compressed())
v_matrix_cut = self.readVMatrix()
self._command = np.dot(v_matrix_cut, amp)
pyfits.writeto(os.path.join(fitsFileName, 'flatDeltaCommand.fits'),
self._command)
return self._command
def diffOpticalMonitoring(self, n_images, delayshort, delaylong):
'''
# Fa due misure poco distanti tra loro e poi aspetta tanto
Parameters
----------
n_images: int
number of images to acquire
delayshort: float
time gap between images couple
delaylong: float
time gap between images couple
Returns
------
tt: string
tracking number of measurements
'''
store_in_folder = fold_name.OPD_SERIES_ROOT_FOLDER
dove, tt = tracking_number_folder.createFolderToStoreMeasurements(
store_in_folder)
zer_list = []
temp_list = []
t0 = time.time()
for i in range(n_images):
for i in range(2):
ti = time.time()
dt = ti - t0
masked_ima = self._interf.acquire_phasemap(1)
temp_vect = self._ott.temperature.getTemperature()
name = Timestamp.now() + '.fits'
fits_file_name = os.path.join(dove, name)
pyfits.writeto(fits_file_name, masked_ima.data)
pyfits.append(fits_file_name, masked_ima.mask.astype(int))
coef, mat = zernike.zernikeFit(masked_ima, np.arange(10) + 1)
vect = np.append(dt, coef)
zer_list.append(vect)
temp_list.append(temp_vect)
fits_file_name = os.path.join(dove, 'zernike.fits')
pyfits.writeto(fits_file_name,
np.array(zer_list),
overwrite=True)
fits_file_name = os.path.join(dove, 'temperature.fits')
pyfits.writeto(fits_file_name,
np.array(temp_list),
overwrite=True)
print('Waiting for next frame in pair')
time.sleep(delayshort)
print('Waiting for next iterations')
time.sleep(delaylong)
return tt
def _createFolderToStoreMeasurements(self):
"""
returns:
dove = all path generated
tt = only tracking number
"""
self._tt = Timestamp.now()
dove = os.path.join(self._rootStoreFolder, self._tt)
if os.path.exists(dove):
raise OSError('Directory %s exists' % dove)
else:
os.makedirs(dove)
return dove, self._tt
def opticalMonitoring(self, n_images, delay):
'''
#monitora
Parameters
----------
n_images: int
number of images to acquire
delay: int [s]
waiting time (in seconds) between two image acquisitions
Returns
------
tt: string
tracking number of measurements
'''
store_in_folder = fold_name.OPD_SERIES_ROOT_FOLDER
dove, tt = tracking_number_folder.createFolderToStoreMeasurements(
store_in_folder)
zer_list = []
temp_list = []
t0 = time.time()
for i in range(n_images):
ti = time.time()
dt = ti - t0
masked_ima = self._interf.acquire_phasemap(1)
temp_vect = self._ott.temperature.getTemperature()
name = Timestamp.now() + '.fits'
fits_file_name = os.path.join(dove, name)
pyfits.writeto(fits_file_name, masked_ima.data)
pyfits.append(fits_file_name, masked_ima.mask.astype(int))
coef, mat = zernike.zernikeFit(masked_ima, np.arange(10) + 1)
vect = np.append(dt, coef)
zer_list.append(vect)
temp_list.append(temp_vect)
fits_file_name = os.path.join(dove, 'zernike.fits')
pyfits.writeto(fits_file_name, np.array(zer_list), overwrite=True)
fits_file_name = os.path.join(dove, 'temperature.fits')
pyfits.writeto(fits_file_name, np.array(temp_list), overwrite=True)
time.sleep(delay)
return tt
def acquireData(self, recording_seconds=5):
'''
Parameters
----------
recording_seconds: int [s]
recording seconds for data acquisition
Returns
-------
name: string
tracking number of measurements
'''
context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect(OpcUaParameters.accelerometers_server)
socket.send_string("START %d" % recording_seconds)
time.sleep(1)
try:
reply = socket.recv(1)
print('Data from %s' % reply)
except:
raise OSError('No reply from socket')
socket.disconnect(OpcUaParameters.accelerometers_server)
lista = os.listdir(OpcUaParameters.accelerometers_data_folder)
lista.sort()
h5_file_name = lista[len(lista) - 1]
tt = Timestamp.now()
name = tt + '.h5'
final_destination = os.path.join(fold_name.ACC_ROOT_FOLDER, name)
print('To %s' % final_destination)
start = os.path.join(OpcUaParameters.accelerometers_data_folder,
h5_file_name)
self._waitForEndAcquisition(start)
self._acc.convertAndSaveData(start, final_destination)
#self._tt = name
return tt
def createFolderToStoreMeasurements(store_in_folder):
"""
Create a new folder using the generation of the tracking number
Parameters
----------
store_in_folder: string
path where to create new fold
Returns
-------
dove: string
all path generated
tt: string
only tracking number
"""
tt = Timestamp.now()
dove = os.path.join(store_in_folder, tt)
if os.path.exists(dove):
raise OSError('Directory %s exists' % dove)
else:
os.makedirs(dove)
return dove, tt
def acquireData(self, recording_seconds=5):
''' some function to simulate accelerometers data
Parameters
----------
recording_seconds: int [s]
number of seconds for data recording
Returns
-------
tt: string
tracking number of mesurements
'''
T = recording_seconds
n = int(T / self._dt)
t = np.linspace(0, T, n)
freqSin = 2
ampSin = 1
vector = ampSin * np.sin(2 * np.pi * freqSin * t)
for i in range(9):
if i == 0:
signal = np.column_stack((vector, vector))
else:
signal = np.column_stack((signal, vector))
tt = Timestamp.now()
name = tt + '.h5'
final_destination = os.path.join(fold_name.ACC_ROOT_FOLDER, name)
# simulatore non rebinnato
hf = h5py.File(final_destination, 'w')
hf.create_dataset('Accelerometers', data=signal[:, 1:])
hf.attrs['DT'] = OpcUaParameters.accelerometers_dt
hf.attrs['ID'] = OpcUaParameters.accelerometers_plc_id
hf.attrs['DIR'] = ['X', 'Z', 'Y', 'Z']
hf.attrs['TIME'] = signal[:, 0]
hf.close()
return tt
def testStringBeginsWith(self):
ts = Timestamp()
self.assertTrue(ts.asNowString().startswith(ts.asTodayString(), 0, 8))
self.assertEqual(str(ts), ts.asNowString())
def testStaticMethods(self):
self.assertTrue(Timestamp.now().startswith(Timestamp.today(), 0, 8))
def opt_aligner(self,
n_images,
zernike_to_be_corrected=None,
dof_command_id=None):
"""
Parameters
----------
n_images: int
number of interferometers frames
Other Parameters
----------
zernike_to_be_corrected: numpy array
None is equal to np.array([0,1,2,3,4])
for tip, tilt, fuoco, coma, coma
commandId: numpy array
array containing the number of degrees of freedom to be commanded
nota: gli zernike possono essere [0,1], [0,1,3,4], [0,1,2,3,4]
e vanno in coppia con i dof [3,4], [1,2,3,4], [0,1,2,3,4]
Returns
-------
cmd: numpy array
final delta command for the optical alignment
dove: string
file path containing measurements
"""
par_position = self._ott.parabola.getPosition()
rm_position = self._ott.referenceMirror.getPosition()
m4_position = self._ott.m4.getPosition()
self._logger.info(
'Calculation of the alignment command using calibration measurements in tt = %s',
self.tt_cal)
self._intMatModesVector = zernike_to_be_corrected
self._commandId = dof_command_id
self._intMat, self._rec, self._cmat = self.selectModesInIntMatAndRecConstruction(
zernike_to_be_corrected, dof_command_id)
img = self._interf.acquire_phasemap(n_images)
name = 'StartImage.fits'
self.tt_al = Timestamp.now()
dove = os.path.join(self._storageFolder(),
self.tt_cal + '--' + self.tt_al)
os.makedirs(dove)
self._interf.save_phasemap(dove, name, img)
if self._who == 'PAR + RM':
cmd, self._zernikeVectorSelected, total_zernike_vector = self._commandGenerator(
img)
self.par_command, self.rm_command = self._reorgCmdForParAndRm(
cmd, dof_command_id)
self._saveData(dove, par_position, rm_position)
#self._alignmentLog(total_zernike_vector, self.tt_al)
self._loggerRuna.info('Calibration tt used = %s', self.tt_cal)
self._loggerRuna.info(
'Zernike calculate on image before alignment = %s',
str(total_zernike_vector))
self._loggerRuna.info(
'Tracking number for alignment measurements = %s', self.tt_al)
return self.par_command, self.rm_command, dove
elif self._who == 'M4':
pass
def scanAstigmComa(self, stepamp, nstep, nframes=10): # by RB 20210117.
'''
Parameters
----------
stepamp: int
amplitude for tip and tilt
nstep: int
number of step measurements
nframes: int
number of interferometr's frames
Returns
------
tt: string
tracking number of measurements
'''
# goal: to measure coma and astigmatism at different PAR position, spanning 500 arcsec
store_in_folder = fold_name.CALIBRATION_ROOT_FOLDER
dove, tt = tracking_number_folder.createFolderToStoreMeasurements(
store_in_folder)
par2rm = -2.05
zern_vect = []
parpos = []
rmpos = []
par0 = self._ott.parabola.getPosition()
rm0 = self._ott.referenceMirror.getPosition()
n2move = np.array([3, 4])
thedirection = np.array([-1, 1])
n_frames_alignment = 3
tt_for_align = '20210111_152430'
for k in n2move:
for v in thedirection:
for i in range(nstep):
par1 = par0.copy()
parmove = stepamp * i * v
par1[k] += parmove
print('Moving PAR[%d] by %d' % (k, parmove))
self._ott.parabola.setPosition(par1)
rm1 = rm0.copy()
rmmove = stepamp * i * v * par2rm
rm1[k] += rmmove
self._ott.referenceMirror.setPosition(rm1)
print('Moving RM[%d] by %d' % (k, rmmove))
par_cmd, rm_cmd = self._ottca.par_and_rm_aligner(
True, tt_for_align, n_frames_alignment,
np.array([0, 1]), np.array([3, 4]))
# a.ott_alignment(n_frames_alignment, 1,
# np.array([0, 1]),
# np.array([3, 4]),
# tt_for_align)
par2 = self._ott.parabola.getPosition()
rm2 = self._ott.referenceMirror.getPosition()
masked_ima = self._interf.acquire_phasemap(nframes)
name = Timestamp.now() + '.fits'
fits_file_name = os.path.join(dove, name)
pyfits.writeto(fits_file_name, masked_ima.data)
pyfits.append(fits_file_name, masked_ima.mask.astype(int))
coef, mat = zernike.zernikeFit(masked_ima,
np.arange(10) + 1)
zern_vect.append(coef)
parpos.append(par2)
rmpos.append(rm2)
fits_file_name = os.path.join(dove, 'zernike.fits')
pyfits.writeto(fits_file_name,
np.array(zern_vect),
overwrite=True)
fits_file_name = os.path.join(dove, 'PAR_positions.fits')
pyfits.writeto(fits_file_name,
np.array(parpos),
overwrite=True)
fits_file_name = os.path.join(dove, 'RM_positions.fits')
pyfits.writeto(fits_file_name,
np.array(rmpos),
overwrite=True)
self._ott.parabola.setPosition(par0)
self._ott.referenceMirror.setPosition(rm0)
return tt