FPTracker Namespace Reference

Classes
class	Beamline
class	Collimator
class	CollimatorData
class	ConfigData
class	DipoleBender
class	EmptySpaceElement
class	FPTrackerConstants
class	IBeamElement
class	IBender
class	IJunkElement
class	IParticle
class	IQuadFocuser
class	LineFormater
class	Magnet
struct	MagnetData
class	NullBender
class	Particle
class	ParticleTracker
class	Plane
class	Point
class	QuadFocuserHorizontal
class	QuadFocuserNull
class	QuadFocuserVertical
class	QuadrupoleBender
class	SelectBySide
class	SolenoidElement
class	Stringer
class	TransversePoint
class	ValueSetter
class	zPosNextElement

Enumerations
enum	Bendplane { hBendplane =0 , vBendplane =1 }
enum	Side { beam1 = 1 , beam2 = 0 }

Functions
std::ostream &	operator<< (std::ostream &os, const Beamline &bl)
TransversePoint	beamlineXPosition (double z)
std::ostream &	operator<< (std::ostream &, const Collimator &)
std::ostream &	operator<< (std::ostream &, const CollimatorData &)
Collimator::Container_t	collSet (const CollimatorData &, Side)
std::ostream &	operator<< (std::ostream &, const ConfigData &)
template<class Array1D>
std::string	array1DToString (const Array1D &arr)
template<class Array2D>
std::string	array2DToString (const Array2D &arr)
template<class Array3D>
std::string	array3DToString (const Array3D &arr)
std::ostream &	operator<< (std::ostream &, const Side &side)
std::shared_ptr< std::ifstream >	getAlfaMagnetConfigFiles (const std::string &dir, const Side &side)
std::shared_ptr< std::ifstream >	getConfigFile (const std::string &dir, const std::string &fn)
std::shared_ptr< std::ifstream >	getMagnetConfigFiles (const std::string &dir, int IP, int magVer, const Side &side)
std::ostream &	operator<< (std::ostream &, const IBeamElement &)
std::ostream &	operator<< (std::ostream &, const IParticle &)
void	junkCaller (int sideSelector)
std::ostream &	operator<< (std::ostream &, const Magnet &)
std::ostream &	operator<< (std::ostream &, const MagnetData &)
Magnet::Ptr_t	magnetFactory (double x, double y, double center, double strength, double length, int apertype, double A1, double A2, double A3, double A4, double X, double pbeam0, Side side, Magnet::Type type)
Magnet::Container_t	magnetSet (const ConfigData &, const Side &side, int magversion, std::shared_ptr< std::ifstream > magfile)
double	magnetStrength (int type, double length, double strength, double Brho)
std::ostream &	operator<< (std::ostream &, const Plane &)
Point	operator+ (const Point &lhs, const Point &rhs)
Point	operator- (const Point &lhs, const Point &rhs)
Point	operator+ (const Point &lhs, const TransversePoint &rhs)
Point	operator- (const Point &lhs, const TransversePoint &rhs)
Point	operator* (double, const Point &lhs)
std::ostream &	operator<< (std::ostream &, const Point &)
template<class Container>
void	printCont (const Container &arr, int perline, int nele)
bool	readConfigData (std::shared_ptr< std::ifstream > confDir, ConfigData &)
Beamline	setupBeamline (const ConfigData &, const Side &, int magver, std::shared_ptr< std::ifstream >)
template<class PtrType>
bool	absZGreater (const PtrType rhs, const PtrType lhs)
TransversePoint	operator+ (const TransversePoint &lhs, const TransversePoint &rhs)
TransversePoint	operator- (const TransversePoint &lhs, const TransversePoint &rhs)
TransversePoint	operator* (double, const TransversePoint &lhs)
std::ostream &	operator<< (std::ostream &, const TransversePoint &)
bool	isEndMarker (const IBeamElement::ConstPtr_t &p)
IBeamElement::Iter_t	findBeamLineEnd (IBeamElement::Container_t &container)
std::string	fixLabel (const std::string &label)
std::string	determineMagnetConfigFileName (int IP, const Side &side, int magver)
std::string	typeToString (Magnet::Type type)
IQuadFocuser::Ptr_t	quadFocuserFactory (Magnet::Type type)
IBender::ConstPtr_t	benderFactory (Magnet::Type type, double length, double strength, double pbeam0, int side)
double	findIPCentre (int magver, Side side, int ip)

