Back to index

CTriggerCalibrator.C

 
//----------------------------------------------------------------------------- 
//  $Header: /asis/offline/ceres/cool/project/RCS/CTriggerCalibrator.C,v 3.0 1996/10/02 09:39:51 voigt Exp $ 
// 
//  COOL Program Library   
//  Copyright (C) CERES collaboration, 1996 
// 
//  Implementation of class CSidcCalibrator 
// 
//----------------------------------------------------------------------------- 
#include <math.h>   
#include "CTriggerCalibrator.h"  
#include "CTriggerServer.h"  
 
CTriggerCalibrator::CTriggerCalibrator(CTriggerServer* newTriggerServer)  
{ 
   // 
   // hold pointer to the triggerServer 
   // 
   triggerServer = newTriggerServer; 
    
   // 
   // initialize 'histograms' 
   // 
   timeBinsBC1   = triggerServer->getSetup()->getTimeBinsBC1Calibration(); 
   minTimeBinBC1 = triggerServer->getSetup()->getMinTimeBinBC1Calibration(); 
   maxTimeBinBC1 = triggerServer->getSetup()->getMaxTimeBinBC1Calibration(); 
   binWidthBC1   = (maxTimeBinBC1 - minTimeBinBC1) / timeBinsBC1; 
   BC1Vector.reshape(timeBinsBC1); 
    
   timeBinsN2   = triggerServer->getSetup()->getTimeBinsN2Calibration(); 
   minTimeBinN2 = triggerServer->getSetup()->getMinTimeBinN2Calibration(); 
   maxTimeBinN2 = triggerServer->getSetup()->getMaxTimeBinN2Calibration(); 
   binWidthN2   = (maxTimeBinN2 - minTimeBinN2) / timeBinsN2; 
   N2Vector.reshape(timeBinsN2); 
    
   timeBinsMinBias   = triggerServer->getSetup()->getTimeBinsMinBiasCalibration(); 
   minTimeBinMinBias = triggerServer->getSetup()->getMinTimeBinMinBiasCalibration(); 
   maxTimeBinMinBias = triggerServer->getSetup()->getMaxTimeBinMinBiasCalibration(); 
   binWidthMinBias   = (maxTimeBinMinBias - minTimeBinMinBias) / timeBinsMinBias; 
   minBiasVector.reshape(timeBinsMinBias); 
    
   reset(); 
    
} 
 
CTriggerCalibrator::~CTriggerCalibrator()  
{ 
} 
 
void CTriggerCalibrator::update() 
{ 
   int i; 
   double index; 
       
   for (i=0; i<triggerServer->getHTDCLength(CTriggerServer::htdcBC1); i++) { 
      index = (triggerServer->getHTDCData(CTriggerServer::htdcBC1, i) - minTimeBinBC1) / binWidthBC1; 
      if (index >= 0 && index < timeBinsBC1) 
	 BC1Vector(int(index)) += 1; 
   } 
   for (i=0; i<triggerServer->getHTDCLength(CTriggerServer::htdcN2); i++) { 
      index = (triggerServer->getHTDCData(CTriggerServer::htdcN2, i) - minTimeBinN2) / binWidthN2; 
      if (index >= 0 && index < timeBinsN2) 
	 N2Vector(int(index)) += 1; 
   } 
   for (i=0; i<triggerServer->getHTDCLength(CTriggerServer::htdcMinBias); i++) { 
      index = (triggerServer->getHTDCData(CTriggerServer::htdcMinBias, i) - 
	       minTimeBinMinBias) / binWidthMinBias; 
      if (index >= 0 && index < timeBinsMinBias) 
	 minBiasVector(int(index)) += 1; 
   } 
 
   numberOfEvents++; 
} 
 
