loon: PlexSEIdAltL Class Reference

00096                             {
00097       kOkay         = 0x0000,
00098       kBadDetector  = 0x0001,
00099       kBadEnd       = 0x0002,
00100       kBadPlane     = 0x0004,
00101       kBadPlaneView = 0x0008,
00102       kUnchecked    = 0x0010,
00103       kBadIsVeto    = 0x0020
00104    } ErrorMask_t;

00106                              {
00107      fmt_Index     = 0x0001,
00108      fmt_Cursor    = 0x0002,
00109      fmt_Best      = 0x0004,
00110      fmt_StripEnd  = 0x0008,
00111      fmt_PixelSpot = 0x0010,
00112      fmt_Weight    = 0x0020,
00113      fmt_PE        = 0x0040,
00114      fmt_SigLin    = 0x0080,
00115      fmt_SigCorr   = 0x0100,
00116      fmt_Time      = 0x0200
00117    } FmtFlagBits_t;

00177    : fCurrent(0), fDemuxVetoFlag(0), fError(kUnchecked)     
00178 {
00179    // Default constructor
00180 }

00184    : std::vector<PlexSEIdAltLItem>(),
00185      fCurrent(rhs.fCurrent), 
00186      fDemuxVetoFlag(rhs.fDemuxVetoFlag), 
00187      fError(kUnchecked)
00188 {
00189 
00190    // deep copy constructor
00191    for (unsigned int i=0; i<rhs.size(); ++i) {
00192       this->push_back(rhs[i]);
00193    }
00194 
00195 }

00199 {
00200    // delete all the owned sub-objects
00201 }

00223 {
00224    // add a new item to the list
00225 
00226    fError = kUnchecked;  // adding a new strip makes consistency unknown
00227 
00228    if (calib) {
00229       PlexSEIdAltLItem item = calib->CalibStripEnd(seid,spot,adc,time);
00230       item.SetWeight(weight);
00231       this->push_back(item);
00232    }
00233    else {
00234       PlexSEIdAltLItem item(seid,spot,weight);
00235       this->push_back(item);
00236    }
00237 }

00697 {
00698    // add to the weight attached to the current PlexStripEndId
00699 
00700    if (!IsValid()) return; // no list or out of range
00701    PlexSEIdAltLIter cursor = this->begin() + fCurrent;
00702    (*cursor).AddToWeight(wgtadd);
00703 
00704 }

00341 {
00342    // set all the weights to zero
00343 
00344    PlexSEIdAltL& self = *this;
00345    for (unsigned int i=0; i<size(); i++) (self[i]).SetWeight(0.0);
00346 }

00241 {
00242    // Remove current item from the list.
00243    // Do not reset current position of iterator.
00244    // An iterative removal should start from Last() and use Previous().
00245 
00246    UShort_t n = size();
00247 
00248    if (n <= 0) return;  // one cannot drop what one doesn't have
00249    if (fCurrent>=n) {   
00250       MSG("Plex",Msg::kWarning)
00251          << "can not DropCurrent (fCurrent=" << fCurrent 
00252          << ") on a list of " << n << " items " << endl;
00253       return;
00254    }
00255 
00256    PlexSEIdAltLIter cursor = this->begin() + fCurrent;
00257    // delete the owned item
00258    this->erase(cursor);
00259 
00260 }

00264 {
00265    // Remove pairs from the list that have weight == 0
00266 
00267    if (size() <= 0) return;  // one cannot drop what one doesn't have
00268 
00269    // move all zero items to the end
00270    PlexSEIdAltLIter new_end = 
00271       remove_if(this->begin(), this->end(), 
00272                 mem_fun_ref(&PlexSEIdAltLItem::IsZeroWeight));
00273 
00274    // erase the moved items out of the array 
00275    this->erase(new_end,this->end());
00276 
00277 }