Enumeration Type Documentation

Bendplane

enum FPTracker::Bendplane

Enumerator
hBendplane
vBendplane

Definition at line 11 of file FPTrackerConstants.h.

{hBendplane=0, vBendplane=1};

Side

enum FPTracker::Side

Enumerator
beam1
beam2

Definition at line 12 of file FPTrackerConstants.h.

{beam1 = 1, beam2 = 0};

Function Documentation

absZGreater()

template<class PtrType>

bool FPTracker::absZGreater	(	const PtrType	rhs,
		const PtrType	lhs )

Definition at line 22 of file FPTracker/FPTracker/STLHelpers.h.

    {
      return lhs->zabspos() > rhs->zabspos();
    }

array1DToString()

template<class Array1D>

std::string FPTracker::array1DToString

(

const Array1D &

arr

)

Definition at line 32 of file DataDumperHelpers.h.

                                                 {
    
    std::ostringstream dump;
    LineFormater lf = std::for_each(arr.begin(), arr.end(), LineFormater(10));
    dump<<lf.toString()+'\n';
    return dump.str();
  }

array2DToString()

template<class Array2D>

std::string FPTracker::array2DToString

(

const Array2D &

arr

)

Definition at line 43 of file DataDumperHelpers.h.

                                               {
    
    std::ostringstream dump;
    for(std::size_t is=0; is<arr.size(); ++is){
      dump << "side "<<is<<'\n';
      
      LineFormater lf = std::for_each(arr[is].begin(), arr[is].end(), LineFormater(10));
      dump<<lf.toString()+'\n';
    }
    return dump.str();
  }

array3DToString()

template<class Array3D>

std::string FPTracker::array3DToString

(

const Array3D &

arr

)

Definition at line 56 of file DataDumperHelpers.h.

                                               {
    
    std::ostringstream dump;
    for(std::size_t is=0; is<arr.size(); ++is){
      dump << "side "<<is<<'\n';
      for (std::size_t ig=0; ig<arr[is].size(); ++ig){
 
    dump << "geom "<<ig<<'\n';
    LineFormater lf = std::for_each(arr[is][ig].begin(), arr[is][ig].end(), LineFormater(10));
    dump<<lf.toString()+'\n';
 
      }
    }
    return dump.str();
  }

beamlineXPosition()

TransversePoint FPTracker::beamlineXPosition

(

double

z

)

Definition at line 11 of file beamlineXPosition.cxx.

  {
    if (std::fabs(z)> FPTrackerConstants::zOfBeamSeparation)
      {
    TransversePoint tp(-FPTrackerConstants::xdis, FPTrackerConstants::ydis);
    return tp;
      }
    TransversePoint tp( 0., 0. );
    return tp;
  }

benderFactory()

IBender::ConstPtr_t FPTracker::benderFactory	(	Magnet::Type	type,
		double	length,
		double	strength,
		double	pbeam0,
		int	side )

Definition at line 39 of file magnetFactory.cxx.

  {
    if( type == Magnet::hbDipole )
      {
    return IBender::ConstPtr_t(new DipoleBender(hBendplane, 
                            length, 
                            strength, 
                            pbeam0,
                            side)
                   );
      }
    
    if ( type == Magnet::vbDipole )
      {
    return IBender::ConstPtr_t(new DipoleBender(vBendplane,
                            length,
                            strength,
                            pbeam0,
                            side)
                   );
      }
    
    if ( type == Magnet::hfQuadrupole )
      {
    return IBender::ConstPtr_t( new QuadrupoleBender(quadFocuserFactory(type),
                             length, 
                             strength,
                             side)
                    );
      }
    
    if ( type == Magnet::vfQuadrupole )
      {
    return IBender::ConstPtr_t( new QuadrupoleBender(quadFocuserFactory(type),
                             length,
                             strength,
                             side)
                    );
      }
    
    throw std::logic_error("unknown magnet type");
  }

collSet()

Collimator::Container_t FPTracker::collSet	(	const CollimatorData &	cData,
		Side	side )

