PlexSEIdAltL.cxx

Go to the documentation of this file.

// $Id: PlexSEIdAltL.cxx,v 1.34 2005/08/26 18:47:03 rhatcher Exp $
//
// PlexSEIdAltL
//
// PlexSEIdAltL is a vector+iterator for PlexSEIdAltLItems
//
// Author:  R. Hatcher 2001.10.22
//

#include "Plex/PlexSEIdAltL.h"
#include "Plex/PlexCalib.h"

#include "MessageService/MsgService.h"
#include "MessageService/MsgStream.h"
#include "MessageService/MsgFormat.h"
CVSID("$Id: PlexSEIdAltL.cxx,v 1.34 2005/08/26 18:47:03 rhatcher Exp $");

#include "TMath.h"

#include <string>
#include <algorithm>
#include <cassert>

// a static dummy PlexSEIdAltLItem for when we need to return a
// reference to an item and the list is empty
static PlexSEIdAltLItem dummyPlexSEIdAltLItem;

ClassImp(PlexSEIdAltL)

//_____________________________________________________________________________

UInt_t PlexSEIdAltL::fgFmtFlag = 0;
const UInt_t defaultFmtFlag = 0xFFFFFFFF & ~PlexSEIdAltL::fmt_PixelSpot;

UInt_t lastFmtFlag = 0;
string fmtHeaderTitle = "";
string fmtHeaderULine = "";

