Midas Bank Functions (bk_xxx)
[The midas.h & midas.c]


Functions

void bk_init (void *event)
void bk_init32 (void *event)
INT bk_size (void *event)
void bk_create (void *event, const char *name, WORD type, void *pdata)
INT bk_close (void *event, void *pdata)
INT bk_list (void *event, char *bklist)
INT bk_locate (void *event, const char *name, void *pdata)
INT bk_find (BANK_HEADER *pbkh, const char *name, DWORD *bklen, DWORD *bktype, void **pdata)
INT bk_iterate (void *event, BANK **pbk, void *pdata)
INT bk_swap (void *event, BOOL force)


Function Documentation

INT bk_close ( void *  event,
void *  pdata 
)

Close the Midas bank priviously created by bk_create(). The data pointer pdata must be obtained by bk_create() and used as an address to fill a bank. It is incremented with every value written to the bank and finally points to a location just after the last byte of the bank. It is then passed to bk_close() to finish the bank creation

Parameters:
event pointer to current composed event
pdata pointer to the data
Returns:
number of bytes contained in bank

Definition at line 13042 of file midas.c.

Referenced by adc_calib(), read_scaler_event(), read_trigger_event(), scaler_accum(), and write_event_midas().

13043 {
13044    if (((BANK_HEADER *) event)->flags & BANK_FORMAT_32BIT) {
13045       BANK32 *pbk32;
13046 
13047       pbk32 = (BANK32 *) ((char *) (((BANK_HEADER *) event) + 1) + ((BANK_HEADER *) event)->data_size);
13048       pbk32->data_size = (DWORD) ((char *) pdata - (char *) (pbk32 + 1));
13049       if (pbk32->type == TID_STRUCT && pbk32->data_size == 0)
13050          printf("Warning: bank %c%c%c%c has zero size\n",
13051                 pbk32->name[0], pbk32->name[1], pbk32->name[2], pbk32->name[3]);
13052       ((BANK_HEADER *) event)->data_size += sizeof(BANK32) + ALIGN8(pbk32->data_size);
13053       return pbk32->data_size;
13054    } else {
13055       BANK *pbk;
13056 
13057       pbk = (BANK *) ((char *) (((BANK_HEADER *) event) + 1) + ((BANK_HEADER *) event)->data_size);
13058       pbk->data_size = (WORD) ((char *) pdata - (char *) (pbk + 1));
13059       if (pbk->type == TID_STRUCT && pbk->data_size == 0)
13060          printf("Warning: bank %c%c%c%c has zero size\n", pbk->name[0], pbk->name[1], pbk->name[2],
13061                 pbk->name[3]);
13062       ((BANK_HEADER *) event)->data_size += sizeof(BANK) + ALIGN8(pbk->data_size);
13063       return pbk->data_size;
13064    }
13065 }

void bk_create ( void *  event,
const char *  name,
WORD  type,
void *  pdata 
)

Create a Midas bank. The data pointer pdata must be used as an address to fill a bank. It is incremented with every value written to the bank and finally points to a location just after the last byte of the bank. It is then passed to the function bk_close() to finish the bank creation.

INT *pdata;
bk_init(pevent);
bk_create(pevent, "ADC0", TID_INT, &pdata);
*pdata++ = 123
*pdata++ = 456
bk_close(pevent, pdata);
Parameters:
event pointer to the data area
name of the bank, must be exactly 4 charaters
type type of bank, one of the Midas Data Types values defined in midas.h
pdata pointer to the data area of the newly created bank
Returns:
void

Definition at line 12930 of file midas.c.

Referenced by adc_calib(), adc_summing(), eb_user(), read_scaler_event(), read_trigger_event(), scaler_accum(), and write_event_midas().

12931 {
12932    if (((BANK_HEADER *) event)->flags & BANK_FORMAT_32BIT) {
12933       BANK32 *pbk32;
12934 
12935       pbk32 = (BANK32 *) ((char *) (((BANK_HEADER *) event) + 1) + ((BANK_HEADER *) event)->data_size);
12936       strncpy(pbk32->name, name, 4);
12937       pbk32->type = type;
12938       pbk32->data_size = 0;
12939       *((void **) pdata) = pbk32 + 1;
12940    } else {
12941       BANK *pbk;
12942 
12943       pbk = (BANK *) ((char *) (((BANK_HEADER *) event) + 1) + ((BANK_HEADER *) event)->data_size);
12944       strncpy(pbk->name, name, 4);
12945       pbk->type = type;
12946       pbk->data_size = 0;
12947       *((void **) pdata) = pbk + 1;
12948    }
12949 }

INT bk_find ( BANK_HEADER pbkh,
const char *  name,
DWORD bklen,
DWORD bktype,
void **  pdata 
)