Definition at line 12 of file collSet.cxx.

                                                                       {
 
    Collimator::Container_t collimators;
    int ncoll = CollimatorData::ncoll;
    double zsign = side == beam2 ? -1.:1.;
    for(int i =0; i<ncoll; ++i){
 
      double zpos = zsign*cData.coll_z[side][i];
      Collimator::Ptr_t col(new Collimator(zpos,  cData.coll_xap[side][i], side));
      collimators.push_back(std::move(col));
      
    }
 
    std::sort(collimators.begin(), collimators.end(), absZGreater<Collimator::ConstPtr_t>);
    return collimators;
  }

determineMagnetConfigFileName()

std::string FPTracker::determineMagnetConfigFileName	(	int	IP,
		const Side &	side,
		int	magver )

Definition at line 15 of file getMagnetConfigFiles.cxx.

  {
    //  Find twiss magnet configuration files used by P Bussey up until 12/08
 
    bool argsOK = (IP == 1 || IP == 5) && (side == beam1 || side == beam2); 
    if (!argsOK)
      {
    std::stringstream ss;
    ss<<"Legal side arg values = beam1 or beam2, is "<<side<<" Legal IP arg values = 1 or 5, is "<<IP<<'\n';
    
    throw std::runtime_error(ss.str().c_str());
      }
 
    
    if(magver == 1)
      {
    if (side  == beam2){return "twiss_65_b2_old.txt";}
    return "twiss_65_b1_old.txt";
      }
    else
      if ( IP==1 ) 
    {
      if( side==beam2 ) { return "LHCB2IR1_6500";}
      return "LHCB1IR1_6500";
    }
      else
    {
      if( side==beam2 ) { return "LHCB2IR5_6500";}
      return "LHCB1IR5_6500";
    }
    
  }

findBeamLineEnd()

IBeamElement::Iter_t FPTracker::findBeamLineEnd

(

IBeamElement::Container_t &

container

)

Definition at line 22 of file FPTracker/src/Beamline.cxx.

                                                                         {
    IBeamElement::Iter_t ei = find_if(container.begin(),
                      container.end(),
                      isEndMarker
                      );
    
    if (ei != container.end()) ++ei;
    else {
    std::string s("Could not find the end of the beamline.");
    throw std::runtime_error(s);
    }
    return ei;
  }

findIPCentre()

double FPTracker::findIPCentre	(	int	magver,
		Side	side,
		int	ip )

Definition at line 20 of file magnetSet.cxx.

  {
    if ( magver == 1 )
      {
    if ( (side == beam2) && (ip == 1) ) { return 26658.88320;}
    if ( (side == beam2) && (ip == 5) ) { return 13329.593967;}
    if ( (side == beam1) && (ip == 1) ) { return 0.;}
    if ( (side == beam1) && (ip == 5) ) { return 13329.289233;}
    assert(false);
      }
    
    
    
    if ( magver == 2 )
      {
    if ( (side == beam2) && (ip == 1) ) { return 13329.28923;}
    if ( (side == beam2) && (ip == 5) ) { return 13329.59397;}
    if ( (side == beam1) && (ip == 1) ) { return 13329.59397;}
    if ( (side == beam1) && (ip == 5) ) { return 13329.28923;}
    assert(false);
      }    
 
    if ( magver == 3 ) //ALFA, from D Pelikan
      {
    if ( (side == beam2) && (ip == 1) ) { return 0.;}
    if ( (side == beam2) && (ip == 5) ) { return 13329.593967;}
    if ( (side == beam1) && (ip == 1) ) { return 0.;}
    if ( (side == beam1) && (ip == 5) ) { return 13329.289233;}
    assert(false);
      }    
    // check that the argument values are in have expected values
    assert(false);
    
    return 0;
  }

fixLabel()

std::string FPTracker::fixLabel

(

const std::string &

label

)

Definition at line 139 of file FPTracker/src/Beamline.cxx.

                                            {
    std::string s = label;
    std::size_t tsize = 30 - label.size(); 
    if (tsize>0){ s += std::string(tsize, ' ');}
    return s;
  }

getAlfaMagnetConfigFiles()

std::shared_ptr< std::ifstream > FPTracker::getAlfaMagnetConfigFiles	(	const std::string &	dir,
		const Side &	side )

Definition at line 14 of file getAlfaMagnetConfigFiles.cxx.

  {
    std::string fn = (side == beam1) ? "alfaTwiss1.txt":"alfaTwiss2.txt";
    return  getConfigFile( dir, fn );
  }

