/* $Id: trigger.c,v 1.69 2005/11/08 10:16:51 michael Exp $ $Source: /home/michael/cvsroot/matching_soft_v1/trigger.c,v $ */ /**********************************************************/ /* */ /* Trigger Module */ /* All code for the trigger unpacking and */ /* trigger decision */ /**********************************************************/ /* * * Some quick_info. * * */ #include #include #include "trigger.h" #include "scheduler.h" #include "matching.h" #define MAX_SHOWER_HITS_CUTOFF 60 unsigned long RICH_hits_theta_phi[100]; unsigned long *RICH_hits_ptr[6] = { 0, 0, 0, 0, 0, 0 } ; unsigned long RICH_hits_length[6] = { 0, 0, 0, 0, 0, 0 } ; unsigned long SHOWER_hits_theta_phi[100]; unsigned long *SHOWER_hits_ptr[6] = { 0, 0, 0, 0, 0, 0 } ; unsigned long SHOWER_hits_length[6] = { 0, 0, 0, 0, 0, 0 } ; unsigned long TOF_hits_theta_phi[100]; unsigned long *TOF_hits_ptr[6] = { 0, 0, 0, 0, 0, 0 } ; unsigned long TOF_hits_length[6] = { 0, 0, 0, 0, 0, 0 } ; unsigned long RICH_sector_hitpattern; unsigned long SHOWER_sector_hitpattern; unsigned long TOF_sector_hitpattern; asm("#include ;"); unsigned long Rich_Resync_Counter = 0; /**********************************************************/ void write_test_data_into_IPU(void) { int i; i=0; read_link_buffer_mem[RICH_LINK_NUMBER][i++] = 0x4c420101; read_link_buffer_mem[RICH_LINK_NUMBER][i++] = 0x44420101; read_link_buffer_mem[RICH_LINK_NUMBER][i++] = 0x54420101; read_link_buffer_mem[RICH_LINK_NUMBER][i++] = 0x50420101; read_link_buffer_mem[RICH_LINK_NUMBER][i++] = 0x58420301; read_link_buffer_mem[RICH_LINK_NUMBER][i++] = 0x15101847; read_link_buffer_mem[RICH_LINK_NUMBER][i++] = 0x1410184c; read_link_buffer_mem[RICH_LINK_NUMBER][i++] = 0x48420101; read_link_buffer_mem_pos[RICH_LINK_NUMBER] = 8; IPU_event_length[RICH_LINK_NUMBER] = 8; i=0; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x00000023; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x00000008; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x512c1142; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x20498000; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x20300010; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x203c0004; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x512d1142; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x204b0004; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x512e1142; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x512f0006; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x512f1142; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x21400002; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x51310008; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x51301142; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x20422000; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x204d0400; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x51330004; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x51311152; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x51340004; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x51321142; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x20390008; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x51331142; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x21530008; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x213c2000; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x51360004; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x51341142; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x51370008; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x51351142; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x21430008; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x214d0020; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x51370004; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x51361142; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x51370008; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x51371142; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x21340100; read_link_buffer_mem[SHOWER_LINK_NUMBER][i++] = 0x21360400; read_link_buffer_mem_pos[SHOWER_LINK_NUMBER] = 36; IPU_event_length[SHOWER_LINK_NUMBER] = 36; i=0; read_link_buffer_mem[TOF_LINK_NUMBER][i++] = 0x00000003; read_link_buffer_mem[TOF_LINK_NUMBER][i++] = 0x00004142; read_link_buffer_mem[TOF_LINK_NUMBER][i++] = 0x14e3ab10; read_link_buffer_mem[TOF_LINK_NUMBER][i++] = 0x177f8f10; read_link_buffer_mem[TOF_LINK_NUMBER][i++] = 0x00000004; read_link_buffer_mem[TOF_LINK_NUMBER][i++] = 0x00004142; read_link_buffer_mem[TOF_LINK_NUMBER][i++] = 0x152ac213; read_link_buffer_mem[TOF_LINK_NUMBER][i++] = 0x207a8f13; read_link_buffer_mem[TOF_LINK_NUMBER][i++] = 0x206f8f13; read_link_buffer_mem[TOF_LINK_NUMBER][i++] = 0x00000008; read_link_buffer_mem[TOF_LINK_NUMBER][i++] = 0x00004142; read_link_buffer_mem[TOF_LINK_NUMBER][i++] = 0x16a2db14; read_link_buffer_mem[TOF_LINK_NUMBER][i++] = 0x1760d614; read_link_buffer_mem[TOF_LINK_NUMBER][i++] = 0x16a4c314; read_link_buffer_mem[TOF_LINK_NUMBER][i++] = 0x18c1ab14; read_link_buffer_mem[TOF_LINK_NUMBER][i++] = 0x2f7fe815; read_link_buffer_mem[TOF_LINK_NUMBER][i++] = 0x2e83e815; read_link_buffer_mem[TOF_LINK_NUMBER][i++] = 0x2455bf15; read_link_buffer_mem_pos[TOF_LINK_NUMBER] = 18; IPU_event_length[TOF_LINK_NUMBER] = 18; } unsigned long determine_rich_sector_hitpattern(void) { unsigned long i, curr_ipu_num, data, length_of_subevent; unsigned long number_of_hits = 0; RICH_sector_hitpattern = 0; for(i=0, curr_ipu_num = 0 ; i < read_link_buffer_mem_pos[RICH_LINK_NUMBER] ; i++) { data = read_link_buffer_mem[RICH_LINK_NUMBER][i]; length_of_subevent = ((data >> 8) & 0xff); if(length_of_subevent > 1) { number_of_hits+= length_of_subevent - 1; RICH_sector_hitpattern |= BIT(curr_ipu_num); i+=length_of_subevent-1; } curr_ipu_num++; } #ifdef ENABLE_DEBUG_T if( ((*debug_register)&0xf) >2 ) { sprintf(print_string, ":%6d: +rich_sector_hitpattern: %8.8x, number of hitpatterns: %d", printf_writes_total, RICH_sector_hitpattern, number_of_hits); printf_vme(print_string); } #endif #ifdef ENABLE_WARNINGS_RICH_RINGS if(number_of_hits > 36) { sprintf(print_string, ":%6d: +rich: found >36 hitpatterns: %d, evt: %d", printf_writes_total, number_of_hits, *GLOBAL_TRIGGER_COUNTER); printf_vme(print_string); } #endif return (number_of_hits); } unsigned long determine_shower_sector_hitpattern(void) { unsigned long i, curr_ipu_num, length_of_subevent; unsigned long number_of_hits = 0; SHOWER_sector_hitpattern = 0; for(i=1, curr_ipu_num = 0 ; i < read_link_buffer_mem_pos[SHOWER_LINK_NUMBER] ; ) { length_of_subevent = (read_link_buffer_mem[SHOWER_LINK_NUMBER][i]&0xffff)>>1; if(length_of_subevent == 0) { sprintf(print_string, ":%6d:++error: shower subeventlength == 0", printf_writes_total); printf_vme(print_string); for(;;); } if(length_of_subevent > (34+SHOWER_TRAILER_WORDS)) { sprintf(print_string, ":%6d:++error: shower ipc_subeventlength > 35", printf_writes_total); printf_vme(print_string); for(;;); } if(length_of_subevent > (2+SHOWER_TRAILER_WORDS) ) { number_of_hits += length_of_subevent - (2 + SHOWER_TRAILER_WORDS); SHOWER_sector_hitpattern |= (BIT(curr_ipu_num>>1)); } i+=length_of_subevent; curr_ipu_num++; } #ifdef ENABLE_DEBUG_T if( ((*debug_register)&0xf) >2 ) { sprintf(print_string, ":%6d: +shower_sector_hitpattern: %8.8x, number of hits: %d", printf_writes_total, SHOWER_sector_hitpattern, number_of_hits); printf_vme(print_string); } #endif return (number_of_hits); } void determine_tof_sector_hitpattern(void) { unsigned long length_of_subevent, i, k; unsigned long sector_number; TOF_sector_hitpattern = 0; for(i=0; i < read_link_buffer_mem_pos[TOF_LINK_NUMBER]; ) { length_of_subevent = read_link_buffer_mem[TOF_LINK_NUMBER][i]; if(length_of_subevent > 0xff) { sprintf(print_string, ":%6d:++error: TOF_determine_tof_sector_hitpattern: length of subevent too large: %x", printf_writes_total, length_of_subevent ); printf_vme(print_string); } for(k=2; (k<= length_of_subevent) && (k<0x1ff); k++) { sector_number = (read_link_buffer_mem[TOF_LINK_NUMBER][i+k])&0xf; if(sector_number >5) { sector_number = 5; #ifdef ENABLE_DEBUG_T if( ((*debug_register)&0xf) >2 ) { sprintf(print_string, ":%6d: +tof_sector_number larger 5: %d", printf_writes_total, sector_number); printf_vme(print_string); } #endif } TOF_sector_hitpattern |= BIT(sector_number); } i+=length_of_subevent+1; } #ifdef ENABLE_DEBUG_T if( ((*debug_register)&0xf) >2 ) { sprintf(print_string, ":%6d: +tof_sector_hitpattern: %8.8x", printf_writes_total, TOF_sector_hitpattern); printf_vme(print_string); } #endif return; } unsigned long determine_tof_number_of_hits(void) { unsigned long length_of_subevent, i; unsigned long number_of_hits = 0; for(i=0; i < read_link_buffer_mem_pos[TOF_LINK_NUMBER]; ) { length_of_subevent = read_link_buffer_mem[TOF_LINK_NUMBER][i]; number_of_hits += length_of_subevent -1; i+=length_of_subevent +1; } #ifdef ENABLE_DEBUG_T if( ((*debug_register)&0xf) >2 ) { sprintf(print_string, ":%6d: TOF: number of hits: %d", printf_writes_total, number_of_hits); printf_vme(print_string); } #endif return (number_of_hits); } unsigned long RICH_transform_xy_to_theta_phi(void) { long i,j,k; unsigned long data, length_of_subevent, sector_number; unsigned long current_column, column_pattern, fifo_number, row_number; unsigned long theta_phi; unsigned long *RICH_hits_curr_ptr; unsigned long number_of_hits=0; unsigned long hit_counter = 0; #if 0 unsigned long theta, phi; #endif for(i=5;i>=0;i--) { RICH_hits_length[i] = 0; } /* i => Start position of sector-data in sub-event-data j => word number in IPU subevent k => bitnumber in RICH hit-pattern */ #ifdef OFFLINE_DEBUG printf("rich_transform_xy_to_theta_phi\n"); #endif #ifdef ENABLE_DEBUG_T if( ((*debug_register>>4) & 0xf) > 1) { sprintf(print_string, ":%6d: RICH_transform_xy_to_theta_phi", printf_writes_total ); printf_vme(print_string); } #endif RICH_hits_curr_ptr = RICH_hits_theta_phi; for(i=0, sector_number=0; i < read_link_buffer_mem_pos[RICH_LINK_NUMBER]; i++, sector_number++) { if( sector_number > 5) { #ifdef ENABLE_DEBUG_T if( ((*debug_register>>4) & 0xf) > 1) { sprintf(print_string, ":%6d: RICH_sector_number > 5: %d", printf_writes_total, sector_number); printf_vme(print_string); } #endif sector_number = 5; } data = read_link_buffer_mem[RICH_LINK_NUMBER][i]; length_of_subevent = ((data >> 8) & 0xff); if(length_of_subevent > 40) { sprintf(print_string, ":%6d:++error: RICH_transform_xy_to_theta_phi: length of subevent too large: %x", printf_writes_total, length_of_subevent ); printf_vme(print_string); } if(length_of_subevent > 1) { RICH_hits_ptr[sector_number] = RICH_hits_curr_ptr; for(j=1; (j> 16 ); fifo_number = ((column_pattern >> 8) & (0xf)) - 1; column_pattern &= 0xff; #ifdef OFFLINE_DEBUG printf("i:%d, j:%d, row:%d, fifo:%d, column_pattern:%x \n", i,j,row_number, fifo_number, column_pattern ); #endif #ifdef ENABLE_DEBUG_T if( ((*debug_register>>4) & 0xf) > 1) { sprintf(print_string, ":%6d: i:%d, j:%d, row:%d, fifo:%d, column_pattern:%x, RICH_hits_curr_ptr: %8.8x ", printf_writes_total, i,j,row_number, fifo_number, column_pattern, RICH_hits_curr_ptr ); printf_vme(print_string); } #endif for(k=0; k<=7; k++) { if ( column_pattern & 0x1) { current_column = 95 - (fifo_number<<3) - k; theta_phi = IPU_RICH_transform[row_number + current_column*96]; if(theta_phi & 0x10000) { #ifdef ENABLE_DEBUG_T if( ((*debug_register>>4) & 0xf) > 1) { sprintf(print_string, ":%6d:++error: k:%d, r:%d, c:%d, theta_phi:%8.8x, sector:%d, no mapping possible!", printf_writes_total, k, row_number, current_column, theta_phi, sector_number); printf_vme(print_string); } #endif column_pattern=column_pattern>>1; continue; } /* theta = theta_phi & 0xff; phi = (theta_phi >> 8) &0xff; phi = (phi|(sector_number<<8)); // correct by sectornumber *(RICH_hits_curr_ptr++)= (phi << 8) | (theta); */ *(RICH_hits_curr_ptr++)= theta_phi|(sector_number<<16); RICH_hits_length[sector_number]++; hit_counter++; if(hit_counter > 40) { sprintf(print_string, ":%6d:++rich transform: hit counter > 40, break", printf_writes_total); printf_vme(print_string); } #ifdef ENABLE_EARLY_TRIGGER_DECISIONS if(hit_counter > *G_MAX_RICH_RINGS_TO_LOOP_OVER) { #ifdef ENABLE_DEBUG_T if( ((*debug_register>>4) & 0xf) > 2) { sprintf(print_string, ":%6d:++rich transform: hit counter >= 6, early trigger", printf_writes_total); printf_vme(print_string); } #endif *G_ACCUMULATED_RICH_HITS += hit_counter; return hit_counter; } #endif #ifdef OFFLINE_DEBUG printf("k:%d, r:%d, c:%d, theta_phi:%8x \n", k, row_number, current_column, *(RICH_hits_curr_ptr-1)); #endif #ifdef ENABLE_DEBUG_T if( ((*debug_register>>4) & 0xf) > 1) { sprintf(print_string, ":%6d: k:%d, r:%d, c:%d, theta_phi:%8.8x, sector:%d, ", printf_writes_total, k, row_number, current_column, theta_phi, sector_number); printf_vme(print_string); } #endif } column_pattern=column_pattern>>1; } // end of loop over all bits /* sprintf(print_string, ":%6d: reached end of loop over all bits", printf_writes_total); printf_vme(print_string); */ } i+=length_of_subevent-1; } } *G_ACCUMULATED_RICH_HITS += hit_counter; #if 0 for(i=0, number_of_hits=0 ;i<=5; i++) { number_of_hits += RICH_hits_length[i]; } *G_ACCUMULATED_RICH_HITS += number_of_hits; #endif #ifdef ENABLE_DEBUG_T if( ((*debug_register>>4) & 0xf) > 0) { sprintf(print_string, ":%6d: num of hits in RICH: %d", printf_writes_total, hit_counter ); printf_vme(print_string); } #endif return hit_counter; } unsigned long SHOWER_transform_xy_to_theta_phi(void) { long i,j,k; unsigned long length_of_subevent, sector_number; unsigned long row_pattern, column_number; unsigned long theta_phi, y; unsigned long ipc_flag = 0; unsigned long ipc_counter = 0; unsigned long *SHOWER_hits_curr_ptr; unsigned long decoding; unsigned long number_of_hits = 0; #if 0 unsigned long theta, phi, combined_theta_phi; #endif #ifdef ENABLE_DEBUG_T_SHOW unsigned long subevent_builder_id; #endif for(i=5;i>=0;i--) { SHOWER_hits_length[i] = 0; } /* i => Start position of sector-data in sub-event-data j => word number in IPU subevent k => bitnumber in SHOWER hit-pattern */ #ifdef OFFLINE_DEBUG printf("SHOWER_transform_xy_to_theta_phi\n"); #endif #ifdef ENABLE_DEBUG_T_SHOW if( ((*debug_register>>4) & 0xf) > 1) { sprintf(print_string, ":%6d: SHOWER_transform_xy_to_theta_phi", printf_writes_total ); printf_vme(print_string); } #endif SHOWER_hits_curr_ptr = SHOWER_hits_theta_phi; SHOWER_hits_ptr[0] = SHOWER_hits_curr_ptr; for(i=1, sector_number=0 , sector_number < 6; i < read_link_buffer_mem_pos[SHOWER_LINK_NUMBER];) { // for(ipc_counter = 0; ipc_counter<2; ipc_counter++) { length_of_subevent = (read_link_buffer_mem[SHOWER_LINK_NUMBER][i]&0xffff)>>1; #ifdef ENABLE_DEBUG_T_SHOW if( ((*debug_register>>4) & 0xf) > 1) { sprintf(print_string, ":%6d: sector number: %d", printf_writes_total, sector_number, ipc_counter ); printf_vme(print_string); } #endif if(length_of_subevent > (34 + SHOWER_TRAILER_WORDS) ) { sprintf(print_string, ":%6d:++error: shower ipc_subeventlength > 35: %d", printf_writes_total, length_of_subevent); printf_vme(print_string); for(;;); } if(length_of_subevent > (2+SHOWER_TRAILER_WORDS) ) { /* 6 means 3 long words, so length, header and trailer */ j=1; /* skip length of subevent j=1 */ #ifdef ENABLE_DEBUG_T_SHOW subevent_builder_id = (read_link_buffer_mem[SHOWER_LINK_NUMBER][i+(j++)]>>16)&0xfff; if( ((*debug_register>>4) & 0xf) > 2) { sprintf(print_string, ":%6d: i:%d, j:%d, sub_ev_builder: %3.3x", printf_writes_total, i,j, subevent_builder_id ); printf_vme(print_string); } #endif /* stop before trailer: length_of_subevent- NUMBER of Trailer words 1 */ for(; j < (length_of_subevent - SHOWER_TRAILER_WORDS); j++) { row_pattern = (read_link_buffer_mem[SHOWER_LINK_NUMBER][i+j]) & 0xffff; /* column => azimuthal => y */ column_number = ( (read_link_buffer_mem[SHOWER_LINK_NUMBER][i+j]) >> 16 ) & 0x1f; decoding = (read_link_buffer_mem[SHOWER_LINK_NUMBER][i+j]>>21)&0x7; #ifdef OFFLINE_DEBUG printf("i:%d, j:%d, row_pattern:%4.4x, column:%d, decoding:%d", i, j, row_number, fifo_number, column_pattern ); #endif #ifdef ENABLE_DEBUG_T_SHOW if( ((*debug_register>>4) & 0xf) > 1) { sprintf(print_string, ":%6d: i:%d, j:%d, row_pattern:%4.4x, column:%d, decoding:%d", printf_writes_total, i,j, row_pattern, column_number, decoding ); printf_vme(print_string); } #endif for(k=0; k<=15; k++) { if ( row_pattern & 0x1) { if(ipc_flag) { y = ( k | 0x10 ); } else { y = k; } /* y*32 */ theta_phi = IPU_SHOWER_transform[ (y<<5) + column_number ]; #if 0 if( ((*debug_register>>4) & 0xf) > 1) { sprintf(print_string, ":%6d: read theta_phi:%8.8x", printf_writes_total, theta_phi); printf_vme(print_string); } #endif if(theta_phi & 0x10000) { #ifdef ENABLE_DEBUG_T_SHOW if( ((*debug_register>>4) & 0xf) > 1) { sprintf(print_string, ":%6d:++error: k:%d, x:%d, y:%d, theta_phi:%8.8x, sector:%d, no mapping possible!", printf_writes_total, k, column_number, y , theta_phi, sector_number); printf_vme(print_string); } #endif row_pattern=row_pattern>>1; continue; } /* theta = theta_phi&0xff; phi = (theta_phi>>8)&0xff; combined_theta_phi = theta | (((sector_number<<8)|phi)<<8); */ *(SHOWER_hits_curr_ptr++) = theta_phi|(sector_number<<16); if(number_of_hits > MAX_SHOWER_HITS_CUTOFF ) { return MAX_SHOWER_HITS_CUTOFF+1; /* SHOWER_hits_curr_ptr--; */ } number_of_hits++; SHOWER_hits_length[sector_number]++; #ifdef OFFLINE_DEBUG printf("k:%d, r:%d, c:%d, theta_phi:%8x \n", k, row_number, current_column, *(SHOWER_hits_curr_ptr-1)); #endif #ifdef ENABLE_DEBUG_T_SHOW if( ((*debug_register>>4) & 0xf) > 1) { sprintf(print_string, ":%6d: k:%d, ipc_flag:%d, y: %d, column: %d, theta_phi:%8.8x, wrote:%8.8x", printf_writes_total, k, ipc_flag, y, column_number, theta_phi, *(SHOWER_hits_curr_ptr-1)); printf_vme(print_string); } #endif } row_pattern = row_pattern >> 1; } } } i+=length_of_subevent; /* toggle ipc_flag */ if(ipc_flag==0) ipc_flag = 1; else { ipc_flag = 0; /* always 2 IPUs for one sector */ sector_number++; /* idiot! you have to check for larger that 5! */ if(sector_number<6) { SHOWER_hits_ptr[sector_number] = SHOWER_hits_curr_ptr; } } } #ifdef ENABLE_DEBUG_T_SHOW if( ((*debug_register>>4) & 0xf) > 0) { sprintf(print_string, ":%6d: num of hits in SHOWER: %d Shower_hits_length: 0:%x,1:%x,2:%x,3:%x,4:%x,5:%x", printf_writes_total, number_of_hits, SHOWER_hits_length[0], SHOWER_hits_length[1], SHOWER_hits_length[2], SHOWER_hits_length[3], SHOWER_hits_length[4], SHOWER_hits_length[5] ); printf_vme(print_string); } #endif return number_of_hits; } unsigned long TOF_transform_xy_to_theta_phi(void) { long i,j; unsigned long length_of_subevent; unsigned long *TOF_hits_curr_ptr; unsigned long sector_number, old_sector_number; unsigned long TOF_reg; unsigned long combined_tof_hit, theta, phi; unsigned long tof_particle_id; unsigned long number_of_hits=0; for(i=5;i>=0;i--) { TOF_hits_length[i] = 0; TOF_hits_ptr[i] = 0; } /* i => current IPU number equals to sector number j => word number in IPU subevent k => bitnumber in SHOWER hit-pattern */ #ifdef OFFLINE_DEBUG printf("TOF_transform_xy_to_theta_phi\n"); #endif #ifdef ENABLE_DEBUG_T if( ((*debug_register>>4) & 0xf) > 1) { sprintf(print_string, ":%6d: TOF_transform_xy_to_theta_phi", printf_writes_total ); printf_vme(print_string); } #endif TOF_hits_curr_ptr = TOF_hits_theta_phi; for(i=0, sector_number = 0, old_sector_number = 0; i < read_link_buffer_mem_pos[TOF_LINK_NUMBER]; i++) { length_of_subevent = read_link_buffer_mem[TOF_LINK_NUMBER][i]; #ifdef ENABLE_DEBUG_T if( ((*debug_register>>4) & 0xf) > 1) { sprintf(print_string, ":%6d: length of subevent: %8.8x", printf_writes_total, length_of_subevent ); printf_vme(print_string); } #endif if(length_of_subevent > 0xff) { sprintf(print_string, ":%6d:++error: TOF-transform: length of subevent too large: %x", printf_writes_total, length_of_subevent ); printf_vme(print_string); } if(length_of_subevent > 1) { TOF_reg = read_link_buffer_mem[TOF_LINK_NUMBER][i+1]; TOF_reg; // remove warning for(j=2; j<=length_of_subevent; j++) { if( i+j >= read_link_buffer_mem_pos[TOF_LINK_NUMBER] ) { sprintf(print_string, ":%6d:+++error in length of data from TOF: pos %8.8x", printf_writes_total, i+j ); printf_vme(print_string); for(;;) ; } sector_number = (read_link_buffer_mem[TOF_LINK_NUMBER][i+j]) & 0xf; if( sector_number < old_sector_number ) { sprintf(print_string, ":%6d:+++error in TOF, sector number decreasing, evt: ", printf_writes_total, *GLOBAL_TRIGGER_COUNTER); printf_vme(print_string); } old_sector_number = sector_number; if( sector_number > 5 ) { #ifdef ENABLE_DEBUG_T sprintf(print_string, ":%6d:+++error in TOF, sector number > 5: %d ", printf_writes_total, sector_number); printf_vme(print_string); #endif sector_number = 5; } if(!TOF_hits_ptr[sector_number]) TOF_hits_ptr[sector_number] = TOF_hits_curr_ptr; theta = (read_link_buffer_mem[TOF_LINK_NUMBER][i+j] >> 8) & 0xff; phi = (read_link_buffer_mem[TOF_LINK_NUMBER][i+j] >> 16) & 0xff; combined_tof_hit = theta | ( ( (sector_number<<8)|phi)<<8); tof_particle_id = (read_link_buffer_mem[TOF_LINK_NUMBER][i+j] >> 5)&0x1; if (tof_particle_id == 0) { /* Bit=0 => Lepton Bit=1 => Other particle */ *(TOF_hits_curr_ptr++) = combined_tof_hit; TOF_hits_length[sector_number]++; number_of_hits++; } #ifdef ENABLE_DEBUG_T if( ((*debug_register>>4) & 0xf) > 1) { sprintf(print_string, ":%6d: i:%d, j:%d, theta:%8.8x, phi:%8.8x, sect:%d TOF_reg:%8.8x, co: %8.8x, pid: %d\n", printf_writes_total, i,j, theta, phi, sector_number, TOF_reg , combined_tof_hit, tof_particle_id ); printf_vme(print_string); } #endif } } i+=length_of_subevent; } #if 0 for(i=0, number_of_hits=0 ;i<=5; i++) { number_of_hits += TOF_hits_length[i]; } #endif #ifdef ENABLE_DEBUG_T if( ((*debug_register>>4) & 0xf) > 0) { sprintf(print_string, ":%6d: num of hits in TOF (elec): %d", printf_writes_total, number_of_hits ); printf_vme(print_string); } #endif return number_of_hits; } void write_downscaled_internal_data(void) { static long downscale_scaler_write = 0; unsigned long *long_ptr; long i; i = mu_subevent_mem_pos; downscale_scaler_write++; if(downscale_scaler_write > (*G_SCALER_DOWNSCALE_FACTOR) ) { downscale_scaler_write = 0; mu_subevent_mem[i++]=((*g_trigger_cond_1_met)>>16)&0xffff; mu_subevent_mem[i++]=(*g_trigger_cond_1_met)&0xffff; mu_subevent_mem[i++]=((*g_trigger_cond_2_met)>>16)&0xffff; mu_subevent_mem[i++]=(*g_trigger_cond_2_met)&0xffff; mu_subevent_mem[i++]=((*g_trigger_cond_3_met)>>16)&0xffff; mu_subevent_mem[i++]=(*g_trigger_cond_3_met)&0xffff; mu_subevent_mem[i++]=((*g_trigger_cond_4_met)>>16)&0xffff; mu_subevent_mem[i++]=(*g_trigger_cond_4_met)&0xffff; mu_subevent_mem[i++]=((*g_trigger_cond_5_met)>>16)&0xffff; mu_subevent_mem[i++]=(*g_trigger_cond_5_met)&0xffff; mu_subevent_mem[i++]= 0xdead; #ifdef ENABLE_EARLY_TRIGGER_DECISIONS mu_subevent_mem[i++]= 0xeaea; #else mu_subevent_mem[i++]= 0xface; #endif mu_subevent_mem[i++]= *PHI_DEVIATION_WINDOW; mu_subevent_mem[i++]= *DELTA_THETA_CUT; mu_subevent_mem[i++]= *G_TRIG_RICH_HITS; mu_subevent_mem[i++]= *G_TRIG_META_HITS; mu_subevent_mem[i++]= *G_TRIG_LEPTONS; mu_subevent_mem[i++]= *G_TRIG_DILEPTONS; long_ptr = (unsigned long *)INVARIANT_MASS_SQUARED_CUT; //mu_subevent_mem[i++]= ((unsigned long)(*INVARIANT_MASS_SQUARED_CUT)>>16)&0xffff; //mu_subevent_mem[i++]= ((unsigned long)*INVARIANT_MASS_SQUARED_CUT)&0xffff; mu_subevent_mem[i++]= ((*long_ptr)>>16)&0xffff; mu_subevent_mem[i++]= (*long_ptr)&0xffff; } mu_subevent_mem_pos = i; } int make_LVL2_trigger_decision(void) { unsigned long trigger_decision = 0; unsigned long hit_matching_result; unsigned long lepton_matching_result; unsigned long number_of_hits_in_RICH; unsigned long number_of_hits_in_SHOWER; unsigned long number_of_hits_in_TOF; unsigned long i = 0,j=0; #if 0 for(i=1; i<=3; i++) { if (read_link_buffer_mem_pos[i] > 0x1ff) { sprintf(print_string, ":%6d:+++error: link: %d, mem_pos larger than 0x1ff", printf_writes_total, i); printf_vme(print_string); } } #endif mu_subevent_mem_pos = 0; #ifdef ENABLE_CHECK_FOR_USE_TEST_DATA if( *G_USE_TEST_DATA ) { write_test_data_into_IPU(); } #endif #ifdef ENABLE_CHECK_FOR_FORCE_DECODE_EVENT if( *G_FORCE_DECODE_EVENT ) { RICH_transform_xy_to_theta_phi(); SHOWER_transform_xy_to_theta_phi(); TOF_transform_xy_to_theta_phi(); hit_matching(); trigger_decision = lepton_matching(); } #endif trigger_decision = 0; number_of_hits_in_RICH = determine_rich_sector_hitpattern(); i=0; mu_subevent_mem[i++] = number_of_hits_in_RICH; if( number_of_hits_in_RICH >= *G_TRIG_RICH_HITS ) { (*g_trigger_cond_1_met)++; #ifdef ENABLE_EARLY_TRIGGER_DECISIONS if (*G_TRIG_META_HITS == 0) { trigger_decision = 1; mu_subevent_mem_pos = i; return trigger_decision; } #ifdef 0 // cut if there are too many rings in RICH if(number_of_hits_in_RICH >= 10 ) { trigger_decision = 0; mu_subevent_mem_pos = i; (*MU_CUT_CONDITION1)++; return trigger_decision; } #endif #ifdef ENABLE_SHORT_CUT_IF_TOO_MANY_RINGS if(number_of_hits_in_RICH >= *G_MAX_RICH_RINGS_TO_LOOP_OVER ) { trigger_decision = 1; mu_subevent_mem_pos = i; (*MU_CUT_CONDITION1)++; return trigger_decision; } #endif #endif number_of_hits_in_SHOWER = determine_shower_sector_hitpattern(); number_of_hits_in_TOF = determine_tof_number_of_hits(); mu_subevent_mem[i++] = number_of_hits_in_SHOWER; mu_subevent_mem[i++] = number_of_hits_in_TOF; /* Number of Hits in IPUs */ if((number_of_hits_in_SHOWER + number_of_hits_in_TOF) >= *G_TRIG_META_HITS ) { /* Try Sector Matching */ (*g_trigger_cond_2_met)++; #ifdef ENABLE_EARLY_TRIGGER_DECISIONS if( (number_of_hits_in_SHOWER + number_of_hits_in_TOF) * number_of_hits_in_RICH >= *MAX_COMBINATORIAL_VALUE) { trigger_decision = 1; mu_subevent_mem_pos = i; (*MU_CUT_CONDITION2)++; return trigger_decision; } if (*G_TRIG_LEPTONS == 0) { trigger_decision = 1; mu_subevent_mem_pos = i; return trigger_decision; } #endif determine_tof_sector_hitpattern(); mu_subevent_mem[i++] = RICH_sector_hitpattern; mu_subevent_mem[i++] = SHOWER_sector_hitpattern; mu_subevent_mem[i++] = TOF_sector_hitpattern; #ifdef ENABLE_DEBUG_T if( (((*debug_register)>>4) & 0xf) > 2) { sprintf(print_string, ":%6d: +hitpatterns: 1: %x, 2:%x, 3:%x", printf_writes_total, RICH_sector_hitpattern, SHOWER_sector_hitpattern, TOF_sector_hitpattern ); printf_vme(print_string); } #endif if ( ( (RICH_sector_hitpattern & SHOWER_sector_hitpattern) || (RICH_sector_hitpattern & TOF_sector_hitpattern) ) || (*G_TRIG_META_HITS) == 0) { (*g_trigger_cond_3_met)++; /* Try Lepton Matching */ /* overwrite first guess of number of events in RICH and SHOWER */ number_of_hits_in_RICH = RICH_transform_xy_to_theta_phi(); number_of_hits_in_SHOWER = SHOWER_transform_xy_to_theta_phi(); number_of_hits_in_TOF = TOF_transform_xy_to_theta_phi(); mu_subevent_mem[0] = number_of_hits_in_RICH; mu_subevent_mem[1] = number_of_hits_in_SHOWER; mu_subevent_mem[2] = number_of_hits_in_TOF; #if 0 #ifdef ENABLE_DEBUG_T_SHOW if( ((*debug_register>>4) & 0xf) > 0) { sprintf(print_string, ":%6d: show call1: %d", printf_writes_total, number_of_hits_in_SHOWER ); printf_vme(print_string); } #endif #endif // cut again, if combinatorial cut exceed if( (number_of_hits_in_RICH > *G_MAX_RICH_RINGS_TO_LOOP_OVER) || ((number_of_hits_in_SHOWER + number_of_hits_in_TOF) * number_of_hits_in_RICH >= *MAX_COMBINATORIAL_VALUE) ) { trigger_decision = 1; mu_subevent_mem_pos = i; (*MU_CUT_CONDITION3)++; return trigger_decision; } // do hit matching to find leptons hit_matching_result = hit_matching(); // write data to mu_subevent mu_subevent_mem[i++] = found_number_of_leptons; for(j=0;(j>16; mu_subevent_mem[i++]=Leptons[j]; } // search for dileptons if number of leptons is enough if( found_number_of_leptons >= *G_TRIG_LEPTONS) { (*g_trigger_cond_4_met)++; #ifdef ENABLE_EARLY_TRIGGER_DECISIONS if (*G_TRIG_DILEPTONS == 0) { trigger_decision = (hit_matching_result == 0 ? 1 : 2); mu_subevent_mem_pos = i; return trigger_decision; } #endif if( hit_matching_result == 0) { // nothing exceeded lepton_matching_result = lepton_matching(); mu_subevent_mem[i++] = found_number_of_dileptons; // write data to mu_subevent for(j=0; (j < (found_number_of_dileptons<<1) && j < 20 ); j+=2) { mu_subevent_mem[i++]=DiLeptons[j]; mu_subevent_mem[i++]=DiLeptons[j+1]>>16; mu_subevent_mem[i++]=DiLeptons[j+1]; } if(lepton_matching_result == 0) { if( found_number_of_dileptons >= *G_TRIG_DILEPTONS ) { (*g_trigger_cond_5_met)++; trigger_decision = 1; } } else { (*g_trigger_cond_5_met)++; trigger_decision = 2; } } else { // to many leptons, so no dilepton search, but positive trigger trigger_decision = 2; } // write downscaled scaler information // mu_subevent_mem_pos = i; //write_downscaled_internal_data(); //i = mu_subevent_mem_pos; } } } } mu_subevent_mem_pos = i; return trigger_decision; } // obsolete unsigned long check_read_IPU_data (unsigned long *trigger_tags, unsigned long trigger_match_flag) { unsigned long best_tag; if ( (trigger_match_flag==0) && ((*glob_error_message_flag) == 1)) { sprintf(print_string, ":%6d:++error_tag: 1: %2.2x, 2: %2.2x, 3: %2.2x tot: %8.8x", printf_writes_total, trigger_tags[1], trigger_tags[2], trigger_tags[3], *GLOBAL_TRIGGER_COUNTER); printf_vme(print_string); for(;;) {} } if(trigger_tags[1] == ((*GLOBAL_TRIGGER_COUNTER)&0xff) ) { best_tag = trigger_tags[1]; } else if(trigger_tags[2] == ((*GLOBAL_TRIGGER_COUNTER)&0xff) ) { best_tag = trigger_tags[2]; } else if(trigger_tags[3] == ((*GLOBAL_TRIGGER_COUNTER)&0xff) ) { best_tag = trigger_tags[3]; } else { best_tag = 0xa5; } return(best_tag); } /* 0 means error, if bit 5 is set: positive trigger (calibration) */ unsigned long Trigger_code_map[] = { 0x00, 0x01, // 1 NORM 0x01, // 2 NORM 0x01, // 3 NORM 0x01, // 4 NORM 0x01, // 5 NORM 0x12, // 6 SPEC1 0x13, // 7 SPEC2 0x14, // 8 SPEC3 0x15, // 9 SPEC4 0x16, // a SPEC5 0x0, 0x0, 0x0, 0x0, 0x0 // 15 }; unsigned long reduction_reached_flag = 0; void check_mapped_trigger_code(unsigned long mapped_trigger_code, unsigned long trigger_code) { if((mapped_trigger_code == 0) && ((*glob_error_message_flag) == 1)) { sprintf(print_string, ":%6d:++error: wrong trigger code received: %x", printf_writes_total, trigger_code); printf_vme(print_string); } } void check_event_completion() { int i,j; unsigned long trigger_tag, trigger_code, positive_trigger_flag; unsigned long trigger_condition; static unsigned long trigger_reduction_counter = 0; int trigger_decision; unsigned long mapped_trigger_code, calibration_trigger_flag; volatile unsigned long dummy_reg, dummy_a, dummy_b; unsigned long global_trigger_counter_tmp; unsigned long pos_trigger_cond_mask_tmp; #ifdef ENABLE_RICH_RESYNC static unsigned long nr_of_consec_cal_triggers = 0; #endif #ifdef ENABLE_TRIGGER_CHECKS unsigned long trigger_tags[4], trigger_match_flag; #endif #ifdef ENABLE_DEBUG_T if( ((*debug_register)&0xf) > 0x1 ) { sprintf(print_string, ":%6d: +event completed!", printf_writes_total); printf_vme(print_string); } #endif pos_trigger_cond_mask_tmp = *pos_trigger_cond_mask; trigger_tag = *GLOBAL_TRIGGER_COUNTER; /* for(j=0;j<=(*LVL2_BUSY_COUNTER);j++) ; */ /* do not check anymore, it is assumed, that no new g_check_event_completion is followed in interrupt! */ g_check_event_completion=0; #ifdef ENABLE_RICH_RESYNC if(Rich_Resync_Counter) { #ifdef ENABLE_DEBUG_T if( ((*debug_register)&0xf) > 2 ) { sprintf(print_string, ":%6d: Rich_resync: Resync_counter: %x", printf_writes_total, Rich_Resync_Counter ); printf_vme(print_string); } #endif IPU_first_read_word_flag[RICH_LINK_NUMBER] = 1; // TOF and SHOWER is read by chained DMA, no first word necessary IPU_first_read_word_flag[TOF_LINK_NUMBER] = 0; IPU_first_read_word_flag[SHOWER_LINK_NUMBER] = 0; TCB_memory[TOF_LINK_NUMBER][5] = 1; TCB_memory[TOF_LINK_NUMBER][15] = ((unsigned long)read_link_buffer_mem[TOF_LINK_NUMBER]&0x1ffff) + 1; TCB_memory[SHOWER_LINK_NUMBER][5] = 1; TCB_memory[SHOWER_LINK_NUMBER][15] = ((unsigned long)read_link_buffer_mem[SHOWER_LINK_NUMBER]&0x1ffff) + 1; global_setup_new_interrupt2 = SHOWER_LINK_NUMBER; global_setup_new_interrupt3 = TOF_LINK_NUMBER; for(i=1;i<=3;i++) { IPU_read_words[i] = 0; read_link_buffer_mem_pos[i] = 0; IPU_current_number_of_address[i] = 1; event_complete_flag[i] = 0; } address_TOF_IPU(); IPU_addressing_base[SHOWER_LINK_NUMBER-1]=IPU_current_number_of_address[SHOWER_LINK_NUMBER]; IPU_addressing_base[RICH_LINK_NUMBER-1]=RICH_IPU_Address_Mapping[IPU_current_number_of_address[RICH_LINK_NUMBER]]; Rich_Resync_Counter--; return; } #endif #ifdef DETERMINE_BEST_TRIGGER_CODE if( ( (*not_connected_ipu_reg)&0x1) == 0 ) { /* trigger code is determined by bit 0-7 from headerword of RICH-IPU-0 */ trigger_code = read_link_buffer_mem[RICH_LINK_NUMBER][0]&0xf; } else if( ( (*not_connected_ipu_reg)&0x2) == 0 ) { /* trigger code is determined by SHOWER */ trigger_code = (read_link_buffer_mem[SHOWER_LINK_NUMBER][2]>>12)&0xf; /* adjust it */ } else if( ( (*not_connected_ipu_reg)&0x4) == 0 ) { /* trigger code is determined by bit 0-7 from headerword of TOF-IPU-0 */ trigger_code = (read_link_buffer_mem[TOF_LINK_NUMBER][1]>>8)&0xf; /* adjust it */ } else { calibration_trigger_flag = 0; trigger_code = 1; mapped_trigger_code = 1; } mapped_trigger_code = Trigger_code_map[trigger_code]&0xf; calibration_trigger_flag = Trigger_code_map[trigger_code]&0x10; #else calibration_trigger_flag = 0; trigger_code = 1; trigger_code; // to remove warning mapped_trigger_code = 1; #endif #ifdef ENABLE_DEBUG_T check_mapped_trigger_code(mapped_trigger_code, trigger_code); if( ((*debug_register)&0xf) > 2 ) { sprintf(print_string, ":%6d: trigger code: %x, mapped tc: %x, cf: %x", printf_writes_total, trigger_code,mapped_trigger_code, calibration_trigger_flag ); printf_vme(print_string); } #endif #ifndef REVERSED_REDUCTION_FACTOR /* fixed reduction of LVL2 triggers */ reduction_reached_flag = 0; if( (pos_trigger_cond_mask_tmp)&0x1 ) { if ( (*lvl2_trigger_rate)) { trigger_reduction_counter++; if ( (*lvl2_trigger_rate) <= trigger_reduction_counter ) { reduction_reached_flag = 1; trigger_reduction_counter = 0; } } } #else reduction_reached_flag = 1; if( (pos_trigger_cond_mask_tmp)&0x1 ) { if ( (*lvl2_trigger_rate)) { trigger_reduction_counter++; if ( (*lvl2_trigger_rate) >= trigger_reduction_counter ) { reduction_reached_flag = 0; trigger_reduction_counter = 0; } } } #endif #ifdef ENABLE_RICH_RESYNC if(calibration_trigger_flag) { nr_of_consec_cal_triggers++; } else { nr_of_consec_cal_triggers=0; } if(nr_of_consec_cal_triggers >=2) { #ifdef ENABLE_DEBUG_T if( ((*debug_register)&0xf) > 2 ) { sprintf(print_string, ":%6d: rich_resync: tc: %x, mapped tc: %x", printf_writes_total, trigger_code, mapped_trigger_code); printf_vme(print_string); } #endif for(j=0;j<=20000;j++) { dummy_a*=dummy_b+12; dummy_b*=dummy_a+13; } mapped_trigger_code &= 0x7; // positive trigger send_LVL2_Trigger_to_CTU( mapped_trigger_code&0x7 , trigger_tag ); // give positive LVL2 trigger decision send_result_to_DAQ( mapped_trigger_code|0x30 , trigger_tag, 0x70); // positive trigger send_LVL2_Trigger_to_CTU( mapped_trigger_code&0x7 , trigger_tag+1 ); // give positive LVL2 trigger decision send_result_to_DAQ( mapped_trigger_code|0x30 , trigger_tag+1, 0x70); // positive trigger send_LVL2_Trigger_to_CTU( mapped_trigger_code&0x7 , trigger_tag+2 ); // give positive LVL2 trigger decision send_result_to_DAQ( mapped_trigger_code|0x30 , trigger_tag+2, 0x70); // positive trigger send_LVL2_Trigger_to_CTU( mapped_trigger_code&0x7 , trigger_tag+3 ); // give positive LVL2 trigger decision send_result_to_DAQ( mapped_trigger_code|0x30 , trigger_tag+3, 0x70); // positive trigger // send_LVL2_Trigger_to_CTU( mapped_trigger_code&0x7 , trigger_tag+4 ); // give positive LVL2 trigger decision // send_result_to_DAQ( mapped_trigger_code|0x30 , trigger_tag+4, 0x70); // positive trigger // Rich_Resync_Counter = 4; Rich_Resync_Counter = 3; nr_of_consec_cal_triggers=0; } #endif /* Make LV2 trigger decision */ trigger_decision = 0; mu_subevent_mem_pos = 0; #ifdef MAKE_LVL2_TRIGGER_DECISION if( *(G_ALWAYS_NEGATIVE_TRIGGERS) ) { /* trigger_decision = 0; already done above */ } else if(calibration_trigger_flag == 0) { trigger_decision = make_LVL2_trigger_decision(); } else if(calibration_trigger_flag) { write_downscaled_internal_data(); } #else trigger_decision = 0; #endif #ifdef ENABLE_DEBUG_T if( ((*debug_register)&0xf) > 2 ) { sprintf(print_string, ":%6d: trigger decision: %d", printf_writes_total,trigger_decision ); printf_vme(print_string); } #endif #ifdef ENABLE_TRIGGER_CHECKS /* if( ((*not_connected_ipu_reg)&0x1) == 0) { trigger_tags[RICH_LINK_NUMBER] = (read_link_buffer_mem[RICH_LINK_NUMBER][0]>>16) & 0xff; } if ( ((*not_connected_ipu_reg)&0x2) == 0) { trigger_tags[SHOWER_LINK_NUMBER] = (read_link_buffer_mem[SHOWER_LINK_NUMBER][2]) & 0xff; } if ( ((*not_connected_ipu_reg)&0x4) == 0) { trigger_tags[TOF_LINK_NUMBER] = (read_link_buffer_mem[TOF_LINK_NUMBER][1]) & 0xff; } */ trigger_tags[RICH_LINK_NUMBER] = (read_link_buffer_mem[RICH_LINK_NUMBER][0]>>16) & 0xff; trigger_tags[SHOWER_LINK_NUMBER] = (read_link_buffer_mem[SHOWER_LINK_NUMBER][2]) & 0xff; trigger_tags[TOF_LINK_NUMBER] = (read_link_buffer_mem[TOF_LINK_NUMBER][1]) & 0xff; global_trigger_counter_tmp = (trigger_tag)&0xff; trigger_match_flag = ( ((trigger_tags[RICH_LINK_NUMBER] == global_trigger_counter_tmp)|((pos_trigger_cond_mask_tmp)&0x2)) && ((trigger_tags[SHOWER_LINK_NUMBER] == global_trigger_counter_tmp)|((pos_trigger_cond_mask_tmp)&0x4)) && ((trigger_tags[TOF_LINK_NUMBER] == global_trigger_counter_tmp)|((pos_trigger_cond_mask_tmp)&0x8)) ); #endif #ifdef ENABLE_RANDOM_DOWNSCALE if( (my_rand() & *RAND_DOWNSCALE_MASK) == *RAND_DOWNSCALE_VALUE) { reduction_reached_flag = 1; } #endif trigger_condition = ( ( reduction_reached_flag ) | ( trigger_decision << 1 ) ); #ifdef ENABLE_DEBUG_T if( ((*debug_register)&0xf) > 2 ) { sprintf(print_string, ":%6d: trigger_condition: %8.8x", printf_writes_total, trigger_condition ); printf_vme(print_string); } #endif positive_trigger_flag = 0; if ( trigger_condition ) { // trigger when at least one bit is set positive_trigger_flag = 1; } else if ( calibration_trigger_flag ) { #ifdef ENABLE_DEBUG_T if( ((*debug_register)&0xf) >=2 ) { sprintf(print_string, ":%6d: detected calibration trigger: %x, mapped to: %x", printf_writes_total, trigger_code, mapped_trigger_code ); printf_vme(print_string); } #endif positive_trigger_flag = 1; } #ifdef ENABLE_DEBUG_T if( ((*debug_register>>8)&0xf) > 0x2 ) { sprintf(print_string, ":%6d: red_rea: %d, trig_dec: %d, cal: %d, pos: %d", printf_writes_total, reduction_reached_flag, trigger_decision, calibration_trigger_flag, positive_trigger_flag ); printf_vme(print_string); } #endif // if( (my_rand() & 0x3f) == 0x30 ) { // check trigger tag #ifdef ENABLE_WARNINGS if ( (trigger_match_flag == 0) && ((*glob_error_message_flag) == 1)) { sprintf(print_string, ":%6d:++error_tag: 1: %2.2x, 2: %2.2x, 3: %2.2x tot: %8.8x", printf_writes_total, trigger_tags[1], trigger_tags[2], trigger_tags[3], *GLOBAL_TRIGGER_COUNTER); printf_vme(print_string); } #endif #ifdef ENABLE_DEBUG_T if( ((*debug_register)&0xf) >=2 ) { sprintf(print_string, ":%6d: trigger tag to CTU: %x", printf_writes_total, trigger_tag ); printf_vme(print_string); } #endif #ifdef ENABLE_DEBUG_T *G_TOTAL_WORDS_RICH += read_link_buffer_mem_pos[RICH_LINK_NUMBER]; *G_TOTAL_WORDS_SHOWER += read_link_buffer_mem_pos[SHOWER_LINK_NUMBER]; *G_TOTAL_WORDS_TOF += read_link_buffer_mem_pos[TOF_LINK_NUMBER]; *G_TOTAL_WORDS_MU += mu_subevent_mem_pos; *G_TOTAL_WORDS += read_link_buffer_mem_pos[RICH_LINK_NUMBER] + read_link_buffer_mem_pos[SHOWER_LINK_NUMBER] + read_link_buffer_mem_pos[TOF_LINK_NUMBER] + mu_subevent_mem_pos; #endif #ifdef ENABLE_RICH_RESYNC if(!Rich_Resync_Counter) { #endif if( positive_trigger_flag ) { mapped_trigger_code &= 0x7; // positive trigger send_LVL2_Trigger_to_CTU( mapped_trigger_code , trigger_tag ); // give LVL2 trigger decision #ifdef ENABLE_TRIGGER_CODE_EXTENTION // BIT(12) marks in the code which becomes the evtId, // that the original LVL1 trigger codes are used. Implemented: 2003-09-08 send_result_to_DAQ( trigger_code | (trigger_condition<<4) | BIT(12) , trigger_tag, trigger_condition); // positive trigger #else send_result_to_DAQ( trigger_code , trigger_tag, trigger_condition); // positive trigger #endif } else { mapped_trigger_code |= 0x8; // negativ trigger send_LVL2_Trigger_to_CTU( mapped_trigger_code , trigger_tag ); // give LVL2 trigger decision } #ifdef ENABLE_RICH_RESYNC } #endif #ifdef ENABLE_LVL2_BUSY_COUNTER for(j=0;j<=(*LVL2_BUSY_COUNTER);j++) { dummy_a*=dummy_b+12; dummy_b*=dummy_a+13; } #endif #ifdef ENABLE_GLOBAL_STOP_CHECK if (*glob_stop_flag != 0) { while( *glob_stop_flag != 0) { *MU_status_register = *MU_status_register | 0x10; }; *MU_status_register = (*MU_status_register) & (~0x10); } #endif IPU_first_read_word_flag[RICH_LINK_NUMBER] = 1; #ifndef USE_DMA IPU_first_read_word_flag[TOF_LINK_NUMBER] = 1; IPU_first_read_word_flag[SHOWER_LINK_NUMBER] = 1; #else #ifdef ENABLE_DEBUG_T if( ((*debug_register)&0xf) >=2 ) { sprintf(print_string, ":%6d: setup new DMA for SHOWER and TOF", printf_writes_total ); printf_vme(print_string); } #endif #ifdef USE_CHAINED_DMA // TOF and SHOWER is read by chained DMA, no first word necessary IPU_first_read_word_flag[TOF_LINK_NUMBER] = 0; IPU_first_read_word_flag[SHOWER_LINK_NUMBER] = 0; TCB_memory[TOF_LINK_NUMBER][5] = 1; TCB_memory[TOF_LINK_NUMBER][15] = ((unsigned long)read_link_buffer_mem[TOF_LINK_NUMBER]&0x1ffff) + 1; TCB_memory[SHOWER_LINK_NUMBER][5] = 1; TCB_memory[SHOWER_LINK_NUMBER][15] = ((unsigned long)read_link_buffer_mem[SHOWER_LINK_NUMBER]&0x1ffff) + 1; global_setup_new_interrupt2 = SHOWER_LINK_NUMBER; global_setup_new_interrupt3 = TOF_LINK_NUMBER; #else // Setup new DMA for SHOWER, not chained TCB_memory[SHOWER_LINK_NUMBER][5] = 1; TCB_memory[SHOWER_LINK_NUMBER][7] = ((unsigned long)read_link_buffer_mem[SHOWER_LINK_NUMBER]&0x1ffff); global_setup_new_interrupt2 = SHOWER_LINK_NUMBER; #endif #endif for(i=1;i<=3;i++) { IPU_read_words[i] = 0; read_link_buffer_mem_pos[i] = 0; IPU_current_number_of_address[i] = 1; event_complete_flag[i] = 0; } // asm("\nBIT CLR MODE1 IRPTEN;\n"); // asm("BIT SET MODE2 BUSLK; \n IF NOT BM JUMP(PC,0); "); address_TOF_IPU(); IPU_addressing_base[SHOWER_LINK_NUMBER-1]=IPU_current_number_of_address[SHOWER_LINK_NUMBER]; IPU_addressing_base[RICH_LINK_NUMBER-1]=RICH_IPU_Address_Mapping[IPU_current_number_of_address[RICH_LINK_NUMBER]]; // asm("BIT CLR MODE2 BUSLK; "); // asm("BIT SET MODE1 IRPTEN; "); #ifdef ENABLE_CHECK_FOR_CLEAR_IPU_RECEIVE_MEMORY if (*G_CLEAR_IPU_RECEIVE_MEMORY) { for(j=1;j<=3;j++) { for(i=0; i<0x20; i++) { read_link_buffer_mem[j][i] = 0; } } } #endif // asm(" BIT SET MODE1 IRPTEN; // 0x00001000 , Enable global interrupt "); return; }