//_____________________________________________________________________________
ostream& operator<<(ostream& os, const PlexSEIdAltL& alt)
{
  // Print out the list
  if (alt.size() <= 0) {
     os << "Empty-PlexSEIdAltL " << endl;
     return os;
  }

  UInt_t fmt = PlexSEIdAltL::GetFmtFlag();
  // disallow no formatting bits
  if (!fmt) fmt = defaultFmtFlag;
  bool doFmtIndex     = fmt & PlexSEIdAltL::fmt_Index;
  bool doFmtCursor    = fmt & PlexSEIdAltL::fmt_Cursor;
  bool doFmtBest      = fmt & PlexSEIdAltL::fmt_Best;
  bool doFmtStripEnd  = fmt & PlexSEIdAltL::fmt_StripEnd;
  bool doFmtPixelSpot = fmt & PlexSEIdAltL::fmt_PixelSpot;
  bool doFmtWeight    = fmt & PlexSEIdAltL::fmt_Weight;
  bool doFmtPE        = fmt & PlexSEIdAltL::fmt_PE;
  bool doFmtSigLin    = fmt & PlexSEIdAltL::fmt_SigLin;
  bool doFmtSigCorr   = fmt & PlexSEIdAltL::fmt_SigCorr;
  bool doFmtTime      = fmt & PlexSEIdAltL::fmt_Time;

  static const MsgFormat i1("%1d");
  static const MsgFormat f3p1("%3.1f");
  static const MsgFormat f5p1("%5.1f");
  static const MsgFormat f7p2("%7.2f");

  if (lastFmtFlag != fmt) {
    // construct the header line and the line of "---"'s and "+"'s
    lastFmtFlag = fmt;
    fmtHeaderTitle = "";
    fmtHeaderULine = "";
    if (doFmtBest) {
      fmtHeaderTitle += " ";
      fmtHeaderULine += "-";
    }
    if (doFmtCursor) {
      fmtHeaderTitle += " ";
      fmtHeaderULine += "-";
    }
    if (doFmtIndex) {
      fmtHeaderTitle += " i |";
      fmtHeaderULine += "---+";
    }
    if (doFmtStripEnd) {
      //                  F0001Uc003-
      fmtHeaderTitle += " StripEndId  |";
      fmtHeaderULine += "-------------+";
    }
    if (doFmtPixelSpot) {
      //                  MUXB-UV-?L00:00-SPOT-0-00-00
      fmtHeaderTitle += " PixelSpot                    |";
      fmtHeaderULine += "------------------------------+";
    }
    if (doFmtWeight) {
      fmtHeaderTitle += " wgt |";
      fmtHeaderULine += "-----+";
    }
    if (doFmtPE) {
      fmtHeaderTitle += " PE    |";
      fmtHeaderULine += "-------+";
    }
    if (doFmtSigLin) {
      fmtHeaderTitle += " Linear  |";
      fmtHeaderULine += "---------+";
    }
    if (doFmtSigCorr) {
      fmtHeaderTitle += " S2SCorr |";
      fmtHeaderULine += "---------+";
    }
    if (doFmtTime) {
      fmtHeaderTitle += " Time    |";
      fmtHeaderULine += "---------+";
    }
  }
  
  os << fmtHeaderTitle << endl;
  os << fmtHeaderULine << endl;

  PlexSEIdAltLItem& best    = dummyPlexSEIdAltLItem;

  for (unsigned int i=0; i<alt.size(); ++i) {
    const PlexSEIdAltLItem& item = alt[i];
    if (doFmtBest)   {   best    = alt.GetBestItem();
                         os << ((item == best)      ? '!' : ' ');
    }
    if (doFmtCursor) {  
                         os << ((i == alt.fCurrent) ? '@' : ' ');
    }
    if (doFmtIndex)      os << " " << i1(i) << " |";
    if (doFmtStripEnd)   os << " " << item.GetSEId().AsString("C") << " |";
    if (doFmtPixelSpot)  os << " " << item.GetPixelSpotId().AsString("c") << " |";
    if (doFmtWeight)     os << " " << f3p1(item.GetWeight()) << " |";
    if (doFmtPE)         os << " " << f5p1(item.GetPE()) << " |";
    if (doFmtSigLin)     os << " " << f7p2(item.GetSigLin()) << " |";
    if (doFmtSigCorr)    os << " " << f7p2(item.GetSigCorr()) << " |";
    if (doFmtTime)       os << " " << f7p2(item.GetTime()) << " |";
    os << endl;
  }
      
#ifdef OLDFORMATTING
    char marker;
    PlexStripEndId seid;
    MsgFormat i2("%2d");
    MsgFormat i3("%3d");
    //     MsgFormat f10("%10.5f");
    
    // format the header line
    os << "     i | StripEndId (size=" << i2(alt.size()) 
       << ",cur=" << i2(alt.fCurrent) << ") "
       << "| weight    " 
       << "| muon unit " 
       << "| t offset  " 
       << endl;
    os << "-------+-----------------------------"
       << "+-----------" 
       << "+-----------" 
       << "+-----------" 
       << endl;
    
    for (unsigned int i=0; i<alt.size(); ++i) {
      (i==alt.fCurrent) ? marker = '*' : marker = ' ';
      PlexSEIdAltLItem item = alt[i];
      seid   = item.GetSEId();
      os << " " << marker << " " << i3(i) 
         << " " << item
         << endl;
    }
#endif

  return os;
}

//_____________________________________________________________________________
PlexSEIdAltL::PlexSEIdAltL()
   : fCurrent(0), fDemuxVetoFlag(0), fError(kUnchecked)     
{
   // Default constructor
}

//_____________________________________________________________________________
PlexSEIdAltL::PlexSEIdAltL(const PlexSEIdAltL &rhs)
   : std::vector<PlexSEIdAltLItem>(),
     fCurrent(rhs.fCurrent), 
     fDemuxVetoFlag(rhs.fDemuxVetoFlag), 
     fError(kUnchecked)
{

   // deep copy constructor
   for (unsigned int i=0; i<rhs.size(); ++i) {
      this->push_back(rhs[i]);
   }

}

//_____________________________________________________________________________
PlexSEIdAltL::~PlexSEIdAltL()
{
   // delete all the owned sub-objects
}

