PulserLinearityCalScheme.cxx

Go to the documentation of this file.

#include "CalVaLinearity.h"
#include "PulserLinearityCalScheme.h"
#include "MessageService/MsgService.h"
#include "PulserCalibration/PulserConventions.h"
#include "math.h"

ClassImp(PulserLinearityCalScheme)
CVSID("$Id: PulserLinearityCalScheme.cxx,v 1.12 2006/05/18 22:45:00 tagg Exp $");
//......................................................................

PulserLinearityCalScheme::PulserLinearityCalScheme() : fPlex(0)
{


 MSG("Calib",Msg::kVerbose) << "PulserLinearityCalScheme::PulserLinearityCalScheme" 
                            << endl;
 Registry r;
 InitializeConfig(r);
}
//......................................................................

PulserLinearityCalScheme::~PulserLinearityCalScheme()
{
}


//......................................................................

FloatErr PulserLinearityCalScheme::GetLinearized(FloatErr rawcharge, 
                                                 const PlexStripEndId& seid) const
{
  //Purpose: Convert from raw ADC to linearized ADC
  //In: raw ADC
  //Out: linearized ADC (siglin)

  if(seid.GetDetector() == Detector::kNear) {
    return GetLinNear(rawcharge, seid);}
  if(seid.GetDetector() == Detector::kFar) {
    return GetLinFar(rawcharge, seid);}

  MSG("Calib",Msg::kError) << "Stripend with invalid detector, cannot linearize"<<endl;
  FloatErr result(0.,0.);
  return result;
}
//......................................................................

FloatErr PulserLinearityCalScheme::DecalLinearity(FloatErr lin, 
                                                 const PlexStripEndId& seid) const
{

  if(seid.GetDetector() == Detector::kNear) {
    return DecalLinNear(lin, seid);}
  if(seid.GetDetector() == Detector::kFar) {
    return DecalLinFar(lin, seid);}

  MSG("Calib",Msg::kError) << "Stripend with invalid detector, cannot apply non-linearity"<<endl;
  FloatErr result(0.,0.);
  return result;
}
//......................................................................