00390 {
00391    // find the PlexSEIdAltLItem with the highest weight
00392 
00393    unsigned int thesize = size();
00394    if (thesize == 0) {
00395      static int msglimit = 25;  // limit the number of complaints
00396      if (msglimit) {
00397        // Empty lists generally happen because of raw channel id's
00398        // that don't map back to real strips (for instance due to
00399        // unused pixels on a tube being illuminated by crosstalk).
00400        // Complain a bit ... but then shut up.
00401        MSG("Plex",Msg::kWarning)
00402          << "can not GetBestItem() from an empty list" << endl;
00403        if (--msglimit == 0) 
00404          MSG("Plex",Msg::kWarning)
00405            << " ... last warning of this type" << endl;
00406      }
00407      return dummyPlexSEIdAltLItem;;
00408    }
00409    else if (thesize == 1) {
00410      // simple case of only one element
00411      return (*this)[0];
00412    }
00413    
00414    PlexSEIdAltLIter cursor = this->begin();
00415    PlexSEIdAltLIter best   = this->begin();
00416    Float_t wgt, maxwgt = -1.0e-37;
00417    while (cursor != this->end()) {
00418       PlexSEIdAltLItem& item = *cursor;
00419       if ( (wgt = item.GetWeight()) > maxwgt ) {
00420          maxwgt = wgt; best = cursor;
00421       }
00422       cursor++;
00423    }
00424    return *best;
00425       
00426 }

00350 {
00351    // find the PlexSEIdAltLItem with the highest weight (const version)
00352 
00353    unsigned int thesize = size();
00354    if (thesize == 0) {
00355      static int msglimit = 25;  // limit the number of complaints
00356      if (msglimit) {
00357        // Empty lists generally happen because of raw channel id's
00358        // that don't map back to real strips (for instance due to
00359        // unused pixels on a tube being illuminated by crosstalk).
00360        // Complain a bit ... but then shut up.
00361        MSG("Plex",Msg::kWarning)
00362          << "can not GetBestItem() from an empty list" << endl;
00363        if (--msglimit == 0) 
00364          MSG("Plex",Msg::kWarning)
00365            << " ... last warning of this type" << endl;
00366      }
00367      return dummyPlexSEIdAltLItem;;
00368    }
00369    else if (thesize == 1) {
00370      // simple case of only one element
00371      return (*this)[0];
00372    }
00373 
00374    PlexSEIdAltLConstIter cursor = this->begin();
00375    PlexSEIdAltLConstIter best   = this->begin();
00376    Float_t wgt, maxwgt = -1.0e-37;
00377    while (cursor != this->end()) {
00378       const PlexSEIdAltLItem& item = *cursor;
00379       if ( (wgt = item.GetWeight()) > maxwgt ) {
00380          maxwgt = wgt; best = cursor;
00381       }
00382       cursor++;
00383    }
00384    return *best;
00385       
00386 }

00430 {
00431    // find the PlexStripEndId with the highest weight and return by value
00432 
00433    return GetBestItem().GetSEId();
00434 
00435 }

00439 {
00440    // find the highest weight
00441 
00442    return GetBestItem().GetWeight();
00443 
00444 }

00468 {
00469    // return by value current PlexSEIdAltLItem
00470 
00471    if (!IsValid()) {
00472      if (size() <= 0) 
00473        MSG("Plex",Msg::kWarning)
00474          << "can not GetCurrentItem() from an empty list" << endl;
00475      else
00476        MSG("Plex",Msg::kWarning)
00477          << "can not GetCurrentItem() when !IsValid()" << endl;
00478      return dummyPlexSEIdAltLItem;;
00479    }
00480 
00481    PlexSEIdAltLIter cursor = this->begin() + fCurrent;
00482    return *cursor;
00483 
00484 }

00448 {
00449    // return by value current PlexSEIdAltLItem (const version)
00450 
00451    if (!IsValid()) {
00452      if (size() <= 0) 
00453        MSG("Plex",Msg::kWarning)
00454          << "can not GetCurrentItem() from an empty list" << endl;
00455      else
00456        MSG("Plex",Msg::kWarning)
00457          << "can not GetCurrentItem() when !IsValid()" << endl;
00458      return dummyPlexSEIdAltLItem;;
00459    }
00460 
00461    PlexSEIdAltLConstIter cursor = this->begin() + fCurrent;
00462    return *cursor;
00463 
00464 }

00488 {
00489    // return by value current PlexStripEndId
00490 
00491    return GetCurrentItem().GetSEId();
00492 
00493 }