#ifdef ALTL_EXPLICIT_ASSIGNMENT
//_____________________________________________________________________________
PlexSEIdAltL& PlexSEIdAltL::operator=(const PlexSEIdAltL& rhs)
{
   // deep assignment
   clear();
   for (unsigned int i=0; i<rhs.size(); ++i) {
      this->push_back(rhs[i]);
   }
   fCurrent       = rhs.fCurrent;
   fDemuxVetoFlag = rhs.fDemuxVetoFlag;
   fError         = rhs.fError;
}
#endif

//_____________________________________________________________________________
void PlexSEIdAltL::AddStripEndId(const PlexStripEndId& seid, 
                                 const PlexPixelSpotId& spot,
                                 Float_t weight, const PlexCalib* calib, 
                                 Int_t adc, Double_t time)
{
   // add a new item to the list

   fError = kUnchecked;  // adding a new strip makes consistency unknown

   if (calib) {
      PlexSEIdAltLItem item = calib->CalibStripEnd(seid,spot,adc,time);
      item.SetWeight(weight);
      this->push_back(item);
   }
   else {
      PlexSEIdAltLItem item(seid,spot,weight);
      this->push_back(item);
   }
}

//_____________________________________________________________________________
void PlexSEIdAltL::DropCurrent()
{
   // Remove current item from the list.
   // Do not reset current position of iterator.
   // An iterative removal should start from Last() and use Previous().

   UShort_t n = size();

   if (n <= 0) return;  // one cannot drop what one doesn't have
   if (fCurrent>=n) {   
      MSG("Plex",Msg::kWarning)
         << "can not DropCurrent (fCurrent=" << fCurrent 
         << ") on a list of " << n << " items " << endl;
      return;
   }

   PlexSEIdAltLIter cursor = this->begin() + fCurrent;
   // delete the owned item
   this->erase(cursor);

}

//_____________________________________________________________________________
void PlexSEIdAltL::DropZeroWeights()
{
   // Remove pairs from the list that have weight == 0

   if (size() <= 0) return;  // one cannot drop what one doesn't have

   // move all zero items to the end
   PlexSEIdAltLIter new_end = 
      remove_if(this->begin(), this->end(), 
                mem_fun_ref(&PlexSEIdAltLItem::IsZeroWeight));

   // erase the moved items out of the array 
   this->erase(new_end,this->end());

}

//_____________________________________________________________________________
void PlexSEIdAltL::KeepTopWeights(UInt_t n, Bool_t keeporder)
{
   // Remove all but "n" pairs from the list (top "n" sorted by weight)
   // Final relative order of elements in the list is unchanged
   // if keeporder=kTRUE otherwise list ordered by decending weights.
   // If "n" would separate values of the same weight then
   // more than "n" are kept.

   unsigned int i, cnt = size();

   if (cnt <= 0) return;  // one cannot drop what one doesn't have

   if (n >= cnt) {
      if (keeporder) return; // keep everything, no change in order
      else n = cnt;          // perform sort but don't go beyond end
   }

   PlexSEIdAltL& self = *this;

   if (n <= 0) { // special case for new size=0
      this->clear();
      return;
   }

   // make a copy of the weights
   // sort it
   // select the nth down the list for lowest weight value to keep
   Float_t *sortedwgt = new Float_t[cnt];
   Int_t   *sortedindx = new Int_t[cnt];
   for (i=0; i<cnt; i++) sortedwgt[i] = self[i].GetWeight();
   Bool_t down=kTRUE;
   TMath::Sort(cnt,sortedwgt,sortedindx,down);
   // n-1 because C arrays start with 0
   Int_t   icut = sortedindx[n-1];
   Float_t  cut = sortedwgt[icut]; 

   // count final size
   // may not be ==n because of two entries with same weight
   vector<PlexSEIdAltLItem> tempVector;
   for (i=0; i<cnt; i++) {
      unsigned int indxold = i;
      if (!keeporder) indxold = sortedindx[i];
      if (self[indxold].GetWeight() >= cut) {
         tempVector.push_back(self[indxold]);
      }
   }

   // replace current vector with newly created temporary
   this->swap(tempVector);

   delete [] sortedwgt;
   delete [] sortedindx;

}