FloatErr PulserLinearityCalScheme::GetLinNear(FloatErr rawcharge, 
                                                 const PlexStripEndId& seid) const
{
  //Purpose: Convert from raw ADC to linearized ADC
  //It would find the Pin value in the gain curve of the requested channel for the given raw ADC value either through interpolation or extrapolation. Then multiply that pin value by the slope from a linear fit of the same gain curve in the linear region to take out the PMT saturation and get the linearized ADC.
  //In: raw ADC
  //Out: linearized ADC (siglin)
  //database tables needed: PULSERGAIN, PULSERGAINPIN, CALPULSERFITS

  Float_t rawchargev = rawcharge.GetValue();
  Float_t rawchargee = rawcharge.GetError();
  std::pair< PlexPinDiodeId,PlexPinDiodeId >  pdids;
  PlexPinDiodeId pdidlo, pdidhi;
  FloatErr result;
  float topin = -9999.; //the pin value to be found

  UInt_t seidkey = (UInt_t)seid.BuildPlnStripEndKey();

  //number of points in the gain curve(stripend & pin)
  Int_t numpoints = 0;
  Int_t numpoints2 = 0;

  vector<float> pmtmeani; //zero-corrected 
  vector<float> pinmeani; //zero-corrected

  //Get PulserGain and PulserGainPin objects
  const PulserGain *pmt = fNearGain.GetRowByIndex(seidkey);

  // Get Pin diode pair
  pdids = GetPinDiodeId(seid);
  //Get low gain (gain =1)
  pdidhi = pdids.second;
  pdidlo = pdids.first;
  
  // For the moment only do near vs low
  const PulserGainPin *pin = 0;
  if (pdidlo.GetGain()==1) {
    pin  = fPin.GetRowByIndex(pdidlo.GetEncoded());
  } else {    
    pin = 0;
  }


  // Get fit results:    
  float linslp = -9999.;
  float linchi2 = -9999.;
  float linxoff = -9999.;

  // For now only NearEnd vs LowGainPin
  const CalPulserFits *linfit = fNearLow.GetRowByIndex(seidkey);

  if(linfit==0) {
    MAXMSG("Calib",Msg::kWarning,10) 
      << "No CalPulserFits Near-Low database row for StripEnd " 
      << seid << " indexed as " << seid.BuildPlnStripEndKey() << endl;
    linslp = 0.;
    linchi2 = 0;
    linxoff = 0;

  } else {
    
    linslp = linfit->GetSlope();
    linchi2 = linfit->GetChisq();
    linxoff = linfit->GetXOffset();
    
  }


  if (pmt && pin) {//value objects
    //Get number of points 
    //Stripend
    numpoints = pmt->GetNumPoints();
    
    //Pin
    numpoints2 = pin->GetNumPoints();
    
    if (numpoints!=numpoints2) {
      MAXMSG("Calib",Msg::kError,10) << "There are " << numpoints << " points at stripend and " 
                               << numpoints2 << " points at pin!!!" << endl;
    }
    
    // Get mean, nentries and ntriggers
    // Stripend
    const Float_t * pmtmean = pmt->GetMean(); 
    const Float_t * pmtent = pmt->GetNumEntries(); 
    const Float_t * pmttrg = pmt->GetNumTriggers();
    // Pin
    const Float_t * pinmean = pin->GetMean(); 
    const Float_t * pinent = pin->GetNumEntries(); 
    const Float_t * pintrg = pin->GetNumTriggers();
    
    // Loop through points in PulserGain to find interval with rawcharge 
    
    for (int ipoint=0; ipoint< numpoints; ipoint++) {//loop through all the points
      if (pmttrg[ipoint]){//zero correction
        pmtmeani.push_back(pmtmean[ipoint]*pmtent[ipoint]/pmttrg[ipoint]);
      }
      else {
        pmtmeani.push_back(pmtmean[ipoint]);
      }
      
      if (pintrg[ipoint]){//zero correction
        pinmeani.push_back(pinmean[ipoint]*pinent[ipoint]/pintrg[ipoint]);
      }
      else {
        pinmeani.push_back(pinmean[ipoint]);
      }
      
      if ((ipoint>0 && rawchargev<pmtmeani[ipoint] && rawchargev>=pmtmeani[ipoint-1])||//will interpolate 
          (ipoint==numpoints-1 && rawchargev>pmtmeani[ipoint])){//will extrapolate
      
      
        // This interval contains rawcharge
        // Get pin value from interpolation or extrapolation (if ipoints==numpoints-1)
      
        // Check if there are enough entries (tables should only have numentries/numtriggers>95%)
        MSG("Calib",Msg::kDebug) << "numEntries at pmt: " << *(pmtent+ipoint) << endl;
        MSG("Calib",Msg::kDebug) << "numEntries at pin: " << *(pinent+ipoint) << endl;
        
        if ((pinmeani[ipoint] - pinmeani[ipoint-1])>0) {
          Float_t intslp = (pmtmeani[ipoint] - pmtmeani[ipoint-1])/
            (pinmeani[ipoint] - pinmeani[ipoint-1]);
          if (intslp>0) {
            // get the pin value for the raw adc
            topin = pinmeani[ipoint-1] + (rawchargev-pmtmeani[ipoint-1])/intslp;
          } else {
            MAXMSG("Calib",Msg::kError,10) << "Invalid slope: " << intslp << endl;
            topin = -9999.;
          }
        } else {
          
          MAXMSG("Calib",Msg::kError,10) << "Invalid pin values: " << pinmeani[ipoint] << ", " 
                                   << pinmeani[ipoint-1] << endl;
          topin=-9999.;
        }
      }
    }
  } else {
    MAXMSG("Calib",Msg::kError,10) <<"Can't get data from database for pmt and pin for stripend "<<seid<<endl; 
    topin=-9999.;
  }
  
  
    
  // Now need to convert back to adc using slope from linear fit:
  
  // Need to add errors....
  // ... and come up with better sanity checks before applying correction
  if (topin>0. //pin value is positive
      && linfit && linslp>0. && linchi2>0 && linxoff>-100. //constants are reasonable
      &&rawchargev>6000. //don't apply the calibration for raw adc less than 6000
      && pmtmeani[numpoints-1]>6000){ //gain curve didn't reach saturation, don't apply
    
    MSG("Calib",Msg::kVerbose)<< "pin value = " << topin << "  slope from table (fit) = " << linslp << "   Fit chi^2 = " << linchi2 <<  endl;
    result.Set((topin-linxoff)*linslp,rawchargee);
  }else{
    result.Set(rawchargev,rawchargee);
    //result.Set(0.,rawchargee);
  }
  return result;
}