00497 {
00498    // return the weight attached to the current PlexStripEndId
00499 
00500    return GetCurrentItem().GetWeight();
00501 
00502 }

00062      { return fDemuxVetoFlag; }

00506 {
00507    // Return the Detector of the PlexStripEndID's in this list.
00508    // This is meaningful only in a correctly filled PlexSEIdAltL
00509 
00510    TestConsistency(reportError);
00511    
00512    if ( fError & kBadDetector || size() < 1 ) 
00513       return (Detector::Detector_t)0; // bad detector
00514 
00515    PlexSEIdAltLConstIter cursor = this->begin();
00516    return (*cursor).GetSEId().GetDetector();
00517 
00518 }

00539 {
00540    // Return the end (kEast,kWest) of the PlexStripEndID's in this list.
00541    // This is meaningful only in a correctly cabled detector
00542    // if there are mis-cablings then it could return nonsense.
00543 
00544    TestConsistency(reportError);
00545 
00546    if ( fError & kBadEnd || size() < 1 ) 
00547       return StripEnd::kUnknown;  // bad end
00548 
00549    PlexSEIdAltLConstIter cursor = this->begin();
00550    return (*cursor).GetSEId().GetEnd();
00551 
00552 }

00071       { TestConsistency(reportError); return fError; }

00120 { return fgFmtFlag; }

00556 {
00557    // Return the plane # of the PlexStripEndId's in this list.
00558    // This is meaningful only in a correctly cabled detector
00559    // if there are mis-cablings then it could return nonsense.
00560 
00561    TestConsistency(reportError);
00562 
00563    if ( fError & kBadPlane || size() < 1 )
00564       return -1;  // bad plane
00565 
00566    PlexSEIdAltLConstIter cursor = this->begin();
00567    return (*cursor).GetSEId().GetPlane();
00568 
00569 }

00574 {
00575    // Return the PlaneView of the PlexStripEndID's in this list.
00576    // This is meaningful only in a correctly cabled detector
00577    // if there are mis-cablings then it could return nonsense.
00578 
00579    TestConsistency(reportError);
00580 
00581    if ( fError & kBadPlaneView || size() < 1 )
00582       return PlaneView::kUnknown;  // bad view
00583 
00584    PlexSEIdAltLConstIter cursor = this->begin();
00585    return (*cursor).GetSEId().GetPlaneView();
00586 
00587 }

00075 { return this->size(); }

00619 {
00620    // is current position a valid entry
00621 
00622   return size()>0 && fCurrent<size(); 
00623 
00624 }

00522 {
00523    // Return the whether this alt-list reflect veto shield strips
00524    // This is meaningful only in a correctly filled PlexSEIdAltL
00525 
00526    TestConsistency(reportError);
00527    
00528    // if inconsistent ... don't take it as part of veto shield
00529    // "nothing" isn't part of a veto shield
00530    if ( fError & kBadIsVeto || size() < 1 ) return false;
00531 
00532    PlexSEIdAltLConstIter cursor = this->begin();
00533    return (*cursor).GetSEId().IsVetoShield();
00534 
00535 }

