CMSSW_4_4_3_patch1/src/FastSimulation/ParticlePropagator/src/MagneticFieldMap.cc

Go to the documentation of this file.

#include "MagneticField/Engine/interface/MagneticField.h"
#include "FastSimulation/ParticlePropagator/interface/MagneticFieldMap.h"
#include "FastSimulation/TrackerSetup/interface/TrackerInteractionGeometry.h"

#include <iostream>

MagneticFieldMap::MagneticFieldMap(const MagneticField* pMF,
                                   const TrackerInteractionGeometry* myGeo) : 
  pMF_(pMF), 
  geometry_(myGeo),
  bins(101), 
  fieldBarrelHistos(200,static_cast<std::vector<double> >
                    (std::vector<double>(bins,static_cast<double>(0.)))),
  fieldEndcapHistos(200,static_cast<std::vector<double> > 
                     (std::vector<double>(bins,static_cast<double>(0.)))),
  fieldBarrelBinWidth(200,static_cast<double>(0.)),
  fieldBarrelZMin(200,static_cast<double>(0.)),
  fieldEndcapBinWidth(200,static_cast<double>(0.)),
  fieldEndcapRMin(200,static_cast<double>(0.))

{
  
  std::list<TrackerLayer>::const_iterator cyliter;
  std::list<TrackerLayer>::const_iterator cylitBeg=geometry_->cylinderBegin();
  std::list<TrackerLayer>::const_iterator cylitEnd=geometry_->cylinderEnd();
  
  // Prepare the histograms
  // std::cout << "Prepare magnetic field local database for FAMOS speed-up" << std::endl;
  for ( cyliter=cylitBeg; cyliter != cylitEnd; ++cyliter ) {
    int layer = cyliter->layerNumber();
    //    cout << " Fill Histogram " << hist << endl;

    // Cylinder bounds
    double zmin = 0.;
    double zmax; 
    double rmin = 0.;
    double rmax; 
    if ( cyliter->forward() ) {
      zmax = cyliter->disk()->position().z();
      rmax = cyliter->disk()->outerRadius();
    } else {
      zmax = cyliter->cylinder()->bounds().length()/2.;
      rmax = cyliter->cylinder()->bounds().width()/2.
           - cyliter->cylinder()->bounds().thickness()/2.;
    }

    // Histograms
    double step;

    // Disk histogram characteristics
    step = (rmax-rmin)/(bins-1);
    fieldEndcapBinWidth[layer] = step;
    fieldEndcapRMin[layer] = rmin;

    // Fill the histo
    int endcapBin = 0;
    for ( double radius=rmin+step/2.; radius<rmax+step; radius+=step ) {
      double field = inTeslaZ(GlobalPoint(radius,0.,zmax));
      fieldEndcapHistos[layer][endcapBin++] = field;
    }

    // Barrel Histogram characteritics
    step = (zmax-zmin)/(bins-1);
    fieldBarrelBinWidth[layer] = step;
    fieldBarrelZMin[layer] = zmin;

    // Fill the histo
    int barrelBin = 0;
    for ( double zed=zmin+step/2.; zed<zmax+step; zed+=step ) {
      double field = inTeslaZ(GlobalPoint(rmax,0.,zed));
      fieldBarrelHistos[layer][barrelBin++] = field;
    }
  }
}


const GlobalVector
MagneticFieldMap::inTesla( const GlobalPoint& gp) const {

  if (!pMF_) {
    return GlobalVector( 0., 0., 4.);
  } else {
    return pMF_->inTesla(gp);
  }

}

const GlobalVector
MagneticFieldMap::inTesla(const TrackerLayer& aLayer, double coord, int success) const {

  if (!pMF_) {
    return GlobalVector( 0., 0., 4.);
  } else {
    return GlobalVector(0.,0.,inTeslaZ(aLayer,coord,success));
  }

}

const GlobalVector 
MagneticFieldMap::inKGauss( const GlobalPoint& gp) const {
  
  return inTesla(gp) * 10.;

}

const GlobalVector
MagneticFieldMap::inInverseGeV( const GlobalPoint& gp) const {
  
  return inKGauss(gp) * 2.99792458e-4;

} 

double 
MagneticFieldMap::inTeslaZ(const GlobalPoint& gp) const {

    return pMF_ ? pMF_->inTesla(gp).z() : 4.0;

}

double
MagneticFieldMap::inTeslaZ(const TrackerLayer& aLayer, double coord, int success) const 
{

  if (!pMF_) {
    return 4.;
  } else {
    // Find the relevant histo
    double theBinWidth;
    double theXMin;
    unsigned layer = aLayer.layerNumber();
    const std::vector<double>* theHisto;

    if ( success == 1 ) { 
      theHisto = theFieldBarrelHisto(layer);
      theBinWidth = fieldBarrelBinWidth[layer];
      theXMin = fieldBarrelZMin[layer];
    } else {
      theHisto = theFieldEndcapHisto(layer);
      theBinWidth = fieldEndcapBinWidth[layer];
      theXMin = fieldEndcapRMin[layer];
    }
    
    // Find the relevant bin
    double x = fabs(coord);
    unsigned bin = (unsigned) ((x-theXMin)/theBinWidth);
    if ( bin+1 == (unsigned)bins ) bin -= 1; // Add a protection against coordinates near the layer edge
    double x1 = theXMin + (bin-0.5)*theBinWidth;
    double x2 = x1+theBinWidth;      

    // Determine the field
    double field1 = (*theHisto)[bin];
    double field2 = (*theHisto)[bin+1];

    return field1 + (field2-field1) * (x-x1)/(x2-x1);

  }

}

double 
MagneticFieldMap::inKGaussZ(const GlobalPoint& gp) const {

    return inTeslaZ(gp)/10.;

}

double 
MagneticFieldMap::inInverseGeVZ(const GlobalPoint& gp) const {

   return inKGaussZ(gp) * 2.99792458e-4;

}