Changeset 14174 for fact

Timestamp:

06/13/12 15:44:01 (12 years ago)

Author:

ogrimm

Message:

Fixed hanging signal handler in Evidence before abort() was called. Added command to determine dynamic range to FADctrl.

Location:

fact

Files:

• Evidence/Evidence.cc (modified) (1 diff)
• Evidence/readme.txt (modified) (1 diff)
• FADctrl/FAD.cc (modified) (4 diffs)
• FADctrl/FADBoard.cc (modified) (6 diffs)
• FADctrl/FADBoard.h (modified) (2 diffs)
• FADctrl/History.txt (modified) (1 diff)

fact/Evidence/Evidence.cc

@@ -360 +360 @@
   // If invoked twice, call exit()
   if (Count == 2) {
-        This->Message(WARN, "Signal handler called twice, invoking exit() (signal %d)", Signal);
+        This->Message(WARN, "Signal handler called twice, invoking exit(). Will abort() on next signal without message. (signal %d)", Signal);
         exit(EXIT_FAILURE);
   }
 
   // If invoked more than twice, call abort()
-  This->Message(WARN, "Signal handler called %d times, invoking abort(). Good bye. (signal %d)", Count, Signal);
+  // Does not use Message() again, as this might be blocked
   abort();
 }

fact/Evidence/readme.txt

@@ -65 +65 @@
                         Edd much faster now. Made a new version Edd:LP for La Palma. History server publishes a list of
                         services subscribed to.
+13/6/2012       Removed calling Message() before abort() in signal handler, as Message() might get stuck

fact/FADctrl/FAD.cc

@@ -617 +617 @@
 void FAD::cmd_dynrange() {
 
-  // Set number of events required for measurement
-  if (Parameter.size()==1 || !ConvertToInt(Parameter[1], &NumEventsRequested) || NumEventsRequested<=0) {
-        NumEventsRequested = DEFAULT_NUM_CALIB_EVENTS;
-  }
-
-  // Start calibration by setting mode
   Mode = dynrange;
-  Message(INFO, "Starting determination of dynamic range with %d events", NumEventsRequested);
+  Message(INFO, "Starting determination of dynamic range");
 }
 
@@ -667 +661 @@
         else if (Mode == acalib) PrintMessage("Current mode is ACALIB (3x%d events, slowest board %d has %d events)\n", NumEventsRequested, SlowestBoard, MinCount);
         else if (Mode == datarun) PrintMessage("Current mode is DATARUN (%d events requested, %d events taken)\n", NumEventsRequested, NumEvents);
-        else if (Mode == dynrange) PrintMessage("Current mode is DYNRANGE (%d events requested)\n", NumEventsRequested);
+        else if (Mode == dynrange) PrintMessage("Current mode is DYNRANGE\n");
         return;
   }    
@@ -957 +951 @@
 
         // If amplitude calibration mode, check if all boards finished procedure