00281 {
00282    // Remove all but "n" pairs from the list (top "n" sorted by weight)
00283    // Final relative order of elements in the list is unchanged
00284    // if keeporder=kTRUE otherwise list ordered by decending weights.
00285    // If "n" would separate values of the same weight then
00286    // more than "n" are kept.
00287 
00288    unsigned int i, cnt = size();
00289 
00290    if (cnt <= 0) return;  // one cannot drop what one doesn't have
00291 
00292    if (n >= cnt) {
00293       if (keeporder) return; // keep everything, no change in order
00294       else n = cnt;          // perform sort but don't go beyond end
00295    }
00296 
00297    PlexSEIdAltL& self = *this;
00298 
00299    if (n <= 0) { // special case for new size=0
00300       this->clear();
00301       return;
00302    }
00303 
00304    // make a copy of the weights
00305    // sort it
00306    // select the nth down the list for lowest weight value to keep
00307    Float_t *sortedwgt = new Float_t[cnt];
00308 #if ROOT_VERSION_CODE < ROOT_VERSION(5,21,5)
00309    Int_t   *sortedindx = new Int_t[cnt];
00310 #else
00311    UInt_t  *sortedindx = new UInt_t[cnt];
00312 #endif
00313    for (i=0; i<cnt; i++) sortedwgt[i] = self[i].GetWeight();
00314    Bool_t down=kTRUE;
00315    TMath::Sort(cnt,sortedwgt,sortedindx,down);
00316    // n-1 because C arrays start with 0
00317    Int_t   icut = sortedindx[n-1];
00318    Float_t  cut = sortedwgt[icut]; 
00319 
00320    // count final size
00321    // may not be ==n because of two entries with same weight
00322    vector<PlexSEIdAltLItem> tempVector;
00323    for (i=0; i<cnt; i++) {
00324       unsigned int indxold = i;
00325       if (!keeporder) indxold = sortedindx[i];
00326       if (self[indxold].GetWeight() >= cut) {
00327          tempVector.push_back(self[indxold]);
00328       }
00329    }
00330 
00331    // replace current vector with newly created temporary
00332    this->swap(tempVector);
00333 
00334    delete [] sortedwgt;
00335    delete [] sortedindx;
00336 
00337 }

00078 { fCurrent++; }

00708 {
00709    // normalize the weights so sum adds up to "wgtsum"
00710    // if all values are exactly zero, then this sets them
00711    // to wgtsum/fSize
00712 
00713    unsigned int n=size();
00714 
00715    if (n < 1) return;
00716 
00717    Float_t sum = 0.0;
00718 
00719    PlexSEIdAltLIter iter, the_end=this->end();
00720 
00721    iter = this->begin();
00722    while (iter != the_end) { sum += (*iter).GetWeight(); iter++; }
00723 
00724    iter = this->begin();
00725    if ( sum != 0.0 ) {
00726       Float_t scale = wgtsum/sum;
00727       while (iter != the_end) {
00728          Float_t wgt = (*iter).GetWeight() * scale;
00729          (*iter).SetWeight(wgt);
00730          iter++;
00731       }
00732    } else {
00733       // all weight values were zero
00734       Float_t equalwgt = wgtsum/(float)n;
00735       while (iter != the_end) { (*iter).SetWeight(equalwgt); iter++; }
00736    }
00737 
00738 }

00079 { fCurrent--; }

00628 {
00629    // Print out the list
00630 
00631    unsigned int n = size();
00632 
00633    if (n <= 0) {
00634       printf("Empty PlexSEIdAltL\n");
00635       return;
00636    }
00637 
00638    const PlexSEIdAltLItem& best = GetBestItem();
00639 
00640    const PlexSEIdAltL& self = *this;
00641    unsigned int i;
00642    char cursormarker, bestmarker;
00643    PlexStripEndId seid;
00644 //   Float_t        weight;
00645 
00646    switch (option[0]) {
00647    case 'c':
00648    case 'C':
00649       // compact notation assumes that there isn't a mixup
00650       // and all items share a common detector/plane/subpart/end
00651       seid = GetCurrentSEId(); // any will do
00652       printf("[%1.1s|%4d %1.1s%1.1s|%1.1s%1.1s]",
00653              Detector::AsString(seid.GetDetector()),
00654              seid.GetPlane(),
00655              PlaneView::AsString(seid.GetPlaneView()),
00656              PlaneCoverage::AsString(seid.GetPlaneCoverage()),
00657              StripEnd::AsString(seid.GetSubPart()),
00658              StripEnd::AsString(seid.GetEnd()));
00659       for (i=0; i<n; i++) {
00660          const PlexSEIdAltLItem& item = self[i];
00661          bestmarker   = (item == best)     ? '!' : ' ';
00662          cursormarker = (i    == fCurrent) ? '@' : ' ';
00663          seid   = item.GetSEId();
00664          printf(" %c%c%3d",bestmarker,cursormarker,seid.GetStrip());
00665 
00666       }
00667       if (option[0] == 'C') {
00668          printf("\n          wgt ");
00669          for (i=0; i<n; i++) {
00670             const PlexSEIdAltLItem& item = self[i];
00671             printf(" %5.3f",item.GetWeight());
00672          }
00673       }
00674       printf("\n");
00675 
00676       break;
00677    default:
00678 
00679      cout << *this;
00680 
00681    }
00682 }

