BfldMeshRect2d.cxx

Go to the documentation of this file.

// $Id: BfldMeshRect2d.cxx,v 1.8 2007/02/04 06:23:28 rhatcher Exp $
// 
// BfldMeshRect2d 
// 
// This structure provides services for a 2d mesh representing an array of
// points where magnetic field map is "known".
//
// This particular type is specialized to deal with a rectangular grid.
//
// Author:  R. Hatcher 2000.06.20
//
#include "BField/BfldMeshRect2d.h"

#include "MessageService/MsgService.h"
CVSID("$Id: BfldMeshRect2d.cxx,v 1.8 2007/02/04 06:23:28 rhatcher Exp $");

#include "TClass.h"
#include "TMath.h"

ClassImp(BfldMeshRect2d)

//_____________________________________________________________________________
BfldMeshRect2d::BfldMeshRect2d() 
   : BfldMesh()
{

}

//_____________________________________________________________________________
BfldMeshRect2d::BfldMeshRect2d(BfldMapRect2d* bmap) 
  : BfldMesh(bmap->GetGrid(),bmap->GetVariant())
{
  CopyMapRect2d(bmap);
}

//_____________________________________________________________________________
BfldMeshRect2d::~BfldMeshRect2d()
{
   MSG("Bfld",Msg::kDebug) 
     << "~BfldMeshRect2d grid " << BfldGrid::AsString(fGrid) 
     << " variant " << fVariant
     << endl;
}

//_____________________________________________________________________________
TVector3 BfldMeshRect2d::GetGeneratorPosition(Int_t generator)
{
   // return the TVector3 associated with a generator (mesh node)

   Float_t x, y;
   GeneratorToXY(generator,x,y);
   return TVector3(x,y,0.);
}

//_____________________________________________________________________________
Bool_t BfldMeshRect2d::InBounds(Float_t x, Float_t y)
{
   // Is x-y within the limits of the map?

  if (fQuadrant) {
    x = TMath::Abs(x);
    y = TMath::Abs(y);
  }

  // assume upper and right boundary lines isn't "in bounds"
  // but that lower and left boundary lines are "in bounds"
  // this simplifies other things (picking bounding triangles)
  return ( x >= fX0 && x < fXmax && y >= fY0 && y < fYmax );

}

//_____________________________________________________________________________
Int_t BfldMeshRect2d::InQuadrant(Float_t x, Float_t y)
{
   // Is x-y in which quadrant (if applicable)
   //     1 | 0
   //   ----+----     + centered at (x0,y0)
   //     2 | 3


  if (fQuadrant) {
    if (x >= fX0) {
      if (y >= fY0) {
        return 0;
      } else {
        return 3;
      }
    } else {
      if (y >= fY0) {
        return 1;
      } else {
        return 2;
      }
    }
      
  } else return 0;

}

//_____________________________________________________________________________
void BfldMeshRect2d::CopyMapRect2d(BfldMapRect2d *map)
{
   // The Rect2d mesh must be told which map it is using
   // as the position info gets read in with the field vectors
   // and isn't available independently

   BfldMapRect2d    *fMap; // for Rect2d the mesh info is actually
   fMap = map;

   // grab the position info from the map 
   fX0 = fMap->GetX0();
   fY0 = fMap->GetY0();
   fDx = fMap->GetDx();
   fDy = fMap->GetDy();
   fNx = fMap->GetNx();
   fNy = fMap->GetNy();
   
   // determine upper limit (lowest point *is* X0 or Y0)
   fXmax = fX0 + (fNx-1)*fDx;
   fYmax = fY0 + (fNy-1)*fDy;
   
   fIsUVZ = fMap->GetIsUVZ();
   
   // if x0=0,y0=0 assume map only has one quadrant 
   fQuadrant = ( 0 == fX0 && 0 == fY0 );
      
   fQuadFlags[0] = fMap->GetQuadFlags()[0];
   fQuadFlags[1] = fMap->GetQuadFlags()[1];
   fQuadFlags[2] = fMap->GetQuadFlags()[2];
   fQuadFlags[3] = fMap->GetQuadFlags()[3];

}

//_____________________________________________________________________________
void BfldMeshRect2d::Pick3Generators(Float_t x, Float_t y,
                                     Int_t& gen_near, 
                                     Int_t& gen_cw, Int_t& gen_ccw)
{
   // return the generator (indx) closest to the (x,y) position
   // and those clockwise and clockwise around it
   // (cw/ccw relative to pointing at center of cell)

   if ( fQuadrant ) {
      // symmetry case -- assume quadrant symmetry
      x = TMath::Abs(x);
      y = TMath::Abs(y);
   }

   // let the map figure out what the generator to the lower left is...
   Int_t llgen = LowerLeftGenerator(x,y);

   Int_t dnx = 0;
   Int_t dny = 0;

   Float_t xllgen = 0;
   Float_t yllgen = 0;
   GeneratorToXY(llgen,xllgen,yllgen);

   if ( x - xllgen > 0.5*fDx) dnx = 1;
   if ( y - yllgen > 0.5*fDy) dny = 1;

   // for now ignore special cases
   // which shouldn't arise anyway 
   // (ie. because we're outside the map region).

   Int_t sval = dny<<1 | dnx;
   switch (sval) {
   case 0:
     // nearest _was_ the lower left corner
     gen_near = llgen;
     gen_cw   = NeighborGenerator(llgen,1,0);
     gen_ccw  = NeighborGenerator(llgen,0,1);
     break;
   case 1:
     // nearest was +x but same y
     gen_near = NeighborGenerator(llgen,1,0);
     gen_cw   = NeighborGenerator(llgen,1,1);
     gen_ccw  = llgen;
     break;
   case 2:
     // nearest was +y but same x
     gen_near = NeighborGenerator(llgen,0,1);
     gen_cw   = llgen;
     gen_ccw  = NeighborGenerator(llgen,1,1);
     break;
   case 3:
     // nearest was +x,+y
     gen_near = NeighborGenerator(llgen,1,1);
     gen_cw   = NeighborGenerator(llgen,0,1);
     gen_ccw  = NeighborGenerator(llgen,1,0);
     break;
   default:
     MSG("Bfld",Msg::kFatal) <<
       "BfldMeshRect2d.cxx::Pick3Generators sval " << sval << endl;
     gen_near = llgen;
     gen_cw   = NeighborGenerator(llgen,1,0);
     gen_ccw  = NeighborGenerator(llgen,0,1);
     break;
   }


   Int_t generator = NeighborGenerator(llgen,dnx,dny);
   if (generator < 0) generator = llgen;


}