//......................................................................

FloatErr PulserLinearityCalScheme::DecalLinNear(FloatErr lin, 
                                                  const PlexStripEndId& seid) const
{

  Float_t linchargev = lin.GetValue();
  Float_t linchargee = lin.GetError();
  std::pair< PlexPinDiodeId,PlexPinDiodeId >  pdids;
  PlexPinDiodeId pdidlo, pdidhi;
  FloatErr result;
  float topin = -9999.; //the pin value to be found

  UInt_t seidkey = (UInt_t)seid.BuildPlnStripEndKey();

  //number of points in the gain curve(stripend & pin)
  Int_t numpoints = 0;
  Int_t numpoints2 = 0;

  vector<float> pmtmeani; //zero-corrected 
  vector<float> pinmeani; //zero-corrected

  //Get PulserGain and PulserGainPin objects
  const PulserGain *pmt = fNearGain.GetRowByIndex(seidkey);

  // Get Pin diode pair
  pdids = GetPinDiodeId(seid);
  //Get low gain (gain =1)
  pdidhi = pdids.second;
  pdidlo = pdids.first;
  
  // For the moment only do near vs low
  const PulserGainPin *pin = 0;
  if (pdidlo.GetGain()==1) {
    pin  = fPin.GetRowByIndex(pdidlo.GetEncoded());
  } else {    
    pin = 0;
  }


  // Get fit results:    
  float linslp = -9999.;
  float linchi2 = -9999.;
  float linxoff = -9999.;

  // For now only NearEnd vs LowGainPin
  const CalPulserFits *linfit = fNearLow.GetRowByIndex(seidkey);

  if(linfit==0) {
    MAXMSG("Calib",Msg::kWarning,10) 
      << "No CalPulserFits Near-Low database row for StripEnd " 
      << seid << " indexed as " << seid.BuildPlnStripEndKey() << endl;
    linslp = 0.;
    linchi2 = 0;
    linxoff = 0;

  } else {
    
    linslp = linfit->GetSlope();
    linchi2 = linfit->GetChisq();
    linxoff = linfit->GetXOffset();
    
  }
  
  float rawchargev = -9999.;

  if (linfit && linslp>0. && linchi2>0 && linxoff>-100. //constants are reasonable
      &&linchargev>6000.){
    topin = linchargev/linslp + linxoff;
  }  
  else {
    result.Set(linchargev,linchargee);
    return result;
  }

  if (pmt && pin) {//value objects
    numpoints = pmt->GetNumPoints();
    numpoints2 = pin->GetNumPoints();
    
    if (numpoints!=numpoints2) {
      MAXMSG("Calib",Msg::kError,10) << "There are " << numpoints << " points at stripend and " 
                               << numpoints2 << " points at pin!!!" << endl;
    }
    
    // Get mean, nentries and ntriggers
    // Stripend
    const Float_t * pmtmean = pmt->GetMean(); 
    const Float_t * pmtent = pmt->GetNumEntries(); 
    const Float_t * pmttrg = pmt->GetNumTriggers();
    // Pin
    const Float_t * pinmean = pin->GetMean(); 
    const Float_t * pinent = pin->GetNumEntries(); 
    const Float_t * pintrg = pin->GetNumTriggers();
    
    for (int ipoint=0; ipoint< numpoints; ipoint++) {//loop through all the points
      if (pmttrg[ipoint]){//zero correction
        pmtmeani.push_back(pmtmean[ipoint]*pmtent[ipoint]/pmttrg[ipoint]);
      }
      else {
        pmtmeani.push_back(pmtmean[ipoint]);
      }
      
      if (pintrg[ipoint]){//zero correction
        pinmeani.push_back(pinmean[ipoint]*pinent[ipoint]/pintrg[ipoint]);
      }
      else {
        pinmeani.push_back(pinmean[ipoint]);
      }
      
      if ((ipoint>0 && topin<pinmeani[ipoint] && topin>=pinmeani[ipoint-1])//will interpolate 
           ||(ipoint==numpoints-1 && topin > pinmeani[ipoint])){//will extrapolate

        
        if ((pmtmeani[ipoint] - pmtmeani[ipoint-1])>0) {
          Float_t intslp = (pinmeani[ipoint] - pinmeani[ipoint-1])/
            (pmtmeani[ipoint] - pmtmeani[ipoint-1]);
          if (intslp>0) {
            // get the pin value for the raw adc
            rawchargev = pmtmeani[ipoint-1] + (topin-pinmeani[ipoint-1])/intslp;
          } else {
            MAXMSG("Calib",Msg::kError,10) << "Invalid slope: " << intslp << endl;
            rawchargev = -9999.;
          }
        } else {
          
          MAXMSG("Calib",Msg::kError,10) << "Invalid pin values: " << pinmeani[ipoint] << ", " 
                                   << pinmeani[ipoint-1] << endl;
          rawchargev=-9999.;
        }
      }
    }
  } else {
    MAXMSG("Calib",Msg::kError,10) <<"Can't get data from database for pmt and pin for stripend "<<seid<<endl; 
    rawchargev=-9999.;
  }

  if (rawchargev!=-9999.){
    result.Set(rawchargev,linchargee);
  }
  else result.Set(linchargev,linchargee);
  
  return result;
}