Finds a MIDAS bank of given name inside an event.

Parameters:
pbkh pointer to current composed event
name bank name to look for
bklen number of elemtents in bank
bktype bank type, one of TID_xxx
pdata pointer to data area of bank, NULL if bank not found
Returns:
1 if bank found, 0 otherwise

Definition at line 13186 of file midas.c.

13187 {
13188    BANK *pbk;
13189    BANK32 *pbk32;
13190    DWORD dname;
13191 
13192    if (bk_is32(pbkh)) {
13193       pbk32 = (BANK32 *) (pbkh + 1);
13194       strncpy((char *) &dname, name, 4);
13195       do {
13196          if (*((DWORD *) pbk32->name) == dname) {
13197             *((void **) pdata) = pbk32 + 1;
13198             if (tid_size[pbk32->type & 0xFF] == 0)
13199                *bklen = pbk32->data_size;
13200             else
13201                *bklen = pbk32->data_size / tid_size[pbk32->type & 0xFF];
13202 
13203             *bktype = pbk32->type;
13204             return 1;
13205          }
13206          pbk32 = (BANK32 *) ((char *) (pbk32 + 1) + ALIGN8(pbk32->data_size));
13207       } while ((DWORD) ((char *) pbk32 - (char *) pbkh) < pbkh->data_size + sizeof(BANK_HEADER));
13208    } else {
13209       pbk = (BANK *) (pbkh + 1);
13210       strncpy((char *) &dname, name, 4);
13211       do {
13212          if (*((DWORD *) pbk->name) == dname) {
13213             *((void **) pdata) = pbk + 1;
13214             if (tid_size[pbk->type & 0xFF] == 0)
13215                *bklen = pbk->data_size;
13216             else
13217                *bklen = pbk->data_size / tid_size[pbk->type & 0xFF];
13218 
13219             *bktype = pbk->type;
13220             return 1;
13221          }
13222          pbk = (BANK *) ((char *) (pbk + 1) + ALIGN8(pbk->data_size));
13223       } while ((DWORD) ((char *) pbk - (char *) pbkh) < pbkh->data_size + sizeof(BANK_HEADER));
13224    }
13225 
13226    /* bank not found */
13227    *((void **) pdata) = NULL;
13228    return 0;
13229 }

void bk_init ( void *  event  ) 

Initializes an event for Midas banks structure. Before banks can be created in an event, bk_init() has to be called first.

Parameters:
event pointer to the area of event

Definition at line 12848 of file midas.c.

Referenced by eb_user(), read_scaler_event(), read_trigger_event(), and write_event_midas().

12849 {
12850    ((BANK_HEADER *) event)->data_size = 0;
12851    ((BANK_HEADER *) event)->flags = BANK_FORMAT_VERSION;
12852 }

void bk_init32 ( void *  event  ) 

Initializes an event for Midas banks structure for large bank size (> 32KBytes) Before banks can be created in an event, bk_init32() has to be called first.

Parameters:
event pointer to the area of event
Returns:
void

Definition at line 12889 of file midas.c.

Referenced by write_event_midas().

12890 {
12891    ((BANK_HEADER *) event)->data_size = 0;
12892    ((BANK_HEADER *) event)->flags = BANK_FORMAT_VERSION | BANK_FORMAT_32BIT;
12893 }

INT bk_iterate ( void *  event,
BANK **  pbk,
void *  pdata 
)

Iterates through banks inside an event. The function can be used to enumerate all banks of an event. The returned pointer to the bank header has following structure:

typedef struct {
char   name[4];
WORD   type;
WORD   data_size;
} BANK;
where type is a TID_xxx value and data_size the size of the bank in bytes.
BANK *pbk;
INT  size;
void *pdata;
char name[5];
pbk = NULL;
do
{
 size = bk_iterate(event, &pbk, &pdata);
 if (pbk == NULL)
  break;
 *((DWORD *)name) = *((DWORD *)(pbk)->name);
 name[4] = 0;
 printf("bank %s found\n", name);
} while(TRUE);
Parameters:
event Pointer to data area of event.
pbk pointer to the bank header, must be NULL for the first call to this function.
pdata Pointer to the bank header, must be NULL for the first call to this function
Returns:
Size of bank in bytes

Definition at line 13267 of file midas.c.

Referenced by ascii_write(), bk_list(), dump_write(), md_bank_event_display(), update_odb(), write_event_ascii(), write_event_hbook(), write_event_midas(), and write_event_odb().