-        if (Mode == acalib) {
+        if (Mode == acalib || Mode == dynrange) {
           bool Done = true;
           for (unsigned int i=0; i<Boards.size(); i++) {
@@ -965 +959 @@
           // Amplitude calibration finished?
           if (Done) {
-            SaveAmplitudeCalibration();
+            if (Mode == acalib) {
+                  SaveAmplitudeCalibration();
+                  Message(INFO, "Amplitude calibration done, mode set to IDLE");
+                }
+            if (Mode == dynrange) {
+                  Message(INFO, "Dynamic range measurement done, mode set to IDLE");
+                }               
                 Mode = idle;
-                Message(INFO, "Amplitude calibration done, mode set to IDLE");
           }
         }

fact/FADctrl/FADBoard.cc

@@ -168 +168 @@
   unsigned short DACCmd[] = {htons(CMD_Write | (BADDR_DAC + 1)), 0, htons(CMD_Write | (BADDR_DAC + 2)), 0, htons(CMD_Write | (BADDR_DAC + 3)), 0, htons(CMD_Execute) };
   string Message = string("ACALIBDONE")+Name+"\n";
-
+  
   switch (State) {
+  // *******************************************************************
+  // ******************   AMPLITUDE CALIBRATION    *********************   
+  // *******************************************************************
+
   // ====== Part A: Check if amplitude calibration should start and initialise =====
   case standbye:
-        if (m->Mode != m->acalib) break;
-
-        // Invalidate current calibration
-        ACalib.Time = -1;
-        Count = 0;
+        if (m->Mode != m->acalib && m->Mode != m->dynrange) break;
 
         // Save initial board status, set all ROIs to 1024 and set DAC values (no triggers while setting ROI)
@@ -188 +188 @@
         Send(&ROICmd[0], ROICmd.size()*sizeof(unsigned short));
 
-        DACCmd[1] = htons(0);
-        DACCmd[3] = htons(0);
-        DACCmd[5] = htons(0);
-        Send(DACCmd, sizeof(DACCmd));
-
-        // Clear sum vector and set state to accumulate
-        memset(Sum, 0, sizeof(Sum));
-        State = baseline;
-        SetStatus("Starting calilbration");
+        if (m->Mode == m->acalib) {
+          // Set DAC to zero
+          DACCmd[1] = htons(0);
+          DACCmd[3] = htons(0);
+          DACCmd[5] = htons(0);
+          Send(DACCmd, sizeof(DACCmd));
+
+          // Invalidate current calibration
+          ACalib.Time = -1;
+          Count = 0;
+
+          // Clear sum vector and set state to accumulate
+          memset(Sum, 0, sizeof(Sum));
+          State = baseline;
+          SetStatus("Starting calilbration");
+        }
+
+        if (m->Mode == m->dynrange) {
+          // No amplitude calibration allowed!
+          DAC_DR = 0;
+          Delta_DAC = 1000;
+          State = setdac;
+        }
+        
         break;
 
@@ -317 +332 @@
         for (unsigned int i=0; i<NTemp; i++) ACalib.Temp += Status.Temp[i] / NTemp;
 
-        // Inform event thread that calibration is finished for this board
-        if (write(m->Pipe[1], Message.data(), Message.size()) == -1) {
-          m->Message(m->ERROR, "write() to Pipe[1] failed in class FADBoard::AmplitudeCalibration (%s)", strerror(errno));
-        }
-
-        SetStatus("Finished calibration");
-        State = cleanup;
-        break;
-
-  // ====== Part E: Write back original ROI and DAC settings =====
-  case cleanup:
-    // ROI values
-
-        ROICmd.clear();
-        for (unsigned int i=0; i<NChips*NChannels; i++) {
-          ROICmd.push_back(htons(CMD_Write | (BADDR_ROI + i)));
-          ROICmd.push_back(htons(InitialStatus.ROI[i/NChannels][i%NChannels]));
-        }
-        ROICmd.push_back(htons(CMD_Execute));
-        Send(&ROICmd[0], ROICmd.size()*sizeof(unsigned short));
-
-        // DAC values
-        DACCmd[1] = htons(InitialStatus.DAC[1]);
-        DACCmd[3] = htons(InitialStatus.DAC[2]);
-        DACCmd[5] = htons(InitialStatus.DAC[3]);
-        Send(DACCmd, sizeof(DACCmd));
-        
         // Update DIM service with calibration information
         for (unsigned int i=0; i<NChips; i++) {
@@ -356 +344 @@
         DIM_ACalData->updateService(ACalData, 3*NChips*NChannels*NBins*sizeof(float));
 
+        SetStatus("Finished calibration");
+        State = cleanup;
+        break;
+
+  // ====== Part E: Write back original ROI and DAC settings =====
+  case cleanup:
+    // ROI values
+
+        ROICmd.clear();
+        for (unsigned int i=0; i<NChips*NChannels; i++) {
+          ROICmd.push_back(htons(CMD_Write | (BADDR_ROI + i)));
+          ROICmd.push_back(htons(InitialStatus.ROI[i/NChannels][i%NChannels]));
+        }
+        ROICmd.push_back(htons(CMD_Execute));
+        Send(&ROICmd[0], ROICmd.size()*sizeof(unsigned short));
+
+        // DAC values
+        DACCmd[1] = htons(InitialStatus.DAC[1]);
+        DACCmd[3] = htons(InitialStatus.DAC[2]);
+        DACCmd[5] = htons(InitialStatus.DAC[3]);
+        Send(DACCmd, sizeof(DACCmd));
+
+        // Inform event thread that calibration is finished for this board
+        if (write(m->Pipe[1], Message.data(), Message.size()) == -1) {
+          m->Message(m->ERROR, "write() to Pipe[1] failed in class FADBoard::AmplitudeCalibration (%s)", strerror(errno));
+        }
+
+        SetStatus("Cleaning up");       
         State = wait;
         break;
@@ -363 +379 @@
         if (m->Mode == m->idle) State = standbye;
         break;
-  }
-}  
+  
+  
+  // ************************************************************************
+  // ******************   DYNAMIC RANGE DETERMINATION   *********************   
+  // ************************************************************************
+  
+  // ====== Set calibration DACs 1-3 =====
+  case setdac:
+        // Check for stopping
+        if (m->Mode != m->dynrange) {
+          State = cleanup;
+          break;
+        }
+
+        // Set new DAC values
+        DACCmd[1] = htons(DAC_DR);
+        DACCmd[3] = htons(DAC_DR);
+        DACCmd[5] = htons(DAC_DR);
+        Send(DACCmd, sizeof(DACCmd));
+
+        SetStatus("Dynamic range: DACs 1-3 at %u", DAC_DR);
+        State = measure;
+        break;
+
+  // ====== Determine mean and sigma =====
+  case measure:
+        // Check for stopping
+        if (m->Mode != m->dynrange) {
+          State = cleanup;
+          break;
+        }
+
+        // Check if current event has correct DAC values
+    if (Status.DAC[1] != DAC_DR || Status.DAC[2] != DAC_DR || Status.DAC[3] != DAC_DR) break;
+
+        // Discard first few events with correct DAC setting (can still have wrong voltage)
+        if (Count_DR++ < 2) break;
+        Count_DR = 0;
+        
+        bool Clip;
+
+        // Evaluate current event for all channels
+        for (unsigned int Chip=0; Chip<NChips; Chip++) {
+          for (unsigned int Chan=0; Chan<NChannels; Chan++) {
+            Clip = false;
+                Mean[Chip][Chan] = 0;
+                
+                // Determine mean value and check if CLIP_LEVEL exceeded
+                for (int i=0; i<Status.ROI[Chip][Chan]; i++) {
+                  Mean[Chip][Chan] += Data[Chip][Chan][i] / Status.ROI[Chip][Chan];
+                  if (abs(Data[Chip][Chan][i]) >= CLIP_LEVEL) Clip = true; 
+                }
+          }
+        }
+        
+        // If clipping occurred, continue to increase/decrease DAC until at 16-bit limit
+        if (Clip) {
+          if (DAC_DR + Delta_DAC < 0 || DAC_DR + Delta_DAC > 65535) State = cleanup;
+          else { 
+                DAC_DR += Delta_DAC;
+                State = setdac;
+          }
+          break;
+        }
+
+        // Start again from maximum DAC value downwards
+        if (Delta_DAC > 0) {
+          for (unsigned int Chip=0; Chip<NChips; Chip++) {
+                for (unsigned int Chan=0; Chan<NChannels; Chan++) Mean_low[Chip][Chan] = Mean[Chip][Chan];
+          }
+          DAC_low = DAC_DR;
+          DAC_DR = 65535;
+          Delta_DAC = -1000;
+          State = setdac;
+          break;
+        }
+
+        // Procedure finished
+        double Sigma;
+        printf("Extrapolated DAC values for range with 1-sigma\nclearance to ADC count level +/-%u\n", CLIP_LEVEL);
+
+        for (unsigned int Chip=0; Chip<NChips; Chip++) {
+          for (unsigned int Chan=0; Chan<NChannels; Chan++) {
+          
+            // Calculate baseline sigma for current event
+                Sigma = 0;
+                for (int i=0; i<Status.ROI[Chip][Chan]; i++) Sigma += pow(Data[Chip][Chan][i] - Mean[Chip][Chan], 2);
+                if (Status.ROI[Chip][Chan] > 1) Sigma = sqrt(Sigma / (Status.ROI[Chip][Chan] - 1));
+
+                // Extrapolate to find DAC values corresponding to 1-sigma clearance to CLIP_LEVEL
+                DR_low[Chip][Chan] = DAC_low - (Mean_low[Chip][Chan] + (CLIP_LEVEL-Sigma))* (DAC_DR-DAC_low) / (Mean[Chip][Chan]-Mean_low[Chip][Chan]);
+                DR_high[Chip][Chan] =  DAC_DR + (CLIP_LEVEL - Sigma - Mean[Chip][Chan]) * (DAC_DR-DAC_low) / (Mean[Chip][Chan]-Mean_low[Chip][Chan]);
+                  
+                printf("Chip %u, chan %u:  DAC Min %6d   Max %d   Range %6d\n", Chip, Chan, DR_low[Chip][Chan], DR_high[Chip][Chan], DR_high[Chip][Chan]-DR_low[Chip][Chan]);  
+          }
+        }
+          
+        State = cleanup;
+        break;
+  }
+}
   
 //