//......................................................................

FloatErr PulserLinearityCalScheme::GetLinFar(FloatErr rawcharge, 
                                                 const PlexStripEndId& seid) const
{
  // Return linearized ADC value for the far detector.

  // No correction for invalid stripends
  if( !seid.IsValid() ) {
    MAXMSG("Calib",Msg::kWarning,1) << seid << " is invalid: no linearity calibrations will be applied to invalid stripends" << endl;
    return rawcharge;
  }

  // No correction for veto-shield channels
  if( seid.IsVetoShield() ) {
    // dont' even compliain. --NJT
    //MAXMSG("Calib",Msg::kWarning,1) << "No linearity calibrations will be applied to veto-shield channels" << endl;
    return rawcharge;
  }


  // For very low pulse-heights, return input value
  if(rawcharge.GetValue() < 200.) return rawcharge;

  // Find near-far fit for this stripend
  UInt_t seidkey = (UInt_t)seid.BuildPlnStripEndKey();
  const CalPulserFits* fit = fNearFar.GetRowByIndex(seidkey);

  // Check for a good fit
  if(fit != 0) {
    if(FitIsOK(*fit)) {

      // If we are below maximum of linear fit there is no correction
      if(fit->GetFitType()==1 && rawcharge.GetValue()<=fit->GetAdcMax()) {
        return rawcharge;
      }

      else if(fit->GetFitType()>=5) {

      // We have a good Pole or Pole+Kicker fit. Use it for the central value, 
      // unless the inversion fails: this happens if the input value is >k1.
      // Also reject fits giving a negative correction.
      // If raw charge is within fit range use error from fit residual. 
      // If we are extrapolating above fit maximum, use other stripends
      // on same pixel to set error. If there are no other good stripends,
      // double error from this fit.

        FloatErr result = GetCorrected(rawcharge,*fit,0);
        if(result.GetValue()>=rawcharge.GetValue()) {
          if(rawcharge.GetValue()<=fit->GetAdcMax()) {
            return result;
          }
          MeanCor others = GetMeanCorrection(rawcharge,seid,0);
          if(others.nstrips>0) {
            Float_t diff = result.GetValue()-rawcharge.GetValue() - others.meancor;
            result += FloatErr(0.,fabs(diff));
          }
          else {
            result.SetError(2.*result.GetError());
          }
          return result;
        }
      }
    }
  }
  else {
    MAXMSG("Calib",Msg::kWarning,20) << "No CALPULSERFITS entry for " << seid << endl;
  }

  // No fit, bad fit or we are above adcmax of a linear fit.
  // Use mean correction for other stripends on this pixel.
  // Set error to be rms of these values.
  MeanCor others = GetMeanCorrection(rawcharge,seid,0);
  if(others.nstrips > 0) {
    MAXMSG("Calib",Msg::kDebug,20) <<"Using "<<others.nstrips<<" stripends to calibrate "<<seid<<endl;
    FloatErr result = rawcharge + FloatErr(others.meancor,others.rmscor);
    return result;
  }

  // No other good stripends on this spot
  MAXMSG("Calib",Msg::kWarning,20) << "Stripend" << seid << " not calibrated" << endl;
  FloatErr result(rawcharge.GetValue(),rawcharge.GetError());
  result *= FloatErr(1.,0.5);
  return result;

}

//......................................................................