//_____________________________________________________________________________
void BfldMeshRect2d::Pick4Generators(Float_t x, Float_t y,
                                     Int_t& gen_ll, Int_t& gen_lr,
                                     Int_t& gen_ur, Int_t& gen_ul)
{
  // return the generator (indx) that surround this point

   if ( fQuadrant ) {
      // symmetry case -- assume quadrant symmetry
      x = TMath::Abs(x);
      y = TMath::Abs(y);
   }

   gen_ll = LowerLeftGenerator(x,y);
   gen_lr = NeighborGenerator(gen_ll,1,0);
   gen_ur = NeighborGenerator(gen_ll,1,1);
   gen_ul = NeighborGenerator(gen_ll,0,1);

}

//_____________________________________________________________________________
void BfldMeshRect2d::GeneratorToXY(Int_t generator, Float_t &x, Float_t &y)
{
   // return the TVector3 associated with a generator (mesh node)

   // BfldMeshRect2d doesn't hold actual positions

   Int_t ix,iy;
   GeneratorToIndices(generator,ix,iy);

   x = ix * fDx + fX0;
   y = iy * fDy + fY0;
   
}

//_____________________________________________________________________________
Int_t BfldMeshRect2d::IndicesToGenerator(Int_t ix, Int_t iy)
{
   // return the generator (indx) based on x-y indices

   return ix*fNy + iy;
}

//_____________________________________________________________________________
void BfldMeshRect2d::GeneratorToIndices(Int_t gen, Int_t &ix, Int_t &iy)
{
   // return the x-y indices base on generator number

   // composed via ix*fNy + iy;

   ix = gen/fNy;
   iy = gen%fNy;

}

//_____________________________________________________________________________
Int_t BfldMeshRect2d::NearestGenerator(Float_t x, Float_t y)
{
   // return the generator (indx) associated with the (x,y) position

   if ( fQuadrant ) {
      // symmetry case -- assume quadrant symmetry
      x = TMath::Abs(x);
      y = TMath::Abs(y);
   }

   Float_t xx = (x - fX0) / fDx;
   Float_t yy = (y - fY0) / fDy;

   // Nearest generator use Nint (while LowerLeft means taking the floor first)
   Int_t ix = TMath::Nint(xx);
   Int_t iy = TMath::Nint(yy);

   ix = TMath::Min(ix,fNx-1);
   iy = TMath::Min(iy,fNy-1);

   ix = TMath::Max(ix,0);
   iy = TMath::Max(iy,0);

   return IndicesToGenerator(ix,iy);
}

//_____________________________________________________________________________
Int_t BfldMeshRect2d::NearestGenerator(TVector3 xyz)
{
   // return the generator (indx) associated with the (x,y) position

   return NearestGenerator(xyz.X(),xyz.Y());
}

//_____________________________________________________________________________
Int_t BfldMeshRect2d::LowerLeftGenerator(Float_t x, Float_t y)
{
   // return the generator (indx) associated with the (x,y) position

   if ( fQuadrant ) {
      // symmetry case -- assume quadrant symmetry
      x = TMath::Abs(x);
      y = TMath::Abs(y);
   }

   Float_t xx = (x - fX0) / fDx;
   Float_t yy = (y - fY0) / fDy;

   // Lower Left means taking the floor first, not just the nearest integer
   Int_t ix = TMath::Nint(floor(xx));
   Int_t iy = TMath::Nint(floor(yy));

   ix = TMath::Min(ix,fNx-1);
   iy = TMath::Min(iy,fNy-1);

   ix = TMath::Max(ix,0);
   iy = TMath::Max(iy,0);

   return IndicesToGenerator(ix,iy);
}

//_____________________________________________________________________________
Int_t BfldMeshRect2d::LowerLeftGenerator(TVector3 xyz)
{
   // return the generator (indx) associated with the (x,y) position

   return LowerLeftGenerator(xyz.X(),xyz.Y());
}

//_____________________________________________________________________________
Int_t BfldMeshRect2d::NeighborGenerator(Int_t gen, Int_t dnx, Int_t dny)
{
   // return the generator (indx) which is a neighbor to the input one
   // return -1 if no such index

   Int_t ix = 0;
   Int_t iy = 0;

   GeneratorToIndices(gen,ix,iy);

   ix = ix + dnx;
   iy = iy + dny;

   if (ix<0 || ix>=fNx) return -1;
   if (iy<0 || iy>=fNy) return -1;

   return IndicesToGenerator(ix,iy);

}

//_____________________________________________________________________________

---