13268 {
13269    if (*pbk == NULL)
13270       *pbk = (BANK *) (((BANK_HEADER *) event) + 1);
13271    else
13272       *pbk = (BANK *) ((char *) (*pbk + 1) + ALIGN8((*pbk)->data_size));
13273 
13274    *((void **) pdata) = (*pbk) + 1;
13275 
13276    if ((DWORD) ((char *) *pbk - (char *) event) >= ((BANK_HEADER *) event)->data_size + sizeof(BANK_HEADER)) {
13277       *pbk = *((BANK **) pdata) = NULL;
13278       return 0;
13279    }
13280 
13281    return (*pbk)->data_size;
13282 }

INT bk_list ( void *  event,
char *  bklist 
)

Extract the MIDAS bank name listing of an event. The bklist should be dimensioned with STRING_BANKLIST_MAX which corresponds to a max of BANKLIST_MAX banks (midas.h: 32 banks max).

INT adc_calib(EVENT_HEADER *pheader, void *pevent)
{
  INT    n_adc, nbanks;
  WORD   *pdata;
  char   banklist[STRING_BANKLIST_MAX];

  // Display # of banks and list of banks in the event
  nbanks = bk_list(pevent, banklist);
  printf("#banks:%d List:%s\n", nbanks, banklist);

  // look for ADC0 bank, return if not present
  n_adc = bk_locate(pevent, "ADC0", &pdata);
  ...
}
Parameters:
event pointer to current composed event
bklist returned ASCII string, has to be booked with STRING_BANKLIST_MAX.
Returns:
number of bank found in this event.

Definition at line 13092 of file midas.c.

Referenced by md_bank_event_display().

13093 {                               /* Full event */
13094    INT nbk, size;
13095    BANK *pmbk = NULL;
13096    BANK32 *pmbk32 = NULL;
13097    char *pdata;
13098 
13099    /* compose bank list */
13100    bklist[0] = 0;
13101    nbk = 0;
13102    do {
13103       /* scan all banks for bank name only */
13104       if (bk_is32(event)) {
13105          size = bk_iterate32(event, &pmbk32, &pdata);
13106          if (pmbk32 == NULL)
13107             break;
13108       } else {
13109          size = bk_iterate(event, &pmbk, &pdata);
13110          if (pmbk == NULL)
13111             break;
13112       }
13113       nbk++;
13114 
13115       if (nbk > BANKLIST_MAX) {
13116          cm_msg(MINFO, "bk_list", "over %i banks -> truncated", BANKLIST_MAX);
13117          return (nbk - 1);
13118       }
13119       if (bk_is32(event))
13120          strncat(bklist, (char *) pmbk32->name, 4);
13121       else
13122          strncat(bklist, (char *) pmbk->name, 4);
13123    }
13124    while (1);
13125    return (nbk);
13126 }

INT bk_locate ( void *  event,
const char *  name,
void *  pdata 
)

Locates a MIDAS bank of given name inside an event.

Parameters:
event pointer to current composed event
name bank name to look for
pdata pointer to data area of bank, NULL if bank not found
Returns:
number of values inside the bank

Definition at line 13136 of file midas.c.

Referenced by adc_calib(), adc_summing(), md_bank_event_display(), and scaler_accum().

13137 {
13138    BANK *pbk;
13139    BANK32 *pbk32;
13140    DWORD dname;
13141 
13142    if (bk_is32(event)) {
13143       pbk32 = (BANK32 *) (((BANK_HEADER *) event) + 1);
13144       strncpy((char *) &dname, name, 4);
13145       while ((DWORD) ((char *) pbk32 - (char *) event) <
13146              ((BANK_HEADER *) event)->data_size + sizeof(BANK_HEADER)) {
13147          if (*((DWORD *) pbk32->name) == dname) {
13148             *((void **) pdata) = pbk32 + 1;
13149             if (tid_size[pbk32->type & 0xFF] == 0)
13150                return pbk32->data_size;
13151             return pbk32->data_size / tid_size[pbk32->type & 0xFF];
13152          }
13153          pbk32 = (BANK32 *) ((char *) (pbk32 + 1) + ALIGN8(pbk32->data_size));
13154       }
13155    } else {
13156       pbk = (BANK *) (((BANK_HEADER *) event) + 1);
13157       strncpy((char *) &dname, name, 4);
13158       while ((DWORD) ((char *) pbk - (char *) event) <
13159              ((BANK_HEADER *) event)->data_size + sizeof(BANK_HEADER)) {
13160          if (*((DWORD *) pbk->name) == dname) {
13161             *((void **) pdata) = pbk + 1;
13162             if (tid_size[pbk->type & 0xFF] == 0)
13163                return pbk->data_size;
13164             return pbk->data_size / tid_size[pbk->type & 0xFF];
13165          }
13166          pbk = (BANK *) ((char *) (pbk + 1) + ALIGN8(pbk->data_size));
13167       }
13168 
13169    }
13170 
13171    /* bank not found */
13172    *((void **) pdata) = NULL;
13173    return 0;
13174 }

