//-------------------------------------------------------------------------------------------------
const string& GetTimeAsStringMini(string& result, const Tickval *tv)
{
const Tickval *startTime;
Tickval gotTime;
if (tv)
startTime = tv;
else
{
gotTime.now();
startTime = &gotTime;
}
#ifdef _MSC_VER
time_t tval(startTime->secs());
struct tm *ptim(localtime (&tval));
#else
struct tm tim, *ptim;
time_t tval(startTime->secs());
localtime_r(&tval, &tim);
ptim = &tim;
#endif
// 14-07-02 23:15:51
ostringstream oss;
oss << setfill('0') << setw(2) << ((ptim->tm_year + 1900) % 100) << '-';
oss << setw(2) << (ptim->tm_mon + 1) << '-' << setw(2) << ptim->tm_mday << ' ' << setw(2) << ptim->tm_hour;
oss << ':' << setw(2) << ptim->tm_min << ':' << setfill('0') << setw(2) << ptim->tm_sec;
return result = oss.str();
}
unsigned long WINAPI threadrun(void * var)
{
unsigned i;
thrdmem_t *t = (thrdmem_t *)var;
int tnum = t->threadnum;
int k = tnum;
int k1;
int counterA = tnum;
Lock(k);
#ifdef _WIN32
Sleep(100);
#else
sleep(1);
#endif
tstart(&t->_tstart);
for(i = 0; i < maxcount; i++) {
k1 = k + 1;
if(k1 >= ncrits)
k1 = 0;
Lock(k1);
Unlock(k);
if(showme) {
if(showme > 1) {
printf("T%d\n",tnum); fflush(stdout);
}
else if (showme > 2) {
printf("T%d: i=%d %d\n", tnum,i,counterA); fflush(stdout);
}
}
counterA += nthreads;
k = k1;
t->tcounter++;
}
Unlock(k);
tend(&t->_tend);
if(showme > 0) {
// Don't let my printf's interfere with the timing of other threads.
SLEEP(2+(nthreads/40));
double tim = tval(&t->_tstart, &t->_tend);
printf("%lu %s/thread Context switches in %7.3f sec ",
maxcount, facility, tim);
printf("%7.3f usec/cswitch",
(tim*1e6)/(maxcount*nthreads));
printf("\n");
fflush(stdout);
}
#ifdef _WIN32
ExitThread(0);
#endif
return 0;
}
static void init()
{
time_t tval(time(0));
#ifdef _MSC_VER
srand (static_cast<unsigned>(((tval % _getpid()) * tval)));
#else
srandom (static_cast<unsigned>(((tval % getpid()) * tval)));
#endif
}
double
SampleStatistic::confidence(int interval) const
{
// IT_IT("SampleStatistic::confidence(int interval)");
int df = n - 1;
if (df <= 0) return HUGE_VAL;
double t = tval(double(100 + interval) * 0.005, df);
if (t == HUGE_VAL)
return t;
else
return (t * stdDev()) / sqrt(double(n));
}
double
SampleStatistic::confidence(double p_value) const
{
// IT_IT("SampleStatistic::confidence(double p_value)");
int df = n - 1;
if (df <= 0) return HUGE_VAL;
double t = tval((1.0 + p_value) * 0.5, df);
if (t == HUGE_VAL)
return t;
else
return (t * stdDev()) / sqrt(double(n));
}
//-------------------------------------------------------------------------------------------------
const string& GetTimeAsStringMS(string& result, const Tickval *tv, const unsigned dplaces, bool use_gm)
{
const Tickval *startTime;
Tickval gotTime;
if (tv)
startTime = tv;
else
{
gotTime.now();
startTime = &gotTime;
}
#ifdef _MSC_VER
time_t tval(startTime->secs());
struct tm *ptim(use_gm ? gmtime(&tval) : localtime (&tval));
#else
struct tm tim, *ptim;
time_t tval(startTime->secs());
use_gm ? gmtime_r(&tval, &tim) : localtime_r(&tval, &tim);
ptim = &tim;
#endif
// 2014-07-02 23:15:51.514776595
ostringstream oss;
oss << setfill('0') << setw(4) << (ptim->tm_year + 1900) << '-';
oss << setw(2) << (ptim->tm_mon + 1) << '-' << setw(2) << ptim->tm_mday << ' ' << setw(2) << ptim->tm_hour;
oss << ':' << setw(2) << ptim->tm_min << ':';
if (dplaces)
{
const double secs((startTime->secs() % 60) + static_cast<double>(startTime->nsecs()) / Tickval::billion);
oss.setf(ios::showpoint);
oss.setf(ios::fixed);
oss << setw(3 + dplaces) << setfill('0') << setprecision(dplaces) << secs;
}
else
oss << setfill('0') << setw(2) << ptim->tm_sec;
return result = oss.str();
}
/**
* @return - nothing
* Check repository settings as defined in the config file. For example,
* we might expect 37 strings in the repository. Their keys will be
* 'StringKey0' through 'StringKey36'. We'll expect to see hex values for
* all of these names (or we will LEAVE). Those keys will be expected
* to exist in the repository and have values 'StringVal0' through 'StringVal36'
* (or whatever).
*/
void CRepositoryCheckStep::CheckRepositoryStringSettings(CRepository *arepository, TInt ancheck)
{
// Careful if the prefix here changes, we don't want to
// blow this buffer. Also note the 'Delete' at the end of the loop.
TBuf<REPCHECKCREATE_KEYBUFLEN> tkey(KStringKeyPrefix);
TBuf<REPCHECKCREATE_VALBUFLEN> tval(KStringValPrefix);
TInt keyslen = tkey.Length();
TInt valslen = tval.Length();
for( TInt count=0 ; count < ancheck ; count++ )
{
tkey.AppendNum(count); // e.g "StringKey21"
tval.AppendNum(count); // e.g "StringVal47"
TInt r=0;
TInt key;
TInt bRet = GetHexFromConfig(ConfigSection(), tkey, key );
if(bRet != 1)
{
ERR_PRINTF2(_L("Failed to get key%d"), count );
SetTestStepResult(EFail);
}
TBuf<REPCHECKCREATE_MAXSTRINGLEN> expectedbuf;
TPtrC expected(expectedbuf);
bRet = GetStringFromConfig(ConfigSection(), tval, expected );
TBuf<REPCHECKCREATE_MAXSTRINGLEN> sval;
r = arepository->Get( key, sval );
if(r!=KErrNone)
{
INFO_PRINTF1(HTML_RED);
ERR_PRINTF2(_L("Repository doesn't have StringKey 0x%x"), key );
INFO_PRINTF1(HTML_RED_OFF);
SetTestStepResult(EFail);
}
else if(sval!=expected)
{
INFO_PRINTF1(HTML_RED);
ERR_PRINTF4(_L("String match failure, key 0x%x, got %S, expected %S"), key, &sval, &expected);
INFO_PRINTF1(HTML_RED_OFF);
SetTestStepResult(EFail);
}
// Restore the key and value names (i.e strip the digits from the end)
tkey.Delete(keyslen, REPCHECKCREATE_KEYBUFLEN);
tval.Delete(valslen, REPCHECKCREATE_VALBUFLEN);
}
// Should we return something?
return;
}
//please move this function to some appropriate place in math/utilities !!!! //JG2013-01-07
// generate vectors with constant step-size dtIn; only time points are considered which are within the interval [tStart,tEnd]
int constTimeStep(Vector& times, Vector& values, double dtIn, double tStart, double tEnd, int interpolation_order)
{
if(tStart >= tEnd || times.Length()!=values.Length() || times.Length() < 2){assert(0 && "Problems during linear interpolation of t-y data to constant time step.");}
MathFunction mf;
mf.SetPiecewise(times, values,interpolation_order);
// start time point
double t = tStart;
if(t<times(1))
{
t = times(1);
}
TArray<double> tt(1000);
TArray<double> tval(1000);
while(t <= tEnd && t <= times.Get(times.GetLen()))
{
tt.Add(t);
tval.Add(mf.Evaluate(t));
t += dtIn;
}
times = Vector(tt);
values = Vector(tval);
return 1;
}
int do_threads()
{
int i;
unsigned mem;
//
// creates ncrits critical sections for use by the threads.
// creates nthreads thread memories
// creates nthreads threads and passes a token back and forth.
//
mem = (ncrits+1) * sizeof(CRITS);
//mem = ((mem + 4095)/4096) * 4096;
crits = (CRITS *) Malloc(mem);
mem = (nthreads+1)*sizeof(thrdmem_t);
//mem = ((mem + 4095)/4096) * 4096;
thrdm = (thrdmem_t *) Malloc(mem);
mem = (nthreads+1)*sizeof(THREAD_T);
//mem = ((mem + 4095)/4096) * 4096;
th_handles = (THREAD_T *) Malloc(mem);
for(i = 0; i < ncrits + 1; i++)
#ifdef _WIN32
InitializeCriticalSection(&crits[i]);
#else
pthread_mutex_init(&crits[i],NULL);
#endif
//printf("%d Threads\n",nthreads); fflush(stdout);
for(i = 0; i < nthreads; i++) {
thrdm[i].threadnum = i;
#ifdef _WIN32
//printf("\b\b\b\b%4d",i); fflush(stdout);
//if((th_handles[i] = CreateThread(NULL, 4096, threadrun,
if((th_handles[i] = CreateThread(NULL, 8192, threadrun,
(void *)&thrdm[i], NULL, &thrdId)) == NULL) {
printf("Creation of %d thread failed err=%d\n", i,errno);
fflush(stdout);
return 1;
}
thrdm[i].thrdId = thrdId;
#else
int terr;
# define DEC ( void *(*)(void*) )
terr = pthread_create(&th_handles[i], NULL,
DEC threadrun, (void *)&thrdm[i]);
if(terr) {
printf("pthread_create %d failed: err=%d\n", i,terr);
fflush(stdout);
return 1;
}
#endif
}
//printf("\n"); fflush(stdout);
for(i = 0; i < nthreads; i++) {
//printf("\b\b\b\b%4d",i); fflush(stdout);
#ifdef _WIN32
if(WaitForSingleObject(th_handles[i],INFINITE) == WAIT_FAILED) {
printf("WaitForSingleObject FAILED: err=%d\n",errno);
#else
if(pthread_join(th_handles[i],NULL)) {
printf("pthread_join FAILED: err=%d\n",errno);
#endif
fflush(stdout);
return 1;
}
}
// Check that all threads actually completed their tasks.
if(thrdm[0].tcounter != maxcount) {
printf("Thread 0 did %lu out of %lu work\n",
thrdm[0].tcounter,maxcount);
fflush(stdout);
return 1;
}
for(i = 1; i < nthreads; i++) {
if(thrdm[i].tcounter != thrdm[0].tcounter) {
printf("Thread %d did %lu out of %lu work\n",
i,thrdm[0].tcounter,maxcount);
fflush(stdout);
return 1;
}
}
#ifdef _WIN32
//printf("All Complete\n"); fflush(stdout);
#endif
double sum = 0.0;
double sum2 = 0.0;
double maxv, minv;
double avg = 0.0;
double tim;
maxv = minv = tval(&thrdm[0]._tstart, &thrdm[0]._tend);
for(i = 0; i < nthreads; i++) {
tim = tval(&thrdm[i]._tstart, &thrdm[i]._tend);
sum += tim;
sum2 += (tim*tim);
if(tim < minv)
minv = tim;
if(tim > maxv)
maxv = tim;
}
avg = sum/nthreads;
if(csv) {
printf("\"%s\",%lu,%d,%d,",
facility, maxcount, nthreads, ncrits);
printf("%.6f,%.6f,%.6f",
(avg*1e6)/(maxcount*nthreads),
(minv*1e6)/(maxcount*nthreads),
(maxv*1e6)/(maxcount*nthreads));
fflush(stdout);
}
else {
printf("AVG: %lu %s t=%d c=%d in %7.3f sec ",
maxcount, facility, nthreads, ncrits, avg);
printf("%7.3f usec/cswitch",
(avg*1e6)/(maxcount*nthreads));
fflush(stdout);
}
printf("\n");
return 0;
}
#include <ctype.h>
size_t atoik(char *s)
{
size_t ret = 0;
size_t base;
if(*s == '0') {
base = 8;
if(*++s == 'x' || *s == 'X') {
base = 16;
s++;
}
}
else
base = 10;
for(; isxdigit(*s); s++) {
if(base == 16)
if(isalpha(*s))
ret = base*ret + (toupper(*s) - 'A');
else
ret = base*ret + (*s - '0');
else if(isdigit(*s))
ret = base*ret + (*s - '0');
else
break;
}
for(; isalpha(*s); s++) {
switch(toupper(*s)) {
case 'K': ret *= 1024; break;
case 'M': ret *= 1024*1024; break;
default:
return ret;
}
}
return ret;
}
int main(int argc, char **argv)
{
int ch, stat, ncols, count, failed, missing, warning;
int icntr1;
int icntr2;
int istatfile;
int cntr1;
int cntr2;
char statfile[MAXSTR];
char tblfile [MAXSTR];
char fitfile [MAXSTR];
char statdir [MAXSTR];
char line [MAXSTR];
char msg [MAXSTR];
char val [MAXSTR];
char status [32];
double a;
double b;
double c;
double crpix1;
double crpix2;
int xmin;
int xmax;
int ymin;
int ymax;
double xcenter;
double ycenter;
double npixel;
double rms;
double boxx;
double boxy;
double boxwidth;
double boxheight;
double boxangle;
FILE *fstat;
FILE *fout;
SVC *svc=NULL;
/***************************************/
/* Process the command-line parameters */
/***************************************/
debug = 0;
opterr = 0;
fstatus = stdout;
while ((ch = getopt(argc, argv, "ds:")) != EOF)
{
switch (ch)
{
case 'd':
debug = 1;
break;
case 's':
if((fstatus = fopen(optarg, "w+")) == (FILE *)NULL)
{
printf("[struct stat=\"ERROR\", msg=\"Cannot open status file: %s\"]\n",
optarg);
exit(1);
}
break;
default:
printf("[struct stat=\"ERROR\", msg=\"Usage: %s [-d] [-s statusfile] statfiles.tbl fits.tbl statdir\"]\n", argv[0]);
exit(1);
break;
}
}
if (argc - optind < 3)
{
printf("[struct stat=\"ERROR\", msg=\"Usage: %s [-d] [-s statusfile] statfiles.tbl fits.tbl statdir\"]\n", argv[0]);
exit(1);
}
strcpy(tblfile, argv[optind]);
strcpy(fitfile, argv[optind + 1]);
strcpy(statdir, argv[optind + 2]);
fout = fopen(fitfile, "w+");
if(fout == (FILE *)NULL)
{
fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Can't open output file.\"]\n");
fflush(stdout);
exit(1);
}
/**************************************************/
/* Open the difference fit status file list table */
/**************************************************/
ncols = topen(tblfile);
if(ncols <= 0)
{
fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Invalid statfiles metadata file: %s\"]\n",
tblfile);
exit(1);
}
icntr1 = tcol( "cntr1");
icntr2 = tcol( "cntr2");
istatfile = tcol( "stat");
if(icntr1 < 0
|| icntr2 < 0
|| istatfile < 0)
{
fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Need columns: cntr1 cntr2 plus minus diff\"]\n");
exit(1);
}
/***************************************/
/* Read the records and call mFitPlane */
/***************************************/
count = 0;
failed = 0;
missing = 0;
warning = 0;
fprintf(fout, "| plus|minus| a | b | c | crpix1 | crpix2 | xmin | xmax | ymin | ymax | xcenter | ycenter | npixel | rms | boxx | boxy | boxwidth | boxheight | boxang |\n");
fflush(fout);
while(1)
{
stat = tread();
if(stat < 0)
break;
cntr1 = atoi(tval(icntr1));
cntr2 = atoi(tval(icntr2));
strcpy(statfile, statdir);
strcat(statfile, "/");
strcat(statfile, tval(istatfile));
if(checkFile(statfile))
{
++count;
++missing;
continue;
}
fstat = fopen(statfile, "r");
if(fstat == (FILE *)NULL)
{
++count;
++missing;
continue;
}
if(fgets(line, MAXSTR, fstat) == (char *)NULL)
{
++count;
++missing;
continue;
}
svc=svc_struct(line);
strcpy( status, svc_val(line, "stat", val));
if(strcmp( status, "ABORT") == 0)
{
strcpy( msg, svc_val(line, "msg", val ));
fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"%s\"]\n", msg);
fflush(stdout);
exit(1);
}
++count;
if(strcmp( status, "ERROR") == 0)
++failed;
else if(strcmp( status, "WARNING") == 0)
++warning;
else
{
a = atof(svc_val(line, "a", val));
b = atof(svc_val(line, "b", val));
c = atof(svc_val(line, "c", val));
crpix1 = atof(svc_val(line, "crpix1", val));
crpix2 = atof(svc_val(line, "crpix2", val));
xmin = atoi(svc_val(line, "xmin", val));
xmax = atoi(svc_val(line, "xmax", val));
ymin = atoi(svc_val(line, "ymin", val));
ymax = atoi(svc_val(line, "ymax", val));
xcenter = atof(svc_val(line, "xcenter", val));
ycenter = atof(svc_val(line, "ycenter", val));
npixel = atof(svc_val(line, "npixel", val));
rms = atof(svc_val(line, "rms", val));
boxx = atof(svc_val(line, "boxx", val));
boxy = atof(svc_val(line, "boxy", val));
boxwidth = atof(svc_val(line, "boxwidth", val));
boxheight = atof(svc_val(line, "boxheight", val));
boxangle = atof(svc_val(line, "boxang", val));
fprintf(fout, " %5d %5d %12.5e %12.5e %12.5e %9.2f %9.2f %6d %6d %6d %6d %9.2f %9.2f %9.0f %12.5e %12.1f %12.1f %12.1f %12.1f %12.1f\n",
cntr1, cntr2, a, b, c, crpix1, crpix2, xmin, xmax, ymin, ymax,
xcenter, ycenter, npixel, rms, boxx, boxy, boxwidth, boxheight, boxangle);
fflush(fout);
}
svc_free(svc);
fclose(fstat);
}
fprintf(fstatus, "[struct stat=\"OK\", count=%d, failed=%d, missing=%d, warning=%d]\n", count, failed, missing, warning);
fflush(stdout);
exit(0);
}
unsigned long WINAPI threadrun(void * var)
{
unsigned i;
char *p = (char *)var;
if(equal(p,"A")) { // Adult
#ifdef _WIN32
HANDLE pipeA, pipeB;
#else
struct sembuf sop;
int pipeA, pipeB;
int i;
#endif
#ifdef _WIN32
pipeA = CreateNamedPipe(pipeAdult,
PIPE_ACCESS_DUPLEX,
PIPE_TYPE_BYTE,
2,
128,
128,
INFINITE,
NULL);
if(pipeA == INVALID_HANDLE_VALUE) {
printf("CreateNamedPipe <%s> failed ERROR=%d\n", pipeAdult,Errno);
ExitThread(1);
}
pipeB = pipeA;
//
// ConnectNamedPipe()
//
if(!ConnectNamedPipe(pipeA, NULL)) {
printf("ConnectNamePipe ERROR: err=%d\n",Errno);
ExitThread(1);
}
#else
pipeA = pipeAfds[1];
pipeB = pipeBfds[0];
#endif
tstart();
//
// ADULT: Writes the first byte.
//
for(i = 0; i < maxcount; i++) {
counter++;
if(!Put(pipeA))
break;
if(!Get(pipeB))
break;
}
tend();
double t = tval();
printf("%d pipe/thread Context switches in %7.3f sec ",
maxcount, t);
printf("%7.3f usec/cswitch",
(t*1e6)/maxcount);
printf("\n");
#ifdef _WIN32
ExitThread(0);
#else
sop.sem_num = 0;
sop.sem_op = -1;
sop.sem_flg = 0;
if(semop(sema, &sop, 1) == -1) {
printf("semop failed (waiting for threads): err=%d\n", Errno);
return 1;
}
#endif
}
else {
#ifdef _WIN32
HANDLE pipeA, pipeB, pipeC;
#else
struct sembuf sop;
int pipeA, pipeB;
int i;
#endif
#ifdef _WIN32
//
//
// Here we call OpenNamedPipe or CreateFile
//
Sleep(1);
pipeC = CreateFile(pipeAdult,
GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_READ|FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if(pipeC == INVALID_HANDLE_VALUE) {
printf("CreateFile for pipe failed: err=%d\n",
Errno);
ExitThread(1);
}
pipeA = pipeB = pipeC;
#else
pipeA = pipeAfds[0];
pipeB = pipeBfds[1];
#endif
//
// CHILD:
// The ALREADY_EXISTS detector will wait for the
// thing to be incremented. The other guy will start
// this off.
//
// Release pipeC and waitfor pipeA
//
tstart2();
for(i = 0; i < maxcount; i++) {
if(!Get(pipeA))
break;
if(!Put(pipeB))
break;
}
tend2();
double t = tval2();
printf("%d pipe/thread Context switches in %7.3f sec ",
maxcount, t);
printf("%7.3f usec/cswitch",
(t*1e6)/maxcount);
printf("\n");
#ifdef _WIN32
ExitThread(0);
#else
sop.sem_num = 0;
sop.sem_op = -1;
sop.sem_flg = 0;
if(semop(sema, &sop, 1) == -1) {
printf("semop failed (waiting for threads): err=%d\n", Errno);
return 1;
}
#endif
}
return 0;
}
int main(int argc, char **argv)
{
int c;
char header[32768];
char temp [MAXSTR];
char fmt [MAXSTR];
char rfmt [MAXSTR];
char pfmt [MAXSTR];
char cfmt [MAXSTR];
char ofile [MAXSTR];
char scale [MAXSTR];
int i, j;
int namelen, nimages, ntotal, stat;
double xpos, ypos;
double lon, lat;
double oxpix, oypix;
int oxpixMin, oypixMin;
int oxpixMax, oypixMax;
int offscl, mode;
int ncols;
FILE *fraw;
FILE *fproj;
FILE *fcorr;
/***************************************/
/* Process the command-line parameters */
/***************************************/
debug = 0;
opterr = 0;
fstatus = stdout;
while ((c = getopt(argc, argv, "ds:")) != EOF)
{
switch (c)
{
case 'd':
debug = 1;
break;
case 's':
if((fstatus = fopen(optarg, "w+")) == (FILE *)NULL)
{
printf("[struct stat=\"ERROR\", msg=\"Cannot open status file: %s\"]\n",
optarg);
exit(1);
}
break;
default:
printf("[struct stat=\"ERROR\", msg=\"Usage: %s [-d][-s statusfile] images.tbl hdr.template raw.tbl projected.tbl corrected.tbl\"]\n", argv[0]);
exit(1);
break;
}
}
if (argc - optind < 5)
{
printf("[struct stat=\"ERROR\", msg=\"Usage: %s [-d][-s statusfile] images.tbl hdr.template raw.tbl projected.tbl corrected.tbl\"]\n", argv[0]);
exit(1);
}
strcpy(origimg_file, argv[optind]);
strcpy(template_file, argv[optind + 1]);
strcpy(rawimg_file, argv[optind + 2]);
strcpy(projimg_file, argv[optind + 3]);
strcpy(corrimg_file, argv[optind + 4]);
checkHdr(template_file, 1, 0);
if(debug)
{
printf("\norigimg_file = [%s]\n", origimg_file);
printf("template_file = [%s]\n\n", template_file);
printf("rawimg_file = [%s]\n", rawimg_file);
printf("projimg_file = [%s]\n", projimg_file);
printf("corrimg_file = [%s]\n", corrimg_file);
fflush(stdout);
}
/*************************************************/
/* Process the output header template to get the */
/* image size, coordinate system and projection */
/*************************************************/
readTemplate(template_file);
if(debug)
{
printf("\noutput.sys = %d\n", output.sys);
printf("output.epoch = %-g\n", output.epoch);
printf("output proj = %s\n", output.wcs->ptype);
fflush(stdout);
}
/*********************************************/
/* Open the image header metadata table file */
/*********************************************/
ncols = topen(origimg_file);
if(ncols <= 0)
{
fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Invalid image metadata file: %s\"]\n",
origimg_file);
exit(1);
}
icntr = tcol("cntr");
ictype1 = tcol("ctype1");
ictype2 = tcol("ctype2");
iequinox = tcol("equinox");
inl = tcol("nl");
ins = tcol("ns");
icrval1 = tcol("crval1");
icrval2 = tcol("crval2");
icrpix1 = tcol("crpix1");
icrpix2 = tcol("crpix2");
icdelt1 = tcol("cdelt1");
icdelt2 = tcol("cdelt2");
icrota2 = tcol("crota2");
iepoch = tcol("epoch");
ifname = tcol("fname");
iscale = tcol("scale");
icd11 = tcol("cd1_1");
icd12 = tcol("cd1_2");
icd21 = tcol("cd2_1");
icd22 = tcol("cd2_2");
if(ins < 0)
ins = tcol("naxis1");
if(inl < 0)
inl = tcol("naxis2");
if(ifname < 0)
ifname = tcol("file");
if(icd11 >= 0 && icd12 >= 0 && icd21 >= 0 && icd12 >= 0)
mode = CD;
else if(icdelt1 >= 0 && icdelt2 >= 0 && icrota2 >= 0)
mode = CDELT;
else
{
fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Not enough information to determine coverages (CDELTs or CD matrix)\"]\n");
exit(1);
}
if(icntr < 0
|| ictype1 < 0
|| ictype2 < 0
|| inl < 0
|| ins < 0
|| icrval1 < 0
|| icrval2 < 0
|| icrpix1 < 0
|| icrpix2 < 0
|| ifname < 0)
{
fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Need columns: cntr ctype1 ctype2 nl ns crval1 crval2 crpix1 crpix2 cdelt1 cdelt2 crota2 fname (equinox optional)\"]\n");
exit(1);
}
/******************************************************/
/* Scan the table to get the true 'file' column width */
/******************************************************/
namelen = 0;
while(1)
{
stat = tread();
if(stat < 0)
break;
strcpy(input.fname, fileName(tval(ifname)));
if(strlen(input.fname) > namelen)
namelen = strlen(input.fname);
}
tseek(0);
/*************************************/
/* Write headers to the output files */
/*************************************/
if((fraw = (FILE *)fopen(rawimg_file, "w+")) == (FILE *)NULL)
{
fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Invalid output metadata file: %s\"]\n",
rawimg_file);
exit(1);
}
fprintf(fraw, "\\datatype=fitshdr\n");
if(iscale >= 0)
{
sprintf(fmt, "|%%5s|%%8s|%%8s|%%6s|%%6s|%%10s|%%10s|%%10s|%%10s|%%11s|%%11s|%%8s|%%7s|%%10s|%%%ds|\n", namelen+2);
fprintf(fraw, fmt,
"cntr",
"ctype1",
"ctype2",
"naxis1",
"naxis2",
"crval1",
"crval2",
"crpix1",
"crpix2",
"cdelt1",
"cdelt2",
"crota2",
"equinox",
"scale",
"file");
fprintf(fraw, fmt,
"int",
"char",
"char",
"int",
"int",
"double",
"double",
"double",
"double",
"double",
"double",
"double",
"int",
"double",
"char");
}
else
{
sprintf(fmt, "|%%5s|%%8s|%%8s|%%6s|%%6s|%%10s|%%10s|%%10s|%%10s|%%11s|%%11s|%%8s|%%7s|%%%ds|\n", namelen+2);
fprintf(fraw, fmt,
"cntr",
"ctype1",
"ctype2",
"naxis1",
"naxis2",
"crval1",
"crval2",
"crpix1",
"crpix2",
"cdelt1",
"cdelt2",
"crota2",
"equinox",
"file");
fprintf(fraw, fmt,
"int",
"char",
"char",
"int",
"int",
"double",
"double",
"double",
"double",
"double",
"double",
"double",
"int",
"char");
}
if((fproj = (FILE *)fopen(projimg_file, "w+")) == (FILE *)NULL)
{
fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Invalid output metadata file: %s\"]\n",
projimg_file);
exit(1);
}
fprintf(fproj, "\\datatype=fitshdr\n");
sprintf(fmt, "|%%5s|%%8s|%%8s|%%6s|%%6s|%%10s|%%10s|%%10s|%%10s|%%11s|%%11s|%%8s|%%7s|%%%ds|\n", namelen+2);
fprintf(fproj, fmt,
"cntr",
"ctype1",
"ctype2",
"naxis1",
"naxis2",
"crval1",
"crval2",
"crpix1",
"crpix2",
"cdelt1",
"cdelt2",
"crota2",
"equinox",
"file");
fprintf(fproj, fmt,
"int",
"char",
"char",
"int",
"int",
"double",
"double",
"double",
"double",
"double",
"double",
"double",
"int",
"char");
if((fcorr = (FILE *)fopen(corrimg_file, "w+")) == (FILE *)NULL)
{
fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Invalid output metadata file: %s\"]\n",
corrimg_file);
exit(1);
}
fprintf(fcorr, "\\datatype=fitshdr\n");
fprintf(fcorr, fmt,
"cntr",
"ctype1",
"ctype2",
"naxis1",
"naxis2",
"crval1",
"crval2",
"crpix1",
"crpix2",
"cdelt1",
"cdelt2",
"crota2",
"equinox",
"file");
fprintf(fcorr, fmt,
"int",
"char",
"char",
"int",
"int",
"double",
"double",
"double",
"double",
"double",
"double",
"double",
"int",
"char");
/************************************************/
/* Read the metadata and process each image WCS */
/************************************************/
namelen = 0;
nimages = 0;
ntotal = 0;
if(iscale >= 0)
sprintf(rfmt, " %%5d %%8s %%8s %%6d %%6d %%10.6f %%10.6f %%10.2f %%10.2f %%11.8f %%11.8f %%8.5f %%7.0f %%10s %%%ds\n", namelen+2);
else
sprintf(rfmt, " %%5d %%8s %%8s %%6d %%6d %%10.6f %%10.6f %%10.2f %%10.2f %%11.8f %%11.8f %%8.5f %%7.0f %%%ds\n", namelen+2);
sprintf(pfmt, " %%5d %%8s %%8s %%6d %%6d %%10.6f %%10.6f %%10.2f %%10.2f %%11.8f %%11.8f %%8.5f %%7.0f p%%%ds\n", namelen+2);
sprintf(cfmt, " %%5d %%8s %%8s %%6d %%6d %%10.6f %%10.6f %%10.2f %%10.2f %%11.8f %%11.8f %%8.5f %%7.0f c%%%ds\n", namelen+2);
while(1)
{
stat = tread();
if(stat < 0)
break;
++ntotal;
strcpy(input.ctype1, tval(ictype1));
strcpy(input.ctype2, tval(ictype2));
input.cntr = atoi(tval(icntr));
input.naxis1 = atoi(tval(ins));
input.naxis2 = atoi(tval(inl));
input.crpix1 = atof(tval(icrpix1));
input.crpix2 = atof(tval(icrpix2));
input.crval1 = atof(tval(icrval1));
input.crval2 = atof(tval(icrval2));
if(mode == CDELT)
{
input.cdelt1 = atof(tval(icdelt1));
input.cdelt2 = atof(tval(icdelt2));
input.crota2 = atof(tval(icrota2));
}
else
{
input.cd11 = atof(tval(icd11));
input.cd12 = atof(tval(icd12));
input.cd21 = atof(tval(icd21));
input.cd22 = atof(tval(icd22));
}
input.epoch = 2000;
strcpy(header, "");
sprintf(temp, "SIMPLE = T" ); stradd(header, temp);
sprintf(temp, "BITPIX = -64" ); stradd(header, temp);
sprintf(temp, "NAXIS = 2" ); stradd(header, temp);
sprintf(temp, "NAXIS1 = %d", input.naxis1 ); stradd(header, temp);
sprintf(temp, "NAXIS2 = %d", input.naxis2 ); stradd(header, temp);
sprintf(temp, "CTYPE1 = '%s'", input.ctype1 ); stradd(header, temp);
sprintf(temp, "CTYPE2 = '%s'", input.ctype2 ); stradd(header, temp);
sprintf(temp, "CRVAL1 = %11.6f", input.crval1 ); stradd(header, temp);
sprintf(temp, "CRVAL2 = %11.6f", input.crval2 ); stradd(header, temp);
sprintf(temp, "CRPIX1 = %11.6f", input.crpix1 ); stradd(header, temp);
sprintf(temp, "CRPIX2 = %11.6f", input.crpix2 ); stradd(header, temp);
if(mode == CDELT)
{
sprintf(temp, "CDELT1 = %11.6f", input.cdelt1 ); stradd(header, temp);
sprintf(temp, "CDELT2 = %11.6f", input.cdelt2 ); stradd(header, temp);
sprintf(temp, "CROTA2 = %11.6f", input.crota2 ); stradd(header, temp);
}
else
{
sprintf(temp, "CD1_1 = %11.6f", input.cd11 ); stradd(header, temp);
sprintf(temp, "CD1_2 = %11.6f", input.cd12 ); stradd(header, temp);
sprintf(temp, "CD2_1 = %11.6f", input.cd21 ); stradd(header, temp);
sprintf(temp, "CD2_2 = %11.6f", input.cd22 ); stradd(header, temp);
}
sprintf(temp, "EQUINOX = %d", input.equinox); stradd(header, temp);
sprintf(temp, "END" ); stradd(header, temp);
if(iequinox >= 0)
input.equinox = atoi(tval(iequinox));
strcpy(input.fname, fileName(tval(ifname)));
if(iscale >= 0)
strcpy(scale, tval(iscale));
if(strlen(input.fname) > namelen)
namelen = strlen(input.fname);
if(debug)
{
printf("Image header to wcsinit():\n%s\n", header);
fflush(stdout);
}
input.wcs = wcsinit(header);
checkWCS(input.wcs, 0);
if(input.wcs == (struct WorldCoor *)NULL)
{
fprintf(fstatus, "[struct stat=\"ERROR\", msg=\"Bad WCS for image %d\"]\n",
nimages);
exit(1);
}
/***************************************************/
/* Check the boundaries of the input image against */
/* the output region of interest */
/***************************************************/
oxpixMin = 100000000;
oxpixMax = -100000000;
oypixMin = 100000000;
oypixMax = -100000000;
/* Check input left and right */
for (j=0; j<input.naxis2+1; ++j)
{
pix2wcs(input.wcs, 0.5, j+0.5, &xpos, &ypos);
convertCoordinates(input.sys, input.epoch, xpos, ypos,
output.sys, output.epoch, &lon, &lat, 0.0);
wcs2pix(output.wcs, lon, lat, &oxpix, &oypix, &offscl);
if(!offscl)
{
if(oxpix < oxpixMin) oxpixMin = oxpix;
if(oxpix > oxpixMax) oxpixMax = oxpix;
if(oypix < oypixMin) oypixMin = oypix;
if(oypix > oypixMax) oypixMax = oypix;
}
pix2wcs(input.wcs, input.naxis1+0.5, j+0.5, &xpos, &ypos);
convertCoordinates(input.sys, input.epoch, xpos, ypos,
output.sys, output.epoch, &lon, &lat, 0.0);
wcs2pix(output.wcs, lon, lat, &oxpix, &oypix, &offscl);
if(!offscl)
{
if(oxpix < oxpixMin) oxpixMin = oxpix;
if(oxpix > oxpixMax) oxpixMax = oxpix;
if(oypix < oypixMin) oypixMin = oypix;
if(oypix > oypixMax) oypixMax = oypix;
}
}
/* Check input top and bottom */
for (i=0; i<input.naxis1+1; ++i)
{
pix2wcs(input.wcs, i+0.5, 0.5, &xpos, &ypos);
convertCoordinates(input.sys, input.epoch, xpos, ypos,
output.sys, output.epoch, &lon, &lat, 0.0);
wcs2pix(output.wcs, lon, lat, &oxpix, &oypix, &offscl);
if(!offscl)
{
if(oxpix < oxpixMin) oxpixMin = oxpix;
if(oxpix > oxpixMax) oxpixMax = oxpix;
if(oypix < oypixMin) oypixMin = oypix;
if(oypix > oypixMax) oypixMax = oypix;
}
pix2wcs(input.wcs, i+0.5, input.naxis2+0.5, &xpos, &ypos);
convertCoordinates(input.sys, input.epoch, xpos, ypos,
output.sys, output.epoch, &lon, &lat, 0.0);
wcs2pix(output.wcs, lon, lat, &oxpix, &oypix, &offscl);
if(!offscl)
{
if(oxpix < oxpixMin) oxpixMin = oxpix;
if(oxpix > oxpixMax) oxpixMax = oxpix;
if(oypix < oypixMin) oypixMin = oypix;
if(oypix > oypixMax) oypixMax = oypix;
}
}
/***************************************************/
/* Check the boundaries of the region of interest */
/* against the input image */
/***************************************************/
/* Check ouput left and right */
for (j=0; j<output.wcs->nypix+1; ++j)
{
pix2wcs(output.wcs, 0.5, j+0.5, &xpos, &ypos);
convertCoordinates(output.sys, output.epoch, xpos, ypos,
input.sys, input.epoch, &lon, &lat, 0.0);
wcs2pix(input.wcs, lon, lat, &oxpix, &oypix, &offscl);
if(!offscl)
{
if(0.5 < oxpixMin) oxpixMin = 0.5;
if(0.5 > oxpixMax) oxpixMax = 0.5;
if(j+0.5 < oypixMin) oypixMin = j+0.5;
if(j+0.5 > oypixMax) oypixMax = j+0.5;
}
pix2wcs(output.wcs, output.wcs->nxpix+0.5, j+0.5, &xpos, &ypos);
convertCoordinates(output.sys, output.epoch, xpos, ypos,
input.sys, input.epoch, &lon, &lat, 0.0);
wcs2pix(input.wcs, lon, lat, &oxpix, &oypix, &offscl);
if(!offscl)
{
if(output.wcs->nxpix+0.5 < oxpixMin) oxpixMin = output.wcs->nxpix+0.5;
if(output.wcs->nxpix+0.5 > oxpixMax) oxpixMax = output.wcs->nxpix+0.5;
if(j+0.5 < oypixMin) oypixMin = j+0.5;
if(j+0.5 > oypixMax) oypixMax = j+0.5;
}
}
/* Check input top and bottom */
for (i=0; i<output.wcs->nxpix+1; ++i)
{
pix2wcs(output.wcs, i+0.5, 0.5, &xpos, &ypos);
convertCoordinates(output.sys, output.epoch, xpos, ypos,
input.sys, input.epoch, &lon, &lat, 0.0);
wcs2pix(input.wcs, lon, lat, &oxpix, &oypix, &offscl);
if(!offscl)
{
if(i+0.5 < oxpixMin) oxpixMin = i+0.5;
if(i+0.5 > oxpixMax) oxpixMax = i+0.5;
if(0.5 < oypixMin) oypixMin = 0.5 ;
if(0.5 > oypixMax) oypixMax = 0.5 ;
}
pix2wcs(output.wcs, i+0.5, output.wcs->nypix+0.5, &xpos, &ypos);
convertCoordinates(output.sys, output.epoch, xpos, ypos,
input.sys, input.epoch, &lon, &lat, 0.0);
wcs2pix(input.wcs, lon, lat, &oxpix, &oypix, &offscl);
if(!offscl)
{
if(i+0.5 < oxpixMin) oxpixMin = i+0.5;
if(i+0.5 > oxpixMax) oxpixMax = i+0.5;
if(output.wcs->nypix+0.5 < oypixMin) oypixMin = output.wcs->nypix+0.5;
if(output.wcs->nypix+0.5 > oypixMax) oypixMax = output.wcs->nypix+0.5;
}
}
if(oxpixMax < oxpixMin) continue;
if(oypixMax < oypixMin) continue;
/* Remove any possible compression extension */
strcpy(ofile, input.fname);
if(strlen(ofile) > 3 && strcmp(ofile+strlen(ofile)-3, ".gz") == 0)
ofile[strlen(ofile)-3] = '\0';
else if(strlen(ofile) > 2 && strcmp(ofile+strlen(ofile)-2, ".Z") == 0)
ofile[strlen(ofile)-2] = '\0';
else if(strlen(ofile) > 2 && strcmp(ofile+strlen(ofile)-2, ".z") == 0)
ofile[strlen(ofile)-2] = '\0';
else if(strlen(ofile) > 4 && strcmp(ofile+strlen(ofile)-4, ".zip") == 0)
ofile[strlen(ofile)-4] = '\0';
else if(strlen(ofile) > 2 && strcmp(ofile+strlen(ofile)-2, "-z") == 0)
ofile[strlen(ofile)-2] = '\0';
else if(strlen(ofile) > 3 && strcmp(ofile+strlen(ofile)-3, "-gz") == 0)
ofile[strlen(ofile)-3] = '\0';
/* Make sure the extension is ".fits" */
if(strlen(ofile) > 5 && strcmp(ofile+strlen(ofile)-5, ".fits") == 0)
ofile[strlen(ofile)-5] = '\0';
else if(strlen(ofile) > 5 && strcmp(ofile+strlen(ofile)-5, ".FITS") == 0)
ofile[strlen(ofile)-5] = '\0';
else if(strlen(ofile) > 4 && strcmp(ofile+strlen(ofile)-4, ".fit") == 0)
ofile[strlen(ofile)-4] = '\0';
else if(strlen(ofile) > 4 && strcmp(ofile+strlen(ofile)-4, ".FIT") == 0)
ofile[strlen(ofile)-4] = '\0';
else if(strlen(ofile) > 4 && strcmp(ofile+strlen(ofile)-4, ".fts") == 0)
ofile[strlen(ofile)-4] = '\0';
else if(strlen(ofile) > 4 && strcmp(ofile+strlen(ofile)-4, ".FTS") == 0)
ofile[strlen(ofile)-4] = '\0';
strcat(ofile, ".fits");
if(iscale >= 0)
{
fprintf(fraw, rfmt,
nimages+1,
output.wcs->ctype[0],
output.wcs->ctype[1],
oxpixMax - oxpixMin + 1,
oypixMax - oypixMin + 1,
output.wcs->crval[0],
output.wcs->crval[1],
output.wcs->crpix[0] - oxpixMin,
output.wcs->crpix[1] - oypixMin,
output.wcs->cdelt[0],
output.wcs->cdelt[1],
output.wcs->rot,
output.epoch,
scale,
ofile);
}
else
{
fprintf(fraw, rfmt,
nimages+1,
output.wcs->ctype[0],
output.wcs->ctype[1],
oxpixMax - oxpixMin + 1,
oypixMax - oypixMin + 1,
output.wcs->crval[0],
output.wcs->crval[1],
output.wcs->crpix[0] - oxpixMin,
output.wcs->crpix[1] - oypixMin,
output.wcs->cdelt[0],
output.wcs->cdelt[1],
output.wcs->rot,
output.epoch,
ofile);
}
fprintf(fproj, pfmt,
nimages+1,
output.wcs->ctype[0],
output.wcs->ctype[1],
oxpixMax - oxpixMin + 1,
oypixMax - oypixMin + 1,
output.wcs->crval[0],
output.wcs->crval[1],
output.wcs->crpix[0] - oxpixMin,
output.wcs->crpix[1] - oypixMin,
output.wcs->cdelt[0],
output.wcs->cdelt[1],
output.wcs->rot,
output.epoch,
ofile);
fprintf(fcorr, cfmt,
nimages+1,
output.wcs->ctype[0],
output.wcs->ctype[1],
oxpixMax - oxpixMin + 1,
oypixMax - oypixMin + 1,
output.wcs->crval[0],
output.wcs->crval[1],
output.wcs->crpix[0] - oxpixMin,
output.wcs->crpix[1] - oypixMin,
output.wcs->cdelt[0],
output.wcs->cdelt[1],
output.wcs->rot,
output.epoch,
ofile);
++nimages;
}
fclose(fraw);
fclose(fproj);
fclose(fcorr);
fprintf(fstatus, "[struct stat=\"OK\", count=\"%d\", total=\"%d\"]\n",
nimages, ntotal);
fflush(stdout);
exit(0);
}
int main(int argc, char **argv)
{
int debug, noAreas, i;
int tableDriven, haveStatus;
int icntr, ifname, cntr;
int ncols, index, istat;
int ia, ib, ic, id;
double A, B, C;
char input_file [MAXSTR];
char output_file[MAXSTR];
char tblfile [MAXSTR];
char corrfile [MAXSTR];
char file [MAXSTR];
char *end;
struct mBackgroundReturn *returnStruct;
FILE *montage_status;
/***************************************/
/* Process the command-line parameters */
/***************************************/
debug = 0;
tableDriven = 0;
noAreas = 0;
haveStatus = 0;
montage_status = stdout;
for(i=0; i<argc; ++i)
{
if(strcmp(argv[i], "-s") == 0)
{
haveStatus = 1;
if(i+1 >= argc)
{
printf("[struct stat=\"ERROR\", msg=\"No status file name given\"]\n");
exit(1);
}
if((montage_status = fopen(argv[i+1], "w+")) == (FILE *)NULL)
{
printf ("[struct stat=\"ERROR\", msg=\"Cannot open status file: %s\"]\n",
argv[i+1]);
exit(1);
}
++i;
}
else if(strcmp(argv[i], "-n") == 0)
noAreas = 1;
else if(strcmp(argv[i], "-t") == 0)
tableDriven = 1;
else if(strcmp(argv[i], "-d") == 0)
{
if(i+1 >= argc)
{
printf("[struct stat=\"ERROR\", msg=\"No debug level given\"]\n");
exit(1);
}
debug = strtol(argv[i+1], &end, 0);
if(end - argv[i+1] < strlen(argv[i+1]))
{
printf("[struct stat=\"ERROR\", msg=\"Debug level string is invalid: '%s'\"]\n", argv[i+1]);
exit(1);
}
if(debug < 0)
{
printf("[struct stat=\"ERROR\", msg=\"Debug level value cannot be negative\"]\n");
exit(1);
}
++i;
}
}
if(haveStatus)
{
argv += 2;
argc -= 2;;
}
if(debug)
{
argv += 2;
argc -= 2;;
}
if(noAreas)
{
++argv;
--argc;
}
if(tableDriven)
{
++argv;
--argc;
}
if (argc < 5)
{
printf ("[struct stat=\"ERROR\", msg=\"Usage: mBackground [-d level] [-n(o-areas)] [-s statusfile] in.fits out.fits A B C | mBackground [-t(able-mode)] [-d level] [-n(o-areas)] [-s statusfile] in.fits out.fits images.tbl corrfile.tbl\"]\n");
exit(1);
}
strcpy(input_file, argv[1]);
if(input_file[0] == '-')
{
printf ("[struct stat=\"ERROR\", msg=\"Invalid input file '%s'\"]\n", input_file);
exit(1);
}
strcpy(output_file, argv[2]);
if(output_file[0] == '-')
{
printf ("[struct stat=\"ERROR\", msg=\"Invalid output file '%s'\"]\n", output_file);
exit(1);
}
A = 0.;
B = 0.;
C = 0.;
if(!tableDriven)
{
if (argc != 6)
{
printf ("[struct stat=\"ERROR\", msg=\"Usage: mBackground [-d level] [-n(o-areas)] [-s statusfile] in.fits out.fits A B C | mBackground [-t](able-mode) [-d level] [-n(o-areas)] [-s statusfile] in.fits out.fits images.tbl corrfile.tbl\"]\n");
exit(1);
}
A = strtod(argv[3], &end);
if(end < argv[3] + strlen(argv[3]))
{
printf ("[struct stat=\"ERROR\", msg=\"A coefficient string is not a number\"]\n");
exit(1);
}
B = strtod(argv[4], &end);
if(end < argv[4] + strlen(argv[4]))
{
printf ("[struct stat=\"ERROR\", msg=\"B coefficient string is not a number\"]\n");
exit(1);
}
C = strtod(argv[5], &end);
if(end < argv[5] + strlen(argv[5]))
{
printf ("[struct stat=\"ERROR\", msg=\"C coefficient string is not a number\"]\n");
exit(1);
}
}
else
{
/* Look up the file cntr in the images.tbl file */
/* and then the correction coefficients in the */
/* corrections table generated by mBgModel */
if (argc != 5)
{
printf ("[struct stat=\"ERROR\", msg=\"Usage: mBackground [-d level] [-n(o-areas)] [-s statusfile] in.fits out.fits A B C | mBackground [-t](able-mode) [-d level] [-n(o-areas)] [-s statusfile] in.fits out.fits images.tbl corrfile.tbl\"]\n");
exit(1);
}
strcpy(tblfile, argv[3]);
strcpy(corrfile, argv[4]);
/* Open the image list table file */
ncols = topen(tblfile);
if(ncols <= 0)
{
fprintf(montage_status, "[struct stat=\"ERROR\", msg=\"Invalid image metadata file: %s\"]\n",
tblfile);
exit(1);
}
icntr = tcol( "cntr");
ifname = tcol( "fname");
if(ifname < 0)
ifname = tcol( "file");
if(icntr < 0
|| ifname < 0)
{
fprintf(montage_status, "[struct stat=\"ERROR\", msg=\"Image table needs columns cntr and fname\"]\n");
exit(1);
}
/* Read the records and find the cntr for our file name */
index = 0;
while(1)
{
istat = tread();
if(istat < 0)
{
fprintf(montage_status, "[struct stat=\"ERROR\", msg=\"Hit end of image table without finding file name\"]\n");
exit(1);
}
cntr = atoi(tval(icntr));
strcpy(file, tval(ifname));
if(strcmp(file, input_file) == 0)
break;
}
tclose();
ncols = topen(corrfile);
icntr = tcol( "id");
ia = tcol( "a");
ib = tcol( "b");
ic = tcol( "c");
if(icntr < 0
|| ia < 0
|| ib < 0
|| ic < 0)
{
fprintf(montage_status, "[struct stat=\"ERROR\", msg=\"Need columns: id,a,b,c in corrections file\"]\n");
exit(1);
}
/* Read the records and find the correction coefficients */
while(1)
{
istat = tread();
if(istat < 0)
{
A = 0.;
B = 0.;
C = 0.;
break;
}
id = atoi(tval(icntr));
if(id != cntr)
continue;
A = atof(tval(ia));
B = atof(tval(ib));
C = atof(tval(ic));
break;
}
tclose();
}
returnStruct = mBackground(input_file, output_file, A, B, C, noAreas, debug);
if(returnStruct->status == 1)
{
fprintf(montage_status, "[struct stat=\"ERROR\", msg=\"%s\"]\n", returnStruct->msg);
exit(1);
}
else
{
fprintf(montage_status, "[struct stat=\"OK\", %s]\n", returnStruct->msg);
exit(0);
}
}
/**
* @return - nothing
* Modify repository settings as defined in the config file. For example,
* we might want to set 37 strings in the repository. Their keys will be
* 'StringKey0' through 'StringKey36'.
*/
void CRepositoryFnStep::ModifyRepositoryStringSettings(CRepository *arepository, TInt anset )
{
// Careful if the prefix here changes, we don't want to
// blow this buffer. Also note the 'Delete' at the end of the loop.
TBuf<REPCHECKCREATE_KEYBUFLEN> tkey(KStringKeyPrefix);
TBuf<REPCHECKCREATE_VALBUFLEN> tval(KStringValPrefix);
TBuf<REPCHECKCREATE_VALBUFLEN> experr(KStringExpectedError);
TBuf<REPCHECKCREATE_VALBUFLEN> function(KStringFunction);
TInt keyslen = tkey.Length();
TInt valslen = tval.Length();
TInt experrlen = experr.Length();
TInt fnlen = function.Length();
for( TInt count=0 ; count < anset ; count++ )
{
// Append the count to the name of the key/value/expected error
// config items..
tkey.AppendNum(count); // e.g "StringKey21"
tval.AppendNum(count); // e.g "StringVal47"
experr.AppendNum(count); // e.g "StringExpErr204"
function.AppendNum(count); // e.g "Stringfn204"
// Get the required function config item. We fetch this as a string
// and convert it..
TInt fn;
// Where to put the string from the config file...
TBuf<REPCHECKCREATE_MAXSTRINGLEN> fnbuf;
TPtrC fns(fnbuf);
if(GetStringFromConfig(ConfigSection(), function, fns) )
fn = FuncToNum(fns);
else
fn = fn_set;
// Get the expected error config item. We fetch this as a string
// and convert it..
TInt err;
// Where to put the string from the config file...
TBuf<REPCHECKCREATE_MAXSTRINGLEN> errbuf;
TPtrC errs(errbuf);
if(GetStringFromConfig(ConfigSection(), experr, errs) )
err = ErrorToNum(errs);
else
err = KErrNone;
// Get the key. It MUST be defined in the config file.
TInt r=0, key;
TInt bRet = GetHexFromConfig(ConfigSection(), tkey, key );
if(bRet != 1)
{
INFO_PRINTF1(HTML_RED);
ERR_PRINTF2(_L("Failed to get string key %S"), &tkey );
INFO_PRINTF1(HTML_RED_OFF);
SetTestStepResult(EFail);
continue;
}
// Where to put the string from the config file...
TBuf<REPCHECKCREATE_MAXSTRINGLEN> setbuf;
TPtrC set(setbuf);
// Get it from the config file...
bRet = GetStringFromConfig(ConfigSection(), tval, set );
if((bRet != 1) && ( (fn==fn_set) || (fn==fn_create) ) )
{
INFO_PRINTF1(HTML_RED);
ERR_PRINTF2(_L("FAIL: Failed to get config stringval%d"), count );
INFO_PRINTF1(HTML_RED_OFF);
SetTestStepResult(EFail);
continue;
}
TInt rr;
TBuf<REPCHECKCREATE_MAXSTRINGLEN> vals;
switch(fn)
{
case fn_set:
INFO_PRINTF3(_L("Setting string, key 0x%x, to %S "), key, &set );
r = arepository->Set( key, set );
break;
case fn_create:
INFO_PRINTF3(_L("Creating string, key 0x%x, to %S "), key, &set );
r = arepository->Create( key, set );
break;
case fn_delete:
INFO_PRINTF2(_L("Deleting string, key 0x%x"), key );
r = arepository->Delete( key );
vals.Delete(0, REPCHECKCREATE_KEYBUFLEN);
rr = arepository->Get( key, vals );
if( rr != KErrNotFound )
{
INFO_PRINTF3(_L("Get following delete gave rc %d, val: %S"), rr, &vals);
}
break;
case fn_reset:
INFO_PRINTF2(_L("Resetting string, key 0x%x"), key );
r = arepository->Reset( key );
break;
default:
INFO_PRINTF1(HTML_RED);
ERR_PRINTF3(_L("FAIL: Unknown function %d for string setting %d"), fn, count );
INFO_PRINTF1(HTML_RED_OFF);
r = KErrNone;
SetTestStepResult(EFail);
break;
}
if(r!=err)
{
INFO_PRINTF1(HTML_RED);
ERR_PRINTF3(_L("Wrong error code. Got %d, expected %d"), r, err);
INFO_PRINTF1(HTML_RED_OFF);
SetTestStepResult(EFail);
}
else
{
INFO_PRINTF2(_L("Got expected error code %d"), r );
}
// Restore the key and value names (i.e strip the digits from the end)
tkey.Delete(keyslen, REPCHECKCREATE_KEYBUFLEN);
tval.Delete(valslen, REPCHECKCREATE_VALBUFLEN);
experr.Delete(experrlen, REPCHECKCREATE_VALBUFLEN);
function.Delete(fnlen, REPCHECKCREATE_VALBUFLEN);
}
// Should we return something?
return;
}
/**
* @return - nothing
* Check repository settings as defined in the config file. For example,
* we might expect 37 reals in the repository. Their keys will be
* 'RealKey0' through 'RealKey36'. We'll expect to see hex values for
* all of these names. Those keys will be expected
* to exist in the repository and have values 'RealVal0' through 'RealVal36'
* (or whatever).
*/
void CRepositoryCheckStep::CheckRepositoryRealSettings(CRepository *arepository,
TInt ancheck)
{
// Careful if the prefix here changes, we don't want to
// blow this buffer. Also note the 'Delete' at the end of the loop.
TBuf<REPCHECKCREATE_KEYBUFLEN> tkey(KRealKeyPrefix);
TBuf<REPCHECKCREATE_VALBUFLEN> tval(KRealValPrefix);
TBuf<REPCHECKCREATE_VALBUFLEN> tmeta(KRealMetaPrefix);
TInt keyslen = tkey.Length();
TInt valslen = tval.Length();
TInt metalen = tmeta.Length();
for( TInt count=0 ; count < ancheck ; count++ )
{
tkey.AppendNum(count); // e.g "RealKey21"
tval.AppendNum(count); // e.g "RealVal47"
tmeta.AppendNum(count); // e.g "RealMeta47"
TInt r=0;
TInt key;
TInt bRet = GetHexFromConfig(ConfigSection(), tkey, key );
if(bRet != 1)
{
ERR_PRINTF2(_L("Failed to get key%d"), count );
SetTestStepResult(EFail);
}
TBuf<REPCHECKCREATE_MAXSTRINGLEN> expectedbuf;
TPtrC expected(expectedbuf);
// Get the real stored in the repository.
TReal rval;
r = arepository->Get( key, rval );
if(r!=KErrNone)
{
INFO_PRINTF1(HTML_RED);
ERR_PRINTF2(_L("Repository doesn't have RealKey 0x%x"), key );
INFO_PRINTF1(HTML_RED_OFF);
SetTestStepResult(EFail);
}
else
{
// Unfortunately there is no 'GetRealFromConfig'
// so we must fetch the real number as a
// string.
bRet = GetStringFromConfig(ConfigSection(), tval, expected );
if(bRet!=1)
{
INFO_PRINTF1(HTML_RED);
ERR_PRINTF2(_L("Config doesn't have RealVal%d"), count );
INFO_PRINTF1(HTML_RED_OFF);
SetTestStepResult(EFail);
}
else
{
TLex tlexp(expected);
TReal expectedreal;
r = tlexp.Val(expectedreal);
// This is of course a little problematic -
// obviously one should never compare reals.
if(rval!=expectedreal)
{
INFO_PRINTF1(HTML_RED);
ERR_PRINTF4(_L("Real match failure, key 0x%x, got %f, expected %f"), key, rval, expectedreal);
INFO_PRINTF1(HTML_RED_OFF);
SetTestStepResult(EFail);
}
}
}
TBuf<REPCHECKCREATE_MAXSTRINGLEN> metabuf;
TPtrC meta(metabuf);
TUint32 expectedmeta;
bRet = GetStringFromConfig(ConfigSection(), tmeta, meta );
if(bRet == 1)
{
TLex lex(meta);
TInt err = lex.Val(expectedmeta, EHex);
if (err)
{
INFO_PRINTF1(HTML_RED);
ERR_PRINTF2(_L("Meta value couldn't be converted to TUint32 for IntKey 0x%x"), key );
INFO_PRINTF1(HTML_RED_OFF);
SetTestStepResult(EFail);
}
TUint32 actualmeta;
r = arepository->GetMeta( key, actualmeta );
if(r!=KErrNone)
{
INFO_PRINTF1(HTML_RED);
ERR_PRINTF2(_L("MetData doesn't exist for key 0x%x"), key );
INFO_PRINTF1(HTML_RED_OFF);
SetTestStepResult(EFail);
}
else if(actualmeta!=expectedmeta)
{
INFO_PRINTF1(HTML_RED);
ERR_PRINTF2(_L("Meta match failure, int%d"), count);
INFO_PRINTF2(_L(" - expectedmeta 0x%x"), expectedmeta );
INFO_PRINTF2(_L(" - actualmeta 0x%x"), actualmeta );
INFO_PRINTF1(HTML_RED_OFF);
SetTestStepResult(EFail);
}
}
// Restore the key and value names (i.e strip the digits from the end)
tkey.Delete(keyslen, REPCHECKCREATE_KEYBUFLEN);
tval.Delete(valslen, REPCHECKCREATE_VALBUFLEN);
tmeta.Delete(metalen, REPCHECKCREATE_VALBUFLEN);
}
// Should we return something?
return;
}
int main(int argc, char **argv)
{
int i, j, l, m, c, count, ismag, ncol;
int dl, dm, width, haveFlux, isImg, csys;
int side, ibegin, iend, nstep, useCenter;
int racol, deccol, fluxcol;
int ra1col, dec1col;
int ra2col, dec2col;
int ra3col, dec3col;
int ra4col, dec4col;
long fpixel, nelements;
double rac, decc;
double ra[4], dec[4];
double x, y, z;
double x0, y0, z0;
double x1, y1, z1;
double oxpix, oypix, equinox;
int offscl;
double ilon;
double ilat;
double pixscale, len, sideLength, dtr;
double offset;
double xn, yn, zn;
double ran, decn;
double sina, cosa;
double sind, cosd;
double a11, a12, a13;
double a21, a22, a23;
double a31, a32, a33;
double x0p, y0p, z0p;
double x1p, y1p, z1p;
double lon0, lon1;
double xp, yp;
double lon;
double pixel_value;
double weights[5][5];
double weights3[5][5] = {{0.0, 0.0, 0.0, 0.0, 0.0},
{0.0, 0.1, 0.2, 0.1, 0.0},
{0.0, 0.2, 1.0, 0.2, 0.0},
{0.0, 0.1, 0.2, 0.1, 0.0},
{0.0, 0.0, 0.0, 0.0, 0.0}};
double weights5[5][5] = {{0.0, 0.1, 0.2, 0.1, 0.0},
{0.1, 0.3, 0.5, 0.3, 0.1},
{0.2, 0.5, 1.0, 0.5, 0.2},
{0.1, 0.3, 0.5, 0.3, 0.1},
{0.0, 0.1, 0.2, 0.1, 0.0}};
double **data;
int status = 0;
char input_file [MAXSTR];
char colname [MAXSTR];
char output_file [MAXSTR];
char template_file[MAXSTR];
int bitpix = DOUBLE_IMG;
long naxis = 2;
double sumweights;
double refmag;
dtr = atan(1.0)/45.;
/***************************************/
/* Process the command-line parameters */
/***************************************/
ismag = 0;
opterr = 0;
useCenter = 0;
strcpy(colname, "");
while ((c = getopt(argc, argv, "pm:d:w:c:")) != EOF)
{
switch (c)
{
case 'm':
ismag = 1;
refmag = atof(optarg);
break;
case 'd':
debug = debugCheck(optarg);
break;
case 'w':
width = atoi(optarg);
break;
case 'c':
strcpy(colname, optarg);
break;
case 'p':
useCenter = 1;
break;
default:
printf("[struct stat=\"ERROR\", msg=\"Usage: %s [-c column][-m refmag][-d level][-w size] in.tbl out.fits hdr.template\"]\n", argv[0]);
exit(1);
break;
}
}
if (argc - optind < 3)
{
printf("[struct stat=\"ERROR\", msg=\"Usage: %s [-c column][-m refmag][-d level][-w size] in.tbl out.fits hdr.template\"]\n", argv[0]);
exit(1);
}
strcpy(input_file, argv[optind]);
strcpy(output_file, argv[optind+1]);
strcpy(template_file, argv[optind+2]);
if(debug >= 1)
{
printf("input_file = [%s]\n", input_file);
printf("colname = [%s]\n", colname);
printf("output_file = [%s]\n", output_file);
printf("template_file = [%s]\n", template_file);
printf("width = %d\n", width);
printf("ismag = %d\n", ismag);
fflush(stdout);
}
/********************************************/
/* Set the weights for spreading the points */
/********************************************/
sumweights = 0.;
for(i=0; i<5; ++i)
{
for(j=0; j<5; ++j)
{
if(width == 3)
sumweights += weights3[i][j];
else if(width == 5)
sumweights += weights5[i][j];
}
}
for(i=0; i<5; ++i)
{
for(j=0; j<5; ++j)
{
if(width == 3)
weights[i][j] = weights3[i][j]/sumweights;
else if(width == 5)
weights[i][j] = weights5[i][j]/sumweights;
else
weights[i][j] = 0.;
}
}
if(width != 3 && width != 5)
weights[2][2] = 1.;
/************************************************/
/* Open the table file and find the data column */
/************************************************/
ncol = topen(input_file);
if(ncol <= 0)
{
printf("[struct stat=\"ERROR\", msg=\"Can't open input table %s\"]\n", input_file);
exit(0);
}
racol = tcol( "ra");
deccol = tcol("dec");
ra1col = tcol( "ra1");
dec1col = tcol("dec1");
ra2col = tcol( "ra2");
dec2col = tcol("dec2");
ra3col = tcol( "ra3");
dec3col = tcol("dec3");
ra4col = tcol( "ra4");
dec4col = tcol("dec4");
haveFlux = 1;
if(strlen(colname) == 0)
haveFlux = 0;
else
fluxcol = tcol(colname);
isImg = 1;
if(ra1col < 0 || dec1col < 0
|| ra2col < 0 || dec2col < 0
|| ra3col < 0 || dec3col < 0
|| ra4col < 0 || dec4col < 0)
isImg = 0;
if(useCenter)
isImg = 0;
if(!isImg)
{
if(racol < 0)
{
printf("[struct stat=\"ERROR\", msg=\"Can't find column 'ra'\"]\n");
exit(0);
}
if(deccol < 0)
{
printf("[struct stat=\"ERROR\", msg=\"Can't find column 'dec'\"]\n");
exit(0);
}
}
if(haveFlux && fluxcol < 0)
{
printf("[struct stat=\"ERROR\", msg=\"Can't find column '%s'\"]\n", colname);
exit(0);
}
/*************************************************/
/* Process the output header template to get the */
/* image size, coordinate system and projection */
/*************************************************/
readTemplate(template_file);
pixscale = fabs(output.wcs->xinc);
if(fabs(output.wcs->yinc) > pixscale)
pixscale = fabs(output.wcs->yinc);
csys = EQUJ;
if(strncmp(output.wcs->c1type, "RA", 2) == 0)
csys = EQUJ;
if(strncmp(output.wcs->c1type, "GLON", 4) == 0)
csys = GAL;
if(strncmp(output.wcs->c1type, "ELON", 4) == 0)
csys = ECLJ;
equinox = output.wcs->equinox;
if(debug >= 1)
{
printf("output.naxes[0] = %ld\n", output.naxes[0]);
printf("output.naxes[1] = %ld\n", output.naxes[1]);
printf("output.sys = %d\n", output.sys);
printf("output.epoch = %-g\n", output.epoch);
printf("output proj = %s\n", output.wcs->ptype);
printf("output crval[0] = %-g\n", output.wcs->crval[0]);
printf("output crval[1] = %-g\n", output.wcs->crval[1]);
printf("output crpix[0] = %-g\n", output.wcs->crpix[0]);
printf("output crpix[1] = %-g\n", output.wcs->crpix[1]);
printf("output cdelt[0] = %-g\n", output.wcs->cdelt[0]);
printf("output cdelt[1] = %-g\n", output.wcs->cdelt[1]);
fflush(stdout);
}
/***********************************************/
/* Allocate memory for the output image pixels */
/***********************************************/
data = (double **)malloc(output.naxes[1] * sizeof(double *));
data[0] = (double *)malloc(output.naxes[0] * output.naxes[1] * sizeof(double));
if(debug >= 1)
{
printf("%ld bytes allocated for image pixels\n",
output.naxes[0] * output.naxes[1] * sizeof(double));
fflush(stdout);
}
/**********************************************************/
/* Initialize pointers to the start of each row of pixels */
/**********************************************************/
for(i=1; i<output.naxes[1]; i++)
data[i] = data[i-1] + output.naxes[0];
if(debug >= 1)
{
printf("pixel line pointers populated\n");
fflush(stdout);
}
for (j=0; j<output.naxes[1]; ++j)
{
for (i=0; i<output.naxes[0]; ++i)
{
data[j][i] = 0.;
}
}
/************************/
/* Create the FITS file */
/************************/
remove(output_file);
if(fits_create_file(&output.fptr, output_file, &status))
printFitsError(status);
/*********************************************************/
/* Create the FITS image. All the required keywords are */
/* handled automatically. */
/*********************************************************/
if (fits_create_img(output.fptr, bitpix, naxis, output.naxes, &status))
printFitsError(status);
if(debug >= 1)
{
printf("FITS image created (not yet populated)\n");
fflush(stdout);
}
/*****************************/
/* Loop over the input files */
/*****************************/
time(&currtime);
start = currtime;
/*******************/
/* For each source */
/*******************/
count = 0;
while(tread() >= 0)
{
++count;
if(isImg)
{
if(debug && count/1000*1000 == count)
{
printf("%9d image outlines processed\n", count);
fflush(stdout);
}
ra [0] = atof(tval( ra1col));
dec[0] = atof(tval(dec1col));
ra [1] = atof(tval( ra2col));
dec[1] = atof(tval(dec2col));
ra [2] = atof(tval( ra3col));
dec[2] = atof(tval(dec3col));
ra [3] = atof(tval( ra4col));
dec[3] = atof(tval(dec4col));
for(side=0; side<4; ++side)
{
ibegin = side;
iend = (side+1)%4;
x0 = cos(ra[ibegin]*dtr) * cos(dec[ibegin]*dtr);
y0 = sin(ra[ibegin]*dtr) * cos(dec[ibegin]*dtr);
z0 = sin(dec[ibegin]*dtr);
x1 = cos(ra[iend]*dtr) * cos(dec[iend]*dtr);
y1 = sin(ra[iend]*dtr) * cos(dec[iend]*dtr);
z1 = sin(dec[iend]*dtr);
xn = y0*z1 - z0*y1;
yn = z0*x1 - x0*z1;
zn = x0*y1 - y0*x1;
len = sqrt(xn*xn + yn*yn + zn*zn);
xn = xn / len;
yn = yn / len;
zn = zn / len;
ran = atan2(yn, xn);
decn = asin(zn);
sina = sin(ran);
cosa = cos(ran);
sind = sin(decn);
cosd = cos(decn);
a11 = cosa*sind;
a12 = sina*sind;
a13 = -cosd;
a21 = -sina;
a22 = cosa;
a23 = 0.;
a31 = cosa*cosd;
a32 = sina*cosd;
a33 = sind;
x0p = a11*x0 + a12*y0 + a13*z0;
y0p = a21*x0 + a22*y0 + a23*z0;
z0p = a31*x0 + a32*y0 + a33*z0;
x1p = a11*x1 + a12*y1 + a13*z1;
y1p = a21*x1 + a22*y1 + a23*z1;
z1p = a31*x1 + a32*y1 + a33*z1;
lon0 = atan2(y0p, x0p);
lon1 = atan2(y1p, x1p);
if(fabs(lon1-lon0)/dtr > 180.)
{
if(lon0 < 0.) lon0 += 360.*dtr;
if(lon1 < 0.) lon1 += 360.*dtr;
}
sideLength = acos(x0*x1 + y0*y1 + z0*z1) / dtr;
offset = pixscale/2.*dtr;
if(lon0 > lon1)
offset = -offset;
nstep = (lon1 - lon0)/offset;
lon = lon0;
for(i=0; i<nstep; ++i)
{
lon += offset;
xp = cos(lon);
yp = sin(lon);
x = a11*xp + a21*yp;
y = a12*xp + a22*yp;
z = a13*xp + a23*yp;
rac = atan2(y,x)/dtr;
decc = asin(z)/dtr;
convertCoordinates (EQUJ, 2000., rac, decc,
csys, equinox, &ilon, &ilat, 0.);
offscl = 0;
wcs2pix(output.wcs, ilon, ilat, &oxpix, &oypix, &offscl);
fixxy(&oxpix, &oypix, &offscl);
if(haveFlux)
pixel_value = atof(tval(fluxcol));
else
pixel_value = 1;
l = (int)(oxpix + 0.5) - 1;
m = (int)(oypix + 0.5) - 1;
if(!offscl)
data[m][l] = pixel_value;
}
}
}
else
{
if(debug && count/1000*1000 == count)
{
printf("%9d sources processed\n", count);
fflush(stdout);
}
rac = atof(tval(racol));
decc = atof(tval(deccol));
convertCoordinates (EQUJ, 2000., rac, decc,
csys, equinox, &ilon, &ilat, 0.);
if(haveFlux)
pixel_value = atof(tval(fluxcol));
else
pixel_value = 1;
if(ismag)
pixel_value = pow(10., 0.4 * (refmag - pixel_value));
wcs2pix(output.wcs, ilon, ilat, &oxpix, &oypix, &offscl);
if(pixel_value < 1.e10)
{
if(debug >= 3)
{
printf(" value = %11.3e at coord = (%12.8f,%12.8f)", pixel_value, ilon, ilat);
if(offscl)
{
printf(" -> opix = (%7.1f,%7.1f) OFF SCALE\n",
oxpix, oypix);
fflush(stdout);
}
else
{
printf(" -> opix = (%7.1f,%7.1f)\n",
oxpix, oypix);
fflush(stdout);
}
}
else if(pixel_value > 1000000.)
{
printf(" value = %11.3e at coord = (%12.8f,%12.8f)", pixel_value, ilon, ilat);
if(offscl)
{
printf(" -> opix = (%7.1f,%7.1f) OFF SCALE\n",
oxpix, oypix);
fflush(stdout);
}
else
{
printf(" -> opix = (%7.1f,%7.1f)\n",
oxpix, oypix);
fflush(stdout);
}
}
if(!offscl)
{
l = (int)(oxpix + 0.5) - 1;
m = (int)(oypix + 0.5) - 1;
if(l < 0 || m < 0 || l >= output.naxes[0] || m >= output.naxes[1])
{
/*
printf("ERROR: l=%d, m=%d\n", l, m);
fflush(stdout);
*/
}
else
{
for(dl=-2; dl<=2; ++dl)
{
if(l+dl < 0 || l+dl>= output.naxes[0])
continue;
for(dm=-2; dm<=2; ++dm)
{
if(m+dm < 0 || m+dm>= output.naxes[1])
continue;
data[m+dm][l+dl] += weights[dm+2][dl+2] * pixel_value;
}
}
}
}
}
}
}
/************************/
/* Write the image data */
/************************/
fpixel = 1;
nelements = output.naxes[0] * output.naxes[1];
if (fits_write_img(output.fptr, TDOUBLE, fpixel, nelements, data[0], &status))
printFitsError(status);
if(debug >= 1)
{
printf("Data array written to FITS image\n");
fflush(stdout);
}
/*************************************/
/* Add keywords from a template file */
/*************************************/
if(fits_write_key_template(output.fptr, template_file, &status))
printFitsError(status);
if(debug >= 1)
{
printf("Template keywords written to FITS image\n");
fflush(stdout);
}
/***********************/
/* Close the FITS file */
/***********************/
if(fits_close_file(output.fptr, &status))
printFitsError(status);
if(debug >= 1)
{
printf("FITS image finalized\n");
fflush(stdout);
}
time(&currtime);
printf("[struct stat=\"OK\", time=%d]\n",
(int)(currtime - start));
fflush(stdout);
exit(0);
}
ComponentPortDescription
CPD_Handler::component_port_description (
const Deployment::ComponentPortDescription& src)
{
DANCE_TRACE("CPD_Handler::component_port_description - reverse");
::XMLSchema::string< ACE_TCHAR > name (ACE_TEXT_CHAR_TO_TCHAR (src.name));
::XMLSchema::string< ACE_TCHAR > stype (ACE_TEXT_CHAR_TO_TCHAR (src.specificType));
::XMLSchema::string< ACE_TCHAR > tval (ACE_TEXT ("true"));
::XMLSchema::string< ACE_TCHAR > fval (ACE_TEXT ("false"));
XMLSchema::boolean provider;
XMLSchema::boolean exclusiveProvider;
XMLSchema::boolean exclusiveUser;
XMLSchema::boolean optional;
if (src.provider)
provider = true;
else
provider = false;
if (src.exclusiveUser)
exclusiveUser = true;
else
provider = false;
if (src.exclusiveProvider)
exclusiveProvider = true;
else
provider = false;
if (src.optional)
optional = true;
else
provider = false;
ComponentPortDescription cpd (name,
provider,
exclusiveProvider,
exclusiveUser,
optional,
CCMComponentPortKind::Facet);
switch (src.kind)
{
case ::Deployment::Facet:
cpd.kind (CCMComponentPortKind::Facet);
break;
case ::Deployment::SimplexReceptacle:
cpd.kind (CCMComponentPortKind::SimplexReceptacle);
break;
case ::Deployment::MultiplexReceptacle:
cpd.kind (CCMComponentPortKind::MultiplexReceptacle);
break;
case ::Deployment::EventEmitter:
cpd.kind (CCMComponentPortKind::EventEmitter);
break;
case ::Deployment::EventPublisher:
cpd.kind (CCMComponentPortKind::EventPublisher);
break;
case ::Deployment::EventConsumer:
cpd.kind (CCMComponentPortKind::EventConsumer);
break;
default:
DANCE_DEBUG (DANCE_LOG_NONFATAL_ERROR,
(LM_ERROR, ACE_TEXT("Invalid port kind in connection %C\n"),
name.c_str ()));
}
for (CORBA::ULong i = 0; i < src.supportedType.length (); ++i)
{
//cpd.add_supportedType (XMLSchema::string< ACE_TCHAR > ((src.supportedType[i])));
}
return cpd;
}
void smokeModifier_do(SmokeModifierData *smd, Scene *scene, Object *ob, DerivedMesh *dm, int useRenderParams, int isFinalCalc)
{
if((smd->type & MOD_SMOKE_TYPE_FLOW))
{
if(scene->r.cfra >= smd->time)
smokeModifier_init(smd, ob, scene, dm);
if(scene->r.cfra > smd->time)
{
// XXX TODO
smd->time = scene->r.cfra;
// rigid movement support
/*
Mat4CpyMat4(smd->flow->mat_old, smd->flow->mat);
Mat4CpyMat4(smd->flow->mat, ob->obmat);
*/
}
else if(scene->r.cfra < smd->time)
{
smd->time = scene->r.cfra;
smokeModifier_reset(smd);
}
}
else if(smd->type & MOD_SMOKE_TYPE_COLL)
{
if(scene->r.cfra >= smd->time)
smokeModifier_init(smd, ob, scene, dm);
if(scene->r.cfra > smd->time)
{
// XXX TODO
smd->time = scene->r.cfra;
if(smd->coll->dm)
smd->coll->dm->release(smd->coll->dm);
smd->coll->dm = CDDM_copy(dm);
// rigid movement support
Mat4CpyMat4(smd->coll->mat_old, smd->coll->mat);
Mat4CpyMat4(smd->coll->mat, ob->obmat);
}
else if(scene->r.cfra < smd->time)
{
smd->time = scene->r.cfra;
smokeModifier_reset(smd);
}
}
else if(smd->type & MOD_SMOKE_TYPE_DOMAIN)
{
SmokeDomainSettings *sds = smd->domain;
float light[3];
PointCache *cache = NULL;
PTCacheID pid;
PointCache *cache_wt = NULL;
PTCacheID pid_wt;
int startframe, endframe, framenr;
float timescale;
int cache_result = 0, cache_result_wt = 0;
framenr = scene->r.cfra;
// printf("time: %d\n", scene->r.cfra);
if(framenr == smd->time)
return;
cache = sds->point_cache[0];
BKE_ptcache_id_from_smoke(&pid, ob, smd);
BKE_ptcache_id_time(&pid, scene, framenr, &startframe, &endframe, ×cale);
cache_wt = sds->point_cache[1];
BKE_ptcache_id_from_smoke_turbulence(&pid_wt, ob, smd);
if(!smd->domain->fluid)
{
BKE_ptcache_id_reset(scene, &pid, PTCACHE_RESET_OUTDATED);
BKE_ptcache_id_reset(scene, &pid_wt, PTCACHE_RESET_OUTDATED);
}
if(framenr < startframe)
return;
if(framenr > endframe)
return;
if(!smd->domain->fluid && (framenr != startframe))
return;
// printf("startframe: %d, framenr: %d\n", startframe, framenr);
if(!smokeModifier_init(smd, ob, scene, dm))
{
printf("bad smokeModifier_init\n");
return;
}
/* try to read from cache */
cache_result = BKE_ptcache_read_cache(&pid, (float)framenr, scene->r.frs_sec);
// printf("cache_result: %d\n", cache_result);
if(cache_result == PTCACHE_READ_EXACT)
{
cache->flag |= PTCACHE_SIMULATION_VALID;
cache->simframe= framenr;
if(sds->wt)
{
cache_result_wt = BKE_ptcache_read_cache(&pid_wt, (float)framenr, scene->r.frs_sec);
if(cache_result_wt == PTCACHE_READ_EXACT)
{
cache_wt->flag |= PTCACHE_SIMULATION_VALID;
cache_wt->simframe= framenr;
}
}
return;
}
tstart();
smoke_calc_domain(scene, ob, smd);
// set new time
smd->time = scene->r.cfra;
/* do simulation */
// low res
cache->flag |= PTCACHE_SIMULATION_VALID;
cache->simframe= framenr;
// simulate the actual smoke (c++ code in intern/smoke)
// DG: interesting commenting this line + deactivating loading of noise files
if(framenr!=startframe)
{
if(sds->flags & MOD_SMOKE_DISSOLVE)
smoke_dissolve(sds->fluid, sds->diss_speed, sds->flags & MOD_SMOKE_DISSOLVE_LOG);
smoke_step(sds->fluid, smd->time);
}
// create shadows before writing cache so we get nice shadows for sstartframe, too
if(get_lamp(scene, light))
smoke_calc_transparency(sds->shadow, smoke_get_density(sds->fluid), sds->p0, sds->p1, sds->res, sds->dx, light, calc_voxel_transp, -7.0*sds->dx);
BKE_ptcache_write_cache(&pid, framenr);
if(sds->wt)
{
if(framenr!=startframe)
{
if(sds->flags & MOD_SMOKE_DISSOLVE)
smoke_dissolve_wavelet(sds->wt, sds->diss_speed, sds->flags & MOD_SMOKE_DISSOLVE_LOG);
smoke_turbulence_step(sds->wt, sds->fluid);
}
cache_wt->flag |= PTCACHE_SIMULATION_VALID;
cache_wt->simframe= framenr;
BKE_ptcache_write_cache(&pid_wt, framenr);
}
tend();
printf ( "Frame: %d, Time: %f\n", (int)smd->time, ( float ) tval() );
}
}
int main(int argc, char **argv)
{
int i, j, k, ncol, nimages;
int haveHdr, itmp, istat, mAddCntr;
int nparents, parent, parent_prev;
int naxis1s, naxis2s;
char line [MAXSTR];
char mproj [MAXSTR];
char survey [MAXSTR];
char band [MAXSTR];
char hdrFile [MAXSTR];
char mosaicCentLon [MAXSTR];
char mosaicCentLat [MAXSTR];
char mosaicWidth [MAXSTR];
char mosaicHeight [MAXSTR];
char mosaicCdelt [MAXSTR];
char workdir [MAXSTR];
char urlbase [MAXSTR];
char workurlbase [MAXSTR];
char timestr [MAXSTR];
char cmd [MAXSTR];
char status [MAXSTR];
char msg [MAXSTR];
char fname [MAXSTR];
char fitname [MAXSTR];
char plusname [MAXSTR];
char minusname [MAXSTR];
char jobid [MAXSTR];
char fileList [MAXSTR];
char parentList [MAXSTR];
char sortedParent [MAXSTR];
char *fileid;
char *parentid;
clock_t timeval;
double width;
double height;
double cdelt;
double crval1, crval2;
double crpix1, crpix2;
int ifname, iurl, icntr1, icntr2, iplusname, iminusname, iscale;
int cntr, cntr1, cntr2, id, level;
int shrinkFactor, shrinkFactorX, shrinkFactorY;
double x, y, z;
double xc, yc, zc;
double xpos, ypos, dtr;
double dist, maxRadius;
double lonc, latc;
FILE *fp;
FILE *fdag;
FILE *ffit;
FILE *fcache;
FILE *furl;
FILE *ffile;
FILE *fparent;
char dv_version [MAXSTR];
int maxtbl = 1000;
char key[MAXSTR];
char val[MAXSTR];
struct stat type;
HT_table_t *depends;
char *path = getenv("MONTAGE_HOME");
/* Various time value variables */
char buffer[256];
int yr, mo, day, hr, min, sec, pid;
time_t curtime;
struct tm *loctime;
char idstr[256];
dtr = atan(1.0)/45.;
strcpy(dv_version, "1.0");
HT_set_debug(0);
/* Generate a unique ID based on data/time/pid */
curtime = time (NULL);
loctime = localtime (&curtime);
strftime(buffer, 256, "%Y", loctime);
yr = atoi(buffer);
strftime(buffer, 256, "%m", loctime);
mo = atoi(buffer);
strftime(buffer, 256, "%d", loctime);
day = atoi(buffer);
strftime(buffer, 256, "%H", loctime);
hr = atoi(buffer);
strftime(buffer, 256, "%M", loctime);
min = atoi(buffer);
strftime(buffer, 256, "%S", loctime);
sec = atoi(buffer);
pid = (int)getpid();
sprintf(idstr, "%04d%02d%02d_%02d%02d%02d_%d",
yr, mo, day, hr, min, sec, pid);
/* Set up the dependency hash table */
depends = HT_create_table(maxtbl);
timeval = time(0);
strcpy(timestr, ctime((const time_t *)(&timeval)));
for(i=0; i<strlen(timestr); ++i)
if(timestr[i] == '\n')
timestr[i] = '\0';
if(debug)
{
fdebug = fopen("debug.txt", "w+");
if(fdebug == (FILE *)NULL)
{
printf("[struct stat=\"ERROR\", msg=\"Error opening debug file\"]\n");
exit(0);
}
fprintf(fdebug, "DEBUGGING mDAG:\n\n");
fflush(fdebug);
if(debug > 1)
svc_debug(fdebug);
}
/* Get the location/size information */
haveHdr = 0;
if(argc < 11)
{
printf("[struct stat=\"ERROR\", msg=\"Usage: %s survey band centerlon centerlat width height cdelt workdir workurlbase urlbase | %s -h survey band hdrfile workdir workurlbase urlbase (object/location string must be a single argument)\"]\n", argv[0], argv[0]);
exit(0);
}
strcpy(survey, argv[1]);
strcpy(band, argv[2]);
strcpy(mosaicCentLon, argv[3]);
strcpy(mosaicCentLat, argv[4]);
strcpy(mosaicWidth, argv[5]);
strcpy(mosaicHeight, argv[6]);
strcpy(mosaicCdelt, argv[7]);
strcpy(workdir, argv[8]);
strcpy(workurlbase, argv[9]);
strcpy(urlbase, argv[10]);
crval1 = atof(mosaicCentLon);
crval2 = atof(mosaicCentLat);
width = fabs(atof(mosaicWidth));
height = fabs(atof(mosaicHeight));
cdelt = fabs(atof(mosaicCdelt));
naxis1 = (int)(width / cdelt) + 0.5;
naxis2 = (int)(height / cdelt) + 0.5;
crpix1 = (naxis1+1.)/2.;
crpix2 = (naxis2+1.)/2.;
istat = stat(workdir, &type);
if(istat < 0)
printError("work directory doesn't exist");
strcpy(mproj, "mProject");
/********************************************************/
/* we have the size/center, we need to build the header */
/********************************************************/
/*******************************/
/* Create header template file */
/*******************************/
sprintf(hdrFile, "%s/region.hdr", workdir);
fp = fopen(hdrFile, "w+");
if(fp == (FILE *)NULL)
{
printf("[struct stat=\"ERROR\", msg=\"Error opening header template file\"]\n");
exit(0);
}
fprintf(fp, "SIMPLE = T\n" );
fprintf(fp, "BITPIX = -64\n" );
fprintf(fp, "NAXIS = 2\n" );
fprintf(fp, "NAXIS1 = %d\n", naxis1 );
fprintf(fp, "NAXIS2 = %d\n", naxis2 );
fprintf(fp, "CTYPE1 = '%s'\n", "GLON-CAR" );
fprintf(fp, "CTYPE2 = '%s'\n", "GLAT-CAR" );
fprintf(fp, "CRVAL1 = %11.6f\n", crval1 );
fprintf(fp, "CRVAL2 = %11.6f\n", crval2 );
fprintf(fp, "CRPIX1 = %11.6f\n", crpix1 );
fprintf(fp, "CRPIX2 = %11.6f\n", crpix2 );
fprintf(fp, "CDELT1 = %.9f\n", -cdelt );
fprintf(fp, "CDELT2 = %.9f\n", cdelt );
fprintf(fp, "CROTA2 = %11.6f\n", 0.0 );
fprintf(fp, "EQUINOX = %d\n", 2000 );
if(strcasecmp(survey, "2MASS") == 0)
{
if(strcasecmp(band, "J") == 0)
fprintf(fp, "MAGZP = %11.6f\n", 20.9044);
else if(strcasecmp(band, "H") == 0)
fprintf(fp, "MAGZP = %11.6f\n", 20.4871);
else if(strcasecmp(band, "K") == 0)
fprintf(fp, "MAGZP = %11.6f\n", 19.9757);
}
fprintf(fp, "END\n" );
fclose(fp);
/***********************************/
/* Create big header template file */
/***********************************/
sprintf(hdrFile, "%s/big_region.hdr", workdir);
fp = fopen(hdrFile, "w+");
if(fp == (FILE *)NULL)
{
printf("[struct stat=\"ERROR\", msg=\"Error opening big header template file\"]\n");
exit(0);
}
fprintf(fp, "SIMPLE = T\n" );
fprintf(fp, "BITPIX = -64\n" );
fprintf(fp, "NAXIS = 2\n" );
fprintf(fp, "NAXIS1 = %d\n", naxis1+3000 );
fprintf(fp, "NAXIS2 = %d\n", naxis2+3000 );
fprintf(fp, "CTYPE1 = '%s'\n", "GLON-CAR" );
fprintf(fp, "CTYPE2 = '%s'\n", "GLAT-CAR" );
fprintf(fp, "CRVAL1 = %11.6f\n", crval1 );
fprintf(fp, "CRVAL2 = %11.6f\n", crval2 );
fprintf(fp, "CRPIX1 = %11.6f\n", crpix1+1500 );
fprintf(fp, "CRPIX2 = %11.6f\n", crpix2+1500 );
fprintf(fp, "CDELT1 = %.9f\n", -cdelt );
fprintf(fp, "CDELT2 = %.9f\n", cdelt );
fprintf(fp, "CROTA2 = %11.6f\n", 0.0 );
fprintf(fp, "EQUINOX = %d\n", 2000 );
if(strcasecmp(survey, "2MASS") == 0)
{
if(strcasecmp(band, "J") == 0)
fprintf(fp, "MAGZP = %11.6f\n", 20.9044);
else if(strcasecmp(band, "H") == 0)
fprintf(fp, "MAGZP = %11.6f\n", 20.4871);
else if(strcasecmp(band, "K") == 0)
fprintf(fp, "MAGZP = %11.6f\n", 19.9757);
}
fprintf(fp, "END\n" );
fclose(fp);
/************************************************/
/* Get list of raw input images for this region */
/************************************************/
/* this is how mExec is implemented */
double scaleWidth = width * 1.42;
double scaleHeight = height * 1.42;
if(path)
sprintf(cmd, "%s/bin/mArchiveList %s %s \"%s %s gal\" %.2f %.2f %s/images.tbl",
path, survey, band, mosaicCentLon, mosaicCentLat, scaleWidth,
scaleHeight, workdir);
else
sprintf(cmd, "mArchiveList %s %s \"%s %s gal\" %.2f %.2f %s/images.tbl",
survey, band, mosaicCentLon, mosaicCentLat, scaleWidth,
scaleHeight, workdir);
if(debug)
{
fprintf(fdebug, "[%s]\n", cmd);
fflush(fdebug);
}
svc_run(cmd);
strcpy( status, svc_value( "stat" ));
if (strcmp( status, "ERROR") == 0)
{
strcpy( msg, svc_value( "msg" ));
printError(msg);
}
if (strcmp(status, "ABORT") == 0)
{
strcpy( msg, svc_value( "msg" ));
printError(msg);
}
nimages = atof(svc_value("count"));
if (nimages == 0)
{
sprintf( msg, "%s has no data covering this area", survey);
printError(msg);
}
/*****************************************/
/* Get the image lists the DAG will need */
/*****************************************/
if(path)
sprintf(cmd, "%s/bin/mDAGTbls %s/images.tbl %s/big_region.hdr %s/rimages.tbl %s/pimages.tbl %s/cimages.tbl",
path, workdir, workdir, workdir, workdir, workdir);
else
sprintf(cmd, "mDAGTbls %s/images.tbl %s/big_region.hdr %s/rimages.tbl %s/pimages.tbl %s/cimages.tbl",
workdir, workdir, workdir, workdir, workdir);
if(debug)
{
fprintf(fdebug, "[%s]\n", cmd);
fflush(fdebug);
}
svc_run(cmd);
strcpy( status, svc_value( "stat" ));
if (strcmp( status, "ERROR") == 0)
{
strcpy( msg, svc_value( "msg" ));
printError(msg);
}
/******************************************/
/* Get the overlap list the DAG will need */
/******************************************/
if(path)
sprintf(cmd, "%s/bin/mOverlaps %s/rimages.tbl %s/diffs.tbl",
path, workdir, workdir);
else
sprintf(cmd, " mOverlaps %s/rimages.tbl %s/diffs.tbl",
workdir, workdir);
if(debug)
{
fprintf(fdebug, "[%s]\n", cmd);
fflush(fdebug);
}
svc_run(cmd);
strcpy( status, svc_value( "stat" ));
if (strcmp( status, "ERROR") == 0)
{
strcpy( msg, svc_value( "msg" ));
printError(msg);
}
/****************************************************/
/* Determine shrink factor for presentation image. */
/****************************************************/
shrinkFactorX = (int)(naxis1 / 1024. + 1.);
shrinkFactorY = (int)(naxis2 / 1024. + 1.);
shrinkFactor = shrinkFactorX;
if(shrinkFactor < shrinkFactorY)
shrinkFactor = shrinkFactorY;
if(debug)
{
fprintf(fdebug, "\n");
fprintf(fdebug, "shrinkFactorX = %d\n", shrinkFactorX);
fprintf(fdebug, "shrinkFactorY = %d\n", shrinkFactorY);
fprintf(fdebug, "shrinkFactor = %d\n", shrinkFactor);
fprintf(fdebug, "\n");
fflush(fdebug);
}
/***********************************************/
/* Now we can generate the DAG XML file itself */
/* First the XML header */
/***********************************************/
if(debug)
{
fprintf(fdebug, "Generating DAG file header ...\n");
fflush(fdebug);
}
sprintf(cmd, "%s/dag.xml", workdir);
fdag = fopen(cmd, "w+");
sprintf(cmd, "%s/cache.list", workdir);
fcache = fopen(cmd, "w+");
sprintf(cmd, "%s/url.list", workdir);
furl = fopen(cmd, "w+");
fprintf(fdag, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
fprintf(fdag, "<!-- Generated: %s -->\n", timestr);
fprintf(fdag, "<!-- Generated by: Montage DAG service -->\n\n");
fprintf(fdag, "<adag xmlns=\"http://pegasus.isi.edu/schema/DAX\"\n");
fprintf(fdag, " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n");
fprintf(fdag, " xsi:schemaLocation=\"http://pegasus.isi.edu/schema/DAX http://pegasus.isi.edu/schema/dax-2.1.xsd\"\n");
fprintf(fdag, " version=\"2.1\" count=\"1\" index=\"0\" name=\"montage\">\n\n");
fflush(fdag);
fprintf(fdag, " <!-- Survey: %-30s -->\n", survey);
fprintf(fdag, " <!-- Band: %-30s -->\n", band);
fprintf(fdag, " <!-- Center Longitude: %-30s -->\n", mosaicCentLon);
fprintf(fdag, " <!-- Center Latitude: %-30s -->\n", mosaicCentLat);
if(haveHdr)
fprintf(fdag, " <!-- (WCS is in input header file) -->\n");
else
{
fprintf(fdag, " <!-- Width: %-30s -->\n", mosaicWidth);
fprintf(fdag, " <!-- Height: %-30s -->\n", mosaicHeight);
}
fprintf(fdag, "\n\n");
fflush(fdag);
/******************************************/
/* compose the url lfn cache list */
/******************************************/
sprintf(cmd, "%s/images.tbl", workdir);
ncol = topen(cmd);
ifname = tcol("file");
iurl = tcol("URL");
if(ifname < 0)
printError("'Raw' image list does not have column 'file'");
if(iurl < 0)
printError("'Raw' image list does not have column 'url'");
while(1)
{
istat = tread();
if(istat < 0)
break;
fprintf(furl, "%s %s pool=\"ipac_cluster\"\n", tval(ifname), tval(iurl));
}
tclose();
fclose(furl);
/******************************************/
/* DAG: "filename" lines for input images */
/******************************************/
if(debug)
{
fprintf(fdebug, "Generating DAG file filename list ...\n");
fflush(fdebug);
}
fprintf(fdag, " <!-- Part 1: Files Used -->\n\n");
sprintf(cmd, "%s/rimages.tbl", workdir);
ncol = topen(cmd);
ifname = tcol("file");
if(ifname < 0)
printError("'Raw' image list does not have column 'file'");
while(1)
{
istat = tread();
if(istat < 0)
break;
fprintf(fdag, " <filename file=\"%s\" link=\"input\"/>\n", tval(ifname));
}
fprintf(fdag, "\n");
fflush(fdag);
tclose();
/**********************************************/
/* DAG: "filename" lines for projected images */
/* including area files */
/**********************************************/
sprintf(cmd, "%s/pimages.tbl", workdir);
ncol = topen(cmd);
ifname = tcol("file");
if(ifname < 0)
printError("'Projected' image list does not have column 'file'");
while(1)
{
istat = tread();
if(istat < 0)
break;
fprintf(fdag, " <filename file=\"%s\" link=\"inout\"/>\n", tval(ifname));
strcpy(fname, tval(ifname));
fname[strlen(fname)-5] = '\0';
strcat(fname, "_area.fits");
fprintf(fdag, " <filename file=\"%s\" link=\"inout\"/>\n", fname);
}
fprintf(fdag, "\n");
fflush(fdag);
tclose();
/***********************************************/
/* DAG: "filename" lines for difference images */
/* and fit output files (plus one more file */
/* with a list of these fits) */
/***********************************************/
sprintf(cmd, "%s/diffs.tbl", workdir);
ncol = topen(cmd);
ifname = tcol("diff");
icntr1 = tcol("cntr1");
icntr2 = tcol("cntr2");
if(ifname < 0)
printError("'Diff' image list does not have column 'diff'");
sprintf(cmd, "%s/statfile.tbl", workdir);
ffit = fopen(cmd, "w+");
sprintf(fmt, "|%%7s|%%7s|%%22s|\n");
sprintf(dfmt, " %%7d %%7d %%22s \n");
fprintf(ffit, fmt, "cntr1", "cntr2", "stat");
fprintf(ffit, fmt, "int", "int", "char");
while(1)
{
istat = tread();
if(istat < 0)
break;
cntr1 = atoi(tval(icntr1));
cntr2 = atoi(tval(icntr2));
fprintf(fdag, " <filename file=\"%s\" link=\"output\"/>\n", tval(ifname));
strcpy(fname, tval(ifname));
fname[strlen(fname)-5] = '\0';
sprintf(fitname, "fit%s.txt", fname+4);
fprintf(fdag, " <filename file=\"%s\" link=\"inout\"/>\n\n", fitname);
fprintf(ffit, dfmt, cntr1, cntr2, fitname);
}
fflush(fdag);
tclose();
fclose(ffit);
fprintf(fdag, " <filename file=\"statfile_%s.tbl\" link=\"input\"/>\n", idstr);
fprintf(fdag, " <filename file=\"fits.tbl\" link=\"inout\"/>\n");
fprintf(fdag, "\n");
fflush(fdag);
fprintf(fcache, "statfile_%s.tbl %s/%s/statfile.tbl pool=\"ipac_cluster\"\n", idstr, workurlbase, workdir);
/***********************************************/
/* DAG: "filename" lines for corrections table */
/* and the corrected image files (including */
/* area files) */
/***********************************************/
fprintf(fdag, " <filename file=\"corrections.tbl\" link=\"inout\"/>\n");
fprintf(fdag, "\n");
fflush(fdag);
sprintf(cmd, "%s/cimages.tbl", workdir);
ncol = topen(cmd);
ifname = tcol("file");
if(ifname < 0)
printError("'Corrected' image list does not have column 'file'");
while(1)
{
istat = tread();
if(istat < 0)
break;
fprintf(fdag, " <filename file=\"%s\" link=\"inout\"/>\n", tval(ifname));
strcpy(fname, tval(ifname));
fname[strlen(fname)-5] = '\0';
strcat(fname, "_area.fits");
fprintf(fdag, " <filename file=\"%s\" link=\"inout\"/>\n", fname);
}
fprintf(fdag, "\n");
fflush(fdag);
tclose();
/***********************************************/
/* DAG: "filename" lines for template files, */
/* subset image files, output files, and */
/* shrunken output files. */
/***********************************************/
fprintf(fdag, " <filename file=\"newcimages.tbl\" link=\"inout\"/>\n");
fprintf(fdag, "\n");
fflush(fdag);
fprintf(fdag, " <filename file=\"big_region_%s.hdr\" link=\"input\"/>\n", idstr);
fprintf(fdag, " <filename file=\"region_%s.hdr\" link=\"input\"/>\n", idstr);
fprintf(fdag, " <filename file=\"pimages_%s.tbl\" link=\"input\"/>\n", idstr);
fprintf(fdag, " <filename file=\"cimages_%s.tbl\" link=\"input\"/>\n", idstr);
fprintf(fdag, " <filename file=\"dag_%s.xml\" link=\"inout\"/>\n", idstr);
fprintf(fdag, " <filename file=\"images_%s.tbl\" link=\"inout\"/>\n", idstr);
fprintf(fdag, "\n");
fprintf(fdag, " <filename file=\"shrunken_%s.hdr\" link=\"inout\"/>\n", idstr);
fprintf(fdag, " <filename file=\"shrunken_%s.fits\" link=\"inout\"/>\n", idstr);
fprintf(fdag, " <filename file=\"shrunken_%s.jpg\" link=\"output\"/>\n", idstr);
fprintf(fdag, "\n\n");
fflush(fdag);
fprintf(fcache, "big_region_%s.hdr %s/%s/big_region.hdr pool=\"ipac_cluster\"\n", idstr, workurlbase, workdir);
fprintf(fcache, "region_%s.hdr %s/%s/region.hdr pool=\"ipac_cluster\"\n", idstr, workurlbase, workdir);
fprintf(fcache, "pimages_%s.tbl %s/%s/pimages.tbl pool=\"ipac_cluster\"\n", idstr, workurlbase, workdir);
fprintf(fcache, "cimages_%s.tbl %s/%s/cimages.tbl pool=\"ipac_cluster\"\n", idstr, workurlbase, workdir);
fflush(fcache);
/* to be saved in user's storage space */
fprintf(fcache, "dag_%s.xml %s/%s/dag.xml pool=\"ipac_cluster\"\n", idstr, workurlbase, workdir);
fprintf(fcache, "images_%s.tbl %s/%s/images.tbl pool=\"ipac_cluster\"\n", idstr, workurlbase, workdir);
/**************************************************/
/* DAG: "job" lines for mProject/mProjectPP jobs. */
/**************************************************/
if(debug)
{
fprintf(fdebug, "Generating DAG file job list ...\n");
fflush(fdebug);
}
id = 0;
level = 9;
fprintf(fdag, " <!-- Part 2: Definition of Jobs -->\n\n");
cntr = 0;
sprintf(cmd, "%s/rimages.tbl", workdir);
ncol = topen(cmd);
ifname = tcol("file");
iscale = tcol("scale");
if(ifname < 0)
printError("'Raw' image list does not have column 'file'");
while(1)
{
istat = tread();
if(istat < 0)
break;
++id;
++cntr;
strcpy(fname, tval(ifname));
fname[strlen(fname) - 5] = '\0';
fprintf(fdag," <job id=\"ID%06d\" name=\"%s\" version=\"3.0\" level=\"%d\" dv-name=\"mProject%d\" dv-version=\"1.0\">\n", id, mproj, level, cntr);
if(iscale >= 0)
fprintf(fdag," <argument>\n -X\n -x %s\n <filename file=\"%s.fits\"/>\n <filename file=\"p%s.fits\"/>\n <filename file=\"big_region_%s.hdr\"/>\n </argument>\n\n", tval(iscale), fname, fname, idstr);
else
fprintf(fdag," <argument>\n -X\n <filename file=\"%s.fits\"/>\n <filename file=\"p%s.fits\"/>\n <filename file=\"big_region_%s.hdr\"/>\n </argument>\n\n", fname, fname, idstr);
fprintf(fdag," <uses file=\"%s.fits\" link=\"input\" transfer=\"true\"/>\n", fname);
sprintf(key, "ID%06d", id);
sprintf(val, "%s.fits", fname);
HT_add_entry(depends, key, val);
fprintf(fcache,"%s.fits %s/%s.fits pool=\"ipac_cluster\"\n",fname,urlbase,fname);
fprintf(fdag," <uses file=\"p%s.fits\" link=\"output\" register=\"false\" transfer=\"false\"/>\n", fname);
sprintf(key, "p%s.fits", fname);
sprintf(val, "ID%06d", id);
HT_add_entry(depends, key, val);
fprintf(fdag," <uses file=\"p%s_area.fits\" link=\"output\" register=\"false\" transfer=\"false\"/>\n", fname);
fprintf(fdag," <uses file=\"big_region_%s.hdr\" link=\"input\" transfer=\"true\"/>\n", idstr);
sprintf(key, "ID%06d", id);
sprintf(val, "big_region.hdr");
HT_add_entry(depends, key, val);
fprintf(fdag," </job>\n\n\n");
}
tclose();
fflush(fcache);
fclose(fcache);
/***************************************/
/* DAG: "job" lines for mDiffFit jobs. */
/***************************************/
cntr = 0;
sprintf(cmd, "%s/diffs.tbl", workdir);
ncol = topen(cmd);
icntr1 = tcol("cntr1");
icntr2 = tcol("cntr2");
iplusname = tcol("plus");
iminusname = tcol("minus");
--level;
while(1)
{
istat = tread();
if(istat < 0)
break;
++id;
++cntr;
cntr1 = atoi(tval(icntr1));
cntr2 = atoi(tval(icntr2));
strcpy(plusname, tval(iplusname));
strcpy(minusname, tval(iminusname));
plusname [strlen(plusname) - 5] = '\0';
minusname[strlen(minusname) - 5] = '\0';
fname[strlen(fname) - 5] = '\0';
fprintf(fdag, " <job id=\"ID%06d\" name=\"mDiffFit\" version=\"3.0\" level=\"%d\" dv-name=\"mDiffFit%d\" dv-version=\"1.0\">\n", id, level, cntr);
fprintf(fdag, " <argument>\n -s <filename file=\"fit.%06d.%06d.txt\"/>\n <filename file=\"p%s.fits\"/>\n <filename file=\"p%s.fits\"/>\n <filename file=\"diff.%06d.%06d.fits\"/>\n <filename file=\"big_region_%s.hdr\"/>\n </argument>\n\n",
cntr1, cntr2, plusname, minusname, cntr1, cntr2, idstr);
fprintf(fdag, " <uses file=\"mDiff\" link=\"input\" transfer=\"true\" type=\"executable\"/>\n");
fprintf(fdag, " <uses file=\"mFitplane\" link=\"input\" transfer=\"true\" type=\"executable\"/>\n");
fprintf(fdag, " <uses file=\"fit.%06d.%06d.txt\" link=\"output\" register=\"false\" transfer=\"false\"/>\n",
cntr1, cntr2);
sprintf(key, "fit.%06d.%06d.txt", cntr1, cntr2);
sprintf(val, "ID%06d", id);
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"p%s.fits\" link=\"input\" transfer=\"true\"/>\n",
plusname);
sprintf(key, "ID%06d", id);
sprintf(val, "p%s.fits", plusname);
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"p%s_area.fits\" link=\"input\" transfer=\"true\"/>\n",
plusname);
fprintf(fdag, " <uses file=\"p%s.fits\" link=\"input\" transfer=\"true\"/>\n",
minusname);
sprintf(key, "ID%06d", id);
sprintf(val, "p%s.fits", minusname);
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"p%s_area.fits\" link=\"input\" transfer=\"true\"/>\n",
minusname);
fprintf(fdag, " <uses file=\"diff.%06d.%06d.fits\" link=\"output\" register=\"false\" transfer=\"false\" optional=\"true\"/>\n", cntr1, cntr2);
sprintf(key, "diff.%06d.%06d.fits", cntr1, cntr2);
sprintf(val, "ID%06d", id);
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"big_region_%s.hdr\" link=\"input\" transfer=\"true\"/>\n", idstr);
sprintf(key, "ID%06d", id);
sprintf(val, "big_region.hdr");
HT_add_entry(depends, key, val);
fprintf(fdag, " </job>\n\n\n");
}
tclose();
/****************************************/
/* DAG: "job" line for mConcatFit jobs. */
/****************************************/
++id;
--level;
fprintf(fdag, " <job id=\"ID%06d\" name=\"mConcatFit\" version=\"3.0\" level=\"%d\" dv-name=\"mConcatFit1\" dv-version=\"1.0\">\n", id, level);
fprintf(fdag, " <argument>\n <filename file=\"statfile_%s.tbl\"/>\n <filename file=\"fits.tbl\"/>\n .\n </argument>\n\n", idstr);
fprintf(fdag, " <uses file=\"statfile_%s.tbl\" link=\"input\" transfer=\"true\"/>\n", idstr);
sprintf(key, "ID%06d", id);
sprintf(val, "statfile.tbl");
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"fits.tbl\" link=\"output\" register=\"false\" transfer=\"false\"/>\n");
sprintf(key, "fits.tbl");
sprintf(val, "ID%06d", id);
HT_add_entry(depends, key, val);
sprintf(cmd, "%s/diffs.tbl", workdir);
ncol = topen(cmd);
icntr1 = tcol("cntr1");
icntr2 = tcol("cntr2");
while(1)
{
istat = tread();
if(istat < 0)
break;
cntr1 = atoi(tval(icntr1));
cntr2 = atoi(tval(icntr2));
fprintf(fdag, " <uses file=\"fit.%06d.%06d.txt\" link=\"input\" transfer=\"true\"/>\n",
cntr1, cntr2);
sprintf(key, "ID%06d", id);
sprintf(val, "fit.%06d.%06d.txt", cntr1, cntr2);
HT_add_entry(depends, key, val);
}
tclose();
fprintf(fdag, " </job>\n\n\n");
/*************************************/
/* DAG: "job" line for mBgModel job. */
/*************************************/
++id;
--level;
fprintf(fdag, " <job id=\"ID%06d\" name=\"mBgModel\" version=\"3.0\" level=\"%d\" dv-name=\"mBgModel1\" dv-version=\"1.0\">\n", id, level);
fprintf(fdag, " <argument>\n -l\n -i 100000\n <filename file=\"pimages_%s.tbl\"/>\n <filename file=\"fits.tbl\"/>\n <filename file=\"corrections.tbl\"/>\n </argument>\n\n", idstr);
fprintf(fdag, " <uses file=\"pimages_%s.tbl\" link=\"input\" transfer=\"true\"/>\n", idstr);
sprintf(key, "ID%06d", id);
sprintf(val, "pimages.tbl");
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"fits.tbl\" link=\"input\" transfer=\"true\"/>\n");
sprintf(key, "ID%06d", id);
sprintf(val, "fits.tbl");
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"corrections.tbl\" link=\"output\" register=\"false\" transfer=\"false\"/>\n");
sprintf(key, "corrections.tbl");
sprintf(val, "ID%06d", id);
HT_add_entry(depends, key, val);
fprintf(fdag, " </job>\n\n\n");
/*****************************************/
/* DAG: "job" line for mBackground jobs. */
/*****************************************/
--level;
cntr = 0;
sprintf(cmd, "%s/rimages.tbl", workdir);
ncol = topen(cmd);
ifname = tcol("file");
if(ifname < 0)
printError("'Raw' image list does not have column 'file'");
while(1)
{
istat = tread();
if(istat < 0)
break;
strcpy(fname, tval(ifname));
fname[strlen(fname) - 5] = '\0';
++id;
++cntr;
fprintf(fdag, " <job id=\"ID%06d\" name=\"mBackground\" version=\"3.0\" level=\"%d\" dv-name=\"mBackground%d\" dv-version=\"1.0\">\n", id, level, cntr);
fprintf(fdag, " <argument>\n -t\n <filename file=\"p%s.fits\"/>\n <filename file=\"c%s.fits\"/>\n <filename file=\"pimages_%s.tbl\"/>\n <filename file=\"corrections.tbl\"/>\n </argument>\n\n",
fname, fname, idstr);
fprintf(fdag, " <uses file=\"p%s.fits\" link=\"input\" transfer=\"true\"/>\n",
fname);
sprintf(key, "ID%06d", id);
sprintf(val, "p%s.fits", fname);
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"p%s_area.fits\" link=\"input\" transfer=\"true\"/>\n",
fname);
fprintf(fdag, " <uses file=\"pimages_%s.tbl\" link=\"input\" transfer=\"true\"/>\n", idstr);
sprintf(key, "ID%06d", id);
sprintf(val, "pimages.tbl");
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"corrections.tbl\" link=\"input\" transfer=\"true\"/>\n");
sprintf(key, "ID%06d", id);
sprintf(val, "corrections.tbl");
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"c%s.fits\" link=\"output\" register=\"false\" transfer=\"false\"/>\n",
fname);
sprintf(key, "c%s.fits", fname);
sprintf(val, "ID%06d", id);
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"c%s_area.fits\" link=\"output\" register=\"false\" transfer=\"false\"/>\n",
fname);
fprintf(fdag, " </job>\n\n\n");
}
fflush(fdag);
/**********************************************/
/* DAG: "job" lines for tile mImgtbl jobs. */
/* We have to regenerate the cimages table(s) */
/* because the pixel offsets and sizes need */
/* to be exactly right and the original is */
/* only an approximation. */
/**********************************************/
--level;
cntr = 0;
++id;
++cntr;
fprintf(fdag, " <job id=\"ID%06d\" name=\"mImgtbl\" version=\"3.0\" level=\"%d\" dv-name=\"mImgtbl%d\" dv-version=\"1.0\">\n",
id, level, cntr);
fprintf(fdag, " <argument>\n .\n -t <filename file=\"cimages_%s.tbl\"/>\n <filename file=\"newcimages.tbl\"/>\n </argument>\n\n", idstr);
fprintf(fdag, " <uses file=\"cimages_%s.tbl\" link=\"input\" transfer=\"true\"/>\n", idstr);
sprintf(key, "ID%06d", id);
sprintf(val, "cimages.tbl");
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"newcimages.tbl\" link=\"output\" register=\"false\" transfer=\"false\"/>\n");
sprintf(key, "newcimages.tbl");
sprintf(val, "ID%06d", id);
HT_add_entry(depends, key, val);
sprintf(cmd, "%s/cimages.tbl", workdir);
ncol = topen(cmd);
ifname = tcol("file");
if(ifname < 0)
printError("'Corrected' image list does not have column 'file'");
while(1)
{
istat = tread();
if(istat < 0)
break;
strcpy(fname, tval(ifname));
fname[strlen(fname) - 5] = '\0';
fprintf(fdag, " <uses file=\"%s.fits\" link=\"input\" transfer=\"true\"/>\n",
fname);
sprintf(key, "ID%06d", id);
sprintf(val, "%s.fits", fname);
HT_add_entry(depends, key, val);
}
tclose();
fprintf(fdag, " </job>\n\n\n");
fflush(fdag);
/*******************************************/
/* DAG: "job" lines for tile mAdd jobs. */
/*******************************************/
--level;
cntr = 0;
++id;
++cntr;
fprintf(fdag, " <job id=\"ID%06d\" name=\"mAdd\" version=\"3.0\" level=\"%d\" dv-name=\"mAdd%d\" dv-version=\"1.0\">\n",
id, level, cntr);
fprintf(fdag, " <argument>\n -e\n <filename file=\"newcimages.tbl\"/>\n <filename file=\"region_%s.hdr\"/>\n <filename file=\"mosaic_%s.fits\"/>\n </argument>\n\n", idstr, idstr);
fprintf(fdag, " <uses file=\"newcimages.tbl\" link=\"input\" transfer=\"true\"/>\n");
sprintf(key, "ID%06d", id);
sprintf(val, "newcimages.tbl");
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"region_%s.hdr\" link=\"input\" transfer=\"true\"/>\n", idstr);
sprintf(key, "ID%06d", id);
sprintf(val, "region.hdr");
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"mosaic_%s.fits\" link=\"output\" register=\"true\" transfer=\"true\"/>\n", idstr);
sprintf(key, "mosaic.fits");
sprintf(val, "ID%06d", id);
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"mosaic_%s_area.fits\" link=\"output\" register=\"true\" transfer=\"true\"/>\n", idstr);
sprintf(cmd, "%s/cimages.tbl", workdir);
ncol = topen(cmd);
ifname = tcol("file");
if(ifname < 0)
printError("'Corrected' image list does not have column 'file'");
while(1)
{
istat = tread();
if(istat < 0)
break;
strcpy(fname, tval(ifname));
fname[strlen(fname) - 5] = '\0';
fprintf(fdag, " <uses file=\"%s.fits\" link=\"input\" transfer=\"true\"/>\n",
fname);
fprintf(fdag, " <uses file=\"%s_area.fits\" link=\"input\" transfer=\"true\"/>\n",
fname);
sprintf(key, "ID%06d", id);
sprintf(val, "%s.fits", fname);
HT_add_entry(depends, key, val);
}
fprintf(fdag, " </job>\n\n\n");
fflush(fdag);
mAddCntr = cntr;
/*******************************************/
/* DAG: "job" lines for tile mShrink jobs. */
/*******************************************/
--level;
cntr = 0;
++id;
++cntr;
fprintf(fdag, " <job id=\"ID%06d\" name=\"mShrink\" version=\"3.0\" level=\"%d\" dv-name=\"mShrink%d\" dv-version=\"1.0\">\n", id, level, cntr);
fprintf(fdag, " <argument>\n <filename file=\"mosaic_%s.fits\"/>\n <filename file=\"shrunken_%s.fits\"/>\n %d\n </argument>\n\n", idstr, idstr, shrinkFactor);
fprintf(fdag, " <uses file=\"mosaic_%s.fits\" link=\"input\" transfer=\"true\"/>\n", idstr);
sprintf(key, "ID%06d", id);
sprintf(val, "mosaic.fits");
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"shrunken_%s.fits\" link=\"output\" register=\"true\" transfer=\"true\"/>\n", idstr);
sprintf(key, "shrunken.fits");
sprintf(val, "ID%06d", id);
HT_add_entry(depends, key, val);
fprintf(fdag, " </job>\n\n\n");
fflush(fdag);
/****************************/
/* DAG: Make the final JPEG */
/****************************/
++id;
--level;
fprintf(fdag, " <job id=\"ID%06d\" name=\"mJPEG\" version=\"3.0\" level=\"%d\" dv-name=\"mJPEG1\" dv-version=\"1.0\">\n", id, level);
fprintf(fdag, " <argument>\n -ct 1\n -gray <filename file=\"shrunken_%s.fits\"/>\n min max gaussianlog\n -out <filename file=\"shrunken_%s.jpg\"/>\n </argument>\n\n", idstr, idstr);
fprintf(fdag, " <uses file=\"shrunken_%s.fits\" link=\"input\" transfer=\"true\"/>\n", idstr);
sprintf(key, "ID%06d", id);
sprintf(val, "shrunken.fits");
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"shrunken_%s.jpg\" link=\"output\" register=\"true\" transfer=\"true\"/>\n", idstr);
sprintf(key, "shrunken.jpg");
sprintf(val, "ID%06d", id);
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"dag_%s.xml\" link=\"input\" transfer=\"true\"/>\n", idstr);
fprintf(fdag, " <uses file=\"dag_%s.xml\" link=\"output\" register=\"false\" transfer=\"true\"/>\n", idstr);
sprintf(key, "dag.xml");
sprintf(val, "ID%06d", id);
HT_add_entry(depends, key, val);
fprintf(fdag, " <uses file=\"images_%s.tbl\" link=\"input\" transfer=\"true\"/>\n", idstr);
fprintf(fdag, " <uses file=\"images_%s.tbl\" link=\"output\" register=\"false\" transfer=\"true\"/>\n", idstr);
sprintf(key, "images.tbl");
sprintf(val, "ID%06d", id);
HT_add_entry(depends, key, val);
fprintf(fdag, " </job>\n\n\n\n");
fflush(fdag);
/*******************************************/
/* DAG: Flow control dependencies. */
/* First, mDiffs depend on mProjects */
/*******************************************/
if(debug)
{
fprintf(fdebug, "Generating DAG file parent/child info ...\n");
fflush(fdebug);
}
fprintf(fdag, " <!-- Part 3: Control-Flow Dependencies -->\n\n");
sprintf(fileList, "%s/files.lis", workdir);
sprintf(parentList, "%s/parents.lis", workdir);
sprintf(sortedParent, "%s/sortedParents.lis", workdir);
for(i=1; i<=id; ++i)
{
sprintf(jobid, "ID%06d", i);
fileid = HT_lookup_key(depends, jobid);
ffile = fopen(fileList, "w+");
if(ffile == (FILE *)NULL)
{
printf("[struct stat=\"ERROR\", msg=\"Error opening working file list for write\"]\n");
exit(0);
}
while(fileid != (char *)NULL)
{
fprintf(ffile, "%s\n", fileid);
fflush(ffile);
fileid = HT_next_entry(depends);
}
fclose(ffile);
ffile = fopen(fileList, "r");
if(ffile == (FILE *)NULL)
{
printf("[struct stat=\"ERROR\", msg=\"Error opening working file list for read\"]\n");
exit(0);
}
fparent = fopen(parentList, "w+");
if(fparent == (FILE *)NULL)
{
printf("[struct stat=\"ERROR\", msg=\"Error opening parent list\"]\n");
exit(0);
}
nparents = 0;
fprintf(fparent, "| parent |\n");
while(1)
{
if(fgets(line, MAXSTR, ffile) == (char *)NULL)
break;
if(line[strlen(line)-1] == '\n')
line[strlen(line)-1] = '\0';
parentid = HT_lookup_key(depends, line);
while(parentid != (char *)NULL)
{
parent = atoi(parentid+2);
fprintf(fparent, " %12d\n", parent);
fflush(fparent);
++nparents;
parentid = HT_next_entry(depends);
}
}
fclose(ffile);
fclose(fparent);
unlink(fileList);
if(nparents > 0)
{
if(path)
sprintf(cmd, "%s/bin/mTblSort %s parent %s", path, parentList, sortedParent);
else
sprintf(cmd, "mTblSort %s parent %s", parentList, sortedParent);
svc_run(cmd);
strcpy( status, svc_value( "stat" ));
if (strcmp( status, "ERROR") == 0)
{
strcpy( msg, svc_value( "msg" ));
printError(msg);
}
unlink(parentList);
fparent = fopen(sortedParent, "r");
if(fparent == (FILE *)NULL)
{
printf("[struct stat=\"ERROR\", msg=\"Error opening sorted parent list\"]\n");
exit(0);
}
fgets(line, MAXSTR, fparent);
fprintf(fdag, " <child ref=\"%s\">\n", jobid);
for(j=0; j<nparents; ++j)
{
if(fgets(line, MAXSTR, fparent) == (char *)NULL)
break;
parent_prev = parent;
parent = atoi(line);
if(j > 0 && parent == parent_prev)
continue;
fprintf(fdag, " <parent ref=\"ID%06d\"/>\n", parent);
}
fprintf(fdag, " </child>\n\n");
fflush(fdag);
fclose(fparent);
}
unlink(sortedParent);
}
fprintf(fdag, "</adag>\n");
fflush(fdag);
fclose(fdag);
if(debug)
{
fprintf(fdebug, "done.\n");
fflush(fdebug);
}
printf("[struct stat=\"OK\", id=\"%s\"]\n", idstr);
exit(0);
}
struct mFitExecReturn *mFitExec(char *tblfile, char *fitfile, char *diffdir, int levelOnly, int debugin)
{
int stat, ncols, count, failed;
int warning, missing;
int icntr1;
int icntr2;
int idiffname;
int cntr1;
int cntr2;
char diffname[MAXSTR];
double a;
double b;
double c;
double crpix1;
double crpix2;
int xmin;
int xmax;
int ymin;
int ymax;
double xcenter;
double ycenter;
double npixel;
double rms;
double boxx;
double boxy;
double boxwidth;
double boxheight;
double boxangle;
FILE *fout;
struct mFitExecReturn *returnStruct;
struct mFitplaneReturn *fitplane;
returnStruct = (struct mFitExecReturn *)malloc(sizeof(struct mFitExecReturn));
memset((void *)returnStruct, 0, sizeof(returnStruct));
returnStruct->status = 1;
/***************************************/
/* Process the command-line parameters */
/***************************************/
mFitExec_debug = debugin;
fout = fopen(fitfile, "w+");
if(fout == (FILE *)NULL)
{
strcpy(returnStruct->msg, "Can't open output file.");
return returnStruct;
}
/***************************************/
/* Open the difference list table file */
/***************************************/
ncols = topen(tblfile);
if(ncols <= 0)
{
sprintf(returnStruct->msg, "Invalid diffs metadata file: %s", tblfile);
fclose(fout);
return returnStruct;
}
icntr1 = tcol( "cntr1");
icntr2 = tcol( "cntr2");
idiffname = tcol( "diff");
if(icntr1 < 0
|| icntr2 < 0
|| idiffname < 0)
{
strcpy(returnStruct->msg, "Need columns: cntr1 cntr2 diff");
fclose(fout);
return returnStruct;
}
/***************************************/
/* Read the records and call mFitplane */
/***************************************/
count = 0;
failed = 0;
warning = 0;
missing = 0;
fprintf(fout, "|%9s|%9s|%16s|%16s|%16s|%14s|%14s|%10s|%10s|%10s|%10s|%13s|%13s|%13s|%16s|%16s|%16s|%16s|%16s|%16s|\n",
"plus", "minus", "a", "b", "c", "crpix1", "crpix2", "xmin", "xmax", "ymin", "ymax", "xcenter", "ycenter", "npixel", "rms", "boxx", "boxy", "boxwidth", "boxheight", "boxang");
fflush(fout);
while(1)
{
stat = tread();
if(stat < 0)
break;
cntr1 = atoi(tval(icntr1));
cntr2 = atoi(tval(icntr2));
strcpy(diffname, montage_filePath(diffdir, tval(idiffname)));
if(montage_checkFile(diffname))
{
++count;
++missing;
continue;
}
fitplane = mFitplane(diffname, levelOnly, 0., 0);
if(mFitExec_debug)
{
printf("mFitplane(%s) -> [%s]\n", diffname, fitplane->msg);
fflush(stdout);
}
if(fitplane->status)
++failed;
else
{
a = fitplane->a;
b = fitplane->b;
c = fitplane->c;
crpix1 = fitplane->crpix1;
crpix2 = fitplane->crpix2;
xmin = fitplane->xmin;
xmax = fitplane->xmax;
ymin = fitplane->ymin;
ymax = fitplane->ymax;
xcenter = fitplane->xcenter;
ycenter = fitplane->ycenter;
npixel = fitplane->npixel;
rms = fitplane->rms;
boxx = fitplane->boxx;
boxy = fitplane->boxy;
boxwidth = fitplane->boxwidth;
boxheight = fitplane->boxheight;
boxangle = fitplane->boxang;
fprintf(fout, " %9d %9d %16.5e %16.5e %16.5e %14.2f %14.2f %10d %10d %10d %10d %13.2f %13.2f %13.0f %16.5e %16.1f %16.1f %16.1f %16.1f %16.1f \n",
cntr1, cntr2, a, b, c, crpix1, crpix2, xmin, xmax, ymin, ymax,
xcenter, ycenter, npixel, rms, boxx, boxy, boxwidth, boxheight, boxangle);
fflush(fout);
}
free(fitplane);
++count;
}
/* Finish up */
returnStruct->status = 0;
sprintf(returnStruct->msg, "count=%d, failed=%d, warning=%d, missing=%d",
count, failed, warning, missing);
sprintf(returnStruct->json, "{\"count\":%d, \"failed\":%d, \"warning\":%d, \"missing\":%d}",
count, failed, warning, missing);
returnStruct->count = count;
returnStruct->failed = failed;
returnStruct->warning = warning;
returnStruct->missing = missing;
return returnStruct;
}
/**
* @return - nothing
* Check repository settings as defined in the config file. For example,
* we might expect 37 integers in the repository. Their keys will be
* 'IntKey0' through 'IntKey36'. We'll expect to see hex values for
* all of these names (or we will LEAVE). Those keys will be expected
* to exist in the repository and have values 'IntVal0' through 'IntVal36'
* (or whatever).
*/
void CRepositoryCheckStep::CheckRepositoryIntegerSettings(CRepository *arepository, TInt ancheck)
{
// Careful if the prefix here changes, we don't want to
// blow this buffer. Also note the 'Delete' at the end of the loop.
TBuf<REPCHECKCREATE_KEYBUFLEN> tkey(KIntKeyPrefix);
TBuf<REPCHECKCREATE_VALBUFLEN> tval(KIntValPrefix);
TBuf<REPCHECKCREATE_VALBUFLEN> tmeta(KIntMetaPrefix);
TInt keyslen = tkey.Length();
TInt valslen = tval.Length();
TInt metalen = tmeta.Length();
for( TInt count=0 ; count < ancheck ; count++ )
{
tkey.AppendNum(count); // e.g "IntKey21"
tval.AppendNum(count); // e.g "IntVal47"
tmeta.AppendNum(count); // e.g "IntMeta47"
TInt r=0;
TInt key;
TInt bRet = GetHexFromConfig(ConfigSection(), tkey, key );
if(bRet != 1)
{
ERR_PRINTF2(_L("Failed to get key%d"), count );
SetTestStepResult(EFail);
}
TInt expectedval;
bRet = GetHexFromConfig(ConfigSection(), tval, expectedval );
if(bRet!=1)
{
ERR_PRINTF2(_L("Failed to get config intval%d"), count );
SetTestStepResult(EFail);
}
TInt intval;
r = arepository->Get( key, intval );
if(r!=KErrNone)
{
INFO_PRINTF1(HTML_RED);
ERR_PRINTF2(_L("Repository doesn't have IntKey 0x%x"), key );
INFO_PRINTF1(HTML_RED_OFF);
SetTestStepResult(EFail);
}
else if(intval!=expectedval)
{
INFO_PRINTF1(HTML_RED);
ERR_PRINTF2(_L("Integer match failure, int%d"), count);
INFO_PRINTF2(_L(" - expectedint 0x%x"), expectedval );
INFO_PRINTF2(_L(" - actualint 0x%x"), intval );
INFO_PRINTF1(HTML_RED_OFF);
SetTestStepResult(EFail);
}
TBuf<REPCHECKCREATE_MAXSTRINGLEN> metabuf;
TPtrC meta(metabuf);
TUint32 expectedmeta;
bRet = GetStringFromConfig(ConfigSection(), tmeta, meta );
if(bRet == 1)
{
TLex lex(meta);
TInt err = lex.Val(expectedmeta, EHex);
if (err)
{
INFO_PRINTF1(HTML_RED);
ERR_PRINTF2(_L("Meta value couldn't be converted to TUint32 for IntKey 0x%x"), key );
INFO_PRINTF1(HTML_RED_OFF);
SetTestStepResult(EFail);
}
TUint32 actualmeta;
r = arepository->GetMeta( key, actualmeta );
if(r!=KErrNone)
{
INFO_PRINTF1(HTML_RED);
ERR_PRINTF2(_L("MetData doesn't exist for key 0x%x"), key );
INFO_PRINTF1(HTML_RED_OFF);
SetTestStepResult(EFail);
}
else if(actualmeta!=expectedmeta)
{
INFO_PRINTF1(HTML_RED);
ERR_PRINTF2(_L("Meta match failure, int%d"), count);
INFO_PRINTF2(_L(" - expectedmeta 0x%x"), expectedmeta );
INFO_PRINTF2(_L(" - actualmeta 0x%x"), actualmeta );
INFO_PRINTF1(HTML_RED_OFF);
SetTestStepResult(EFail);
}
}
// Restore the key and value names (i.e strip the digits from the end)
tkey.Delete(keyslen, REPCHECKCREATE_KEYBUFLEN);
tval.Delete(valslen, REPCHECKCREATE_VALBUFLEN);
tmeta.Delete(metalen, REPCHECKCREATE_VALBUFLEN);
}
// Should we return something?
return;
}