getConfigFile()

std::shared_ptr< std::ifstream > FPTracker::getConfigFile	(	const std::string &	dir,
		const std::string &	fn )

Definition at line 11 of file getConfigFile.cxx.

  {
    std::ifstream infile;
    std::shared_ptr<std::ifstream> pfile(new std::ifstream);
    FPTracker::openFile(dir, fn, pfile);
    return pfile;
  }

getMagnetConfigFiles()

std::shared_ptr< std::ifstream > FPTracker::getMagnetConfigFiles	(	const std::string &	dir,
		int	IP,
		int	magVer,
		const Side &	side )

Definition at line 51 of file getMagnetConfigFiles.cxx.

  {
    return  getConfigFile( dir, determineMagnetConfigFileName(IP, side, magVer) );
  }

isEndMarker()

bool FPTracker::isEndMarker

(

const IBeamElement::ConstPtr_t &

p

)

Definition at line 20 of file FPTracker/src/Beamline.cxx.

{return p->isEndElement();}

junkCaller()

void FPTracker::junkCaller

(

int

sideSelector

)

magnetFactory()

Magnet::Ptr_t FPTracker::magnetFactory	(	double	x,
		double	y,
		double	center,
		double	strength,
		double	length,
		int	apertype,
		double	A1,
		double	A2,
		double	A3,
		double	A4,
		double	X,
		double	pbeam0,
		Side	side,
		Magnet::Type	type )

Definition at line 87 of file magnetFactory.cxx.

                                   {
    
    IBender::ConstPtr_t bender( benderFactory(type, length, strength, pbeam0, side) );
    std::string label( typeToString(type) );
    
    return Magnet::Ptr_t(new Magnet( x,
                      y, 
                      center, 
                      strength, 
                      length, 
                      apertype, 
                      A1, 
                      A2, 
                      A3, 
                      A4, 
                      X, 
                      side, 
                      bender.get(), 
                      label
                      )
                  );
    
  }

magnetSet()

Magnet::Container_t FPTracker::magnetSet	(	const ConfigData &	cData,
		const Side &	side,
		int	magversion,
		std::shared_ptr< std::ifstream >	magfile )