FloatErr PulserLinearityCalScheme::DecalLinFar(FloatErr lin, 
                                                 const PlexStripEndId& seid) const
{
  // Apply non-linearity to MC ADC value for the far detector.

  // No non-linearity for invalid stripends
  if( !seid.IsValid() ) {
    MAXMSG("Calib",Msg::kWarning,1) << seid << " is invalid: no non-linearity will be applied to invalid stripends" << endl;
    return lin;
  }

  // No non-linearity for veto-shield channels
  if( seid.IsVetoShield() ) {
    MAXMSG("Calib",Msg::kWarning,1) << "No non-linearity will be applied to veto-shield channels" << endl;
    return lin;
  }

  // For very low pulse-heights, return input value
  if(lin.GetValue() < 200.) return lin;

  // Find near-far fit for this stripend
  UInt_t seidkey = (UInt_t)seid.BuildPlnStripEndKey();
  const CalPulserFits* fit = fNearFar.GetRowByIndex(seidkey);

  // Check for a good fit
  if(fit != 0) {
    if(FitIsOK(*fit)) {

      // If we are below maximum of linear fit there is no non-linearity
      if(fit->GetFitType()==1 && lin.GetValue()<=fit->GetAdcMax()) {
        return lin;
      }

      else if(fit->GetFitType()>=5) {

      // We have a good Pole or Pole+Kicker fit. 
        FloatErr result = GetCorrected(lin,*fit,1);
        // Do not add extra error
        result.SetError(lin.GetError());
        return result;
      }
    }
  }
  else {
    MAXMSG("Calib",Msg::kWarning,20) << "No CALPULSERFITS entry for " << seid << endl;
  }

  // No fit, bad fit or we are above adcmax of a linear fit.
  // Use mean correction for other stripends on this pixel.
  MeanCor others = GetMeanCorrection(lin,seid,1);
  if(others.nstrips > 0) {
    MAXMSG("Calib",Msg::kInfo,20) <<"Using "<<others.nstrips<<" stripends to unlinearize "<<seid<<endl;
    FloatErr result = lin + FloatErr(others.meancor,others.rmscor);
    // Do not add extra error
    result.SetError(lin.GetError());
    return result;
  }

  // No other good stripends on this spot
  MAXMSG("Calib",Msg::kWarning,20) << "Stripend" << seid << " not unlinearized" << endl;
  return lin;

}

//......................................................................

FloatErr PulserLinearityCalScheme::GetCorrected(FloatErr incharge, const CalPulserFits& fit, Int_t flag) 
{
  // Calculate (un)linearized value and error using this fit
  // Flag = 0: calculate linearized value
  // Flag != 0: apply non-linearity (for MC)

  Double_t  x = incharge.GetValue();
  Double_t dx = incharge.GetError();

  Double_t par[8];
  par[0] = fit.GetFitType();
  if(flag == 0) par[0] -= 1.;
  par[1] = fit.GetPar1();
  par[2] = fit.GetPar2();
  par[3] = fit.GetPar3();
  par[4] = fit.GetPar4();
  par[5] = 0.;
  par[6] = fit.GetXOffset();
  par[7] = 1./fit.GetSlope();

  Double_t xcor = CalVaLinearity::FitFunction(&x,par);  
  xcor = (xcor-par[6])/par[7];

  // Set error on correction to max(mean residual, 0.5%) of the correction
  Double_t dxcor = fit.GetMeanRes();
  if(dxcor < 0.5) dxcor = 0.5;
  dxcor *= 0.01*fabs(xcor-x);
  dxcor = sqrt(dx*dx+dxcor*dxcor);

  FloatErr result(xcor,dxcor);
  return result;
}

//......................................................................