@@ -723 +838 @@
   }
 }
-
-
-
-//
-// Dynamic range determination
-//
-void FADBoard::DynamicRange() {
-
-  #if 0
-  vector<unsigned short> ROICmd;
-  unsigned short DACCmd[] = {htons(CMD_Write | (BADDR_DAC + 1)), 0, htons(CMD_Write | (BADDR_DAC + 2)), 0, htons(CMD_Write | (BADDR_DAC + 3)), 0, htons(CMD_Execute) };
-  string Message = string("ACALIBDONE")+Name+"\n";
-
-  switch (StateDR) {
-  // ====== Check if dynamic range measurement should start and initialise =====
-  case standbye:
-        if (m->Mode != m->dynrange) break;
-
-        // Save initial board status, and set all ROIs to 1024
-        InitialStatus = GetStatus();
-
-        for (unsigned int i=0; i<NChips*NChannels; i++) {
-          ROICmd.push_back(htons(CMD_Write | (BADDR_ROI + i)));
-          ROICmd.push_back(htons(NBins));
-        }
-        ROICmd.push_back(htons(CMD_Execute));
-        Send(&ROICmd[0], ROICmd.size()*sizeof(unsigned short));
-
-        // Start measurement
-        DAC_DR = 0;
-        StateDR = setdac;
-        SetStatus("Starting dynamic range measurement");
-        break;
-
-  // ====== Set calibration DAC =====
-  case setdac:
-        // Check for stopping
-        if (m->Mode != m->dynrange) {
-          StateDR = cleanup;
-          break;
-        }
-
-        if (DAC_DR > 66000) {
-          StateDR = cleanup;
-          break;
-        }
-
-        // Set new DAC values
-        DACCmd[1] = htons(DAC_DR);
-        DACCmd[3] = htons(DAC_DR);
-        DACCmd[5] = htons(DAC_DR);
-        Send(DACCmd, sizeof(DACCmd));
-
-        StateDR = measure;
-        break;
-
-  // ====== Determine mean and sigma =====
-  case measure:
-        // Check for stopping
-        if (m->Mode != m->dynrange) {
-          StateDR = cleanup;
-          break;
-        }
-
-        Mean = 0;
-        Sigma = 0;
-        for (unsigned int Chip=0; Chip<NChips; Chip++) {
-          for (unsigned int Chan=0; Chan<NChannels; Chan++) {
-                for (int i=0; i<Status.ROI[Chip][Chan]; i++) {
-                  Mean += Data[Chip][Chan][i];
-                  Sigma += Data[Chip][Chan][i]*Data[Chip][Chan][i];
-                }
-                Mean /= Status.ROI[Chip][Chan];
-                Sigma = sqrt(Status.ROI[Chip][Chan]/(Status.ROI[Chip][Chan]-1)*(Sigma/Status.ROI[Chip][Chan]-Mean*Mean));               
-          }
-        }
-        
-        DAC_DR += 1000;
-
-        StateDR = setdac;
-        break;
-
-  // ====== Write back original ROI and DAC settings =====
-  case cleanup:
-    // ROI values
-        ROICmd.clear();
-        for (unsigned int i=0; i<NChips*NChannels; i++) {
-          ROICmd.push_back(htons(CMD_Write | (BADDR_ROI + i)));
-          ROICmd.push_back(htons(InitialStatus.ROI[i/NChannels][i%NChannels]));
-        }
-        ROICmd.push_back(htons(CMD_Execute));
-        Send(&ROICmd[0], ROICmd.size()*sizeof(unsigned short));
-
-        // DAC values
-        DACCmd[1] = htons(InitialStatus.DAC[1]);
-        DACCmd[3] = htons(InitialStatus.DAC[2]);
-        DACCmd[5] = htons(InitialStatus.DAC[3]);
-        Send(DACCmd, sizeof(DACCmd));
-        
-        StateDR = wait;
-        break;
-
-  // ====== Wait for Mode not being idle =====
-  case wait:
-        if (m->Mode == m->idle) StateDR = standbye;
-        break;
-  }
-  #endif
-}  

fact/FADctrl/FADBoard.h

@@ -96 +96 @@
         void Lock();
         void Unlock();
-        void DynamicRange();
 
         unsigned short Port;
@@ -110 +109 @@
 
   private:
-        enum StateType {standbye, baseline, gain, secondary, cleanup, wait};
+        enum StateType {standbye, baseline, gain, secondary, cleanup, wait, setdac, measure};
+        StateType State;
+
         struct BoardStatus InitialStatus;
-        StateType State;
+        uint16_t DAC_DR, DAC_low;
+        int16_t Delta_DAC;
+        unsigned int Count_DR;
+    static const short CLIP_LEVEL = 2000;
+        double Mean[NChips][NChannels], Mean_low[NChips][NChannels];
+        int DR_low[NChips][NChannels], DR_high[NChips][NChannels];
 };
 

fact/FADctrl/History.txt

@@ -35 +35 @@
 24/6/2011       PLL lock status published as DIM service
 7/7/2011        Fixed error in setting the active boards in EventThread()
-13/7/2911   FAD board time published as DIM service
+13/7/2011   FAD board time published as DIM service
+13/6/2012   New command to determine dynamic range using the calibration DACs