Definition at line 56 of file magnetSet.cxx.

  {
    //  Coordinate system: take z = forwards, x= to left , y = up.
    //  For quadrupoles, input the quantity K1L.  type = 1,2 if K1L is +,-ve.
    //  Input type = 3 here to let the program decide.
    //  HKICK and VKICK are read and treated as bending magnets. 
    
    
    
    //-------- Arrange to read the magnet data from CERN files.
    //         twiss_b1.txt and twiss_b2.txt for beam 1 and beam 2
    //         beam 2 is on side=0 here and beam 1 is on side=1
    //         Read through the files to pick up the requested magnets.
    
    
    const int&    IP         = cData.IP;
    const double& apermb     = cData.apermb;
    const double& brho       = cData.brho;
    const float& absZMagMax  = cData.absZMagMax;
    
    Magnet::Container_t magnets;
    
    double  centreIP = findIPCentre(magver, side, IP);
    
    std::ifstream& myMags = *magfile;
    
    
    //std::cout<<"Open magnets file for beam "<<ifile<<std::endl; 
    //--- Skip introductory material, indicated by the 1st character of a record.
    while (myMags.peek() =='@' || myMags.peek() =='*' || myMags.peek() =='$')
      {
    myMags.ignore(1000,'\n');
      }
    
    // side 1 == direction to +ve s of IP  == beam 1.
    // NB "dist" is -Delta(s) but magcen, i.e. z,  is then -dist.
    
    while(true)
      { 
    
    double endpos=0, maglength=0, K0L=0, K1L=0, K2L=0, K3L=0, HKICK=0, VKICK=0;
    float  BETX=0,ALFX=0,MUX=0,DX=0,DPX=0,X=0,PX=0,BETY=0,ALFY=0,MUY=0,DY=0,DPY=0,Y=0,PY=0,A1=0,A2=0,A3=0,A4=0;
    
    std::string magname,magsort, basicmag ;
    
    std::string aperture;
    
    if( magver==1 )
      {
      myMags>>magname>>magsort>>endpos>>maglength>>K0L>>K1L>>K2L>>K3L>>HKICK>>VKICK
        >>BETX>>ALFX>>MUX>>DX>>DPX>>X>>PX>>BETY>>ALFY>>MUY>>DY>>DPY>>Y>>PY
        >>aperture>>A1>>A2>>A3>>A4;
      }
    else if( magver==2 or magver==3 )
      {
        myMags>>magname>>magsort>>basicmag>>endpos>>maglength>>HKICK>>VKICK>>K0L
          >>K1L>>K2L>>K3L>>X>>Y>>PX>>PY>>BETX>>BETY>>ALFX>>ALFY
          >>MUX>>MUY>>DX>>DY>>DPX>>DPY>>aperture>>A1>>A2>>A3>>A4;
      }
    else
      {
        assert(false);
      }
    
    if(magver==1)
      {       // Some more fudges to give more precision
        if(std::fabs(K0L)==0.000188) K0L=K0L*188.175/188.0  ;   
        if(std::fabs(K0L)==0.001129) K0L=K0L*1129.049/1129. ;   
        if(std::fabs(K1L)==0.055577) K0L=K0L*55576.561/55577. ; 
        if(std::fabs(K1L)==0.047986) K0L=K0L*47986.041/47986. ;
        if(std::fabs(VKICK)==0.00020) VKICK=VKICK*20.171/20. ; 
        if(std::fabs(VKICK)==0.00019) VKICK=VKICK*19.17/19. ; 
      }
    
    double dist = centreIP - endpos + 0.5*maglength ;
    
    float adist=std::fabs(dist) ;
 
    // decide how to progress down the magnet files
    // the file formats are not constant. first
    // consider the magver=1 or 2 (these are two formats used by AFP.
    if ( magver == 1 or magver == 2 )
      {
        if (side == beam1)
          {
        if( dist > 0.          ) {continue;}
        if( adist > absZMagMax ) {break;}
          }
        else
          {
        if( adist > absZMagMax ) {continue;}
        if ( dist <=  0.       ) {break;}
          }
      }
    else if( magver == 3 ) //ALFA. from D. Pelikan
      {
        if( dist > 0.          ) {continue;}
        if( adist > absZMagMax ) {break;}
      }
 
    Magnet::Type mmagtype    = Magnet::notAMagnet;  
    double magstrength = 0;
    if (K0L != 0.)  
      { 
        mmagtype     =  Magnet::hbDipole; //type = 0
        magstrength =  K0L;
        if(side == beam2)
          {
        magstrength = -magstrength;
          }
        
      } 
    else if(K1L != 0.)
      {
        magstrength              =  K1L;
        mmagtype = magstrength >= 0 ? Magnet::hfQuadrupole:Magnet::vfQuadrupole;  // type = 3 ->1,2 
        assert(maglength > 0.);
        magstrength  = std::fabs(brho*magstrength/maglength);
      } 
    else if(HKICK != 0.)
      { 
        mmagtype                  = Magnet::hbDipole;  // type = 0
        magstrength              =  -HKICK;
      } 
    else if(VKICK != 0.)
      { 
        mmagtype                  = Magnet::vbDipole;  // type = 4
        magstrength              =  VKICK;
      } 
    
    if(mmagtype == Magnet::notAMagnet)  {continue;}  // --(not a magnet) 
    
    
    double mmagcen          = -dist;
 
 
    // more differences between AFP and ALFA files (from D. Pelikan)
    if (magver == 3)
      {
        if (side == beam2 ){ mmagcen = dist; }
 
      }
    
 
    int mmagapertype = 0;
    // CLassify apertures.
    if(aperture == "\"NONE\"") 
      {
        mmagapertype              = 0;
      } 
    else if(aperture == "\"CIRCLE\"" && A1 == 0.) 
      {
        mmagapertype              =0;
      } 
    else if(aperture == "\"CIRCLE\"" && A1 >  0.)
      {
        mmagapertype              =1;
      } 
    else if(aperture == "\"RECTELLIPSE\"") 
      {
        mmagapertype              =2;
      } 
    else if(aperture == "\"OCTAGON\"") 
      {
        mmagapertype              =3;
      } 
    else 
      {
          throw std::runtime_error(" Unknown magnet aperture type "+aperture+"\n");
      }
    
    
    if(apermb > 0)
      {      // -------alter the MB apertures
        int pos = magname.find("MB.");
        if(pos==1)
          { 
        A3=apermb; A4=apermb; 
          }
      }
    
    // note the sign convention for xdis. This shift of the magnet
    // x location accounts for the splitting of the beams somewhere
    // around 155. m. The x coordinate is wrt to beamline position,
    // and not the magnet center.
    double mmagnet_x  = beamlineXPosition(mmagcen)[0];
    double mmagnet_y  = beamlineXPosition(mmagcen)[1];
    
    Magnet::Ptr_t mptr = magnetFactory(mmagnet_x,
                        mmagnet_y,
                        mmagcen,
                        magstrength,
                        maglength,
                        mmagapertype,
                        A1,
                        A2,
                        A3,
                        A4,
                        X,
                        cData.pbeam0,
                        side,
                        mmagtype);
    magnets.push_back(std::move(mptr));
    }
    std::sort(magnets.begin(), magnets.end(), absZGreater< Magnet::ConstPtr_t >);
    return magnets;
  }

