/***********************************************************************//**
* @brief Save the selected event list(s)
*
* This method saves the selected event list(s) into FITS file(s). There are
* two modes, depending on the m_use_xml flag.
*
* If m_use_xml is true, all selected event list(s) will be saved into FITS
* files, where the output filenames are constructued from the input
* filenames by prepending the m_prefix string to name. Any path information
* will be stripped form the input name, hence event files will be written
* into the local working directory (unless some path information is present
* in the prefix). In addition, an XML file will be created that gathers
* the filename information for the selected event list(s). If an XML file
* was present on input, all metadata information will be copied from this
* input file.
*
* If m_use_xml is false, the selected event list will be saved into a FITS
* file.
***************************************************************************/
void ctobssim::save(void)
{
// Write header
if (logTerse()) {
log << std::endl;
if (m_obs.size() > 1) {
log.header1("Save observations");
}
else {
log.header1("Save observation");
}
}
// Case A: Save event file(s) and XML metadata information
if (m_use_xml) {
save_xml();
}
// Case B: Save event file as FITS file
else {
save_fits();
}
// Return
return;
}
void fitall(){
double p0[4],p[4],half,width;
int i,j,k,ud,info;
char str1[256];
FitGraceinit();
half=0.0;
GracePrintf("focus g0");
for(j=0;j<4;j++){
for(k=0;k<NCH;k++){
mn=10000000;
mx=0;
for(i=0;i<NPOINTS;i++){
fitdat[i]=data[j][k][i];
if(fitdat[i]>=mx) mx=fitdat[i];
if(fitdat[i]<=mn) mn=fitdat[i];
}
half=(mn+mx)/2.0;
if((j==0) || (j==2)){
fitud=1;
for(i=0;i<NPOINTS-1;i++){
if((fitdat[i]>=half) && (fitdat[i+1]<=half)){
/*printf("LoMid = %i\n",i);*/
p0[1]=x[i]; /* center */
p0[2]=60.0; /* width (V) */
p0[0]=(mx-mn)/2;/* height */
p0[3]=mn; /* baseline */
}
}
}
if((j==1) || (j==3)){
fitud=-1;
for(i=0;i<NPOINTS-1;i++){
if((fitdat[i]<=half) && (fitdat[i+1]>=half)){
/*printf("LoMid = %i\n",i);*/
p0[1]=x[i]; /* center */
p0[2]=60.0; /* width (V) */
p0[0]=(mx-mn)/2;/* height */
p0[3]=mn; /* baseline */
}
}
}
printf("Before: p0=%g p1=%g p2=%g p3=%g\n",p0[0],p0[1],p0[2],p0[3]);
fit(p0,&info);
printf("After: p0=%g p1=%g p2=%g p3=%g info=%i\n",p0[0],p0[1],p0[2],p0[3],info);
for(i=0;i<4;i++) fits[j][k][i]=p0[i];
/*printf("Center=%g width=%g max=%g min=%g info=%i\n",fits[j][k][1],fits[j][k][2],fits[j][k][0]+fits[j][k][3],info);*/
sprintf(str1,"g0.s%i point %g, %g",j,fits[j][k][1],fits[j][k][2]);
GracePrintf(str1);
}
GracePrintf("autoscale");
GracePrintf("redraw");
}
if(save_fits()) printf("save fits error\n");
}
long AOloopControl_PredictiveControl_builPFloop_WatchInput(long loop, long PFblock, long PFblockStart, long PFblockEnd)
{
long IDinb0;
long IDinb1;
char imnameb0[500];
char imnameb1[500];
long cnt0, cnt1;
long cnt0_old, cnt1_old;
long IDinb;
long twaitus = 100000; // 0.1 sec
long PFblockSize;
long PFblockOrder;
float PFblockLag;
float PFblockdgain;
FILE *fp;
char fname[500];
int ret;
int Tupdate = 0;
time_t t;
struct tm *uttime;
struct timespec timenow;
long xsize, ysize, zsize, xysize;
int cube;
long IDout;
uint32_t *imsizearray;
uint8_t atype;
char imnameout[500];
long ii, kk;
long ave;
char inmaskname[200];
char inmaskfname[200];
char outmaskfname[200];
long IDinmask;
PFblockSize = PFblockEnd - PFblockStart;
if(sprintf(imnameb0, "aol%ld_modeval_ol_logbuff0", loop) < 1)
printERROR(__FILE__, __func__, __LINE__, "sprintf wrote <1 char");
if(sprintf(imnameb1, "aol%ld_modeval_ol_logbuff1", loop) < 1)
printERROR(__FILE__, __func__, __LINE__, "sprintf wrote <1 char");
IDinb0 = read_sharedmem_image(imnameb0);
IDinb1 = read_sharedmem_image(imnameb1);
cnt0_old = data.image[IDinb0].md[0].cnt0;
cnt1_old = data.image[IDinb1].md[0].cnt0;
xsize = data.image[IDinb0].md[0].size[0];
ysize = data.image[IDinb0].md[0].size[1];
xysize = xsize*ysize;
zsize = data.image[IDinb0].md[0].size[2];
atype = data.image[IDinb0].md[0].atype;
list_image_ID();
if(system("mkdir -p PredictiveControl") != 0)
printERROR(__FILE__, __func__, __LINE__, "system() returns non-zero value");
if(sprintf(inmaskname, "inmaskPFb%ld", PFblock) < 1)
printERROR(__FILE__, __func__, __LINE__, "sprintf wrote <1 char");
IDinmask = create_2Dimage_ID(inmaskname, xysize, 1);
for(ii=0; ii<xysize; ii++)
data.image[IDinmask].array.F[ii] = 0.0;
for(ii=PFblockStart; ii<PFblockEnd; ii++)
data.image[IDinmask].array.F[ii] = 1.0;
if(sprintf(inmaskfname, "!./PredictiveControl/inmaskPF%ld.fits", PFblock) < 1)
printERROR(__FILE__, __func__, __LINE__, "sprintf wrote <1 char");
save_fits(inmaskname, inmaskfname);
if(sprintf(outmaskfname, "!./PredictiveControl/outmaskPF%ld.fits", PFblock) < 1)
printERROR(__FILE__, __func__, __LINE__, "sprintf wrote <1 char");
save_fits(inmaskname, outmaskfname);
printf("Create aol%ld_modevalol_PFb%ld : %ld x 1 x %ld\n", loop, PFblock, PFblockSize, zsize);
fflush(stdout);
imsizearray = (uint32_t*) malloc(sizeof(uint32_t)*3);
imsizearray[0] = PFblockSize;
imsizearray[1] = 1;
imsizearray[2] = zsize;
if(sprintf(imnameout, "aol%ld_modevalol_PFb%ld", loop, PFblock) < 1)
printERROR(__FILE__, __func__, __LINE__, "sprintf wrote <1 char");
IDout = create_image_ID(imnameout, 3, imsizearray, atype, 1, 1);
free(imsizearray);
COREMOD_MEMORY_image_set_semflush(imnameout, -1);
printf("Done\n");
fflush(stdout);
for(;;)
{
cnt0 = data.image[IDinb0].md[0].cnt0;
cnt1 = data.image[IDinb1].md[0].cnt0;
if(cnt0!=cnt0_old)
{
cube = 0;
cnt0_old = cnt0;
IDinb = IDinb0;
Tupdate = 1;
}
if(cnt1!=cnt1_old)
{
cube = 1;
cnt1_old = cnt1;
IDinb = IDinb1;
Tupdate = 1;
}
if(Tupdate == 1)
{
t = time(NULL);
uttime = gmtime(&t);
clock_gettime(CLOCK_REALTIME, &timenow);
printf("%02d:%02d:%02ld.%09ld NEW TELEMETRY BUFFER AVAILABLE [%d]\n", uttime->tm_hour, uttime->tm_min, timenow.tv_sec % 60, timenow.tv_nsec, cube);
data.image[IDout].md[0].write = 1;
for(kk=0; kk<zsize; kk++)
for(ii=0; ii<PFblockSize; ii++)
data.image[IDout].array.F[kk*PFblockSize + ii] = data.image[IDinb].array.F[kk*xysize + (ii+PFblockStart)];
for(ii=0; ii<PFblockSize; ii++)
{
ave = 0.0;
for(kk=0; kk<zsize; kk++)
ave += data.image[IDout].array.F[kk*PFblockSize + ii];
ave /= zsize;
for(kk=0; kk<zsize; kk++)
data.image[IDout].array.F[kk*PFblockSize + ii] -= ave;
}
COREMOD_MEMORY_image_set_sempost_byID(IDout, -1);
data.image[IDout].md[0].cnt0++;
data.image[IDout].md[0].write = 0;
Tupdate = 0;
}
usleep(twaitus);
}
return (IDout);
}
///
/// predictive control based on SVD
///
/// input:
/// mode values trace [ii: time, jj: mode number]
/// mode index
/// delayfr [delay in frame unit]
/// filtsize [number of samples in filter]
///
double AOloopControl_PredictiveControl_testPredictiveFilter(const char *IDtrace_name, long modeout, double delayfr, long filtsize, const char *IDfilt_name, double SVDeps)
{
long IDtrace;
long IDmatA;
long NBtraceVec; // number of measurement vectors in trace
long NBmvec; // number of measurements in measurement matrix
long NBch; // number of channels in measurement
long IDmatC;
long IDfilt;
long l,m;
float *marray; // measurement array
FILE *fp;
float tmpv;
long delayfr_int;
float delayfr_x;
long ch, l1;
double err0, err1;
float v0;
float NoiseAmpl = 0.02;
IDtrace = image_ID(IDtrace_name);
NBtraceVec = data.image[IDtrace].md[0].size[0];
NBch = data.image[IDtrace].md[0].size[1];
NBmvec = NBtraceVec - filtsize - (long) (delayfr+1.0);
// build measurement matrix
fp = fopen("tracepts.txt","w");
IDmatA = create_2Dimage_ID("WFPmatA", NBmvec, filtsize*NBch);
// each column is a measurement
for(m=0; m<NBmvec; m++) // column index
{
fprintf(fp, "%5ld %f\n", m, data.image[IDtrace].array.F[NBtraceVec*modeout+m+filtsize]);
for(l=0; l<filtsize; l++)
for(ch=0; ch<NBch; ch++)
{
l1 = ch*filtsize + l;
data.image[IDmatA].array.F[l1*NBmvec+m] = data.image[IDtrace].array.F[NBtraceVec*ch + (m+l)];
}
}
fclose(fp);
// build measurement vector
delayfr_int = (int) delayfr;
delayfr_x = delayfr - delayfr_int;
printf("%f = %ld + %f\n", delayfr, delayfr_int, delayfr_x);
marray = (float*) malloc(sizeof(float)*NBmvec);
fp = fopen("tracepts1.txt","w");
for(m=0; m<NBmvec; m++)
{
marray[m] = data.image[IDtrace].array.F[NBtraceVec*modeout+(m+filtsize+delayfr_int)]*(1.0-delayfr_x) + data.image[IDtrace].array.F[NBtraceVec*modeout+(m+filtsize+delayfr_int+1)]*delayfr_x;
fprintf(fp, "%5ld %f %f\n", m, data.image[IDtrace].array.F[NBtraceVec*modeout+m+filtsize], marray[m]);
}
fclose(fp);
linopt_compute_SVDpseudoInverse("WFPmatA", "WFPmatC", SVDeps, 10000, "WFP_VTmat");
save_fits("WFPmatA", "!WFPmatA.fits");
save_fits("WFPmatC", "!WFPmatC.fits");
IDmatC = image_ID("WFPmatC");
IDfilt = create_2Dimage_ID(IDfilt_name, filtsize, NBch);
for(l=0; l<filtsize; l++)
for(ch=0; ch<NBch; ch++)
{
tmpv = 0.0;
for(m=0; m<NBmvec; m++)
tmpv += data.image[IDmatC].array.F[(ch*filtsize+l)*NBmvec+m] * marray[m];
data.image[IDfilt].array.F[ch*filtsize+l] = tmpv;
}
fp = fopen("filt.txt", "w");
tmpv = 0.0;
for(l=0; l<filtsize; l++)
for(ch=0; ch<NBch; ch++)
{
tmpv += data.image[IDfilt].array.F[ch*filtsize+l];
fprintf(fp, "%3ld %3ld %f %f\n", ch, l, data.image[IDfilt].array.F[l], tmpv);
}
fclose(fp);
printf("filter TOTAL = %f\n", tmpv);
// TEST FILTER
// col #1 : time index m
// col #2 : value at index m
// col #3 : predicted value at m+delay
// col #4 : actual value at m+delay
fp = fopen("testfilt.txt", "w");
err0 = 0.0;
err1 = 0.0;
for(m=filtsize; m<NBtraceVec-(delayfr_int+1); m++)
{
tmpv = 0.0;
for(l=0; l<filtsize; l++)
for(ch=0; ch<NBch; ch++)
tmpv += data.image[IDfilt].array.F[ch*filtsize+l]*data.image[IDtrace].array.F[NBtraceVec*ch + (m-filtsize+l)];
fprintf(fp, "%5ld %20f %20f %20f\n", m, data.image[IDtrace].array.F[NBtraceVec*modeout + m], tmpv, marray[m-filtsize]);
v0 = tmpv - marray[m-filtsize];
err0 += v0*v0;
v0 = data.image[IDtrace].array.F[NBtraceVec*modeout + m] - marray[m-filtsize];
err1 += v0*v0;
}
fclose(fp);
free(marray);
err0 = sqrt(err0/(NBtraceVec-filtsize-(delayfr_int+1)));
err1 = sqrt(err1/(NBtraceVec-filtsize-(delayfr_int+1)));
printf("Prediction error (using optimal filter) : %f\n", err0);
printf("Prediction error (using last measurement) : %f\n", err1);
return(err1);
}