//_____________________________________________________________________________
void PlexSEIdAltL::ClearWeights()
{
   // set all the weights to zero

   PlexSEIdAltL& self = *this;
   for (unsigned int i=0; i<size(); i++) (self[i]).SetWeight(0.0);
}

//_____________________________________________________________________________
const PlexSEIdAltLItem& PlexSEIdAltL::GetBestItem() const
{
   // find the PlexSEIdAltLItem with the highest weight (const version)

   unsigned int thesize = size();
   if (thesize == 0) {
     static int msglimit = 25;  // limit the number of complaints
     if (msglimit) {
       // Empty lists generally happen because of raw channel id's
       // that don't map back to real strips (for instance due to
       // unused pixels on a tube being illuminated by crosstalk).
       // Complain a bit ... but then shut up.
       MSG("Plex",Msg::kWarning)
         << "can not GetBestItem() from an empty list" << endl;
       if (--msglimit == 0) 
         MSG("Plex",Msg::kWarning)
           << " ... last warning of this type" << endl;
     }
     return dummyPlexSEIdAltLItem;;
   }
   else if (thesize == 1) {
     // simple case of only one element
     return (*this)[0];
   }

   PlexSEIdAltLConstIter cursor = this->begin();
   PlexSEIdAltLConstIter best   = this->begin();
   Float_t wgt, maxwgt = -1.0e-37;
   while (cursor != this->end()) {
      const PlexSEIdAltLItem& item = *cursor;
      if ( (wgt = item.GetWeight()) > maxwgt ) {
         maxwgt = wgt; best = cursor;
      }
      cursor++;
   }
   return *best;
      
}

//_____________________________________________________________________________
PlexSEIdAltLItem& PlexSEIdAltL::GetBestItem()
{
   // find the PlexSEIdAltLItem with the highest weight

   unsigned int thesize = size();
   if (thesize == 0) {
     static int msglimit = 25;  // limit the number of complaints
     if (msglimit) {
       // Empty lists generally happen because of raw channel id's
       // that don't map back to real strips (for instance due to
       // unused pixels on a tube being illuminated by crosstalk).
       // Complain a bit ... but then shut up.
       MSG("Plex",Msg::kWarning)
         << "can not GetBestItem() from an empty list" << endl;
       if (--msglimit == 0) 
         MSG("Plex",Msg::kWarning)
           << " ... last warning of this type" << endl;
     }
     return dummyPlexSEIdAltLItem;;
   }
   else if (thesize == 1) {
     // simple case of only one element
     return (*this)[0];
   }
   
   PlexSEIdAltLIter cursor = this->begin();
   PlexSEIdAltLIter best   = this->begin();
   Float_t wgt, maxwgt = -1.0e-37;
   while (cursor != this->end()) {
      PlexSEIdAltLItem& item = *cursor;
      if ( (wgt = item.GetWeight()) > maxwgt ) {
         maxwgt = wgt; best = cursor;
      }
      cursor++;
   }
   return *best;
      
}

//_____________________________________________________________________________
PlexStripEndId PlexSEIdAltL::GetBestSEId() const
{
   // find the PlexStripEndId with the highest weight and return by value

   return GetBestItem().GetSEId();

}

//_____________________________________________________________________________
Float_t PlexSEIdAltL::GetBestWeight() const
{
   // find the highest weight

   return GetBestItem().GetWeight();

}