magnetStrength()

double FPTracker::magnetStrength	(	int	type,
		double	length,
		double	strength,
		double	Brho )

Definition at line 8 of file magnetStrength.cxx.

                                                                                { 
    // calculate qpole gradient from formula g = K1L brho /L
    //                                           K1L from CERN database
    //                                           brho = 23349. = 3.345*7000 - now pbeam0/speedOflight (12//11/09)
    //                                           L = mag length
    
    assert(type>=0 and type<5);
 
    if(type==0 || type==4) return strength;  
    strength = brho*strength/length;
 
    if (type == 1){ return  strength;}
    if (type == 2){ return -strength;}
    //itype == 3 only remains....
    return strength >=0. ? strength:-strength;
    
    // strength = bend angle for dipoles, -> gradient for quadrupoles
     // type = 0 for dipole,
     //        1 for hor focussing qpoles,
     //        2 for vert focussing qpoles.
  }

operator*() [1/2]

Point FPTracker::operator*	(	double	scalar,
		const Point &	lhs )

Definition at line 123 of file FPTracker/src/Point.cxx.

                                                      {
    Point p = point;
    return p*=scalar;
  }

operator*() [2/2]

TransversePoint FPTracker::operator*	(	double	scalar,
		const TransversePoint &	lhs )

Definition at line 85 of file FPTracker/src/TransversePoint.cxx.

                                                                          {
    TransversePoint p = point;
    return p*=scalar;
  }

operator+() [1/3]

Point FPTracker::operator+	(	const Point &	lhs,
		const Point &	rhs )

Definition at line 98 of file FPTracker/src/Point.cxx.

                                                     {
    Point point(lhs);
    return point += rhs;
  }

operator+() [2/3]

Point FPTracker::operator+	(	const Point &	lhs,
		const TransversePoint &	rhs )

Definition at line 108 of file FPTracker/src/Point.cxx.

                                                               {
    Point point(lhs);
    return point += rhs;
  }

operator+() [3/3]

TransversePoint FPTracker::operator+	(	const TransversePoint &	lhs,
		const TransversePoint &	rhs )

Definition at line 71 of file FPTracker/src/TransversePoint.cxx.

                                                                                   {
    TransversePoint point(lhs);
    return point += rhs;
  }

operator-() [1/3]

Point FPTracker::operator-	(	const Point &	lhs,
		const Point &	rhs )

Definition at line 103 of file FPTracker/src/Point.cxx.

                                                     {
    Point point(lhs);
    return point -= rhs;
  }

operator-() [2/3]

Point FPTracker::operator-	(	const Point &	lhs,
		const TransversePoint &	rhs )

Definition at line 113 of file FPTracker/src/Point.cxx.

                                                               {
    Point point(lhs);
    return point -= rhs;
  }

operator-() [3/3]

TransversePoint FPTracker::operator-	(	const TransversePoint &	lhs,
		const TransversePoint &	rhs )

Definition at line 76 of file FPTracker/src/TransversePoint.cxx.

                                                                                   {
    TransversePoint point(lhs);
    return point -= rhs;
  }

operator<<() [1/12]