INT bk_size ( void *  event  ) 

Returns the size of an event containing banks. The total size of an event is the value returned by bk_size() plus the size of the event header (sizeof(EVENT_HEADER)).

Parameters:
event pointer to the area of event
Returns:
number of bytes contained in data area of event

Definition at line 12903 of file midas.c.

Referenced by eb_user(), process_event(), read_scaler_event(), and read_trigger_event().

12904 {
12905    return ((BANK_HEADER *) event)->data_size + sizeof(BANK_HEADER);
12906 }

INT bk_swap ( void *  event,
BOOL  force 
)

Swaps bytes from little endian to big endian or vice versa for a whole event.

An event contains a flag which is set by bk_init() to identify the endian format of an event. If force is FALSE, this flag is evaluated and the event is only swapped if it is in the "wrong" format for this system. An event can be swapped to the "wrong" format on purpose for example by a front-end which wants to produce events in a "right" format for a back-end analyzer which has different byte ordering.

Parameters:
event pointer to data area of event
force If TRUE, the event is always swapped, if FALSE, the event is only swapped if it is in the wrong format.
Returns:
1==event has been swap, 0==event has not been swapped.

Definition at line 13342 of file midas.c.

Referenced by ascii_write(), dump_write(), eb_mfragment_add(), md_event_swap(), process_event(), and source_scan().

13343 {
13344    BANK_HEADER *pbh;
13345    BANK *pbk;
13346    BANK32 *pbk32;
13347    void *pdata;
13348    WORD type;
13349    BOOL b32;
13350 
13351    pbh = (BANK_HEADER *) event;
13352 
13353    /* only swap if flags in high 16-bit */
13354    if (pbh->flags < 0x10000 && !force)
13355       return 0;
13356 
13357    /* swap bank header */
13358    DWORD_SWAP(&pbh->data_size);
13359    DWORD_SWAP(&pbh->flags);
13360 
13361    /* check for 32bit banks */
13362    b32 = ((pbh->flags & BANK_FORMAT_32BIT) > 0);
13363 
13364    pbk = (BANK *) (pbh + 1);
13365    pbk32 = (BANK32 *) pbk;
13366 
13367    /* scan event */
13368    while ((char *) pbk - (char *) pbh < (INT) pbh->data_size + (INT) sizeof(BANK_HEADER)) {
13369       /* swap bank header */
13370       if (b32) {
13371          DWORD_SWAP(&pbk32->type);
13372          DWORD_SWAP(&pbk32->data_size);
13373          pdata = pbk32 + 1;
13374          type = (WORD) pbk32->type;
13375       } else {
13376          WORD_SWAP(&pbk->type);
13377          WORD_SWAP(&pbk->data_size);
13378          pdata = pbk + 1;
13379          type = pbk->type;
13380       }
13381 
13382       /* pbk points to next bank */
13383       if (b32) {
13384          pbk32 = (BANK32 *) ((char *) (pbk32 + 1) + ALIGN8(pbk32->data_size));
13385          pbk = (BANK *) pbk32;
13386       } else {
13387          pbk = (BANK *) ((char *) (pbk + 1) + ALIGN8(pbk->data_size));
13388          pbk32 = (BANK32 *) pbk;
13389       }
13390 
13391       switch (type) {
13392       case TID_WORD:
13393       case TID_SHORT:
13394          while ((char *) pdata < (char *) pbk) {
13395             WORD_SWAP(pdata);
13396             pdata = (void *) (((WORD *) pdata) + 1);
13397          }
13398          break;
13399 
13400       case TID_DWORD:
13401       case TID_INT:
13402       case TID_BOOL:
13403       case TID_FLOAT:
13404          while ((char *) pdata < (char *) pbk) {
13405             DWORD_SWAP(pdata);
13406             pdata = (void *) (((DWORD *) pdata) + 1);
13407          }
13408          break;
13409 
13410       case TID_DOUBLE:
13411          while ((char *) pdata < (char *) pbk) {
13412             QWORD_SWAP(pdata);
13413             pdata = (void *) (((double *) pdata) + 1);
13414          }
13415          break;
13416       }
13417    }
13418 
13419    return CM_SUCCESS;
13420 }


Midas DOC Version 3.0.0 ---- PSI Stefan Ritt ----
Contributions: Pierre-Andre Amaudruz - Sergio Ballestrero - Suzannah Daviel - Doxygen - Peter Green - Qing Gu - Greg Hackman - Gertjan Hofman - Paul Knowles - Exaos Lee - Rudi Meier - Glenn Moloney - Dave Morris - John M O'Donnell - Konstantin Olchanski - Renee Poutissou - Tamsen Schurman - Andreas Suter - Jan M.Wouters - Piotr Adam Zolnierczuk