//_____________________________________________________________________________
const PlexSEIdAltLItem& PlexSEIdAltL::GetCurrentItem() const
{
   // return by value current PlexSEIdAltLItem (const version)

   if (!IsValid()) {
     if (size() <= 0) 
       MSG("Plex",Msg::kWarning)
         << "can not GetCurrentItem() from an empty list" << endl;
     else
       MSG("Plex",Msg::kWarning)
         << "can not GetCurrentItem() when !IsValid()" << endl;
     return dummyPlexSEIdAltLItem;;
   }

   PlexSEIdAltLConstIter cursor = this->begin() + fCurrent;
   return *cursor;

}

//_____________________________________________________________________________
PlexSEIdAltLItem& PlexSEIdAltL::GetCurrentItem()
{
   // return by value current PlexSEIdAltLItem

   if (!IsValid()) {
     if (size() <= 0) 
       MSG("Plex",Msg::kWarning)
         << "can not GetCurrentItem() from an empty list" << endl;
     else
       MSG("Plex",Msg::kWarning)
         << "can not GetCurrentItem() when !IsValid()" << endl;
     return dummyPlexSEIdAltLItem;;
   }

   PlexSEIdAltLIter cursor = this->begin() + fCurrent;
   return *cursor;

}

//_____________________________________________________________________________
PlexStripEndId PlexSEIdAltL::GetCurrentSEId() const
{
   // return by value current PlexStripEndId

   return GetCurrentItem().GetSEId();

}

//_____________________________________________________________________________
Float_t PlexSEIdAltL::GetCurrentWeight() const
{
   // return the weight attached to the current PlexStripEndId

   return GetCurrentItem().GetWeight();

}

//_____________________________________________________________________________
Detector::Detector_t PlexSEIdAltL::GetDetector(Bool_t reportError) const
{
   // Return the Detector of the PlexStripEndID's in this list.
   // This is meaningful only in a correctly filled PlexSEIdAltL

   TestConsistency(reportError);
   
   if ( fError & kBadDetector || size() < 1 ) 
      return (Detector::Detector_t)0; // bad detector

   PlexSEIdAltLConstIter cursor = this->begin();
   return (*cursor).GetSEId().GetDetector();

}

//_____________________________________________________________________________
Bool_t PlexSEIdAltL::IsVetoShield(Bool_t reportError) const
{
   // Return the whether this alt-list reflect veto shield strips
   // This is meaningful only in a correctly filled PlexSEIdAltL

   TestConsistency(reportError);
   
   // if inconsistent ... don't take it as part of veto shield
   // "nothing" isn't part of a veto shield
   if ( fError & kBadIsVeto || size() < 1 ) return false;

   PlexSEIdAltLConstIter cursor = this->begin();
   return (*cursor).GetSEId().IsVetoShield();

}

//_____________________________________________________________________________
StripEnd::StripEnd_t PlexSEIdAltL::GetEnd(Bool_t reportError) const
{
   // Return the end (kEast,kWest) of the PlexStripEndID's in this list.
   // This is meaningful only in a correctly cabled detector
   // if there are mis-cablings then it could return nonsense.

   TestConsistency(reportError);

   if ( fError & kBadEnd || size() < 1 ) 
      return StripEnd::kUnknown;  // bad end

   PlexSEIdAltLConstIter cursor = this->begin();
   return (*cursor).GetSEId().GetEnd();

}

//_____________________________________________________________________________
Int_t PlexSEIdAltL::GetPlane(Bool_t reportError) const
{
   // Return the plane # of the PlexStripEndId's in this list.
   // This is meaningful only in a correctly cabled detector
   // if there are mis-cablings then it could return nonsense.

   TestConsistency(reportError);

   if ( fError & kBadPlane || size() < 1 )
      return -1;  // bad plane

   PlexSEIdAltLConstIter cursor = this->begin();
   return (*cursor).GetSEId().GetPlane();

}