std::ostream & FPTracker::operator<<	(	std::ostream &	os,
		const Collimator &	coll )

Definition at line 88 of file FPTracker/src/Collimator.cxx.

                                                                {
    os<<coll.str();
    return os;
  }

operator<<() [2/12]

std::ostream & FPTracker::operator<<	(	std::ostream &	os,
		const CollimatorData &	cData )

Definition at line 38 of file FPTracker/src/CollimatorData.cxx.

                                                                     {
    os<<cData.toString();
    return os;
  }

operator<<() [3/12]

std::ostream & FPTracker::operator<<	(	std::ostream &	os,
		const ConfigData &	cd )

Definition at line 58 of file FPTracker/src/ConfigData.cxx.

                                                              {
    os<<cd.toString();
    return os;
  }

operator<<() [4/12]

std::ostream & FPTracker::operator<<	(	std::ostream &	os,
		const IBeamElement &	ibe )

Definition at line 10 of file FPTracker/src/IBeamElement.cxx.

  {
    os<<ibe.str();
    return os;
  }

operator<<() [5/12]

std::ostream & FPTracker::operator<<	(	std::ostream &	os,
		const IParticle &	p )

Definition at line 10 of file ForwardDetectors/FPTracker/src/IParticle.cxx.

  {
    os<<p.str();
    return os;
  }

operator<<() [6/12]

std::ostream & FPTracker::operator<<	(	std::ostream &	os,
		const Magnet &	mag )

Definition at line 229 of file FPTracker/src/Magnet.cxx.

                                                           {
    os << mag.str();
    return os;
    }

operator<<() [7/12]

std::ostream & FPTracker::operator<<	(	std::ostream &	os,
		const MagnetData &	md )

Definition at line 75 of file MagnetData.cxx.

                                                              {
    os<<md.toString();
    return os;
  }

operator<<() [8/12]

std::ostream & FPTracker::operator<<	(	std::ostream &	os,
		const Plane &	p )

Definition at line 66 of file FPTracker/src/Plane.cxx.

                                                      {
    os<<p.str();
    return os;
  }

operator<<() [9/12]

std::ostream & FPTracker::operator<<	(	std::ostream &	os,
		const Point &	p )

Definition at line 118 of file FPTracker/src/Point.cxx.

                                                        {
    os<<p.str();
    return os;
  }

operator<<() [10/12]

std::ostream & FPTracker::operator<<	(	std::ostream &	os,
		const Side &	side )

Definition at line 16 of file FPTrackerConstants.cxx.

                                                          {
    std::string label = side == beam1 ? " beam1 ":" beam2 ";
    os << label;
    return os;
  }

operator<<() [11/12]

std::ostream & FPTracker::operator<<	(	std::ostream &	os,
		const TransversePoint &	p )

Definition at line 80 of file FPTracker/src/TransversePoint.cxx.

                                                                  {
    os<<p.str();
    return os;
  }

operator<<() [12/12]

std::ostream & FPTracker::operator<<	(	std::ostream &	os,
		const Beamline &	bl )

Definition at line 163 of file FPTracker/src/Beamline.cxx.

                                                            {
    os<<bl.str()<<std::endl;
    return os;
  }

printCont()

template<class Container>

void FPTracker::printCont	(	const Container &	arr,
		int	perline,
		int	nele )

Definition at line 10 of file printCont.h.

                                                             {
    int  linecount = 0;
    for(int i = 0; i<nele; ++i){
      std::cout<<" "<<arr[i];
      if(++linecount == perline){
    linecount = 0;
    std::cout<<'\n';
      }
    }
    std::cout<<'\n';
 }

quadFocuserFactory()

IQuadFocuser::Ptr_t FPTracker::quadFocuserFactory

(

Magnet::Type

type

)

Definition at line 29 of file magnetFactory.cxx.

  {
    
    if ( type == Magnet::hfQuadrupole ){return IQuadFocuser::Ptr_t(new QuadFocuserHorizontal);}
    if ( type == Magnet::vfQuadrupole ){return IQuadFocuser::Ptr_t(new QuadFocuserVertical);}
      
    throw std::logic_error("bad magnet type for QuadFocuser");
  }

readConfigData()

bool FPTracker::readConfigData	(	std::shared_ptr< std::ifstream >	confDir,
		ConfigData &	configData )