PulserLinearityCalScheme::MeanCor PulserLinearityCalScheme::GetMeanCorrection(FloatErr incharge, const PlexStripEndId& seid, Int_t flag) const
{
  // Find the average correction from other stripends on same pixel.
  // N.B. the average correction is the value which must be added to
  // the raw charge to obtain the (un)linearized value.
  // Flag = 0: calculate linearized value
  // Flag != 0: calculate non-linearity (for MC)
 
  MeanCor result;

  PlexSEIdAltL altlist = fPlex->GetSEIdAltL(fPlex->GetRawChannelId(seid));
  Int_t n = 0;
  Float_t sumcor = 0.;
  Float_t sumcor2 = 0.;
  for (PlexSEIdAltL::const_iterator it = altlist.begin(); it!=altlist.end();it++) {
    const CalPulserFits* fit = fNearFar.GetRowByIndex((*it).GetSEId().BuildPlnStripEndKey());
    if(fit != 0) {
      if(FitIsOK(*fit)) {
        Float_t cor;
        if(fit->GetFitType()==1) {cor = 0.;}
        else {cor = GetCorrected(incharge,*fit,flag).GetValue() - incharge.GetValue();}
        // If k1>adcmax, correction fit returns zero: don't use
        // Also do not use values above adcmax
        if(flag==0 && (cor<0. || incharge.GetValue()>fit->GetAdcMax())) {continue;}
        if(flag !=0 && (cor>0. || incharge.GetValue()+cor>fit->GetAdcMax())) {continue;}
          sumcor += cor;
          sumcor2 += cor*cor;
          n++;
      }
    }
  }

  if(n > 0) {
    sumcor /= n;
    sumcor2 = sumcor2/n - sumcor*sumcor;
    if(sumcor2 > 0.) {
      sumcor2 = sqrt(sumcor2);
    }
    else {
      sumcor2 = 0.05*sumcor;
    }
  }

  result.nstrips = n;
  result.meancor = sumcor;
  result.rmscor = sumcor2;
  return result;
}

//......................................................................

Bool_t PulserLinearityCalScheme::FitIsOK(const CalPulserFits& fit)
{
  // Require Linear, Pole or Pole+Kicker Fit
  if(fit.GetFitType()<0) return false;

  // Require minimum number of constraints and reasonable chisq
  Int_t npar = 1;
  if(fit.GetFitType()==5) npar = 3;
  if(fit.GetFitType()==25) {
    npar = 5;
    if(fabs(fit.GetXOffset())>1.e-5) npar = 6;
  }
  if(fit.GetNPFit()-npar < 10) return false;
  if(fit.GetChisq()/(fit.GetNPFit()-npar) > 3.) return false;

  // Require good mean residual
  if(fit.GetMeanRes() > 1.) return false;

  // Require sensible parameters for Pole fits
  if(fit.GetFitType()>1) {
    if(fit.GetPar1()<10000. || fit.GetPar1()>20000.) return false;
  }

  // Fit OK
  return true;
}


//......................................................................

void PulserLinearityCalScheme::ConfigModified() 
{
}

//......................................................................
//
void PulserLinearityCalScheme::PrintConfig( std::ostream& /*os*/ ) const
{
}

//......................................................................

void PulserLinearityCalScheme::DoReset(const VldContext& vc)
{
  // Use latest GC for linearity corrections (need to make sure data is there...).
  //
  //VldTimeStamp ts = vc.GetTimeStamp();
  // Gain curve values (near detector only):
  if (vc.GetDetector()==Detector::kNear) {
    fNearGain.NewQuery(vc,Pulser::kNearEnd);
    MSG("Calib",Msg::kDebug) << "Done querying PULSERGAIN." << endl;
    // Near Det task=1
    fPin.NewQuery(vc,1);
    MSG("Calib",Msg::kDebug) << "Done querying PULSERGAINPIN." << endl;
  }

  // Get fit results
  if (vc.GetDetector()==Detector::kNear) {
    fNearLow.NewQuery(vc,Pulser::kNearLow);
    fNearHigh.NewQuery(vc,Pulser::kNearHigh);
  }
  if (vc.GetDetector()==Detector::kFar) {
    fNearFar.NewQuery(vc,Pulser::kNearFar);
  }

  MSG("Calib",Msg::kDebug) << "Done querying CALPULSERFITS." << endl;

  if (fPlex) delete fPlex;
  MSG("Calib",Msg::kDebug) << "Delete Plex. " << fPlex << endl;

  fPlex = new PlexHandle(vc);
  MSG("Calib",Msg::kDebug) << "Get new plexhandle." << endl;
  
}

std::pair< PlexPinDiodeId,PlexPinDiodeId > PulserLinearityCalScheme::GetPinDiodeId(const PlexStripEndId & seid) const
{

  PlexPinDiodeId pdid;  
  PlexLedId lid;
  std::pair< PlexPinDiodeId,PlexPinDiodeId > pdids;

  if (fPlex) {  
    lid = fPlex->GetLedId(seid);
    
    pdids = fPlex->GetPinDiodeIds(lid);
    //    cout << "PB, Led: " << lid.GetLedInBox() << ", " << lid.GetPulserBox() << endl;
    
  }

  return pdids;
  

}


//......................................................................

---