BField.h

Go to the documentation of this file.

// $Id: BField.h,v 1.25 2017/06/01 20:17:00 rhatcher Exp $
//
// BField
//
// This is the code that the end-user would normally see
// It takes care of dealing with geometry (in/out of steel), 
// plane chemistry, getting coil current corrections applied, etc.
// It uses BfldHandler to do the search of the node list (BfldMesh, which
// might be a Voronoi structure) and interpolation of values (in the 
// BfldMap structure).
//
// Author:  R. Hatcher 2000.06.20
//
#ifndef BFIELD_H
#define BFIELD_H

#include "TVector3.h"

#include "BField/BfldGrid.h"
#include "BField/BfldInterpMethod.h"

#include "Validity/VldContext.h"
#include "Validity/VldRange.h"
#include "UgliGeometry/Ugli.h"

class BfldHandler;
class BfldCache;
class BfldMap;
class BfldLoanPool;
class BfldDbiPlaneMap;

class BField : public TObject {

 public:
   BField();
   BField(VldContext vldc, Int_t coarseness = -1, Int_t useEverywhere=0);
   // copy ctor and assignment
   BField(const BField& that);
   BField& operator=(const BField& that);
   // dtor
   virtual ~BField();

   virtual TVector3 GetBField(TVector3& position, Bool_t isUVZ=false);

   virtual void  ResetVldContext(const VldContext& vldc);

   virtual void  SetInterpMethod(BfldInterpMethod::InterpMethod_t method);

   virtual void  SetGridHandler(Detector::Detector_t detector, 
                                Int_t coarseness);

   // NOTE: the DoLocalTranform,InZTest,ZTolerance are a properties 
   // of the BfldCache which might be shared amongst various BField objects. 
   Int_t         GetDoLocalTransform() const;
   Int_t         GetRequireInZTest() const;
   Double_t      GetZTolerance() const;
   void          SetDoLocalTransform(Int_t iflg);
   void          SetRequireInZTest(Int_t ival);
   void          SetZTolerance(Double_t zeps);

   // unshared configuration flags
   void  SetDoBHCorrection(Int_t ival)     { fDoBHCorrection     = ival; }
   void  SetDoSlotCorrection(Int_t ival)   { fDoSlotCorrection   = ival; }
   void  SetDoInterPlaneField(Int_t ival)  { fDoInterPlaneField  = ival; }
   void  SetDoSMGapAndEndField(Int_t ival) { fDoSMGapAndEndField = ival; }
   void  SetUseDCSCoilDir(Int_t ival)      { fUseDCSCoilDir      = ival; }
   void  SetUseDCSCurrent(Int_t ival)      { fUseDCSCurrent      = ival; }

   Int_t GetDoBHCorrection()     const { return fDoBHCorrection;     }
   Int_t GetDoSlotCorrection()   const { return fDoSlotCorrection;   }
   Int_t GetDoInterPlaneField()  const { return fDoInterPlaneField;  }
   Int_t GetDoSMGapAndEndField() const { return fDoSMGapAndEndField; }
   Int_t GetUseDCSCoilDir()      const { return fUseDCSCoilDir;      }
   Int_t GetUseDCSCurrent()      const { return fUseDCSCurrent;      }

   // ugly hack, shouldn't be needed anymore
   void          SetNoFieldBeyondZ(Double_t z) { fNoFieldBeyondZ = z; }
   Double_t      GetNoFieldBeyondZ()     const { return fNoFieldBeyondZ; }

   void  Print(Option_t *option="") const;
   VldContext GetVldContext() const { return fVldContext; }
   VldRange   GetVldRange() const { return fVldRange; }

 protected:

   void Init();
   void InitFlagsFromLoanPool();
   void FindSteelFromZ(Float_t z) const;

   BfldMap* SetupHandlerForMap(Int_t mapVariant);

   void ApplySlotFactorCorr(TVector3& b);
   void ApplyBHFactorCorr(TVector3& b);
   void ApplyBHCurveCorr(TVector3& b);

   TVector3 BFromLineSource(TVector3& posRelCoil, Double_t current);

   TVector3 SMGapAndEndField(const TVector3& pos, Ugli::SMRegion_t iregion);
   TVector3 SMGapAndEndFieldNear(const TVector3& pos, Ugli::SMRegion_t iregion);
   TVector3 SMGapAndEndFieldFar(const TVector3& pos, Ugli::SMRegion_t iregion);
   
   Bool_t                 fNoField;         // short cut for CalDet
   VldContext             fVldContext;      // validity used for ctor
   VldRange               fVldRange;        // validity parameters
   BfldGrid::Grid_t       fGrid;            // mesh grid to be used

   BfldLoanPool          *fLoanPool;        // look this up just once
   BfldHandler           *fHandler;         // created upon instantiation
   BfldCache             *fCache;           // owned by loanpool
                                            // various schemes might
                                            // have more than one of these

   // these may be needed by special case handling (coil, SM gap, interplane)
   Bool_t                 fPositionIsUVZ;   // passed into GetBField
   Bool_t                 fPowerOff;        // was power off?
   Bool_t                 fDegaussed;       // I=0 has two cases
   Double_t               fCoilCurrent;     // current current

   const BfldDbiPlaneMap *fCurrentPlaneMap; // last plane info
   BfldDbiPlaneMap       *fOwnedPlaneMap;   // scratch area
   Int_t                  fLastMapVariant;  // avoid any unnecessary re-init

   // various configuration flags
   Int_t                  fDoBHCorrection;
   Int_t                  fDoSlotCorrection;
   Int_t                  fDoInterPlaneField;
   // 0 = no field outside steel
   // 1 = use detail map if in that region
   //     use full map if it exists, or line current if not
   // 2 = like 1, except always use line current outside detail
   // 3 = use detail map if in that region, otherwise zero

   Int_t                  fDoSMGapAndEndField; 
   // if  0 no SM check just use gap map (if InterPlaneField)
   // if <0 do SM check, but return 0 always
   // if >0 do SM check, try some method for getting field

   Int_t                  fUseDCSCoilDir;
   //       CoilTools::IsReverse()    abs(BfldDbiPlaneMap scale signs)
   //   0       no                         no
   //   1       yes                        yes
   //   2       yes                        no
   //   3       no                         yes
   //   >3  *(-1)

   Int_t                  fUseDCSCurrent;
   //  scales field by DCS (ACNET for Near) current readback
   //  bypasses CoilTools::IsOK() test

   Int_t                  fGapLineSrc;
   // 0 = no line src,  1 = central line src,  3 = central + return line src

   Int_t                  fApplyBdotScale;

   Double_t               fOverallScale;
   // overall multiplicative factor

   // this is a temporary ruse used to bypass linkage to the geometry
   // during the development ... it should _not_ remain in final code
   // (nor should its use in the ctor).
   Int_t                  fUseEverywhere;   // which map to use everywhere

   // another crazy hack to deal with one SM w/ field and one without
   // and geometry lookup adding too much time
   Double_t               fNoFieldBeyondZ;

 private:

   ClassDef(BField,0)
};

inline TVector3 BField::SMGapAndEndField(const TVector3& pos, 
                                         Ugli::SMRegion_t iregion)
{
  Detector::Detector_t det = fVldContext.GetDetector();
  switch (det) {
  case Detector::kNear: return SMGapAndEndFieldNear(pos,iregion);
  case Detector::kFar:  return SMGapAndEndFieldFar(pos,iregion);
  default:              return TVector3(0,0,0);
  }
}

#endif // BFIELD_H

---