BfldCache.h

Go to the documentation of this file.

// $Id: BfldCache.h,v 1.12 2008/01/24 01:32:16 rhatcher Exp $
// 
// BfldCache
// 
// BfldCache caches info for the BfldHandler
//
// Author:  R. Hatcher 2000.06.20
//

#ifndef BFLDCACHE_H
#define BFLDCACHE_H

#include "TObject.h"
#include "TVector3.h"

#include "Validity/VldContext.h"
#include "Validity/VldRange.h"
#include "UgliGeometry/UgliGeomHandle.h"
#include "UgliGeometry/UgliSteelPlnHandle.h"

#include "DatabaseInterface/DbiResultPtr.h"
#include "BField/BfldDbiPlaneMap.h"

#include <string>

class BfldCache : public TObject {

 public:
   BfldCache();
   BfldCache(const VldContext& vldc);
   virtual ~BfldCache();
   
   VldRange                GetVldRange() const { return fVldRange; }

   const BfldDbiPlaneMap*  FindPlaneMap(TVector3& position, Bool_t isUVZ=false);
   Bool_t                  FindWasInSteel(Bool_t lie = true) const;
   TVector3                GetPositionInSteel() const { return fPosInSteel; }
   UgliSteelPlnHandle      GetCurrentSteelPlnHandle() const { return fSteelCache; 
}
#ifdef OBSOLETE_METHOD
   const BfldDbiPlaneMap*  FindPlaneMapFromId(PlexPlaneId plnid);
#endif

   Ugli::SMRegion_t        InSMRegion(const TVector3& pos, Bool_t isUVZ);
   Ugli::XYRegion_t        InXYRegion(const TVector3& pos, Bool_t isUVZ);

   static Int_t            GetDefaultMapVariant(const VldContext& vldc);
   static Double_t         GetDefaultScale(const VldContext& vldc);

   Int_t    GetDoLocalTransform()   const  { return fDoLocalTransform; }
   Int_t    GetRequireInZTest()     const  { return fInZTest; }
   Double_t GetZTolerance()         const  { return fZTolerance; }
   void     SetDoLocalTransform(Int_t flg) { fDoLocalTransform = flg; }
   void     SetRequireInZTest(Int_t ival)  { fInZTest = ival; }
   void     SetZTolerance(Double_t zeps)   { fZTolerance = zeps; }

   virtual void Print(Option_t *option = "") const;

   void  IncrementRef() { fRef++; }
   void  DecrementRef() { fRef--; }
   Int_t CountRef()     { return fRef; }
 
 protected:

   void InitFlags();
   void SetSteelAndPlaneMapCache(TVector3& position, Bool_t isUVZ=false);
   void SetSteelLimits();
   void SetPlaneMapCache(PlexPlaneId steelid);
   void InvalidateCaches();
   void FillSMZLimits();

 private:

   Detector::Detector_t          fDetector;
   VldRange                      fVldRange;
   mutable Int_t                 fRef;  

   UgliGeomHandle                fUgliGeomHandle; 
   UgliSteelPlnHandle            fSteelCache;     
   Double_t                      fSteelZmin;      
   Double_t                      fSteelZmax;      

   Int_t                         fDoLocalTransform;  // Local<-->Global 0=none,1=shift,2=shift+rotation
   Int_t                         fInZTest;   // 0=no test,1=warn,2=require pass
   Double_t                      fZTolerance;     

   DbiResultPtr<BfldDbiPlaneMap> fPlaneMaps;     
   Int_t                         fDbiMapEntries; 
   const BfldDbiPlaneMap*        fPlaneMapCache; 

   Bool_t                        fFindWasInSteel; 
   TVector3                      fPosInSteel;     

   Double_t                      fSMZLimits[4];

   Int_t                         fWasHigh; 
   Int_t                         fWasLow;  
   Double_t                      fSumHigh; 
   Double_t                      fSumLow;  

   ClassDef(BfldCache,4)
};

inline Bool_t BfldCache::FindWasInSteel(Bool_t lie) const
{ 
  if ( lie && fInZTest < 2 ) return true;
  return fFindWasInSteel; 
}

#endif // BFLDCACHE_H

---