BfldDbiPlaneMap.h

Go to the documentation of this file.

// $Id: BfldDbiPlaneMap.h,v 1.10 2008/03/14 05:14:13 rhatcher Exp $

#ifndef BFLDDBIPLANEMAP_H
#define BFLDDBIPLANEMAP_H

// BfldDbiPlaneMap
//
// Package: BField
//
// Concept: DBI table to record when what maps to use for which planes
//          in the detector (at any given VldContext)
//
//
// Author: R. Hatcher 2003-05-29
//

#include "DatabaseInterface/DbiTableRow.h"
#include "LeakChecker/Lea.h"

#include "Plex/PlexPlaneId.h"
#include "Validity/VldContext.h"

class DbiValidityRec;

class BfldDbiPlaneMap;
std::ostream& operator<<(std::ostream& os, const BfldDbiPlaneMap& pi);

class BfldDbiPlaneMap : public DbiTableRow
{

public:

// Constructors and destructors.

   BfldDbiPlaneMap();
   virtual ~BfldDbiPlaneMap(){ LEA_DTOR; };

   // enums and their types
   typedef enum EMapIndex {
     kFullSteelA,    // full map in the steel
     kFullSteelB,
     kPowerOffA,     // full map with power off
     kPowerOffB,
     kDetailSteelA,  // detail of the steel
     kDetailSteelB,
     kDetailGapA,    // detail of gap region (inter-steel plane)
     kDetailGapB,
     kFullGapA,      // full map of gap region
     kFullGapB,
     kEndOfList
   } MapIndex_t;

   typedef enum EMapShape {
     kCircle,
     kSquare,
     kDiamond  // square in UV space
   } MapShape_t;

// State testing member functions

   PlexPlaneId  GetPlaneId() const      { return fPlaneId; }
   Int_t        GetMapVariant(UInt_t indx=0) const;
   Double_t     GetScale(UInt_t indx=0) const;
   Double_t     GetDetailSize() const   { return fDetailSize; }
   MapShape_t   GetDetailShape() const  { return fDetailShape; }
   Int_t        GetBHCurveIndex() const { return fBHCurve; }
   Double_t     GetBHFactor() const     { return fBHFactor; }
   Double_t     GetBHCutoff() const     { return fBHCutoff; }
   Double_t     GetSlotFactor() const   { return fSlotFactor; }
   Double_t     GetSlotCutoff() const   { return fSlotCutoff; }
   Double_t     GetBdotScale() const    { return fBdotScale; }

   Bool_t       IsInDetail(Double_t x, Double_t y) const;

   Bool_t       IsNull(UInt_t indx) const;
   Bool_t       IsPairNull(UInt_t indx) const;

   virtual DbiTableRow* CreateTableRow() const { return new BfldDbiPlaneMap; }

// I/O  member functions

   virtual void Fill(DbiResultSet& rs,
                     const DbiValidityRec* vrec);
   virtual void Store(DbiOutRowStream& ors,
                      const DbiValidityRec* vrec) const;

   virtual void Print(Option_t *option = "") const;
   virtual std::ostream& FormatToOStream(std::ostream& os,
                                         Option_t *option="") const;

   virtual   Int_t GetAggregateNo() const;
   virtual  UInt_t GetIndex(UInt_t defIndex) const;

   // trust proper use of "const" to avoid misuse of these methods
   void SetPlaneId(PlexPlaneId plnid)       { fPlaneId     = plnid; }
   void SetMapVariant(UInt_t indx, Int_t imap);
   void SetScale(UInt_t indx, Double_t scale);
   void SetDetailSize(Double_t rinscribed)  { fDetailSize  = rinscribed; }
   void SetDetailShape(Int_t ishape);
   void SetBHCurveIndex(UInt_t bhcurve)     { fBHCurve     = bhcurve; }
   void SetBHFactor(Double_t bhfactor)      { fBHFactor    = bhfactor; }
   void SetBHCutoff(Double_t bhcutoff)      { fBHCutoff    = bhcutoff; }
   void SetSlotFactor(Double_t slotfactor)  { fSlotFactor  = slotfactor; }
   void SetSlotCutoff(Double_t slotcutoff)  { fSlotCutoff  = slotcutoff; }
   void SetBdotScale(Double_t bdotscale)    { fBdotScale   = bdotscale; }

   static const char* GetTableDescr();
   static void        SetDefensiveUnpkg(Bool_t defensive) 
     { fgDefensiveUnpkg = defensive; }
   static Bool_t      GetDefensiveUnpkg() { return fgDefensiveUnpkg; }

private:  

// Constructors and destructors.

   BfldDbiPlaneMap(const BfldDbiPlaneMap& from)
     : DbiTableRow(from) { LEA_CTOR; *this = from; }

// Data members

   PlexPlaneId              fPlaneId;
   Int_t                    fMapVariant[kEndOfList]; // map index
   Double_t                 fScale[kEndOfList];      // linear scale factor
   Double_t                 fDetailSize;            // inscribed size of detail region
   MapShape_t               fDetailShape;           // shape of detail region
   Int_t                    fBHCurve;               // chemistry index
   Double_t                 fBHFactor;              // alt BH correction factor
   Double_t                 fBHCutoff;              // alt BH correction factor
   Double_t                 fSlotFactor;            // alt correction factor
   Double_t                 fSlotCutoff;            // alt correction factor
   Double_t                 fBdotScale;             // scale factor for BDot

// class-wide static

   static Bool_t fgDefensiveUnpkg;

ClassDef(BfldDbiPlaneMap,0)

};

inline Int_t BfldDbiPlaneMap::GetMapVariant(UInt_t indx) const {
  if ( indx < kEndOfList ) return fMapVariant[indx];
  // MSGMAX("Bfld",Msg::kWarning,10)
  //  << "GetMapVariant indx=" << indx << " must be [0,1]." << endl;
  return 0;
}
inline Double_t BfldDbiPlaneMap::GetScale(UInt_t indx) const {
  if ( indx < kEndOfList ) return fScale[indx];
  // MSGMAX("Bfld",Msg::kWarning,10)
  //  << "GetScale indx=" << indx << " must be [0,1]." << endl;
  return 0.0;
}

inline Bool_t BfldDbiPlaneMap::IsNull(UInt_t indx) const
{
  // no info  non-zero map/scale combination
  if ( indx >= kEndOfList ) return true;
  return ( ( fMapVariant[indx] * fScale[indx] ) == 0 );
}

inline Bool_t BfldDbiPlaneMap::IsPairNull(UInt_t indx) const
{
  // no info  non-zero map/scale combination for A+B pair
  if ( indx >= kEndOfList-1 ) return true;
  return ( ( fMapVariant[indx]   * fScale[indx]   ) == 0 &&
           ( fMapVariant[indx+1] * fScale[indx+1] ) == 0    );
}

inline void BfldDbiPlaneMap::SetMapVariant(UInt_t indx, Int_t imap) {
  if ( indx < kEndOfList ) { fMapVariant[indx] = imap; return; }
  // MSGMAX("Bfld",Msg::kWarning,10)
  //  << "SetMapVariant indx=" << indx 
  //  << " must be [0," << kEndOfList << "]." << endl;
}
inline void BfldDbiPlaneMap::SetScale(UInt_t indx, Double_t scale) {
  if ( indx < kEndOfList ) { fScale[indx] = scale; return; }
  // MSGMAX("Bfld",Msg::kWarning,10)
  //  << "SetScale indx=" << indx 
  //  << " must be [0," << kEndOfList << "]." << endl;
}

#endif  // BFLDDBIPLANEMAP_H

---