//_____________________________________________________________________________
PlaneView::PlaneView_t PlexSEIdAltL::GetPlaneView(Bool_t reportError) const
{
   // Return the PlaneView of the PlexStripEndID's in this list.
   // This is meaningful only in a correctly cabled detector
   // if there are mis-cablings then it could return nonsense.

   TestConsistency(reportError);

   if ( fError & kBadPlaneView || size() < 1 )
      return PlaneView::kUnknown;  // bad view

   PlexSEIdAltLConstIter cursor = this->begin();
   return (*cursor).GetSEId().GetPlaneView();

}

//_____________________________________________________________________________
Bool_t PlexSEIdAltL::SetToOppositeEnds(PlexSEIdAltL& that)
{
   // Given two PlexSEIdAltL's set both "current" iterators
   // to entries that are at opposite ends of the same strip
   // and return true.  If no legal combination exists then
   // return false leaving current positions unchanged.

   UInt_t where_this =      fCurrent;
   UInt_t where_that = that.fCurrent;

   this->SetFirst();
   while (this->IsValid()) {
      PlexStripEndId seid_this = this->GetCurrentSEId();
      that.SetFirst();
      while (that.IsValid()) {
         PlexStripEndId seid_that = that.GetCurrentSEId();
         if (seid_this.IsOppositeStripEnd(seid_that)) return true;
         that.Next();
      }
      this->Next();
   }
   // fell through means no legal match
   fCurrent      = where_this;
   that.fCurrent = where_that;
   return false;

}
//_____________________________________________________________________________
Bool_t PlexSEIdAltL::IsValid() const
{
   // is current position a valid entry

  return size()>0 && fCurrent<size(); 

}

//_____________________________________________________________________________
void PlexSEIdAltL::Print(Option_t *option) const
{
   // Print out the list

   unsigned int n = size();

   if (n <= 0) {
      printf("Empty PlexSEIdAltL\n");
      return;
   }

   const PlexSEIdAltLItem& best = GetBestItem();

   const PlexSEIdAltL& self = *this;
   unsigned int i;
   char cursormarker, bestmarker;
   PlexStripEndId seid;
//   Float_t        weight;

   switch (option[0]) {
   case 'c':
   case 'C':
      // compact notation assumes that there isn't a mixup
      // and all items share a common detector/plane/subpart/end
      seid = GetCurrentSEId(); // any will do
      printf("[%1.1s|%4d %1.1s%1.1s|%1.1s%1.1s]",
             Detector::AsString(seid.GetDetector()),
             seid.GetPlane(),
             PlaneView::AsString(seid.GetPlaneView()),
             PlaneCoverage::AsString(seid.GetPlaneCoverage()),
             StripEnd::AsString(seid.GetSubPart()),
             StripEnd::AsString(seid.GetEnd()));
      for (i=0; i<n; i++) {
         const PlexSEIdAltLItem& item = self[i];
         bestmarker   = (item == best)     ? '!' : ' ';
         cursormarker = (i    == fCurrent) ? '@' : ' ';
         seid   = item.GetSEId();
         printf(" %c%c%3d",bestmarker,cursormarker,seid.GetStrip());

      }
      if (option[0] == 'C') {
         printf("\n          wgt ");
         for (i=0; i<n; i++) {
            const PlexSEIdAltLItem& item = self[i];
            printf(" %5.3f",item.GetWeight());
         }
      }
      printf("\n");

      break;
   default:

     cout << *this;

   }
}

//_____________________________________________________________________________
void PlexSEIdAltL::SetCurrentWeight(Float_t weight)
{
   // set the weight attached to the current PlexStripEndId

   if (!IsValid()) return; // no list or out of range
   PlexSEIdAltLIter cursor = this->begin() + fCurrent;
   (*cursor).SetWeight(weight);

}

//_____________________________________________________________________________
void PlexSEIdAltL::AddToCurrentWeight(Float_t wgtadd)
{
   // add to the weight attached to the current PlexStripEndId

   if (!IsValid()) return; // no list or out of range
   PlexSEIdAltLIter cursor = this->begin() + fCurrent;
   (*cursor).AddToWeight(wgtadd);

}