Definition at line 59 of file readConfigData.cxx.

                                                                                   {
    // ConfigData readConfigData(std::string& dir){
    // Read data cards from Data.txt file 
 
    
    std::ifstream& in = *p_mydata;
    std::string    line;
    ValueSetter    vs;
 
    boost::char_separator<char> sep(" \f\t\v");
    typedef boost::tokenizer<boost::char_separator<char> > Tokenizer;
 
    
    std::ostringstream ost;
    while( std::getline(in, line) )
      {
    Tokenizer tok(line, sep);
    std::vector< std::string > tokens(tok.begin(), tok.end());
 
    if ( tokens.size() > 1 )
      {
        ost<<tokens[0]<<" "<<tokens[1]<<'\n';
        std::string& dataname = tokens[0];
        std::string& svalue   = tokens[1];
        if(dataname == "IP"  ) vs.setValue(configData.IP,         svalue);
        if(dataname == "APER") vs.setValue(configData.useaper,    svalue);
        if(dataname == "MBAP") vs.setValue(configData.apermb,     svalue);
        if(dataname == "COL1") vs.setValue(configData.xcol1,      svalue);
        if(dataname == "COL2") vs.setValue(configData.xcol2,      svalue);
        if(dataname == "ZMAX") vs.setValue(configData.absZMagMax, svalue);
        if(dataname == "ENDM") vs.setValue(configData.endMarker,  svalue);
 
        if(dataname == "PBEA") {
          float pbeam;
          if ( vs.setValue(pbeam, svalue) ){configData.setpbeam(pbeam);}
        }
        
 
      }
    
      }
 
    return !vs.errors();
  }

setupBeamline()

Beamline FPTracker::setupBeamline	(	const ConfigData &	configData,
		const Side &	side,
		int	magver,
		std::shared_ptr< std::ifstream >	magfile )

Definition at line 25 of file setupBeamline.cxx.

  {
    
    Magnet::Container_t   magnets    = magnetSet(configData, side, magver, std::move(magfile));
    Plane::Ptr_t          endPlane( new Plane(configData.endMarker, side) );
    CollimatorData  collimatorData(configData);
    Collimator::Container_t collimators = collSet(collimatorData, side);
 
    IBeamElement::List_t elements;
    //elements.reserve( 2*(magnets.size()+collimators.size()+planes.size()) );
    elements.assign(magnets.begin(), magnets.end());
    elements.push_back(std::move(endPlane));
    elements.insert(elements.end(), collimators.begin(), collimators.end());
    elements.sort(absZGreater< IBeamElement::ConstPtr_t >);
 
 
    IBeamElement::ListIter_t current  = elements.begin();
    IBeamElement::ListIter_t last     = elements.end();
 
    elements.push_front
      (
       EmptySpaceElement::Ptr_t(
                     new EmptySpaceElement( 
                               0., 
                               (*current)->frontFace(),
                               beamlineXPosition(0.),
                               (*current)->side()
                               ) 
                     )
       );
    ++current;
 
    for(; current != last; ++current){
      IBeamElement::ListIter_t previous = current;
      --previous;
      elements.insert(current, 
              EmptySpaceElement::Ptr_t(
                            new  EmptySpaceElement(
                                       *previous, 
                                       *current
                                       )
                            )
              );
    }
      
    Beamline beamline(elements.begin(), elements.end());
 
    double pbeam = configData.pbeam0;
    std::shared_ptr<IParticle> ip = (side ==  beam1) ? 
      std::shared_ptr<IParticle>(new Particle(0., 0., 0., 0., 0.,     pbeam) ):
      std::shared_ptr<IParticle>(new Particle(0., 0., 0., 0., 0., -1.*pbeam) );
    beamline.calibrate( *ip );
 
 
    return beamline;
  }

typeToString()

std::string FPTracker::typeToString

(

Magnet::Type

type

)

Definition at line 20 of file magnetFactory.cxx.

  {
    if ( type == Magnet::hbDipole )    { return "hbDipole"; }
    if ( type == Magnet::vbDipole )    { return "vbDipole"; }
    if ( type == Magnet::hfQuadrupole ){ return "hfQuad";   }
    if ( type == Magnet::vfQuadrupole) { return "vfQuad";   }
    throw std::logic_error("unknown magnet type");
  }