#include #include #include #include #include #include #include "ctk.h" #include "gdecomp.h" #define DEBUG 0 /* globals */ volatile extern TRACKINGPAR Pars; /*----------------------------------------------------------------------------*/ int writeTrack (int trackStatus, TRACK_STRUCT * track, CLUSTER_INTPTS Clstr[MAXCLUSTERHITS], int *nClusters, STAT * ctkStat) { /* this function first writes the original data to the */ /* output data sream, then it writes the tracked data. */ /* this function is for offline use. online the serializeTrack */ /* is used */ /* declarations */ static int nwritten = 0; int siz, iCluster, i1, ng, nmTS; float rn, rn1; unsigned int grnum = 0; char str[128]; long long int mTS[1000]; int wo[1000]; #if(DEBUG) int nobytes = 0; #endif PAYLOAD *ptinp; GEBDATA *ptgd; CRYS_INTPTS *gtinp; GEBDATA trackGeb; char *payLoad; TRACKED_GAMMA_RAY tgr; long long int dTS; static long long int oldTS; static int nn = 0; int checksum, *iptr; int i, j; /* write the tracked data to tracked data stream */ if (Pars.trackDataStream > 0) { /* assign mean gamma ray time stamps */ /* and check things */ ng = 0; // printf ("\n\n---------\n"); for (iCluster = 0; iCluster < *nClusters; iCluster++) { /* per default we do not write it out. */ /* The clusters have to qualify first */ wo[iCluster] = 0; mTS[iCluster] = 0; nmTS = 0; /* now loop and find good gamma rays */ if (Clstr[iCluster].valid && Clstr[iCluster].tracked && Clstr[iCluster].ndet > 0 && Clstr[iCluster].ndet < MAX_NDET) { /* find the mean time for this gamma ray */ for (j = 0; j < Clstr[iCluster].ndet; j++) { mTS[iCluster] += Clstr[iCluster].intpts[j].timestamp; nmTS++; // printf("%lli\n",Clstr[iCluster].intpts[j].timestamp); }; if (nmTS > 1) mTS[iCluster] /= (long long int) nmTS; /* mark for writeout if it qualifies */ if (nmTS > 0 && mTS[iCluster] > 0) { wo[iCluster] = 1; ng++; }; // printf ("nmTS=%i, mTS[iCluster=%i]=%lli,ng=%i, wo=%i\n", nmTS, iCluster, mTS[iCluster], ng, wo[iCluster]); }; }; /* if there was a problem with the tracking */ /* we suppress the writeout of tracked data */ if (trackStatus != 0) ng = 0; /* write the coincidence length out */ if (ng == 0) { // printf ("not writing tracked gamma rays out, cause ng=%i\n", ng); i1 = track->n; if (!Pars.mode2) //LR siz = write (Pars.trackDataStream, (char *) &i1, sizeof (int)); } else { // printf ("writing tracked gamma ray out\n"); // fflush (stdout); i1 = 1 + track->n; /* +1 for tracked */ if (!Pars.mode2) //LR siz = write (Pars.trackDataStream, (char *) &i1, sizeof (int)); }; /*-------------------------*/ /* write the original data */ /*-------------------------*/ /* simple echo of input data to the tracking task. */ /* It may contain external data for all we know */ ptgd = track->gd; ptinp = track->payload; for (i = 0; i < track->n; i++) { siz = write (Pars.trackDataStream, (char *) ptgd, sizeof (GEBDATA)); assert (siz == sizeof (GEBDATA)); // printf("wrote data of type %i, length=%i\n", ptgd->type, ptgd->length); siz = write (Pars.trackDataStream, (char *) ptinp, ptgd->length); assert (siz == ptgd->length); ptgd++; ptinp++; }; // printf ("done\n"); // fflush (stdout); /* write tracked data out */ if (ng > 0) { /*--------------------*/ /* write tracked data */ /*--------------------*/ trackGeb.type = GEB_TYPE_TRACK; trackGeb.length = 0; trackGeb.timestamp = 0; /* use the average time stamp for */ /* the GEB header */ for (iCluster = 0; iCluster < *nClusters; iCluster++) if (wo[iCluster]) trackGeb.timestamp += mTS[iCluster]; trackGeb.timestamp /= (long long int) ng; // printf ("--> trackGeb.timestamp=%lli\n", trackGeb.timestamp); /* first write multiplicity of event */ /* we of course only write valid clusters */ /* out, skipping discarded ones */ /* allocate space for payLoad */ payLoad = (char *) calloc (1, ng * sizeof (TRACKED_GAMMA_RAY) + 2 * sizeof (int)); assert (payLoad != NULL); /* write number of gamma rays following */ memcpy (payLoad + trackGeb.length, (char *) &ng, sizeof (int)); trackGeb.length += sizeof (int); /* pad with extra word for 64 bit machines, make it serial # */ memcpy (payLoad + trackGeb.length, (char *) &grnum, sizeof (int)); trackGeb.length += sizeof (int); grnum++; /* now write the gamma rays */ for (iCluster = 0; iCluster < *nClusters; iCluster++) if (wo[iCluster]) { bzero ((char *) &tgr, sizeof (TRACKED_GAMMA_RAY)); tgr.esum = Clstr[iCluster].esum; tgr.ndet = Clstr[iCluster].ndet; tgr.fom = Clstr[iCluster].fom; tgr.tracked = Clstr[iCluster].tracked; #if(0) printf ("sizeof (TRACKED_GAMMA_RAY)=%i bytes\n", sizeof (TRACKED_GAMMA_RAY)); printf ("sizeof(int)=%i\n", sizeof (int)); printf ("sizeof(float)=%i\n", sizeof (float)); printf ("sizeof(long long int)=%i\n", sizeof (long long int)); printf ("sizeof(char)=%i\n", sizeof (char)); printf ("tgr.esum=%f ;", tgr.esum); printf ("tgr.ndet=%i;", tgr.ndet); printf ("tgr.fom=%f ;", tgr.fom); printf ("tgr.tracked=%i ;", tgr.tracked); printf ("\n"); #endif /* find and extract first and second interaction points */ for (j = 0; j < Clstr[iCluster].ndet; j++) { if (Clstr[iCluster].intpts[j].order == 0) { tgr.x0 = Clstr[iCluster].intpts[j].xx; tgr.y0 = Clstr[iCluster].intpts[j].yy; tgr.z0 = Clstr[iCluster].intpts[j].zz; tgr.e0 = Clstr[iCluster].intpts[j].edet; tgr.timestamp = Clstr[iCluster].intpts[j].timestamp; } if (Clstr[iCluster].intpts[j].order == 1) { tgr.x1 = Clstr[iCluster].intpts[j].xx; tgr.y1 = Clstr[iCluster].intpts[j].yy; tgr.z1 = Clstr[iCluster].intpts[j].zz; tgr.e1 = Clstr[iCluster].intpts[j].edet; } }; /* store in payload */ memcpy (payLoad + trackGeb.length, (char *) &tgr, sizeof (TRACKED_GAMMA_RAY)); trackGeb.length += sizeof (TRACKED_GAMMA_RAY); }; #if(0) /* check timestamp */ dTS = trackGeb.timestamp - oldTS; if (dTS > 500000 || dTS < -500000 || trackGeb.timestamp == 0) { printf ("trackGeb.timestamp=%lli, dTS=%lli\n", trackGeb.timestamp, dTS); sprintf (str, "bad.%i", nn); printAllClusters (str, str, Clstr, nClusters); if (nn > 100) exit (0); nn++; } oldTS = trackGeb.timestamp; assert (trackGeb.timestamp > 0); #endif /* write to disk */ siz = write (Pars.trackDataStream, (char *) &trackGeb, sizeof (GEBDATA)); // printf("wrote type %i data, length=%i; ", trackGeb.type, trackGeb.length);; siz = write (Pars.trackDataStream, (char *) payLoad, trackGeb.length); // printf("actual siz=%i\n",siz); free (payLoad); }; // printf ("wrote event # %i out\n", nwritten); // nwritten++; return (0); }; return (0); } /*----------------------------------------------------------------------------*/ #if(0) /*--------------------------------------------------------*/ /* Here is Carls new CRYS_INTPTS *gtinp; fancy data output routine. Even..... */ /* though I don't use it directly, we keep it here so.... */ /* it follows my updates. Wed 12 Jan 2011 02:43:28 PM CST */ /*--------------------------------------------------------*/ /* this function is out of date!!!!! */ void * serializeTrack (TRACK_STRUCT * track, CLUSTER_INTPTS Clstr[MAXCLUSTERHITS], int *nClusters, int *bufferlen) { /* this produces an output buffer identical to what writeTrack would write */ /* declarations */ int iCluster, i1, nValidClusters, ninteractions; char *retval, *bptr; int retsize = 0; CRYS_INTPTS *ptinp; GEBDATA *ptgd; int i, j; retsize = track->n * (sizeof (CRYS_INTPTS) + sizeof (GEBDATA)); retsize += sizeof (int); /* find number of valid clusters */ nValidClusters = 0; for (iCluster = 0; iCluster < *nClusters; iCluster++) if (Clstr[iCluster].valid) nValidClusters++; /* calculate how much buffer space we need */ /* for the clusters */ retsize = retsize + nValidClusters * sizeof (CLUSTER_INTPTS) + sizeof (int); /* and allocate space */ retval = (char *) malloc (retsize); if (!retval) { *bufferlen = 0; return 0; } bptr = retval; /*----------*/ /* raw data */ /*----------*/ /* first write multiplicity of event */ memcpy (bptr, (char *) &track->n, sizeof (int)); bptr += sizeof (int); /* then write the rest of the event */ ptgd = track->gd; ptinp = track->inp; for (i = 0; i < track->n; i++) { memcpy (bptr, (char *) ptgd, sizeof (GEBDATA)); bptr += sizeof (GEBDATA); memcpy (bptr, (char *) ptinp, ptgd->length); bptr += ptgd->length; ptgd++; ptinp++; }; /*--------------*/ /* tracked data */ /*--------------*/ /* first write multiplicity of event */ /* we of course only write valid clusters */ /* out, skipping discarded ones */ /* nValidClusters already determined above */ memcpy (bptr, (char *) &nValidClusters, sizeof (int)); bptr += sizeof (int); /* now write the data */ for (iCluster = 0; iCluster < *nClusters; iCluster++) if (Clstr[iCluster].valid) { memcpy (bptr, (char *) &Clstr[iCluster], sizeof (CLUSTER_INTPTS)); bptr += sizeof (CLUSTER_INTPTS); } *bufferlen = retsize; return retval; } #endif