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 }

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

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

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 }

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

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

00426 {
00427    // find the PlexStripEndId with the highest weight and return by value
00428 
00429    return GetBestItem().GetSEId();
00430 
00431 }

00435 {
00436    // find the highest weight
00437 
00438    return GetBestItem().GetWeight();
00439 
00440 }

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

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

00484 {
00485    // return by value current PlexStripEndId
00486 
00487    return GetCurrentItem().GetSEId();
00488 
00489 }

00493 {
00494    // return the weight attached to the current PlexStripEndId
00495 
00496    return GetCurrentItem().GetWeight();
00497 
00498 }

00062      { return fDemuxVetoFlag; }

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

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

00071       { TestConsistency(reportError); return fError; }

00120 { return fgFmtFlag; }

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

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

00075 { return this->size(); }

00615 {
00616    // is current position a valid entry
00617 
00618   return size()>0 && fCurrent<size(); 
00619 
00620 }

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

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    Int_t   *sortedindx = new Int_t[cnt];
00309    for (i=0; i<cnt; i++) sortedwgt[i] = self[i].GetWeight();
00310    Bool_t down=kTRUE;
00311    TMath::Sort(cnt,sortedwgt,sortedindx,down);
00312    // n-1 because C arrays start with 0
00313    Int_t   icut = sortedindx[n-1];
00314    Float_t  cut = sortedwgt[icut]; 
00315 
00316    // count final size
00317    // may not be ==n because of two entries with same weight
00318    vector<PlexSEIdAltLItem> tempVector;
00319    for (i=0; i<cnt; i++) {
00320       unsigned int indxold = i;
00321       if (!keeporder) indxold = sortedindx[i];
00322       if (self[indxold].GetWeight() >= cut) {
00323          tempVector.push_back(self[indxold]);
00324       }
00325    }
00326 
00327    // replace current vector with newly created temporary
00328    this->swap(tempVector);
00329 
00330    delete [] sortedwgt;
00331    delete [] sortedindx;
00332 
00333 }

00078 { fCurrent++; }

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

00079 { fCurrent--; }

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

00092 { this->push_back(item); }

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

00087 { fDemuxVetoFlag = flag; }

00080 { fCurrent = 0; }

00119 { fgFmtFlag = fmtflg; }

00081 { fCurrent = GetSize()-1; }

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

00091 { return this->size(); }

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


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
DetectorType::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