//_____________________________________________________________________________
void PlexSEIdAltL::NormalizeWeights(Float_t wgtsum)
{
   // normalize the weights so sum adds up to "wgtsum"
   // if all values are exactly zero, then this sets them
   // to wgtsum/fSize

   unsigned int n=size();

   if (n < 1) return;

   Float_t sum = 0.0;

   PlexSEIdAltLIter iter, the_end=this->end();

   iter = this->begin();
   while (iter != the_end) { sum += (*iter).GetWeight(); iter++; }

   iter = this->begin();
   if ( sum != 0.0 ) {
      Float_t scale = wgtsum/sum;
      while (iter != the_end) {
         Float_t wgt = (*iter).GetWeight() * scale;
         (*iter).SetWeight(wgt);
         iter++;
      }
   } else {
      // all weight values were zero
      Float_t equalwgt = wgtsum/(float)n;
      while (iter != the_end) { (*iter).SetWeight(equalwgt); iter++; }
   }

}

//_____________________________________________________________________________

void PlexSEIdAltL::TestConsistency(Bool_t reportError) const
{
   // Set the fError flag if the list is inconsistent
   // in terms of GetDetector, GetEnd, GetPlane, GetPlaneView

   // skip if already checked (adding values clears this flag)
   if ( kUnchecked != fError ) return;

   // clear all errors
   fError = 0;

   unsigned int n = size();

   // a single entry is consistent with itself
   if ( 1 == n ) return;

   // an empty list is consistent with nothing
   // and asking for these value will be problematic
   if ( 0 == n ) {
      fError = kBadDetector | kBadEnd | kBadPlane | kBadPlaneView;
      return;
   }

   PlexSEIdAltLConstIter iter = this->begin();
   PlexSEIdAltLConstIter the_end = this->end();

   PlexStripEndId first_seid = (*iter).GetSEId();
   Detector::Detector_t     firstdet = first_seid.GetDetector();
   StripEnd::StripEnd_t     firstend = first_seid.GetEnd();
   Int_t                    firstpln = first_seid.GetPlane();
   PlaneView::PlaneView_t   firstpvw = first_seid.GetPlaneView();
   Bool_t                   firstisv = first_seid.IsVetoShield();

   iter++;  // no need to recheck the first against itself
   while (iter != the_end) {
      PlexStripEndId alt_seid = (*iter).GetSEId();
      Detector::Detector_t     altdet = alt_seid.GetDetector();
      StripEnd::StripEnd_t     altend = alt_seid.GetEnd();
      Int_t                    altpln = alt_seid.GetPlane();
      PlaneView::PlaneView_t   altpvw = alt_seid.GetPlaneView();
      Bool_t                   altisv = alt_seid.IsVetoShield();
      if ( altdet != firstdet ) fError |= kBadDetector;
      if ( altend != firstend ) fError |= kBadEnd;
      // veto shield connections span modules (and thus "planes"
      // and "planeviews")
      if ( ! altisv ) {
        if ( altpln != firstpln ) fError |= kBadPlane;
        if ( altpvw != firstpvw ) fError |= kBadPlaneView;
      }
      if ( altisv != firstisv ) fError |= kBadIsVeto;
      iter++;
   }
   
   if ( fError != kOkay && reportError ) {
      MSG("Plex",Msg::kWarning)
         << "PlexSEIdAltL::TestConsistency - list is inconsistent " 
         << "(0x" << hex << setfill('0') << setw(2) << fError
         << setfill(' ') << dec << ")" << endl;

      UInt_t old_fmt = GetFmtFlag();
      SetFmtFlag(fmt_Index|fmt_StripEnd|fmt_PixelSpot);
      this->Print();
      SetFmtFlag(old_fmt);
   }

}

//_____________________________________________________________________________

---