00092 { this->push_back(item); }

00686 {
00687    // set the weight attached to the current PlexStripEndId
00688 
00689    if (!IsValid()) return; // no list or out of range
00690    PlexSEIdAltLIter cursor = this->begin() + fCurrent;
00691    (*cursor).SetWeight(weight);
00692 
00693 }

00087 { fDemuxVetoFlag = flag; }

00080 { fCurrent = 0; }

00119 { fgFmtFlag = fmtflg; }

00081 { fCurrent = GetSize()-1; }

00591 {
00592    // Given two PlexSEIdAltL's set both "current" iterators
00593    // to entries that are at opposite ends of the same strip
00594    // and return true.  If no legal combination exists then
00595    // return false leaving current positions unchanged.
00596 
00597    UInt_t where_this =      fCurrent;
00598    UInt_t where_that = that.fCurrent;
00599 
00600    this->SetFirst();
00601    while (this->IsValid()) {
00602       PlexStripEndId seid_this = this->GetCurrentSEId();
00603       that.SetFirst();
00604       while (that.IsValid()) {
00605          PlexStripEndId seid_that = that.GetCurrentSEId();
00606          if (seid_this.IsOppositeStripEnd(seid_that)) return true;
00607          that.Next();
00608       }
00609       this->Next();
00610    }
00611    // fell through means no legal match
00612    fCurrent      = where_this;
00613    that.fCurrent = where_that;
00614    return false;
00615 
00616 }

00091 { return this->size(); }

00743 {
00744    // Set the fError flag if the list is inconsistent
00745    // in terms of GetDetector, GetEnd, GetPlane, GetPlaneView
00746 
00747    // skip if already checked (adding values clears this flag)
00748    if ( kUnchecked != fError ) return;
00749 
00750    // clear all errors
00751    fError = 0;
00752 
00753    unsigned int n = size();
00754 
00755    // a single entry is consistent with itself
00756    if ( 1 == n ) return;
00757 
00758    // an empty list is consistent with nothing
00759    // and asking for these value will be problematic
00760    if ( 0 == n ) {
00761       fError = kBadDetector | kBadEnd | kBadPlane | kBadPlaneView;
00762       return;
00763    }
00764 
00765    PlexSEIdAltLConstIter iter = this->begin();
00766    PlexSEIdAltLConstIter the_end = this->end();
00767 
00768    PlexStripEndId first_seid = (*iter).GetSEId();
00769    Detector::Detector_t     firstdet = first_seid.GetDetector();
00770    StripEnd::StripEnd_t     firstend = first_seid.GetEnd();
00771    Int_t                    firstpln = first_seid.GetPlane();
00772    PlaneView::PlaneView_t   firstpvw = first_seid.GetPlaneView();
00773    Bool_t                   firstisv = first_seid.IsVetoShield();
00774 
00775    iter++;  // no need to recheck the first against itself
00776    while (iter != the_end) {
00777       PlexStripEndId alt_seid = (*iter).GetSEId();
00778       Detector::Detector_t     altdet = alt_seid.GetDetector();
00779       StripEnd::StripEnd_t     altend = alt_seid.GetEnd();
00780       Int_t                    altpln = alt_seid.GetPlane();
00781       PlaneView::PlaneView_t   altpvw = alt_seid.GetPlaneView();
00782       Bool_t                   altisv = alt_seid.IsVetoShield();
00783       if ( altdet != firstdet ) fError |= kBadDetector;
00784       if ( altend != firstend ) fError |= kBadEnd;
00785       // veto shield connections span modules (and thus "planes"
00786       // and "planeviews")
00787       if ( ! altisv ) {
00788         if ( altpln != firstpln ) fError |= kBadPlane;
00789         if ( altpvw != firstpvw ) fError |= kBadPlaneView;
00790       }
00791       if ( altisv != firstisv ) fError |= kBadIsVeto;
00792       iter++;
00793    }
00794    
00795    if ( fError != kOkay && reportError ) {
00796       MSG("Plex",Msg::kWarning)
00797          << "PlexSEIdAltL::TestConsistency - list is inconsistent " 
00798          << "(0x" << hex << setfill('0') << setw(2) << fError
00799          << setfill(' ') << dec << ")" << endl;
00800 
00801       UInt_t old_fmt = GetFmtFlag();
00802       SetFmtFlag(fmt_Index|fmt_StripEnd|fmt_PixelSpot);
00803       this->Print();
00804       SetFmtFlag(old_fmt);
00805    }
00806 
00807 }