CBoolean CTriggerCalibrator::doCalibration() 
{ 
   int oldWindowWidth, i, maxEntries, indexOfMax, newCentralValue; 
    
   // 
   // BC1: find maximum in histogram and set window with the same width as the old one 
   // 
   oldWindowWidth = (triggerServer->getSetup()->getUpperEdgeBC1Window() - 
                    triggerServer->getSetup()->getLowerEdgeBC1Window()) / 2; 
   maxEntries = 0; 
   indexOfMax = 0; 
   for (i=0; i<BC1Vector.length(); i++) { 
      if (BC1Vector(i) > maxEntries) { 
	 maxEntries = BC1Vector(i); 
	 indexOfMax = i; 
      } 
   } 
   if (indexOfMax == 0 || indexOfMax == BC1Vector.length()-1) { 
      cerr << "CTriggerCalibrator::doCalibration():\n"; 
      cerr << "\tWARNING\n"; 
      cerr << "\t new calibration value out of range for BC1\n"; 
   } 
   newCentralValue = int(minTimeBinBC1 + indexOfMax * binWidthBC1); 
   lowerEdgeBC1Window = newCentralValue - oldWindowWidth; 
   upperEdgeBC1Window = newCentralValue + oldWindowWidth; 
    
   // 
   // N2: find maximum in histogram and set window to the location of 
   // 1/10 * amplitude of max +- 10 time bins 
   // 
   maxEntries = 0; 
   indexOfMax = 0; 
   for (i=0; i<N2Vector.length(); i++) { 
      if (N2Vector(i) > maxEntries) { 
	 maxEntries = N2Vector(i); 
	 indexOfMax = i; 
      } 
   } 
   i = indexOfMax; 
   while (i>=0 && N2Vector(i--) > maxEntries/10);    
   lowerEdgeN2Window = int(minTimeBinN2 + i * binWidthN2) - 10; 
   if (i < 0) { 
      cerr << "CTriggerCalibrator::doCalibration():\n"; 
      cerr << "\tERROR\n"; 
      cerr << "\tcould not determin lower edge of N2 window\n"; 
      return False; 
   } 
   i = indexOfMax; 
   while (i<N2Vector.length() && N2Vector(i++) > maxEntries/10);    
   if (i >= N2Vector.length()) { 
      cerr << "CTriggerCalibrator::doCalibration():\n"; 
      cerr << "\tERROR\n"; 
      cerr << "\tcould not determin upper edge of N2 window\n"; 
      return False; 
   } 
   upperEdgeN2Window = int(minTimeBinN2 + i * binWidthN2) + 10; 
    
   // 
   // min bias: find maximum in histogram and set window with the same width as the old one 
   // 
   oldWindowWidth = (triggerServer->getSetup()->getUpperEdgeMinBiasWindow() - 
                    triggerServer->getSetup()->getLowerEdgeMinBiasWindow()) / 2; 
   maxEntries = 0; 
   for (i=0; i<minBiasVector.length(); i++) { 
      if (minBiasVector(i) > maxEntries) { 
	 maxEntries = minBiasVector(i); 
	 indexOfMax = i; 
      } 
   } 
   if (indexOfMax == 0 || indexOfMax == minBiasVector.length()-1) { 
      cerr << "CTriggerCalibrator::doCalibration():\n"; 
      cerr << "\tWARNING\n"; 
      cerr << "\t new calibration value out of range for min bias\n"; 
   } 
   newCentralValue = int(minTimeBinMinBias + indexOfMax * binWidthMinBias); 
   lowerEdgeMinBiasWindow = newCentralValue - oldWindowWidth; 
   upperEdgeMinBiasWindow = newCentralValue + oldWindowWidth; 
    
   return True; 
} 
 
void CTriggerCalibrator::reset() 
{ 
   lowerEdgeBC1Window = 0; 
   upperEdgeBC1Window = 0; 
   lowerEdgeN2Window = 0; 
   upperEdgeN2Window = 0; 
   lowerEdgeMinBiasWindow = 0; 
   upperEdgeMinBiasWindow = 0; 
    
   BC1Vector = 0; 
   N2Vector = 0; 
   minBiasVector = 0; 
    
   numberOfEvents = 0; 
} 
 
void CTriggerCalibrator::printCalibration() 
{ 
   cout << "calibrated lowerEdgeBC1Window:" << dec << lowerEdgeBC1Window << endl; 
   cout << "calibrated upperEdgeBC1Window:" << dec << upperEdgeBC1Window << endl; 
   cout << "calibrated lowerEdgeN2Window:" << dec << lowerEdgeN2Window << endl; 
   cout << "calibrated upperEdgeN2Window:" << dec << upperEdgeN2Window << endl; 
   cout << "calibrated lowerEdgeMinBiasWindow:" << dec << lowerEdgeMinBiasWindow << endl; 
   cout << "calibrated upperEdgeMinBiasWindow:" << dec << upperEdgeMinBiasWindow << endl; 
} 

Back to index