Exemplo n.º 1
0
void DumpPmtVerbose(int n, uint32_t *pmt_buf, char* msg_buf)
{
  int i,j;
  char msg[10000];
  memset(msg,'\0',10000);
  for (i=0;i<n*3;i+=3)
  {
    if (!(i%32)){
      sprintf(msg+strlen(msg),"No\tCh\tCell\t\tGT\tQlx\tQhs\tQhl\tTAC\tES\tMC\tLGI\tNC/CC\tCr\tBd\n");
      sprintf(msg+strlen(msg),"--------------------------------------------------------------------------------------\n");
    }
    sprintf(msg+strlen(msg),"% 4d\t%2u\t%2u\t%8u\t%4u\t%4u\t%4u\t%4u\t%u%u%u\t%1u\t%1u\t%1u\t%2u\t%2u\n",
        i/3,
        (uint32_t) UNPK_CHANNEL_ID(pmt_buf+i),
        (uint32_t) UNPK_CELL_ID(pmt_buf+i),
        (uint32_t) UNPK_FEC_GT_ID(pmt_buf+i),
        (uint32_t) UNPK_QLX(pmt_buf+i),
        (uint32_t) UNPK_QHS(pmt_buf+i),
        (uint32_t) UNPK_QHL(pmt_buf+i),
        (uint32_t) UNPK_TAC(pmt_buf+i),
        (uint32_t) UNPK_CMOS_ES_16(pmt_buf+i),
        (uint32_t) UNPK_CGT_ES_16(pmt_buf+i),
        (uint32_t) UNPK_CGT_ES_24(pmt_buf+i),
        (uint32_t) UNPK_MISSED_COUNT(pmt_buf+i),
        (uint32_t) UNPK_LGI_SELECT(pmt_buf+i),
        (uint32_t) UNPK_NC_CC(pmt_buf+i),
        (uint32_t) UNPK_CRATE_ID(pmt_buf+i),
        (uint32_t) UNPK_BOARD_ID(pmt_buf+i));
  }
  sprintf(msg_buf+strlen(msg_buf),"%s",msg);
  lprintf("%s",msg);
}
Exemplo n.º 2
0
void *pt_read_bundle(void *args)
{
  read_bundle_t arg = *(read_bundle_t *) args;
  free(args);

  fd_set thread_fdset;
  FD_ZERO(&thread_fdset);
  FD_SET(rw_xl3_fd[arg.crate_num],&thread_fdset);

  int errors = 0;
  uint32_t crate,slot,chan,gt8,gt16,cmos_es16,cgt_es16,cgt_es8,nc_cc;
  int cell;
  double qlx,qhs,qhl,tac;
  uint32_t pmtword[3];
  errors += xl3_rw(READ_MEM+arg.slot_num*FEC_SEL,0x0,pmtword,arg.crate_num,&thread_fdset);
  errors += xl3_rw(READ_MEM+arg.slot_num*FEC_SEL,0x0,pmtword+1,arg.crate_num,&thread_fdset);
  errors += xl3_rw(READ_MEM+arg.slot_num*FEC_SEL,0x0,pmtword+2,arg.crate_num,&thread_fdset);
  if (errors != 0){
    pt_printsend("There were %d errors reading out the bundles.\n",errors);
    unthread_and_unlock(0,(0x1<<arg.crate_num),arg.thread_num);
    return;
  }
  pt_printsend("%08x %08x %08x\n",pmtword[0],pmtword[1],pmtword[2]);
  if (arg.quiet == 0){
    crate = (uint32_t) UNPK_CRATE_ID(pmtword);
    slot = (uint32_t)  UNPK_BOARD_ID(pmtword);
    chan = (uint32_t)  UNPK_CHANNEL_ID(pmtword);
    cell = (int) UNPK_CELL_ID(pmtword);
    gt8 = (uint32_t)   UNPK_FEC_GT8_ID(pmtword);
    gt16 = (uint32_t)  UNPK_FEC_GT16_ID(pmtword);
    cmos_es16 = (uint32_t) UNPK_CMOS_ES_16(pmtword);
    cgt_es16 = (uint32_t)  UNPK_CGT_ES_16(pmtword);
    cgt_es8 = (uint32_t)   UNPK_CGT_ES_24(pmtword);
    nc_cc = (uint32_t) UNPK_NC_CC(pmtword);
    qlx = (double) MY_UNPK_QLX(pmtword);
    qhs = (double) UNPK_QHS(pmtword);
    qhl = (double) UNPK_QHL(pmtword);
    tac = (double) UNPK_TAC(pmtword);
    pt_printsend("crate %d, slot %d, chan %d, cell %d, gt8 %08x, gt16 %08x, cmos_es16 %08x,"
        " cgt_es16 %08x, cgt_es8 %08x, nc_cc %08x, qlx %6.1f, qhs %6.1f, qhl %6.1f, tac %6.1f\n",
        (int)crate,(int)slot,(int)chan,cell,gt8,
        gt16,cmos_es16,cgt_es16,cgt_es8,nc_cc,qlx,qhs,qhl,tac);
  }
  unthread_and_unlock(0,(0x1<<arg.crate_num),arg.thread_num);
}
Exemplo n.º 3
0
int ChinjScan(int crateNum, uint32_t slotMask, uint32_t channelMask, float frequency, int gtDelay, int pedWidth, int numPedestals, float upper, float lower, int qSelect, int pedOn, int updateDB, int finalTest)
{
  lprintf("*** Starting Charge Injection Test *****\n");

  float *qhls;
  float *qhss;
  float *qlxs;
  float *tacs;
  int *scan_errors;
  int errors = 0;
  int count,crateID,ch,cell,num_events;
  uint16_t dacvalue;
  uint32_t *pmt_buffer,*pmt_iter;
  struct pedestal *ped;
  uint32_t result, select_reg;
  uint32_t default_ch_mask;
  int chinj_err[16];

  pmt_buffer = (uint32_t *) malloc( 0x20000*sizeof(uint32_t));
  ped = (struct pedestal *) malloc( 32 * sizeof(struct pedestal));
  qhls = (float *) malloc(32*16*2*26*sizeof(float));
  qhss = (float *) malloc(32*16*2*26*sizeof(float));
  qlxs = (float *) malloc(32*16*2*26*sizeof(float));
  tacs = (float *) malloc(32*16*2*26*sizeof(float));
  scan_errors = (int *) malloc(32*16*2*26*sizeof(int));
  if (pmt_buffer == NULL || ped == NULL || qhls == NULL || qhss == NULL || qlxs == NULL || tacs == NULL || scan_errors == NULL){
    lprintf("Problem mallocing! Exiting\n");
    if (pmt_buffer != NULL)
      free(pmt_buffer);
    if (ped != NULL)
      free(ped);
    if (qhls != NULL)
      free(qhls);
    if (qhss != NULL)
      free(qhss);
    if (qlxs != NULL)
      free(qlxs);
    if (tacs != NULL)
      free(tacs);
    if (scan_errors != NULL)
      free(scan_errors);
    return -1;
  }

  for (int i=0;i<16;i++){
    chinj_err[i] = 0;
    for (int j=0;j<32;j++)
      for (int k=0;k<26;k++)
        for (int l=0;l<2;l++){
          qhls[k*16*32*2+i*32*2+j*2+l] = 0;
          qhss[k*16*32*2+i*32*2+j*2+l] = 0;
          qlxs[k*16*32*2+i*32*2+j*2+l] = 0;
          tacs[k*16*32*2+i*32*2+j*2+l] = 0;
          scan_errors[k*16*32*2+i*32*2+j*2+l] = 0;
        }
  }

  try {

    for (int dac_iter=0;dac_iter<26;dac_iter++){

      dacvalue = dac_iter*10;

      for (int slot_iter = 0; slot_iter < 16; slot_iter ++){
        if ((0x1 << slot_iter) & slotMask){
          select_reg = FEC_SEL*slot_iter;
          xl3s[crateNum]->RW(CMOS_CHIP_DISABLE_R + select_reg + WRITE_REG,0xFFFFFFFF,&result);
          xl3s[crateNum]->RW(GENERAL_CSR_R + select_reg + WRITE_REG,0x2,&result);
          xl3s[crateNum]->RW(GENERAL_CSR_R + select_reg + WRITE_REG,0x0,&result);
          xl3s[crateNum]->RW(CMOS_CHIP_DISABLE_R + select_reg + WRITE_REG,~channelMask,&result);
        }
      }
      xl3s[crateNum]->DeselectFECs(); 

      //pt_printsend("Reset FECs\n");

      errors = 0;
      errors += xl3s[crateNum]->LoadCrateAddr(slotMask);
      if (pedOn){
        //pt_printsend("enabling pedestals.\n");
        errors += xl3s[crateNum]->SetCratePedestals(slotMask, channelMask);
      }
      xl3s[crateNum]->DeselectFECs(); 

      if (errors){
        lprintf("error setting up FEC crate for pedestals. Exiting.\n");
        free(pmt_buffer);
        free(ped);
        free(qhls);
        free(qhss);
        free(qlxs);
        free(tacs);
        free(scan_errors);
        return -1;
      }

      //setup charge injection
      xl3s[crateNum]->SetupChargeInjection(slotMask,channelMask,dacvalue);

      errors = mtc->SetupPedestals(0,pedWidth,gtDelay,DEFAULT_GT_FINE_DELAY,(0x1<<crateNum),(0x1<<crateNum));
      if (errors){
        lprintf("Error setting up MTC for pedestals. Exiting.\n");
        mtc->UnsetPedCrateMask(MASKALL);
        mtc->UnsetGTCrateMask(MASKALL);
        free(pmt_buffer);
        free(ped);
        free(qhls);
        free(qhss);
        free(qlxs);
        free(tacs);
        free(scan_errors);
        return -1;
      }

      // send the softgts
      mtc->MultiSoftGT(numPedestals*16);

      // LOOP OVER SLOTS
      for (int slot_iter = 0; slot_iter < 16; slot_iter ++){
        if ((0x1<<slot_iter) & slotMask){

          // initialize pedestal struct
          for (int i=0;i<32;i++){
            //pedestal struct
            ped[i].channelnumber = i; //channel numbers start at 0!!!
            ped[i].per_channel = 0;

            for (int j=0;j<16;j++){
              ped[i].thiscell[j].cellno = j;
              ped[i].thiscell[j].per_cell = 0;
              ped[i].thiscell[j].qlxbar = 0;
              ped[i].thiscell[j].qlxrms = 0;
              ped[i].thiscell[j].qhlbar = 0;
              ped[i].thiscell[j].qhlrms = 0;
              ped[i].thiscell[j].qhsbar = 0;
              ped[i].thiscell[j].qhsrms = 0;
              ped[i].thiscell[j].tacbar = 0;
              ped[i].thiscell[j].tacrms = 0;
            }
          }


          /////////////////////
          // READOUT BUNDLES //
          /////////////////////

          count = xl3s[crateNum]->ReadOutBundles(slot_iter, pmt_buffer, numPedestals*32*16,1);

          //check for readout errors
          if (count <= 0){
            lprintf("there was an error in the count!\n");
            lprintf("Errors reading out MB(%2d) (errno %i)\n", slot_iter, count);
            errors+=1;
            continue;
          }else{
            //pt_printsend("MB(%2d): %5d bundles read out.\n", slot_iter, count);
          }

          if (count < numPedestals*32*16)
            errors += 1;

          //process data
          pmt_iter = pmt_buffer;

          for (int i=0;i<count;i++){
            crateID = (int) UNPK_CRATE_ID(pmt_iter);
            if (crateID != crateNum){
              lprintf("Invalid crate ID seen! (crate ID %2d, bundle %2i)\n", crateID, i);
              pmt_iter+=3;
              continue;
            }
            ch = (int) UNPK_CHANNEL_ID(pmt_iter);
            cell = (int) UNPK_CELL_ID(pmt_iter);
            ped[ch].thiscell[cell].qlxbar += (double) MY_UNPK_QLX(pmt_iter);
            ped[ch].thiscell[cell].qhsbar += (double) UNPK_QHS(pmt_iter);
            ped[ch].thiscell[cell].qhlbar += (double) UNPK_QHL(pmt_iter);
            ped[ch].thiscell[cell].tacbar += (double) UNPK_TAC(pmt_iter);

            ped[ch].thiscell[cell].qlxrms += pow((double) MY_UNPK_QLX(pmt_iter),2.0);
            ped[ch].thiscell[cell].qhsrms += pow((double) UNPK_QHS(pmt_iter),2.0);
            ped[ch].thiscell[cell].qhlrms += pow((double) UNPK_QHL(pmt_iter),2.0);
            ped[ch].thiscell[cell].tacrms += pow((double) UNPK_TAC(pmt_iter),2.0);

            ped[ch].per_channel++;
            ped[ch].thiscell[cell].per_cell++;

            pmt_iter += 3; //increment pointer
          }

          // do final step
          // final step of calculation
          for (int i=0;i<32;i++){
            if (ped[i].per_channel > 0){
              for (int j=0;j<16;j++){
                num_events = ped[i].thiscell[j].per_cell;

                //don't do anything if there is no data here or n=1 since
                //that gives 1/0 below.
                if (num_events > 1){

                  // now x_avg = sum(x) / N, so now xxx_bar is calculated
                  ped[i].thiscell[j].qlxbar /= num_events;
                  ped[i].thiscell[j].qhsbar /= num_events;
                  ped[i].thiscell[j].qhlbar /= num_events;
                  ped[i].thiscell[j].tacbar /= num_events;

                  // now x_rms^2 = n/(n-1) * (<xxx^2>*N/N - xxx_bar^2)
                  ped[i].thiscell[j].qlxrms = num_events / (num_events -1)
                    * ( ped[i].thiscell[j].qlxrms / num_events
                        - pow( ped[i].thiscell[j].qlxbar, 2.0));
                  ped[i].thiscell[j].qhlrms = num_events / (num_events -1)
                    * ( ped[i].thiscell[j].qhlrms / num_events
                        - pow( ped[i].thiscell[j].qhlbar, 2.0));
                  ped[i].thiscell[j].qhsrms = num_events / (num_events -1)
                    * ( ped[i].thiscell[j].qhsrms / num_events
                        - pow( ped[i].thiscell[j].qhsbar, 2.0));
                  ped[i].thiscell[j].tacrms = num_events / (num_events -1)
                    * ( ped[i].thiscell[j].tacrms / num_events
                        - pow( ped[i].thiscell[j].tacbar, 2.0));

                  // finally x_rms = sqrt(x_rms^2)
                  ped[i].thiscell[j].qlxrms = sqrt(ped[i].thiscell[j].qlxrms);
                  ped[i].thiscell[j].qhsrms = sqrt(ped[i].thiscell[j].qhsrms);
                  ped[i].thiscell[j].qhlrms = sqrt(ped[i].thiscell[j].qhlrms);
                  ped[i].thiscell[j].tacrms = sqrt(ped[i].thiscell[j].tacrms);
                }else{
                  ped[i].thiscell[j].qlxrms = 0;
                  ped[i].thiscell[j].qhsrms = 0;
                  ped[i].thiscell[j].qhlrms = 0;
                  ped[i].thiscell[j].tacrms = 0;
                }
              }
            }
          }

          ///////////////////
          // PRINT RESULTS //
          ///////////////////

          lprintf("########################################################\n");
          lprintf("Slot (%2d)\n", slot_iter);
          lprintf("########################################################\n");

          for (int i = 0; i<32; i++){
            //pt_printsend("Ch Cell  #   Qhl         Qhs         Qlx         TAC\n");
            for (int j=0;j<16;j++){
              if (j == 0){
                qhls[dac_iter*16*32*2+slot_iter*32*2+i*2] = ped[i].thiscell[j].qhlbar;
                qhss[dac_iter*16*32*2+slot_iter*32*2+i*2] = ped[i].thiscell[j].qhsbar;
                qlxs[dac_iter*16*32*2+slot_iter*32*2+i*2] = ped[i].thiscell[j].qlxbar;
                tacs[dac_iter*16*32*2+slot_iter*32*2+i*2] = ped[i].thiscell[j].tacbar;
              }
              if (j == 1){
                qhls[dac_iter*16*32*2+slot_iter*32*2+i*2+1] = ped[i].thiscell[j].qhlbar;
                qhss[dac_iter*16*32*2+slot_iter*32*2+i*2+1] = ped[i].thiscell[j].qhsbar;
                qlxs[dac_iter*16*32*2+slot_iter*32*2+i*2+1] = ped[i].thiscell[j].qlxbar;
                tacs[dac_iter*16*32*2+slot_iter*32*2+i*2+1] = ped[i].thiscell[j].tacbar;
              }
              if (qSelect == 0){
                if (ped[i].thiscell[j].qhlbar < lower ||
                    ped[i].thiscell[j].qhlbar > upper) {
                  chinj_err[slot_iter]++;
                  //pt_printsend(">>>>>Qhl Extreme Value<<<<<\n");
                  if (j%2 == 0)
                    scan_errors[dac_iter*16*32*2+slot_iter*32*2+i*2]++;
                  else
                    scan_errors[dac_iter*16*32*2+slot_iter*32*2+i*2+1]++;
                }
              }
              else if (qSelect == 1){
                if (ped[i].thiscell[j].qhsbar < lower ||
                    ped[i].thiscell[j].qhsbar > upper) {
                  chinj_err[slot_iter]++;
                  //pt_printsend(">>>>>Qhs Extreme Value<<<<<\n");
                  if (j%2 == 0)
                    scan_errors[dac_iter*16*32*2+slot_iter*32*2+i*2]++;
                  else
                    scan_errors[dac_iter*16*32*2+slot_iter*32*2+i*2+1]++;
                }
              }
              else if (qSelect == 2){
                if (ped[i].thiscell[j].qlxbar < lower ||
                    ped[i].thiscell[j].qlxbar > upper) {
                  chinj_err[slot_iter]++;
                  //pt_printsend(">>>>>Qlx Extreme Value<<<<<\n");
                  if (j%2 == 0)
                    scan_errors[dac_iter*16*32*2+slot_iter*32*2+i*2]++;
                  else
                    scan_errors[dac_iter*16*32*2+slot_iter*32*2+i*2+1]++;
                }
              }
              if (j==0){
                lprintf("%2d %3d %4d %6.1f %4.1f %6.1f %4.1f %6.1f %4.1f %6.1f %4.1f\n",
                    dacvalue,i,ped[i].thiscell[j].per_cell,
                    ped[i].thiscell[j].qhlbar, ped[i].thiscell[j].qhlrms,
                    ped[i].thiscell[j].qhsbar, ped[i].thiscell[j].qhsrms,
                    ped[i].thiscell[j].qlxbar, ped[i].thiscell[j].qlxrms,
                    ped[i].thiscell[j].tacbar, ped[i].thiscell[j].tacrms);
              }
            }
          }

        } // end if slotmask
      } // end loop over slots


      //    if (arg.q_select == 0){
      //    pt_printsend("Qhl lower, Upper bounds = %f %f\n",arg.chinj_lower,arg.chinj_upper);
      //    pt_printsend("Number of Qhl overflows = %d\n",chinj_err[slot_iter]);
      //    }
      //    else if (arg.q_select == 1){
      //    pt_printsend("Qhs lower, Upper bounds = %f %f\n",arg.chinj_lower,arg.chinj_upper);
      //    pt_printsend("Number of Qhs overflows = %d\n",chinj_err[slot_iter]);
      //    }
      //    else if (arg.q_select == 2){
      //    pt_printsend("Qlx lower, Upper bounds = %f %f\n",arg.chinj_lower,arg.chinj_upper);
      //    pt_printsend("Number of Qlx overflows = %d\n",chinj_err[slot_iter]);
      //    }



      //disable trigger enables
      mtc->UnsetPedCrateMask(MASKALL);
      mtc->UnsetGTCrateMask(MASKALL);

      //unset pedestalenable
      errors += xl3s[crateNum]->SetCratePedestals(slotMask, 0x0);

      xl3s[crateNum]->DeselectFECs();
    } // end loop over dacvalue

    free(pmt_buffer);
    free(ped);

    // lets update this database
    if (updateDB){
      lprintf("updating the database\n");
      for (int i=0;i<16;i++)
      {
        if ((0x1<<i) & slotMask){
          JsonNode *newdoc = json_mkobject();
          JsonNode *qhl_even = json_mkarray();
          JsonNode *qhl_odd = json_mkarray();
          JsonNode *qhs_even = json_mkarray();
          JsonNode *qhs_odd = json_mkarray();
          JsonNode *qlx_even = json_mkarray();
          JsonNode *qlx_odd = json_mkarray();
          JsonNode *tac_even = json_mkarray();
          JsonNode *tac_odd = json_mkarray();
          JsonNode *error_even = json_mkarray();
          JsonNode *error_odd = json_mkarray();
          for (int j=0;j<32;j++){
            JsonNode *qhleventemp = json_mkarray();
            JsonNode *qhloddtemp = json_mkarray();
            JsonNode *qhseventemp = json_mkarray();
            JsonNode *qhsoddtemp = json_mkarray();
            JsonNode *qlxeventemp = json_mkarray();
            JsonNode *qlxoddtemp = json_mkarray();
            JsonNode *taceventemp = json_mkarray();
            JsonNode *tacoddtemp = json_mkarray();
            JsonNode *erroreventemp = json_mkarray();
            JsonNode *erroroddtemp = json_mkarray();
            for (int k=0;k<26;k++){
              json_append_element(qhleventemp,json_mknumber(qhls[k*16*32*2+i*32*2+j*2]));	
              json_append_element(qhloddtemp,json_mknumber(qhls[k*16*32*2+i*32*2+j*2+1]));	
              json_append_element(qhseventemp,json_mknumber(qhss[k*16*32*2+i*32*2+j*2]));	
              json_append_element(qhsoddtemp,json_mknumber(qhss[k*16*32*2+i*32*2+j*2+1]));	
              json_append_element(qlxeventemp,json_mknumber(qlxs[k*16*32*2+i*32*2+j*2]));	
              json_append_element(qlxoddtemp,json_mknumber(qlxs[k*16*32*2+i*32*2+j*2+1]));	
              json_append_element(taceventemp,json_mknumber(tacs[k*16*32*2+i*32*2+j*2]));	
              json_append_element(tacoddtemp,json_mknumber(tacs[k*16*32*2+i*32*2+j*2+1]));	
              json_append_element(erroreventemp,json_mkbool(scan_errors[k*16*32*2+i*32*2+j*2]));	
              json_append_element(erroroddtemp,json_mkbool(scan_errors[k*16*32*2+i*32*2+j*2+1]));	
            }
            json_append_element(qhl_even,qhleventemp);
            json_append_element(qhl_odd,qhloddtemp);
            json_append_element(qhs_even,qhseventemp);
            json_append_element(qhs_odd,qhsoddtemp);
            json_append_element(qlx_even,qlxeventemp);
            json_append_element(qlx_odd,qlxoddtemp);
            json_append_element(tac_even,taceventemp);
            json_append_element(tac_odd,tacoddtemp);
            json_append_element(error_even,erroreventemp);
            json_append_element(error_odd,erroroddtemp);
          }
          json_append_member(newdoc,"type",json_mkstring("chinj_scan"));
          json_append_member(newdoc,"QHL_even",qhl_even);
          json_append_member(newdoc,"QHL_odd",qhl_odd);
          json_append_member(newdoc,"QHS_even",qhs_even);
          json_append_member(newdoc,"QHS_odd",qhs_odd);
          json_append_member(newdoc,"QLX_even",qlx_even);
          json_append_member(newdoc,"QLX_odd",qlx_odd);
          json_append_member(newdoc,"TAC_even",tac_even);
          json_append_member(newdoc,"TAC_odd",tac_odd);
          json_append_member(newdoc,"errors_even",error_even);
          json_append_member(newdoc,"errors_odd",error_odd);
          json_append_member(newdoc,"pass",json_mkbool(!(chinj_err[i])));
          if (finalTest){
            json_append_member(newdoc,"final_test_id",json_mkstring(finalTestIDs[crateNum][i]));	
          }
          PostDebugDoc(crateNum,i,newdoc);
        }
      }
    }

    if (errors)
      lprintf("There were %d errors\n", errors);
    else
      lprintf("No errors seen\n");

    free(qhls);
    free(qhss);
    free(qlxs);
    free(tacs);
    free(scan_errors);

  }
  catch(const char* s){
    lprintf("ChinjScan: %s\n",s);
    if (pmt_buffer != NULL)
      free(pmt_buffer);
    if (ped != NULL)
      free(ped);
    if (qhls != NULL)
      free(qhls);
    if (qhss != NULL)
      free(qhss);
    if (qlxs != NULL)
      free(qlxs);
    if (tacs != NULL)
      free(tacs);
    if (scan_errors != NULL)
      free(scan_errors);

  }

  lprintf("****************************************\n");
  return 0;
}