Public Types
typedef PlexSEIdAltL::iterator	PlexSEIdAltLIter
typedef PlexSEIdAltL::const_iterator	PlexSEIdAltLConstIter
typedef enum PlexSEIdAltL::EErrorMasks	ErrorMask_t
typedef enum PlexSEIdAltL::EFmtFlagBits	FmtFlagBits_t
enum	EErrorMasks { kOkay = 0x0000, kBadDetector = 0x0001, kBadEnd = 0x0002, kBadPlane = 0x0004, kBadPlaneView = 0x0008, kUnchecked = 0x0010, kBadIsVeto = 0x0020 }
enum	EFmtFlagBits { fmt_Index = 0x0001, fmt_Cursor = 0x0002, fmt_Best = 0x0004, fmt_StripEnd = 0x0008, fmt_PixelSpot = 0x0010, fmt_Weight = 0x0020, fmt_PE = 0x0040, fmt_SigLin = 0x0080, fmt_SigCorr = 0x0100, fmt_Time = 0x0200 }
Public Member Functions
	PlexSEIdAltL ()
	PlexSEIdAltL (const PlexSEIdAltL &rhs)
virtual	~PlexSEIdAltL ()
void	AddStripEndId (const PlexStripEndId &seid, const PlexPixelSpotId &spot, Float_t weight=0, const PlexCalib *calib=0, Int_t adc=0, Double_t time=0)
void	ClearWeights ()
void	DropCurrent ()
void	DropZeroWeights ()
void	KeepTopWeights (UInt_t n=2, Bool_t keeporder=kFALSE)
const PlexSEIdAltLItem &	GetBestItem () const
PlexSEIdAltLItem &	GetBestItem ()
PlexStripEndId	GetBestSEId () const
Float_t	GetBestWeight () const
const PlexSEIdAltLItem &	GetCurrentItem () const
PlexSEIdAltLItem &	GetCurrentItem ()
PlexStripEndId	GetCurrentSEId () const
Float_t	GetCurrentWeight () const
UShort_t	GetDemuxVetoFlag () const
Bool_t	IsVetoShield (Bool_t reportError=true) const
Detector::Detector_t	GetDetector (Bool_t reportError=true) const
StripEnd::StripEnd_t	GetEnd (Bool_t reportError=true) const
Int_t	GetPlane (Bool_t reportError=true) const
PlaneView::PlaneView_t	GetPlaneView (Bool_t reportError=true) const
Int_t	GetError (Bool_t reportError=true) const
Bool_t	SetToOppositeEnds (PlexSEIdAltL &that)
Int_t	GetSize () const
Bool_t	IsValid () const
void	Next () const
void	Previous () const
void	SetFirst () const
void	SetLast () const
void	SetCurrentWeight (Float_t weight)
void	AddToCurrentWeight (Float_t wgtadd)
void	NormalizeWeights (Float_t wgtsum=1.0)
void	SetDemuxVetoFlag (UShort_t flag)
UInt_t	Size () const
void	Push_Back (const PlexSEIdAltLItem &item)
void	Print (Option_t *option="") const
Static Public Member Functions
void	SetFmtFlag (const UInt_t fmtflg)
UInt_t	GetFmtFlag ()
Private Member Functions
void	TestConsistency (Bool_t reportError=true) const
Private Attributes
UShort_t	fCurrent
UShort_t	fDemuxVetoFlag
UShort_t	fError
Static Private Attributes
UInt_t	fgFmtFlag = 0
Friends
std::ostream &	operator<< (std::ostream &os, const PlexSEIdAltL &alt)

PlexSEIdAltL Class Reference

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation