BfldLoanPool.cxx

Go to the documentation of this file.

// $Id: BfldLoanPool.cxx,v 1.32 2009/09/16 16:55:44 rhatcher Exp $
//
// BfldLoanPool
//
// A singleton class to instantiate BfldMesh (rectangular grids and
// Voronoi diagrams) and BfldMaps.
//
// It does NOT -construct- them in the sense of turning an FEA node
// list into a Voronoi diagram or running ANSYS, but rather simply
// supplies methods for getting a copy of the appropriate structure
// (presumably by reading it from a file or using data from the database).
//
// This version is *NOT* thread safe!!!
//
// Author:  R. Hatcher 2000.06.20
//
#include "BField/BfldLoanPool.h"

#include <cassert>
#include <iomanip>

#include "TSystem.h"
#include "TString.h"

#include "Util/UtilString.h"

#include "BField/BfldCache.h"

#include "BField/BfldMeshRect2d.h"
#include "BField/BfldMapRect2d.h"

#include "BField/BfldMeshVoronoi.h"
#include "BField/BfldMapVoronoi.h"

#include "UgliGeometry/UgliLoanPool.h"

#include "MessageService/MsgService.h"
CVSID("$Id: BfldLoanPool.cxx,v 1.32 2009/09/16 16:55:44 rhatcher Exp $");
#include "MessageService/MsgFormat.h"


ClassImp(BfldLoanPool)

//_____________________________________________________________________________
// initialize static member
BfldLoanPool *BfldLoanPool::fgInstance = 0;

//_____________________________________________________________________________
BfldLoanPool::BfldLoanPool()
  // these initializations will immediately get overridden by 
  // DefaultConfig() initializing the Registry in Instance()
  // followed by the Update().
  : fMaxUnrefCaches(1),     fInZTest(3),              fDoLocalTransform(0),
    fDoBHCorrection(0),     fDoSlotCorrection(0), 
    fDoInterPlaneField(1),  fDoSMGapAndEndField(1),   fUseDCSCoilDir(1),
    fUseDCSCurrent(0),      fGapLineSrc(3),           fApplyBdotScale(0),
    fZTolerance(0.0),       fNoFieldBeyondZ(9999.), 
    fForceUseEverywhere(0), fIgnoreUseEverywhere(1)
{
  // Default ctor -- called by self only

   if (fgInstance && fgInstance != this) {
     MSG("Bfld",Msg::kWarning)
       << "BfldLoanPool ctor() called but global already exists"
       << " -- memory leak (existing one will be lost)"
       << endl;
   }
   fgInstance = this;

   MSG("Bfld",Msg::kSynopsis) << "BfldLoanPool ctor" << endl;

   fBfldMeshList.SetOwner(true);
   fBfldMapList.SetOwner(true);
   fBfldCacheList.SetOwner(true);
}

//_____________________________________________________________________________
BfldLoanPool::~BfldLoanPool()
{
  // dtor
  // delete all the owned sub-objects

   MSG("Bfld",Msg::kSynopsis) << "BfldLoanPool shutdown" << endl;

   fgInstance = 0;
   fBfldMeshList.Delete();
   fBfldMapList.Delete();
   fBfldCacheList.Delete();
}

//_____________________________________________________________________________
BfldLoanPool *BfldLoanPool::Instance()
{
  // protect Singleton to ensure there is only one
  if (fgInstance == 0) {
     MSG("Bfld",Msg::kSynopsis) << "BfldLoanPool instance creation" << endl;

     // before creating the first & only instance make sure that
     // there is a UgliLoanPool instance to ensure that the
     // singleton dtor's happen in the right order ( first ctor, last dtor )
     UgliLoanPool::Instance();

     static BfldLoanPool::Cleaner c; // end-of-run clean up
     c.ClassIsUsed();

     fgInstance = new BfldLoanPool;

     // initialize initial (default) configuration
     Registry& r = fgInstance->GetConfig();
     r.SetName("BfldLoanPool Registry");
     r.Merge(fgInstance->DefaultConfig());
     r.LockKeys();
     fgInstance->SetConfigFromEnvironment();
     fgInstance->Update();
  }
  return fgInstance;
}
//_____________________________________________________________________________
void BfldLoanPool::Config()
{
  //  Reconfigure after internal registry update.

  Registry& r = GetConfig();

  int    tmpi;
  double tmpd;
  const char* tmps;

  if (r.Get("MaxUnrefCaches",     tmpi)) fMaxUnrefCaches     = tmpi;

  if (r.Get("RequireInZTest",     tmpi)) fInZTest            = tmpi;
  if (r.Get("DoLocalTransform",   tmpi)) fDoLocalTransform   = tmpi;

  if (r.Get("DoBHCorrection",     tmpi)) fDoBHCorrection     = tmpi;
  if (r.Get("DoSlotCorrection",   tmpi)) fDoSlotCorrection   = tmpi;
  if (r.Get("DoInterPlaneField",  tmpi)) fDoInterPlaneField  = tmpi;
  if (r.Get("DoSMGapAndEndField", tmpi)) fDoSMGapAndEndField = tmpi;
  if (r.Get("UseDCSCoilDir",      tmpi)) fUseDCSCoilDir      = tmpi;
  if (r.Get("UseDCSCurrent",      tmpi)) fUseDCSCurrent      = tmpi;
  if (r.Get("GapLineSrc",         tmpi)) fGapLineSrc         = tmpi;
  if (r.Get("ApplyBdotScale",     tmpi)) fApplyBdotScale     = tmpi;

  if (r.Get("ZTolerance",         tmpd)) fZTolerance         = tmpd;

  if (r.Get("NoFieldBeyondZ",     tmpd)) fNoFieldBeyondZ     = tmpd;

  if (r.Get("ForceUseEverywhere", tmpi)) fForceUseEverywhere = tmpi;
  if (r.Get("IgnoreUseEverywhere",tmpi)) fIgnoreUseEverywhere= tmpi;

  if (r.Get("AllBellsAndWhistles",tmpi) && tmpi != 0 ) {
    // maximum enhancements! damn the torpedos
    MSG("Bfld",Msg::kInfo)
      << "BfldLoanPool configured for AllBellsAndWhistles! (toot)! (toot)!"
      << endl;
    fInZTest             =   3; // this is needed for InterPlaneField
    fDoLocalTransform    =   2;
    fDoInterPlaneField   =   1;
    fDoBHCorrection      =  -1;
    fDoSlotCorrection    =   1;
    fApplyBdotScale      =   1; 
  }

  if (r.Get("SwimmerChoice",tmps) && tmps != 0 ) {
    TString swimname(tmps);
    swimname.Remove(TString::kBoth,' ').ToLower();
    bool handled = false;

    if ("old" == swimname) {
      // old swimmer behaviour
      MSG("Bfld",Msg::kInfo)
        << "BfldLoanPool configured for old Swimmer"
        << endl;
      fForceUseEverywhere  =   0;
      fIgnoreUseEverywhere =   0;
      fInZTest             =   1;  // steel within tolerance, complain outside
      fDoInterPlaneField   =   0;
      fDoSMGapAndEndField  =   0;
      fZTolerance          =  0.25*Munits::mm;
      handled = true;
    }
    if ("geo" == swimname) {
      // GeoSwimmer behaviour
      MSG("Bfld",Msg::kInfo)
        << "BfldLoanPool configured for GeoSwimmer"
        << endl;
      fForceUseEverywhere  =   0;
      fIgnoreUseEverywhere =   1;
      fInZTest             =   3;  // steel within tolerance, complain outside
      fDoInterPlaneField   =   1;
      fDoSMGapAndEndField  =   1;
      fZTolerance          =  0.0*Munits::mm;
      handled = true;
    } 

    if ( ! handled && swimname != "" ) {
      MSG("Bfld",Msg::kInfo)
        << "BfldLoanPool doesn't know how to configure for Swimmer: "
        << "\"" << swimname << "\""
        << endl;
    }
  } // non-zero SwimmerChoice

}

//_____________________________________________________________________________
const Registry& BfldLoanPool::DefaultConfig() const
{
  //======================================================================
  // The default configuration for this framework component
  //======================================================================
  //int itrue  = 1; // Work around for Registry's lack of bool
  //int ifalse = 0; // Work around for Registry's lack of bool
  static Registry r;
  
  std::string name = this->GetName();
  name += ".config.default";
  r.SetName(name.c_str());
  
  r.UnLockValues();

  // Limit # of spare caches (depends on geometry)
  r.Set("MaxUnrefCaches",         1);
    
  // Require (even if UseEverywhere) that we only compute BField 
  // inside z boundary of steel
  //  0 = no test
  //  1 = complain if problems
  //  2 = complain and return B=0 if outside any steel z range
  //  3 = use gap map or line current when outside steel
  r.Set("RequireInZTest",         3);

  // do coordinate transformation local <--> global for steel
  // 0 = none:  assume x0-y0 global = x0-y0 map, no rotation
  // 1 = transform position before lookup
  // 2 = transform resulting field back (account for rotation)
  r.Set("DoLocalTransform",       0);

  // configurable additions to the basic map interpolation
  r.Set("DoBHCorrection",     0);  // -1 = use BHFactor/BHCutoff method
  r.Set("DoSlotCorrection",   0);

  // 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
  r.Set("DoInterPlaneField",  1);

  r.Set("DoSMGapAndEndField", 1);

  r.Set("UseDCSCoilDir",      1);  // generally 1 or 0
  r.Set("UseDCSCurrent",      0);  // don't use CoilTools::CoilCurrent()
  r.Set("GapLineSrc",         3);  // 3= central + return line src

  r.Set("ApplyBdotScale",     0);  // for now have this off ...
                                   // until numbers have been validated

  // turn on all the above flags in one go or based on swimmer
  r.Set("AllBellsAndWhistles",    0);
  r.Set("SwimmerChoice",         "");  // "old", "geo"

  // Limit on the out-of-steel tolerance in z position
  r.Set("ZTolerance",      0.0);   // was 0.25*Munits::mm

  // Force B=0 for positions beyond this z.
  // Useful for UseEverywhere with 2nd SuperModule not energizied.
  r.Set("NoFieldBeyondZ",      9999.0);

  // Force a particular map?
  // Even overrides any value passed to BField ctor, but in turn 
  // overridden by IgnoreUseEverywhere.
  r.Set("ForceUseEverywhere",     0);
  // Ignore the UseEverywhere flag in favor of the geometry?
  // Use BfldDbiPlaneMap for determining which map to use for each plane
  r.Set("IgnoreUseEverywhere",    1);

  r.LockValues();

  return r;

}

//_____________________________________________________________________________
void BfldLoanPool::SetConfigFromEnvironment()
{
  // Setup configuration from ENV_BFLD environment variable
  // which consists of a semi-colon separated list of 
  // configuration requests

  const char* strENV_BFLD = gSystem->Getenv("ENV_BFLD");
  if ( strENV_BFLD == 0 || strlen(strENV_BFLD) == 0 ) return;
  
  MSG("Plex",Msg::kInfo) 
    << "Configuring BField from the environment variable ENV_BFLD:" << endl
    << "   " << strENV_BFLD << endl;

  std::vector<std::string> configRequests;
  UtilString::StringTok(configRequests, strENV_BFLD, ";");

  for (unsigned entry = 0; entry < configRequests.size(); ++entry)
    this->Set(configRequests[entry].c_str());

}

//_____________________________________________________________________________
BfldMap* BfldLoanPool::GetMap(BfldGrid::Grid_t grid, Int_t variant)
{
   // Get the requested magnetic field map
   //
   // Assumes that "BfldMap" structure supports a query about
   // what type of grid it is (returns BfldGrid::Grid_t) and
   // what variant it is.

   BfldMap *bmap;

   // Look in the list for a match
   TIter iter(&fBfldMapList);
   while ( ( bmap = (BfldMap *)iter.Next() ) ) {
     // Check if it is compatible
     if ( bmap->GetGrid()    == grid && 
          bmap->GetVariant() == variant ) return bmap;
   }

   // Nothing in the list matches

   // actual code for retrieving a copy of the appropriate BFieldMap
   // appropriate for this grid and variant (which might specify
   // plane chemistry or an end-plane variation)

   MSG("Bfld",Msg::kInfo) 
     << "BfldLoanPool::GetMap new map, type " 
     << (int)grid << " '" << BfldGrid::AsString(grid)
     << "', variant " << variant << endl;

   if (BfldGrid::kRect2dGrid == grid) {
      bmap = new BfldMapRect2d(grid,variant);
   } else {
      bmap = new BfldMapVoronoi(grid,variant);
   }
   // add it to the list
   fBfldMapList.Add(bmap);

   return bmap;
}

//_____________________________________________________________________________
BfldMesh* BfldLoanPool::GetMesh(BfldGrid::Grid_t grid, Int_t variant)
{
   // Get the requested Mesh Diagram
   //
   // Assumes that "Mesh" structure supports a query about
   // what type of grid it is (returns BfldGrid::Grid_t)
   // Rect2d mesh's are particular for a given map variant

   BfldMesh *mesh;
   Bool_t isRect2d = ( BfldGrid::kRect2dGrid == grid );

   // Look in the list for a match
   TIter iter(&fBfldMeshList);
   while ( ( mesh = (BfldMesh *)iter.Next() ) ) {
      // Check if it is compatible
     if ( isRect2d ) {
       if ( mesh->GetGrid()    == grid && 
            mesh->GetVariant() == variant ) return mesh;
     }  // voronoi doesn't care about variant like rect2d
     else if ( mesh->GetGrid() == grid )    return mesh;
   }

   // Nothing in the list matches

   // actual code for retrieving a copy of the appropriate Mesh diagram
   // pass back a pointer to the object
  
   if ( isRect2d ) {
      // the associated mesh should have been created when the map was
      // perhaps we're calling them out of order
      BfldMapRect2d* bmap2d = 
        dynamic_cast<BfldMapRect2d*>(GetMap(grid,variant));
      if ( ! bmap2d ) {
        MSG("Bfld",Msg::kError)
          << "BfldLoanPool::GetMap for Rect2d variant " << variant
          << " failed, building mesh is going to fail."
          << endl;
        // caller probably isn't going to expect this
        // but the BfldMeshRect2d ctor will definitely SEGV
        return 0;  
      }
      mesh = new BfldMeshRect2d(bmap2d);
   } else {
      mesh = new BfldMeshVoronoi(grid,variant);
   }
   // add it to the list
   fBfldMeshList.Add(mesh);
   
   return mesh;
}

//_____________________________________________________________________________
BfldCache* BfldLoanPool::GetCache(VldContext& vldc)
{
   // Get a shared cache 
   //
   BfldCache *cache;

   // Look in the list for a match
   // Count # of unreferenced caches in case we don't find a match
   Int_t todelete = -fMaxUnrefCaches;   
   TIter iter(&fBfldCacheList);
   while ( ( cache = (BfldCache *)iter.Next() ) ) {
     // Check if it is compatible
     if ( cache->GetVldRange().IsCompatible(vldc) ) return cache;
     if ( cache->CountRef() <= 0 ) todelete++;
   }

   // Nothing in the list matches

   // Purge extraneous unref'd caches
   // Iterate from the front (default) so oldest gets cleaned out first
   if (todelete > 0) {
     TObjArrayIter iter_rm(&fBfldCacheList);
     BfldCache* other_cache = 0;
     while ( ( other_cache = (BfldCache *)iter_rm.Next() ) &&
             todelete > 0 ) {
       if ( other_cache->CountRef() <= 0 ) {
         fBfldCacheList.Remove(other_cache);
         delete other_cache;
         todelete--;
       }
     }
     // remove the spaces we freed up
     fBfldCacheList.Compress();
   }

   // Create an appropriate entry
   MSG("Bfld",Msg::kDebug) 
     << "GetCache created a new BfldCache" << endl;
   cache = new BfldCache(vldc);
   fBfldCacheList.Add(cache);

   return cache;
}
//_____________________________________________________________________________
void BfldLoanPool::Print(Option_t * /* option */) const
{
   // output info about what the loan pool has in stock

   MSG("Bfld",Msg::kVerbose) 
      << "BfldLoanPool::Print" << endl;

   MSG("Bfld",Msg::kInfo) 
     << "BfldLoanPool Configuration (local values):" << endl
     << " InZTest: " << fInZTest
     << ", ZTolerance: " << (fZTolerance/Munits::mm) << "mm"
     << ", NoFieldBeyondZ: " << fNoFieldBeyondZ
     << endl
     << " UseDCSCoilDir: " << fUseDCSCoilDir
     << ", UseDCSCurrent: " << fUseDCSCurrent
     << ", GapLineSrc: " << fGapLineSrc
     << ", InterPlaneField: " << fDoInterPlaneField
     << ", SMGapAndEndField: " << fDoSMGapAndEndField
     << ", ApplyBdotScale: " << (fApplyBdotScale?"yes":"no")
     << endl
     << " BHCorr: " << fDoBHCorrection
     << ", SlotCorr: " << fDoSlotCorrection
     << ", ForceUseEverywhere: " << fForceUseEverywhere
     << ", IgnoreUseEverywhere: " << fIgnoreUseEverywhere
     << endl;

   GetConfig().Print();

   static MsgFormat i4("i4");
   Bool_t doheader;


   BfldGrid::Grid_t grid;

   BfldMesh *mesh;

   MSG("Bfld",Msg::kInfo) 
      << " --- Mesh list : " << fBfldMeshList.GetEntries() 
      << " entries ---" << endl;

   doheader = kTRUE;
   TIter itermesh(&fBfldMeshList);
   while ( ( mesh = (BfldMesh *)itermesh.Next() ) ) {
      if (doheader) {
         doheader = kFALSE;
         MSG("Bfld",Msg::kInfo) 
           << "   RefCnt  Grid " << endl;
      }
      grid = mesh->GetGrid();
      MSG("Bfld",Msg::kInfo) 
        << "     " << i4(mesh->CountRef())
        << "  " << BfldGrid::AsString(grid) << endl;
   }

   MSG("Bfld",Msg::kInfo) 
      << " --- Map list : " << fBfldMapList.GetEntries() 
      << " entries ---" << endl;

   BfldMap *bmap;

   doheader = kTRUE;
   TIter iterbmap(&fBfldMapList);
   while ( ( bmap = (BfldMap *)iterbmap.Next() ) ) {
      if (doheader) {
         doheader = kFALSE;
         MSG("Bfld",Msg::kInfo) 
           << "   RefCnt  Variant  Grid " << endl;
      }
      grid = bmap->GetGrid();
      MSG("Bfld",Msg::kInfo) 
        << "     " << i4(bmap->CountRef())
        << "     " << i4(bmap->GetVariant())
        << "  " << BfldGrid::AsString(grid) << endl;
   }

   BfldCache *cache;
   int icache=0;

   MSG("Bfld",Msg::kInfo) 
      << " --- Cache list : " << fBfldCacheList.GetEntries() 
      << " entries ---" << endl;

   doheader = kTRUE;
   TIter itercache(&fBfldCacheList);
   while ( ( cache = (BfldCache *)itercache.Next() ) ) {
      if (doheader) {
         doheader = kFALSE;
      }
      MSG("Bfld",Msg::kInfo) << " [" << setw(2) << icache << "] ";
      cache->Print();
      icache++;
   }

   MSG("Bfld",Msg::kInfo) 
     << " --- End of BfldLoanPool ---" 
     << endl;
}

//_____________________________________________________________________________
void BfldLoanPool::ClearPool(Bool_t cache, Bool_t map, Bool_t mesh)
{
  if (cache) fBfldCacheList.Delete();
  if (map)   fBfldMapList.Delete();
  if (mesh)  fBfldMeshList.Delete();
}

//_____________________________________________________________________________

---