CDCGeometryPar Class Reference

The Class for CDC Geometry Parameters. More...

#include <CDCGeometryPar.h>

Public Types
enum	EWirePosition {   c_Base = 0 ,   c_Misaligned ,   c_Aligned }
	Wire position set. More...

Public Member Functions
virtual	~CDCGeometryPar ()
	Destructor.
void	clear ()
	Clears.
void	Print () const
	Print some debug information.
void	readFromDB (const CDCGeometry &)
	Gets geometry parameters from database.
void	readWirePositionParams (EWirePosition set, const CDCGeometry *geom)
	Read displacement or (mis)alignment params from text file.
void	setWirPosAlignParams ()
	Set wire alignment params.
void	setWirPosMisalignParams ()
	Set wire misalignment params.
void	readXT (const GearDir &gbxParams, int mode=0)
	Read XT-relation table.
void	newReadXT (const GearDir &gbxParams, int mode=0)
	Read XT-relation table in new format.
void	setXT ()
	Set XT-relation table (from DB).
void	setXtRel ()
	Set XT-relation table (from DB) (new).
void	readSigma (const GearDir &gbxParams, int mode=0)
	Read spatial resolution table.
void	newReadSigma (const GearDir &gbxParams, int mode=0)
	Read spatial resolution table in new format.
void	readFFactor (const GearDir &gbxParams, int mode=0)
	Read fudge factors.
void	setSResol ()
	Set spatial resolution (from DB).
void	setFFactor ()
	Set fudge factors (from DB).
void	readPropSpeed (const GearDir &gbxParams, int mode=0)
	Read the propagation speed along the sense wire.
void	setPropSpeed ()
	Set prop.
void	readT0 (const GearDir &gbxParams, int mode=0)
	Read t0 parameters (from a file).
void	setT0 ()
	Set t0 parameters (from DB)
void	calcMeanT0 (double minT0=3800, double maxT0=5800, int maxIt=10, double nStdv=3, double epsi=0.1)
	Calculate mean t0 in ns (over all good wires)
void	setBadWire ()
	Set bad-wires (from DB)
void	readChMap ()
	Read channel map between wire-id and electronics-id.
void	setChMap ()
	Set channel map (from DB)
void	readTW (const GearDir &gbxParams, int mode=0)
	Read time-walk parameter.
void	readEDepToADC (const GearDir &gbxParams, int mode=0)
	Read spatial edep-to-adc conv.
void	setTW ()
	Set time-walk parameters.
void	setEDepToADCConversions ()
	Set edep-to-ADC conversion params.
double	getEDepToADCConvFactor (unsigned short layer, unsigned short cell, double edep, double dx, double costh)
	Return edep-to-ADC conversion factor.
double	getEDepToADCMainFactor (unsigned short layer, unsigned short cell, double costh=0)
	Return edep-to-ADC conversion main factor (in count/keV)
double	getEDepToADCSigma (unsigned short layer, unsigned short cell)
	Return sigma for extra smearing of edep to ADC conversion.
void	generateXML (const std::string &of)
	Generate an xml file used in gearbox.
std::string	version () const
	Returns the version of cdc geometry parameters.
double	motherInnerR () const
	The method to get cdc mother volume inner R.
double	motherOuterR () const
	The method to get cdc mother volume outer R.
double	motherLength () const
	The method to get cdc mother volume length.
int	momBound () const
	to get the number of boundary position of the CDC mother volume
double	momZ (int iBound) const
	Returns boundary position in Z axis of the CDC mother volume.
double	momRmin (int iBound) const
	Returns inner radius of the CDC mother volume.
unsigned	cellId (unsigned layerId, const B2Vector3D &position) const
	The method to get cell id based on given layer id and the position.
double	innerRadiusOuterWall () const
	Returns the inner radius of the outer wall.
double	outerRadiusOuterWall () const
	Returns the outer radius of the outer wall.
double	zOuterWall () const
	Returns the length of the outer wall in Z.
double	zOffsetOuterWall () const
	Returns the offset of the outer wall in z direction.
double	innerRadiusInnerWall () const
	Returns the inner radius of the inner wall.
double	outerRadiusInnerWall () const
	Returns the outer radius of the inner wall.
double	zInnerWall () const
	Returns the length of the inner wall in Z.
double	zOffsetInnerWall () const
	Returns the offset of the outer wall in z direction.
double	senseWireDiameter () const
	Returns diameter of the sense wire.
double	fieldWireDiameter () const
	Returns diameter of the field wire.
unsigned	nWireLayers () const
	Returns a number of wire layers.
unsigned	nWiresInLayer (int layerId) const
	Returns wire numbers in a layer.
const double *	innerRadiusWireLayer () const
	Returns an array of inner radius of wire layers.
const double *	outerRadiusWireLayer () const
	Returns an array of outer radius of wire layers.
const double *	zForwardWireLayer () const
	Returns an array of forward z of wire layers.
const double *	zBackwardWireLayer () const
	Returns an array of backward z of wire layers.
double	zOffsetWireLayer (unsigned i) const
	Returns the offset of z of the wire layer i.
double	getMeanT0 () const
	Returns the mean t0 over all wires.
const B2Vector3D	wireForwardPosition (uint layerId, int cellId, EWirePosition set=c_Base) const
	Returns the forward position of the input sense wire.
const B2Vector3D	wireForwardPosition (const WireID &wireID, EWirePosition set=c_Base) const
	The same function but in a different input format.
const B2Vector3D	wireForwardPosition (uint layerId, int cellId, double z, EWirePosition set=c_Base) const
	Returns a virtual forward position corresp. to a tangent to the wire at the input z-position.
const B2Vector3D	wireForwardPosition (const WireID &wireID, double z, EWirePosition set=c_Base) const
	The same function but in a different input format.
const B2Vector3D	wireBackwardPosition (uint layerId, int cellId, EWirePosition set=c_Base) const
	Returns the backward position of the input sense wire.
const B2Vector3D	wireBackwardPosition (const WireID &wireID, EWirePosition set=c_Base) const
	The same function but in a different input format.
const B2Vector3D	wireBackwardPosition (uint layerId, int cellId, double z, EWirePosition set=c_Base) const
	Returns a virtual backward position corresp. to a tangent to the wire at the input z-position.
const B2Vector3D	wireBackwardPosition (const WireID &wireID, double z, EWirePosition set=c_Base) const
	The same function but in a different input format.
double	getWireSagCoef (EWirePosition set, uint layerId, int cellId) const
	Returns coefficient for the sense wire sag.
double	getThresholdEnerguDeposit () const
	Returns threshold for energy deposit in one G4 step.
double	getMinTrackLength () const
	Returns the minimum track length required in one G4 step (only secondary particles which pass this criterion are to be saved in MCParticle)
bool	isWireSagOn () const
	Returns on/off for sense wire sag in FullSim.
bool	isModifiedLeftRightFlagOn () const
	Returns on/off for modified left/right calculation in FullSim.
float	getT0 (const WireID &wireID) const
	Returns t0 parameter of the specified sense wire.
unsigned short	getBoardID (const WireID &wID) const
	Returns frontend board id. corresponding to the wire id.
unsigned short	getChannelID (const WireID &wID) const
	Returns frontend channel id. corresponding to the wire id.
const WireID	getWireID (unsigned short bd, unsigned short ch) const
	Returns wire id. corresponding to the board-and-cannel ids.
double	getTimeWalk (const WireID &wID, unsigned short adcCount) const
	Returns time-walk.
void	setShiftInSuperLayer ()
	Calculates and saves shifts in super-layers (to be used in searching hits in neighboring cells)
signed short	getShiftInSuperLayer (unsigned short iSuperLayer, unsigned short iLayer) const
	Returns shift in the super-layer.
double	senseWireR (int layerId) const
	Returns radius of sense wire in each layer.
double	senseWireFZ (int layerId) const
	Returns forward z position of sense wire in each layer.
double	senseWireBZ (int layerId) const
	Returns backward z position of sense wire in each layer.
double	fieldWireR (int layerId) const
	Returns radius of field wire in each layer.
double	fieldWireFZ (int layerId) const
	Returns forward z position of field wire in each layer.
double	fieldWireBZ (int layerId) const
	Returns backward z position of field wire in each layer.
int	nShifts (int layerId) const
	Returns number shift.
double	offset (int layerID) const
	Return wire offset in phi direction at endplate.
void	setSenseWireR (int layerId, double r)
	Set radius of sense wire in each layer.
void	setSenseWireFZ (int layerId, double fz)
	Set forward z position of sense wires.
void	setSenseWireBZ (int layerId, double bz)
	set backward z position of sense wires.
unsigned short	getTdcOffset () const
	Return TDC offset value (default = 0 ch).
double	getTdcBinWidth () const
	Return TDC bin width (nsec).
double	getNominalDriftV () const
	Return the nominal drift velocity of He-ethane gas (default: 4.0x10^-3 cm/nsec).
double	getNominalPropSpeed () const
	Return the nominal propagation speed of the sense wire (default: 27.25 cm/nsec).
double	getNominalSpaceResol () const
	Return the nominal spatial resolution.
int	getMaterialDefinitionMode () const
	Return mode for material definition.
int	getSenseWireZposMode () const
	Return mode for sense wire z position.
double	getBwdDeltaZ (unsigned short layerID) const
	Return backward 'deltaZ'.
double	getFwdDeltaZ (unsigned short layerID) const
	Return forward 'deltaZ'.
void	setNominalSpaceResol (double resol)
	Set the nominal spatial resolution in the unit of um.
double	getPropSpeedInv (const unsigned int layerID) const
	Get the inversel of propagation speed in the sense wire.
bool	isBadWire (const WireID &wid)
	Inquire if the wire is totally-dead.
bool	isDeadWire (const WireID &wid, double &eff)
	Inquire if the wire is dead.
bool	isHotWire (const WireID &wid)
	Inquire if the wire is hot.
void	getWireSagEffect (EWirePosition set, unsigned layerID, unsigned cellID, double zw, double &ywb_sag, double &ywf_sag) const
	Compute effects of the sense wire sag.
double	getDriftV (double dt, unsigned short layer, unsigned short lr, double alpha=0., double theta=0.5 *M_PI) const
	Get the realistic drift velocity.
double	getDriftLength (double dt, unsigned short layer, unsigned short lr, double alpha=0., double theta=0.5 *M_PI, bool calculateMinTime=true, double minTime=0.) const
	Return the drift dength to the sense wire.
double	getDriftLength0 (double dt, unsigned short layer, unsigned short lr, double alpha=0., double theta=0.5 *M_PI) const
	Return the drift dength to the sense wire; tentative ver.
double	getMinDriftTime (unsigned short layer, unsigned short lr, double alpha=0., double theta=0.5 *M_PI) const
	Return the min.
double	getDriftTime (double dist, unsigned short layer, unsigned short lr, double alpha, double theta) const
	Return the drift time to the sense wire.
double	getSigma (double dist, unsigned short layer, unsigned short lr, double alpha=0., double theta=0.5 *M_PI) const
	Return the basic resolution of drift length (cm).
double	getFudgeFactorForSigma (unsigned short target) const
	Return the fuge factor for space resol.
unsigned short	getOldLeftRight (const B2Vector3D &posOnWire, const B2Vector3D &posOnTrack, const B2Vector3D &momentum) const
	Returns old left/right.
unsigned short	getNewLeftRightRaw (const B2Vector3D &posOnWire, const B2Vector3D &posOnTrack, const B2Vector3D &momentum) const
	Returns new left/right_raw.
double	getAlpha (const B2Vector3D &posOnWire, const B2Vector3D &momentum) const
	Returns track incident angle in rphi plane (alpha in rad.).
double	getTheta (const B2Vector3D &momentum) const
	Returns track incident angle (theta in rad.).
unsigned short	getOutgoingLR (const unsigned short lr, const double alpha) const
	Converts incoming-lr to outgoing-lr.
double	getOutgoingAlpha (const double alpha) const
	Converts incoming- to outgoing-alpha.
double	getOutgoingTheta (const double alpha, const double theta) const
	Converts incoming- to outgoing-theta.
void	getClosestAlphaPoints (const double alpha, double &wal, unsigned short points[2], unsigned short lrs[2]) const
	Returns the two closest alpha points for the input track incident angle (alpha).
void	getClosestAlphaPoints4Sgm (const double alpha, double &wal, unsigned short points[2], unsigned short lrs[2]) const
	Returns the two closest alpha points for sigma for the input track incident angle (alpha).
void	getClosestThetaPoints (const double alpha, const double theta, double &wth, unsigned short points[2]) const
	Returns the two closest theta points for the input track incident angle (theta).
void	getClosestThetaPoints4Sgm (const double alpha, const double theta, double &wth, unsigned short points[2]) const
	Returns the two closest theta points for sigma for the input track incident angle (theta).
void	setDesignWirParam (unsigned layerID, unsigned cellID)
	Set the desizend wire parameters.
void	outputDesignWirParam (unsigned layerID, unsigned cellID) const
	Write the designed wire parameters to the alignment.dat (default).
void	setDisplacement ()
	Set displacement of sense wire.
ushort	getNumberOfSenseWires () const
	Get the number of sense wires.
ushort	getNumberOfFieldWires () const
	Get the number of field wires.
ushort	getNumberOfSenseLayers () const
	Get the number of sense layers.
ushort	getNumberOfFieldLayers () const
	Get the number of field layers.
ushort	getMaxNumberOfSuperLayers () const
	Get the maximum number of super layers.
ushort	getOffsetOfFirstLayer () const
	Get the offset of the first layer.
ushort	getOffsetOfFirstSuperLayer () const
	Get the offset of the first super layer.
ushort	getMaxNumberOfCellsPerLayer () const
	Get the maximum number of cells in one layer.

Static Public Member Functions
static CDCGeometryPar &	Instance (const CDCGeometry *=nullptr)
	Static method to get a reference to the CDCGeometryPar instance.

Private Member Functions
	CDCGeometryPar (const CDCGeometry *=nullptr)
	Singleton class.
	CDCGeometryPar (const CDCGeometryPar &)
	Singleton class.
CDCGeometryPar &	operator= (const CDCGeometryPar &)
	Singleton class.

Private Attributes
bool	m_debug
	Switch for debug printing.
bool	m_linearInterpolationOfXT
	Switch for linear interpolation of xt.
bool	m_linearInterpolationOfSgm
	Switch for linear interpolation of sigma.
bool	m_XTetc
	Switch for reading x-t etc.
bool	m_displacement
	Switch for displacement.
bool	m_misalignment
	Switch for misalignment.
bool	m_alignment
	Switch for alignment.
bool	m_XTetc4Recon
	Switch for selecting xt etc.
bool	m_wireSag
	Switch for sense wire sag.
bool	m_modLeftRightFlag
	Switch for modified left/right flag.
std::string	m_version
	The version of geometry parameters.
int	m_materialDefinitionMode
	Control switch for gas and wire material definition.
int	m_senseWireZposMode
	Mode for sense wire z position corr.
int	m_xtFileFormat
	Format of xt input file.
int	m_xtParamMode
	Mode for xt parameterization.
int	m_sigmaFileFormat
	Format of sigma input file.
int	m_sigmaParamMode
	Mode for sigma parameterization.
int	m_twParamMode
	Mode for tw parameterization.
int	m_nSLayer
	The number of sense wire layer.
int	m_nFLayer
	The number of field wire layer.
unsigned short	m_nAlphaPoints
	No.
unsigned short	m_nThetaPoints
	No.
unsigned short	m_nAlphaPoints4Sgm
	No.
unsigned short	m_nThetaPoints4Sgm
	No.
signed short	m_shiftInSuperLayer [c_nSuperLayers][8]
	shift in phi-direction wrt the 1st layer in each super layer
double	m_rWall [4]
	The array to store radius of inner wall and outer wall.
double	m_zWall [4][2]
	The array to store z position of inner wall and outer wall.
double	m_rSLayer [c_maxNSenseLayers]
	The array to store radius of sense wire layers.
double	m_zSForwardLayer [c_maxNSenseLayers]
	The array to store forward z position of sense wire layers.
double	m_dzSForwardLayer [c_maxNSenseLayers]
	Corrections for forward z position of sense wire layers.
double	m_zSBackwardLayer [c_maxNSenseLayers]
	The array to store backward z position of sense wire layers.
double	m_dzSBackwardLayer [c_maxNSenseLayers]
	Corrections for backward z position of sense wire layers.
double	m_rFLayer [c_maxNFieldLayers]
	The array to store radius of field wire layers.
double	m_zFForwardLayer [c_maxNFieldLayers]
	The array to store forward z position of field wire layers.
double	m_zFBackwardLayer [c_maxNFieldLayers]
	The array to store backward z position of field wire layers.
double	m_offSet [c_maxNSenseLayers]
	The array to store z offset of sense wire layers.
double	m_cellSize [c_maxNSenseLayers]
	The array to store cell size in each sense wire layer.
int	m_nShifts [c_maxNSenseLayers]
	The array to store shifted cell number in each sense wire layer.
unsigned	m_nWires [c_maxNSenseLayers]
	The array to store the wire number in each sense wire layre.
double	m_senseWireDiameter
	The diameter of sense wires.
double	m_senseWireTension
	The tension of sense wires.
double	m_senseWireDensity
	The density of sense wires.
double	m_fieldWireDiameter
	The diameter of field wires.
double	m_globalPhiRotation
	Global ratation in phi (rad.); only for sense wires now.
double	m_momZ [7]
	Z-cordinates of the cdc mother volume (7 segments).
double	m_momRmin [7]
	R_min of the cdc mother volume (7 segments).
double	m_thresholdEnergyDeposit
	Energy thresh.
double	m_minTrackLength
	Minimum track length for G4 step.
float	m_FWirPos [c_maxNSenseLayers][c_maxNDriftCells][3]
	Wire position incl.
float	m_BWirPos [c_maxNSenseLayers][c_maxNDriftCells][3]
	Wire position incl.
float	m_WireSagCoef [c_maxNSenseLayers][c_maxNDriftCells]
	Wire sag coefficient for each cell; ibid.
float	m_FWirPosMisalign [c_maxNSenseLayers][c_maxNDriftCells][3]
	Wire position incl.
float	m_BWirPosMisalign [c_maxNSenseLayers][c_maxNDriftCells][3]
	Wire position incl.
float	m_WireSagCoefMisalign [c_maxNSenseLayers][c_maxNDriftCells]
	Wire sag coefficient incl.
float	m_FWirPosAlign [c_maxNSenseLayers][c_maxNDriftCells][3]
	Wire position incl.
float	m_BWirPosAlign [c_maxNSenseLayers][c_maxNDriftCells][3]
	Wire position incl.
float	m_WireSagCoefAlign [c_maxNSenseLayers][c_maxNDriftCells]
	Wire sag coefficient incl.
float	m_eDepToADCParams [c_maxNSenseLayers][c_maxNDriftCells][7] = {}
	edep-to-ADC conv.
float	m_alphaPoints [c_maxNAlphaPoints]
	alpha sampling points for xt (rad)
float	m_thetaPoints [c_maxNThetaPoints]
	theta sampling points for xt (rad)
float	m_alphaPoints4Sgm [c_maxNAlphaPoints]
	alpha sampling points for sigma (rad)
float	m_thetaPoints4Sgm [c_maxNThetaPoints]
	theta sampling points for sigma (rad)
float	m_XT [c_maxNSenseLayers][2][c_maxNAlphaPoints][c_maxNThetaPoints][c_nXTParams]
	XT-relation coefficients for each layer, Left/Right, entrance angle and polar angle.
float	m_Sigma [c_maxNSenseLayers][2][c_maxNAlphaPoints][c_maxNThetaPoints][c_nSigmaParams]
	position resolution for each layer.
float	m_propSpeedInv [c_maxNSenseLayers]
	Inverse of propagation speed of the sense wire.
float	m_t0 [c_maxNSenseLayers][c_maxNDriftCells] = {}
	t0 for each sense-wire (in nsec).
float	m_timeWalkCoef [c_nBoards][2]
	coefficients for time walk.
double	m_meanT0
	mean t0 over all wires; should be double.
std::map< WireID, unsigned short >	m_wireToBoard
	map relating wire-id and board-id.
std::map< WireID, unsigned short >	m_wireToChannel
	map relating wire-id and channel-id.
unsigned short	m_boardAndChannelToWire [c_nBoards][48]
	array relating board-channel-id and wire-id.
unsigned short	m_tdcOffset
	Not used; to be removed later.
double	m_clockFreq4TDC
	Clock frequency used for TDC (GHz).
double	m_tdcBinWidth
	TDC bin width (nsec/bin).
double	m_nominalDriftV
	Nominal drift velocity (4.0x10^-3 cm/nsec).
double	m_nominalDriftVInv
	Inverse of the nominal drift velocity.
double	m_nominalPropSpeed
	Nominal propagation speed of the sense wire (27.25 cm/nsec).
double	m_nominalSpaceResol
	Nominal spatial resolution (0.0130 cm).
double	m_maxSpaceResol
	max space resolution allowed (cm).
double	m_fudgeFactorForSigma [3]
	Fuge factor for space resol.
DBObjPtr< CDCTimeZeros > *	m_t0FromDB
	t0s retrieved from DB.
DBObjPtr< CDCBadWires > *	m_badWireFromDB
	bad-wires retrieved from DB.
DBObjPtr< CDCPropSpeeds > *	m_propSpeedFromDB
	prop.
DBObjPtr< CDCTimeWalks > *	m_timeWalkFromDB
	time-walk coeffs.
DBObjPtr< CDCXtRelations > *	m_xtRelFromDB
	xt params.
DBObjPtr< CDCSpaceResols > *	m_sResolFromDB
	sigma params.
DBObjPtr< CDCFudgeFactorsForSigma > *	m_fFactorFromDB
	fudge factors retrieved from DB.
DBArray< CDCChannelMap > *	m_chMapFromDB
	channel map retrieved from DB.
DBArray< CDCDisplacement > *	m_displacementFromDB
	displacement params.
DBObjPtr< CDCAlignment > *	m_alignmentFromDB
	alignment params.
DBObjPtr< CDCMisalignment > *	m_misalignmentFromDB
	misalignment params.
DBObjPtr< CDCEDepToADCConversions > *	m_eDepToADCConversionsFromDB
	Pointer to edep-to-ADC conv.
DBObjPtr< HardwareClockSettings >	m_clockSettings
	hardware clock settings
ushort	m_nSenseWires = c_nSenseWires
	Maximum number of Sense Wires.
ushort	m_nFieldWires = c_nFieldWires
	Maximum number of Field Wires.
ushort	m_maxNSenseLayers = c_maxNSenseLayers
	Maximum number of Sense Wire Layers.
ushort	m_maxNFieldLayers = c_maxNFieldLayers
	Maximum number of Field Wire Layers.
ushort	m_maxNSuperLayers = c_nSuperLayers
	Maximum number of Super Layers.
ushort	m_firstLayerOffset = 0
	Offset of the first layer (for reduced CDC studies)
ushort	m_firstSuperLayerOffset = 0
	Offset of the first super layer (for reduced CDC studies)
ushort	m_maxNCellsPerLayer = c_maxNDriftCells
	Maximum number wires within a layer.

Static Private Attributes
static CDCGeometryPar *	m_B4CDCGeometryParDB = 0
	Pointer that saves the instance of this class.

Detailed Description

The Class for CDC Geometry Parameters.

This class provides CDC geometry parameters for simulation, reconstruction and so on. These parameters are gotten from gearbox.

Definition at line 51 of file CDCGeometryPar.h.

Member Enumeration Documentation

EWirePosition

enum EWirePosition

Wire position set.

Definition at line 56 of file CDCGeometryPar.h.

{c_Base = 0, c_Misaligned, c_Aligned};

Constructor & Destructor Documentation

~CDCGeometryPar()

~CDCGeometryPar ( )

virtual

Destructor.

Definition at line 142 of file CDCGeometryPar.cc.

{
  //  B2INFO("CDCGeometryPar: destructor called");
  //  if (m_t0FromDB)           delete m_t0FromDB;
  //  if (m_badWireFromDB)      delete m_badWireFromDB;
  //  if (m_propSpeedFromDB)    delete m_propSpeedFromDB;
  //  if (m_timeWalkFromDB)     delete m_timeWalkFromDB;
  //  if (m_xtRelFromDB)        delete m_xtRelFromDB;
  //  if (m_sResolFromDB)       delete m_sResolFromDB;
  //  if (m_chMapFromDB)        delete [] m_chMapFromDB;
  //  if (m_displacementFromDB) delete [] m_displacementFromDB;
  //  if (m_chMapFromDB)        delete m_chMapFromDB;
  //  if (m_displacementFromDB) delete m_displacementFromDB;
  //  if (m_alignmentFromDB)    delete m_alignmentFromDB;
  //  if (m_misalignmentFromDB) delete m_misalignmentFromDB;
  //  B2INFO("CDCGeometryPar: destructor ended");
}

CDCGeometryPar()

CDCGeometryPar ( const CDCGeometry *  geom = nullptr )

private

Singleton class.

Definition at line 38 of file CDCGeometryPar.cc.

{
 
  CDCGeoControlPar& gcp = CDCGeoControlPar::getInstance();
 
  if (gcp.getT0InputType()) {
    m_t0FromDB = new DBObjPtr<CDCTimeZeros>;
    if ((*m_t0FromDB).isValid()) {
      (*m_t0FromDB).addCallback(this, &CDCGeometryPar::setT0);
    }
  }
 
  if (gcp.getBwInputType()) {
    m_badWireFromDB = new DBObjPtr<CDCBadWires>;
    if ((*m_badWireFromDB).isValid()) {
      (*m_badWireFromDB).addCallback(this, &CDCGeometryPar::setBadWire);
    }
  }
 
  if (gcp.getPropSpeedInputType()) {
    m_propSpeedFromDB = new DBObjPtr<CDCPropSpeeds>;
    if ((*m_propSpeedFromDB).isValid()) {
      (*m_propSpeedFromDB).addCallback(this, &CDCGeometryPar::setPropSpeed);
    }
  }
 
  if (gcp.getTwInputType()) {
    m_timeWalkFromDB = new DBObjPtr<CDCTimeWalks>;
    if ((*m_timeWalkFromDB).isValid()) {
      (*m_timeWalkFromDB).addCallback(this, &CDCGeometryPar::setTW);
    }
  }
 
  if (gcp.getXtInputType()) {
    m_xtRelFromDB = new DBObjPtr<CDCXtRelations>;
    if ((*m_xtRelFromDB).isValid()) {
      (*m_xtRelFromDB).addCallback(this, &CDCGeometryPar::setXtRel);
    }
  }
 
  if (gcp.getSigmaInputType()) {
    m_sResolFromDB = new DBObjPtr<CDCSpaceResols>;
    if ((*m_sResolFromDB).isValid()) {
      (*m_sResolFromDB).addCallback(this, &CDCGeometryPar::setSResol);
    }
  }
 
  if (gcp.getFFactorInputType()) {
    m_fFactorFromDB = new DBObjPtr<CDCFudgeFactorsForSigma>;
    if ((*m_fFactorFromDB).isValid()) {
      (*m_fFactorFromDB).addCallback(this, &CDCGeometryPar::setFFactor);
    }
  }
 
  if (gcp.getChMapInputType()) {
    m_chMapFromDB = new DBArray<CDCChannelMap>;
    if ((*m_chMapFromDB).isValid()) {
      (*m_chMapFromDB).addCallback(this, &CDCGeometryPar::setChMap);
    }
  }
 
  if (gcp.getDisplacementInputType()) {
    m_displacementFromDB = new DBArray<CDCDisplacement>;
    if ((*m_displacementFromDB).isValid()) {
      (*m_displacementFromDB).addCallback(this, &CDCGeometryPar::setDisplacement);
    }
  }
 
  if (gcp.getAlignmentInputType()) {
    m_alignmentFromDB = new DBObjPtr<CDCAlignment>;
    if ((*m_alignmentFromDB).isValid()) {
      (*m_alignmentFromDB).addCallback(this, &CDCGeometryPar::setWirPosAlignParams);
    }
  }
 
  if (gcp.getMisalignment()) {
    if (gcp.getMisalignmentInputType()) {
      m_misalignmentFromDB = new DBObjPtr<CDCMisalignment>;
      if ((*m_misalignmentFromDB).isValid()) {
        (*m_misalignmentFromDB).addCallback(this, &CDCGeometryPar::setWirPosMisalignParams);
      }
    }
  }
 
  //TODO in future: make a new (singleton?) class and move all EDepToADC things there.
  if (gcp.getEDepToADCInputType()) {
    m_eDepToADCConversionsFromDB = new OptionalDBObjPtr<CDCEDepToADCConversions>;
    if ((*m_eDepToADCConversionsFromDB).isValid()) {
      (*m_eDepToADCConversionsFromDB).addCallback(this, &CDCGeometryPar::setEDepToADCConversions);
    }
  }
 
  clear();
  if (geom) {
    //    B2INFO("CDCGeometryPar: Read Geometry object");
    readFromDB(*geom);
  } else {
    //    std::cout <<"readcalled" << std::endl;
    //    read();
    //    B2FATAL("CDCGeometryPar: Strange that readFromDB is not called !");
    B2WARNING("CDCGeometryPar: Strange that readFromDB is not called! Please make sure that CDC is included in Geometry.");
  }
}

Member Function Documentation

calcMeanT0()

void calcMeanT0	(	double	minT0 = 3800,
		double	maxT0 = 5800,
		int	maxIt = 10,
		double	nStdv = 3,
		double	epsi = 0.1
	)

Calculate mean t0 in ns (over all good wires)

Parameters

minT0	min. of t0 window (ns)
maxT0	max. of t0 window (ns)
maxIt	max. no. of iterations
nStdv	standard-deviation cut applied for next iteration
epsi	criterion for iteration stop (ns)

Definition at line 1387 of file CDCGeometryPar.cc.

{
  double oldMeanT0 = 0;
  unsigned short it1 = 0;
  for (unsigned short it = 0; it < maxIt; ++it) {
    it1 = it;
    double effiSum = 0.;
    m_meanT0 = 0.;
    double stdvT0 = 0;
    for (unsigned short iCL = 0; iCL < c_maxNSenseLayers; ++iCL) {
      for (unsigned short iW = 0; iW < m_nWires[iCL]; ++iW) {
        if (m_t0[iCL][iW] < minT0 || m_t0[iCL][iW] > maxT0) continue;
        const WireID wid = WireID(iCL, iW);
        if (isHotWire(wid)) continue;
        if (isBadWire(wid)) continue;
        double effi = 1.;
        isDeadWire(wid, effi);
        effiSum += effi;
        m_meanT0 += (iCL < m_firstLayerOffset) ? 0. : effi * m_t0[iCL][iW];
        stdvT0   += (iCL < m_firstLayerOffset) ? 0. : effi * m_t0[iCL][iW] * m_t0[iCL][iW];
      }
    }
    if (effiSum > 0.) {
      m_meanT0 /= effiSum;
      stdvT0   /= effiSum;
      stdvT0 = sqrt(fabs(stdvT0 - m_meanT0 * m_meanT0));
      B2DEBUG(29, it << " " << effiSum << " " << m_meanT0 << " " << stdvT0);
      if (fabs(m_meanT0 - oldMeanT0) < epsi) break;
      oldMeanT0 = m_meanT0;
      minT0 = m_meanT0 - nStdv * stdvT0;
      maxT0 = m_meanT0 + nStdv * stdvT0;
    } else {
      B2FATAL("Wire efficiency sum <= 0!");
    }
  }
  if (it1 == maxIt - 1) B2WARNING("Max. iterations(=" << maxIt << ") needed to calculate the mean t0. Strange.");
}

cellId()

unsigned cellId	(	unsigned	layerId,
		const B2Vector3D &	position
	)		const

The method to get cell id based on given layer id and the position.

Parameters

layerId	The given layer id.
position	The given position to calculate cell id.

Returns

Cell id.

Definition at line 1831 of file CDCGeometryPar.cc.

{
  if (layerId < m_firstLayerOffset) {
    return 0;
  }
 
  const unsigned nWires = m_nWires[layerId];
 
  double offset = m_offSet[layerId];
  //...Offset modification to be aligned to axial at z=0...
  const double phiSize = 2 * M_PI / double(nWires);
  /*{
    const double phiF = phiSize * offset
                        + phiSize * 0.5 * double(m_nShifts[layerId]);
    const double phiB = phiSize * offset;
    const B2Vector3D f(m_rSLayer[layerId] * cos(phiF), m_rSLayer[layerId] * sin(phiF), m_zSForwardLayer[layerId]);
    const B2Vector3D b(m_rSLayer[layerId] * cos(phiB), m_rSLayer[layerId] * sin(phiB), m_zSBackwardLayer[layerId]);
 
    const B2Vector3D v = f - b;
    const B2Vector3D u = v.Unit();
    const double beta = (0 - b.Z()) / u.Z();
    const B2Vector3D p = b + beta * u;
    double phi0 = - atan2(p.Y(), p.X());
    offset += phi0 / (2 * M_PI / double(nWires));
  }*/
 
  unsigned j = 0;
  for (unsigned i = 0; i < 1; ++i) {
    const double phiF = phiSize * (double(i) + offset)
                        + phiSize * 0.5 * double(m_nShifts[layerId]) + m_globalPhiRotation;
    const double phiB = phiSize * (double(i) + offset)   + m_globalPhiRotation;
    const B2Vector3D f(m_rSLayer[layerId] * cos(phiF), m_rSLayer[layerId] * sin(phiF), m_zSForwardLayer[layerId]);
    const B2Vector3D b(m_rSLayer[layerId] * cos(phiB), m_rSLayer[layerId] * sin(phiB), m_zSBackwardLayer[layerId]);
    const B2Vector3D v = f - b;
    const B2Vector3D u = v.Unit();
    const double beta = (position.Z() - b.Z()) / u.Z();
    const B2Vector3D p = b + beta * u;
    double dPhi = std::atan2(position.Y(), position.X())
                  - std::atan2(p.Y(), p.X())
                  + phiSize / 2.;
    while (dPhi < 0) dPhi += (2. * M_PI);
    j = int(dPhi / phiSize);
    while (j >= nWires) j -= nWires;
  }
 
  return j;
}

clear()

void clear

(

)

Clears.

Definition at line 160 of file CDCGeometryPar.cc.

{
  m_version = "unknown";
  m_nSLayer = 0;
  m_nFLayer = 0;
  m_senseWireDiameter = 0.0;
  m_senseWireTension  = 0.0;
  m_senseWireDensity  = 0.0;
  m_fieldWireDiameter = 0.0;
 
  m_tdcOffset         = 0; //not used; to be removed later
  m_clockFreq4TDC     = 0.0;
  m_tdcBinWidth       = 0.0;
  m_nominalDriftV     = 0.0;
  m_nominalPropSpeed  = 0.0;
  m_nominalSpaceResol = 0.0;
 
  for (unsigned i = 0; i < 4; ++i) {
    m_rWall[i] = 0;
    for (unsigned j = 0; j < 2; ++j)
      m_zWall[i][j] = 0;
  }
  for (unsigned i = 0; i < c_maxNSenseLayers; ++i) {
    m_rSLayer[i] = 0;
    m_zSForwardLayer[i] = 0;
    m_dzSForwardLayer[i] = 0;
    m_zSBackwardLayer[i] = 0;
    m_dzSBackwardLayer[i] = 0;
    m_cellSize[i] = 0;
    m_nWires[i] = 0;
    m_offSet[i] = 0;
    m_nShifts[i] = 0;
    m_propSpeedInv[i] = 0.;
  }
  for (unsigned i = 0; i < c_maxNFieldLayers; ++i) {
    m_rFLayer[i] = 0;
    m_zFForwardLayer[i] = 0;
    m_zFBackwardLayer[i] = 0;
  }
 
  for (unsigned L = 0; L < c_maxNSenseLayers; ++L) {
    for (unsigned C = 0; C < c_maxNDriftCells; ++C) {
      for (unsigned i = 0; i < 3; ++i) {
        m_FWirPos        [L][C][i] = 0.;
        m_BWirPos        [L][C][i] = 0.;
        m_FWirPosMisalign[L][C][i] = 0.;
        m_BWirPosMisalign[L][C][i] = 0.;
        m_FWirPosAlign   [L][C][i] = 0.;
        m_BWirPosAlign   [L][C][i] = 0.;
      }
      for (unsigned i = 0; i < 7; ++i) {
        m_eDepToADCParams[L][C][i] = 0.;
      }
      m_WireSagCoef        [L][C] = 0.;
      m_WireSagCoefMisalign[L][C] = 0.;
      m_WireSagCoefAlign   [L][C] = 0.;
      m_t0                 [L][C] = 0.;
    }
  }
 
  for (unsigned L = 0; L < c_maxNSenseLayers; ++L) {
    for (unsigned i = 0; i < 2; ++i) {
      for (unsigned alpha = 0; alpha < c_maxNAlphaPoints; ++alpha) {
        for (unsigned theta = 0; theta < c_maxNThetaPoints; ++theta) {
          for (unsigned xtparam = 0; xtparam < c_nXTParams; ++xtparam) {
            m_XT[L][i][alpha][theta][xtparam] = 0.;
          }
 
          for (unsigned sigmaparam = 0; sigmaparam < c_nSigmaParams; ++sigmaparam) {
            m_Sigma[L][i][alpha][theta][sigmaparam] = 0.;
          }
        }
      }
    }
  }
 
  for (unsigned board = 0; board < c_nBoards; ++board) {
    for (unsigned i = 0; i < 2; ++i) {
      m_timeWalkCoef[board][i] = 0.;
    }
    for (unsigned channel = 0; channel < 48; ++channel) {
      m_boardAndChannelToWire[board][channel] = 0.;
    }
  }
 
  for (unsigned superLayer = 0; superLayer < c_nSuperLayers; ++superLayer) {
    for (unsigned layer = 0; layer < 8; ++layer) {
      m_shiftInSuperLayer[superLayer][layer] = 0;
    }
  }
 
}

fieldWireBZ()

double fieldWireBZ ( int  layerId ) const

inline

Returns backward z position of field wire in each layer.

Parameters

layerId

The layer id of field wires.

Returns

The backward z position of field wire in layer layerId.

Definition at line 1299 of file CDCGeometryPar.h.

    {
      return m_zFBackwardLayer[layerID];
    }

fieldWireDiameter()

double fieldWireDiameter ( ) const

inline

Returns diameter of the field wire.

Returns

Diameter of the field wire.

Definition at line 1349 of file CDCGeometryPar.h.

    {
      return m_fieldWireDiameter;
    }

fieldWireFZ()

double fieldWireFZ ( int  layerId ) const

inline

Returns forward z position of field wire in each layer.

Parameters

layerId

The layer id of field wires.

Returns

The forward z position of field wire in layer layerId.

Definition at line 1294 of file CDCGeometryPar.h.

    {
      return m_zFForwardLayer[layerID];
    }

fieldWireR()

double fieldWireR ( int  layerId ) const

inline

Returns radius of field wire in each layer.

Parameters

layerId

The layer id of field wires.

Returns

The radius of field wire in layer layerId.

Definition at line 1289 of file CDCGeometryPar.h.

    {
      return m_rFLayer[layerID];
    }

generateXML()

void generateXML

(

const std::string &

of

)

Generate an xml file used in gearbox.

Parameters

of	The file name.

Definition at line 1879 of file CDCGeometryPar.cc.

{
  //...Open xml file...
  std::ofstream ofs(of.c_str(), std::ios::out);
  if (! ofs) {
    B2ERROR("CDCGeometryPar::read !!! can not open file : "
            << of);
  }
  ofs << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
      << endl
      << "<Subdetector type=\"CDC\">"
      << endl
      << "  <Name>CDC BelleII </Name>"
      << endl
      << "  <Description>CDC geometry parameters</Description>"
      << endl
      << "  <Version>0</Version>"
      << endl
      << "  <GeoCreator>CDCBelleII</GeoCreator>"
      << endl
      << "  <Content>"
      << endl
      << "    <Rotation desc=\"Rotation of the whole cdc detector (should be the same as beampipe)\" unit=\"mrad\">0.0</Rotation>"
      << endl
      << "    <OffsetZ desc=\"The offset of the whole cdc in z with respect to the IP (should be the same as beampipe)\" unit=\"mm\">0.0</OffsetZ>"
      << endl
      << "    <Material>CDCGas</Material>"
      << endl
      << endl;
 
  ofs << "    <SLayers>" << endl;
 
  for (int i = 0; i < m_nSLayer; i++) {
    ofs << "      <SLayer id=\"" << i << "\">" << endl;
    ofs << "        <Radius desc=\"Radius of wires in this layer\" unit=\"mm\">" << senseWireR(i) << "</Radius>" << endl;
    ofs << "        <BackwardZ desc=\"z position of this wire layer at backward endplate\" unit=\"mm\">" << senseWireBZ(
          i) << "</BackwardZ>" << endl;
    ofs << "        <ForwardZ desc=\"z position of this wire layer at forward endplate\" unit=\"mm\">" << senseWireFZ(
          i) << "</ForwardZ>" << endl;
//    ofs << "        <BackwardPhi desc=\"azimuth angle of the first wire in this layer at backward endplate\" unit=\"rad\">" << wireBackwardPosition(i).phi() << "</BackwardPhi>" << endl;
//    ofs << "        <ForwardPhi desc=\"azimuth angle of the first wire in this layer at forward endplate\" unit=\"rad\">" << wireForwardPosition(i).phi() << "</ForwardPhi>" << endl;
    ofs << "        <NHoles desc=\"the number of holes in this layer, 2*(cell number)\">" << nWiresInLayer(
          i) * 2 << "</NHoles>" << endl;
    ofs << "        <NShift desc=\"the shifted hole number of each wire in this layer\">" << nShifts(i) << "</NShift>" << endl;
    ofs << "        <Offset desc=\"wire offset in phi direction at endplate\">" << m_offSet[i] << "</Offset>" << endl;
    ofs << "      </SLayer>" << endl;
  }
 
  ofs << "    </SLayers>" << endl;
  ofs << "    <FLayers>" << endl;
 
  for (int i = 0; i < m_nFLayer; i++) {
    ofs << "      <FLayer id=\"" << i << "\">" << endl;
    ofs << "        <Radius desc=\"Radius of field wires in this layer\" unit=\"mm\">" << fieldWireR(i) << "</Radius>" << endl;
    ofs << "        <BackwardZ desc=\"z position of this field wire layer at backward endplate\" unit=\"mm\">" << fieldWireBZ(
          i) << "</BackwardZ>" << endl;
    ofs << "        <ForwardZ desc=\"z position of this field wire layer at forward endplate\" unit=\"mm\">" << fieldWireFZ(
          i) << "</ForwardZ>" << endl;
    ofs << "      </FLayer>" << endl;
  }
 
  ofs << "    </FLayers>" << endl;
 
  ofs << "    <InnerWall name=\"InnerWall\">" << endl;
  ofs << "      <InnerR desc=\"Inner radius\" unit=\"mm\">" << innerRadiusInnerWall() << "</InnerR>" << endl;
  ofs << "      <OuterR desc=\"Outer radius\" unit=\"mm\">" << outerRadiusInnerWall() << "</OuterR>" << endl;
  ofs << "      <BackwardZ desc=\"z position at backward endplate\" unit=\"mm\">" << m_zWall[0][0] << "</BackwardZ>" << endl;
  ofs << "      <ForwardZ desc=\"z position at forward endplate\" unit=\"mm\">" << m_zWall[0][1] << "</ForwardZ>" << endl;
  ofs << "    </InnerWall>" << endl;
 
  ofs << "    <OuterWall name=\"OuterWall\">" << endl;
  ofs << "      <InnerR desc=\"Inner radius\" unit=\"mm\">" << innerRadiusOuterWall() << "</InnerR>" << endl;
  ofs << "      <OuterR desc=\"Outer radius\" unit=\"mm\">" << outerRadiusOuterWall() << "</OuterR>" << endl;
  ofs << "      <BackwardZ desc=\"z position at backward endplate\" unit=\"mm\">" << m_zWall[2][0] << "</BackwardZ>" << endl;
  ofs << "      <ForwardZ desc=\"z position at forward endplate\" unit=\"mm\">" << m_zWall[2][1] << "</ForwardZ>" << endl;
  ofs << "    </OuterWall>" << endl;
 
  ofs << "  </Content>"                                         << endl
      << "</Subdetector>"                                       << endl;
}

getAlpha()

double getAlpha	(	const B2Vector3D &	posOnWire,
		const B2Vector3D &	momentum
	)		const

Returns track incident angle in rphi plane (alpha in rad.).

Parameters

posOnWire	Position on the wire at the closest point.
momentum	Track momentum at the closest point.

Definition at line 2795 of file CDCGeometryPar.cc.

{
  const double wx = posOnWire.X();
  const double wy = posOnWire.Y();
  const double px = momentum.X();
  const double py = momentum.Y();
 
  const double cross = wx * py - wy * px;
  const double dot   = wx * px + wy * py;
 
  return atan2(cross, dot);
}

getBoardID()

unsigned short getBoardID ( const WireID &  wID ) const

inline

Returns frontend board id. corresponding to the wire id.

Parameters

wID

wire id.

Returns

board id.

Definition at line 570 of file CDCGeometryPar.h.

      {
        std::map<WireID, unsigned short>::const_iterator it = m_wireToBoard.find(wID);
        unsigned short iret = (it != m_wireToBoard.end()) ? it->second : -999;
        return iret;
      }

getBwdDeltaZ()

double getBwdDeltaZ ( unsigned short  layerID ) const

inline

Return backward 'deltaZ'.

Parameters

[in]

layerID

(0-55)

Definition at line 794 of file CDCGeometryPar.h.

      {
        return m_dzSBackwardLayer[layerID];
      }

getChannelID()

unsigned short getChannelID ( const WireID &  wID ) const

inline

Returns frontend channel id. corresponding to the wire id.

Parameters

wID

wire id.

Returns

channel id. (0-47)

Definition at line 582 of file CDCGeometryPar.h.

      {
        std::map<WireID, unsigned short>::const_iterator it = m_wireToChannel.find(wID);
        unsigned short iret = (it != m_wireToChannel.end()) ? it->second : -999;
        return iret;
      }

getClosestAlphaPoints()

void getClosestAlphaPoints	(	const double	alpha,
		double &	wal,
		unsigned short	points[2],
		unsigned short	lrs[2]
	)		const

Returns the two closest alpha points for the input track incident angle (alpha).

Definition at line 2842 of file CDCGeometryPar.cc.

{
  double alphao = getOutgoingAlpha(alpha);
  weight = 1.;
 
  if (alphao < m_alphaPoints[0]) {
    points[0] = m_nAlphaPoints - 1;
    points[1] = 0;
    if (m_nAlphaPoints > 1) {
      lrs[0] = abs(lrs[0] - 1); //flip lr
      weight = (alphao - (m_alphaPoints[points[0]] - M_PI)) / (m_alphaPoints[points[1]] - (m_alphaPoints[points[0]] - M_PI));
    }
  } else if (m_alphaPoints[m_nAlphaPoints - 1] <= alphao) {
    points[0] = m_nAlphaPoints - 1;
    points[1] = 0;
    if (m_nAlphaPoints > 1) {
      lrs[1] = abs(lrs[1] - 1); //flip lr
      weight = (alphao - m_alphaPoints[points[0]]) / (m_alphaPoints[points[1]] + M_PI - m_alphaPoints[points[0]]);
    }
  } else {
    const float* upper = std::upper_bound(m_alphaPoints,
                                          m_alphaPoints + m_nAlphaPoints, alphao);
    points[1] = upper - m_alphaPoints;
    points[0] = points[1] - 1;
    weight = (alphao - m_alphaPoints[points[0]]) / (m_alphaPoints[points[1]] - m_alphaPoints[points[0]]);
  }
}

getClosestAlphaPoints4Sgm()

void getClosestAlphaPoints4Sgm	(	const double	alpha,
		double &	wal,
		unsigned short	points[2],
		unsigned short	lrs[2]
	)		const

Returns the two closest alpha points for sigma for the input track incident angle (alpha).

TODO: unify the two getClosestAlphaPoints().

Definition at line 2872 of file CDCGeometryPar.cc.

{
  double alphao = getOutgoingAlpha(alpha);
  weight = 1.;
 
  if (alphao < m_alphaPoints4Sgm[0]) {
    points[0] = m_nAlphaPoints4Sgm - 1;
    points[1] = 0;
    if (m_nAlphaPoints4Sgm > 1) {
      lrs[0] = abs(lrs[0] - 1); //flip lr
      weight = (alphao - (m_alphaPoints4Sgm[points[0]] - M_PI)) / (m_alphaPoints4Sgm[points[1]] - (m_alphaPoints4Sgm[points[0]] - M_PI));
    }
  } else if (m_alphaPoints4Sgm[m_nAlphaPoints4Sgm - 1] <= alphao) {
    points[0] = m_nAlphaPoints4Sgm - 1;
    points[1] = 0;
    if (m_nAlphaPoints4Sgm > 1) {
      lrs[1] = abs(lrs[1] - 1); //flip lr
      weight = (alphao - m_alphaPoints4Sgm[points[0]]) / (m_alphaPoints4Sgm[points[1]] + M_PI - m_alphaPoints4Sgm[points[0]]);
    }
  } else {
    const float* upper = std::upper_bound(m_alphaPoints4Sgm,
                                          m_alphaPoints4Sgm + m_nAlphaPoints4Sgm, alphao);
    points[1] = upper - m_alphaPoints4Sgm;
    points[0] = points[1] - 1;
    weight = (alphao - m_alphaPoints4Sgm[points[0]]) / (m_alphaPoints4Sgm[points[1]] - m_alphaPoints4Sgm[points[0]]);
  }
}

getClosestThetaPoints()

void getClosestThetaPoints	(	const double	alpha,
		const double	theta,
		double &	wth,
		unsigned short	points[2]
	)		const

Returns the two closest theta points for the input track incident angle (theta).

Definition at line 2902 of file CDCGeometryPar.cc.

{
  const double thetao = getOutgoingTheta(alpha, theta);
 
  if (thetao < m_thetaPoints[0]) {
    //    points[0] = 0;
    //    points[1] = 1;
    points[0] = 0;
    points[1] = 0;
    weight = 1.;
  } else if (m_thetaPoints[m_nThetaPoints - 1] <= thetao) {
    //    points[0] = m_nThetaPoints - 2;
    //    points[1] = m_nThetaPoints - 1;
    points[0] = m_nThetaPoints - 1;
    points[1] = m_nThetaPoints - 1;
    weight = 1.;
  } else {
    const float* upper = std::upper_bound(m_thetaPoints,
                                          m_thetaPoints + m_nThetaPoints, thetao);
    points[1] = upper - m_thetaPoints;
    points[0] = points[1] - 1;
    weight = (thetao - m_thetaPoints[points[0]]) / (m_thetaPoints[points[1]] - m_thetaPoints[points[0]]);
  }
}

getClosestThetaPoints4Sgm()

void getClosestThetaPoints4Sgm	(	const double	alpha,
		const double	theta,
		double &	wth,
		unsigned short	points[2]
	)		const

Returns the two closest theta points for sigma for the input track incident angle (theta).

Definition at line 2928 of file CDCGeometryPar.cc.

{
  const double thetao = getOutgoingTheta(alpha, theta);
 
  if (thetao < m_thetaPoints4Sgm[0]) {
    points[0] = 0;
    points[1] = 0;
    weight = 1.;
  } else if (m_thetaPoints4Sgm[m_nThetaPoints4Sgm - 1] <= thetao) {
    points[0] = m_nThetaPoints4Sgm - 1;
    points[1] = m_nThetaPoints4Sgm - 1;
    weight = 1.;
  } else {
    const float* upper = std::upper_bound(m_thetaPoints4Sgm,
                                          m_thetaPoints4Sgm + m_nThetaPoints4Sgm, thetao);
    points[1] = upper - m_thetaPoints4Sgm;
    points[0] = points[1] - 1;
    weight = (thetao - m_thetaPoints4Sgm[points[0]]) / (m_thetaPoints4Sgm[points[1]] - m_thetaPoints4Sgm[points[0]]);
  }
}

getDriftLength()

double getDriftLength	(	double	dt,
		unsigned short	layer,
		unsigned short	lr,
		double	alpha = 0.,
		double	theta = 0.5 * M_PI,
		bool	calculateMinTime = true,
		double	minTime = 0.
	)		const

Return the drift dength to the sense wire.

Parameters

[in]	dt	Drift time (ns).
[in]	layer	Layer ID.
[in]	lr	Left/Right
[in]	alpha	incident angle (in rphi plane) w.r.t. the cell (rad).
[in]	theta	incident angle (polar angle) (rad).
	calculateMinTime	calculate min. drift time inside this function (=true) or feed as input (=false).
	minTime	input min. drift time when calculateMinTime=false.

Definition at line 2286 of file CDCGeometryPar.cc.

{
  if (iCLayer < m_firstLayerOffset || iCLayer >= c_maxNSenseLayers) {
    return 0.;
  }
 
  double dist = 0.;
 
  //calculate min. drift time
  double minTime = calculateMinTime ? getMinDriftTime(iCLayer, lr, alpha, theta) : inputMinTime;
  double delta = time - minTime;
 
  //convert incoming- to outgoing-lr
  unsigned short lro = getOutgoingLR(lr, alpha);
 
  //  std::cout << m_linearInterpolationOfXT << std::endl;
  //  exit(-1);
  if (!m_linearInterpolationOfXT) {
    B2FATAL("linearInterpolationOfXT = false is not allowed now !");
  } else {
    double wal(0.);
    unsigned short ial[2] = {0};
    unsigned short ilr[2] = {lro, lro};
    getClosestAlphaPoints(alpha, wal, ial, ilr);
    double wth(0.);
    unsigned short ith[2] = {0};
    getClosestThetaPoints(alpha, theta, wth, ith);
 
    unsigned short jal(0), jlr(0), jth(0);
    double w = 0.;
 
    //use xt reversed at (x=0,t=tmin) for delta<0 ("negative drifttime")
    double timep = delta < 0. ? minTime - delta : time;
 
    //    std::cout << "iCLayer,alpha,theta,lro= " << iCLayer <<" "<< (180./M_PI)*alpha <<" "<< (180./M_PI)*theta <<" "<< lro << std::endl;
 
    //compute linear interpolation (=weithed average over 4 points) in (alpha-theta) space
    for (unsigned k = 0; k < 4; ++k) {
      if (k == 0) {
        jal = ial[0];
        jlr = ilr[0];
        jth = ith[0];
        w = (1. - wal) * (1. - wth);
      } else if (k == 1) {
        jal = ial[0];
        jlr = ilr[0];
        jth = ith[1];
        w = (1. - wal) * wth;
      } else if (k == 2) {
        jal = ial[1];
        jlr = ilr[1];
        jth = ith[0];
        w = wal * (1. - wth);
      } else if (k == 3) {
        jal = ial[1];
        jlr = ilr[1];
        jth = ith[1];
        w = wal * wth;
      }
 
      //      std::cout << "k,w= " << k <<" "<< w << std::endl;
      //      std::cout << "ial[0],[1],jal,wal= " << ial[0] <<" "<< ial[1] <<" "<< jal <<" "<< wal << std::endl;
      //      std::cout << "ith[0],[1],jth,wth= " << ith[0] <<" "<< ith[1] <<" "<< jth <<" "<< wth << std::endl;
 
      /*
      std::cout <<"iCLayer= " << iCLayer << std::endl;
      std::cout <<"lr= " << lr << std::endl;
      std::cout <<"jal,jth= " << jal <<" "<< jth << std::endl;
      std::cout <<"wal,wth= " << wal <<" "<< wth << std::endl;
      for (int i=0; i<9; ++i) {
      std::cout <<"a= "<< i <<" "<< m_XT[iCLayer][lro][jal][jth][i] << std::endl;
      }
      */
      double boundary = m_XT[iCLayer][jlr][jal][jth][6];
 
      if (timep < boundary) {
        if (m_xtParamMode == 1) {
          dist += w * ROOT::Math::Chebyshev5(timep, m_XT[iCLayer][jlr][jal][jth][0], m_XT[iCLayer][jlr][jal][jth][1],
                                             m_XT[iCLayer][jlr][jal][jth][2], m_XT[iCLayer][jlr][jal][jth][3], m_XT[iCLayer][jlr][jal][jth][4], m_XT[iCLayer][jlr][jal][jth][5]);
        } else {
          dist += w * (m_XT[iCLayer][jlr][jal][jth][0] + timep
                       * (m_XT[iCLayer][jlr][jal][jth][1] + timep
                          * (m_XT[iCLayer][jlr][jal][jth][2] + timep
                             * (m_XT[iCLayer][jlr][jal][jth][3] + timep
                                * (m_XT[iCLayer][jlr][jal][jth][4] + timep
                                   * (m_XT[iCLayer][jlr][jal][jth][5]))))));
        }
      } else {
        dist += w * (m_XT[iCLayer][jlr][jal][jth][7] * (timep - boundary) + m_XT[iCLayer][jlr][jal][jth][8]);
      }
      //      std::cout <<"k,w,dist= " << k <<" "<< w <<" "<< dist << std::endl;
    } //end of weighted mean loop
  }
 
  dist = fabs(dist);
  if (delta < 0.) dist *= -1.;
  return dist;
 
}

getDriftLength0()

double getDriftLength0	(	double	dt,
		unsigned short	layer,
		unsigned short	lr,
		double	alpha = 0.,
		double	theta = 0.5 * M_PI
	)		const

Return the drift dength to the sense wire; tentative ver.

Parameters

[in]	dt	Drift time (ns).
[in]	layer	Layer ID.
[in]	lr	Left/Right
[in]	alpha	incident angle (in rphi plane) w.r.t. the cell (rad).
[in]	theta	incident angle (polar angle) (rad).

Definition at line 2204 of file CDCGeometryPar.cc.

{
  if (iCLayer < m_firstLayerOffset || iCLayer >= c_maxNSenseLayers) {
    return 0.;
  }
 
  double dist = 0.;
 
  //convert incoming- to outgoing-lr
  unsigned short lro = getOutgoingLR(lr, alpha);
 
  //  std::cout << m_linearInterpolationOfXT << std::endl;
  //  exit(-1);
  if (!m_linearInterpolationOfXT) {
    B2FATAL("linearInterpolationOfXT = false is not allowed now !");
  } else {
    double wal(0.);
    unsigned short ial[2] = {0};
    unsigned short ilr[2] = {lro, lro};
    getClosestAlphaPoints(alpha, wal, ial, ilr);
    double wth(0.);
    unsigned short ith[2] = {0};
    getClosestThetaPoints(alpha, theta, wth, ith);
 
    unsigned short jal(0), jlr(0), jth(0);
    double w = 0.;
 
    //use xt reversed at (x=0,t=tmin) for delta<0 ("negative drifttime")
    double timep = time;
    //    std::cout << "iCLayer,alpha,theta,lro= " << iCLayer <<" "<< (180./M_PI)*alpha <<" "<< (180./M_PI)*theta <<" "<< lro << std::endl;
 
    //compute linear interpolation (=weithed average over 4 points) in (alpha-theta) space
    for (unsigned k = 0; k < 4; ++k) {
      if (k == 0) {
        jal = ial[0];
        jlr = ilr[0];
        jth = ith[0];
        w = (1. - wal) * (1. - wth);
      } else if (k == 1) {
        jal = ial[0];
        jlr = ilr[0];
        jth = ith[1];
        w = (1. - wal) * wth;
      } else if (k == 2) {
        jal = ial[1];
        jlr = ilr[1];
        jth = ith[0];
        w = wal * (1. - wth);
      } else if (k == 3) {
        jal = ial[1];
        jlr = ilr[1];
        jth = ith[1];
        w = wal * wth;
      }
 
      double boundary = m_XT[iCLayer][jlr][jal][jth][6];
 
      if (timep < boundary) {
        if (m_xtParamMode == 1) {
          dist += w * ROOT::Math::Chebyshev5(timep, m_XT[iCLayer][jlr][jal][jth][0], m_XT[iCLayer][jlr][jal][jth][1],
                                             m_XT[iCLayer][jlr][jal][jth][2], m_XT[iCLayer][jlr][jal][jth][3], m_XT[iCLayer][jlr][jal][jth][4], m_XT[iCLayer][jlr][jal][jth][5]);
        } else {
          dist += w * (m_XT[iCLayer][jlr][jal][jth][0] + timep
                       * (m_XT[iCLayer][jlr][jal][jth][1] + timep
                          * (m_XT[iCLayer][jlr][jal][jth][2] + timep
                             * (m_XT[iCLayer][jlr][jal][jth][3] + timep
                                * (m_XT[iCLayer][jlr][jal][jth][4] + timep
                                   * (m_XT[iCLayer][jlr][jal][jth][5]))))));
        }
      } else {
        dist += w * (m_XT[iCLayer][jlr][jal][jth][7] * (timep - boundary) + m_XT[iCLayer][jlr][jal][jth][8]);
      }
      //      std::cout <<"k,w,dist= " << k <<" "<< w <<" "<< dist << std::endl;
    } //end of weighted mean loop
  }
 
  //  dist = fabs(dist);
  return dist;
 
}

getDriftTime()

double getDriftTime	(	double	dist,
		unsigned short	layer,
		unsigned short	lr,
		double	alpha,
		double	theta
	)		const

Return the drift time to the sense wire.

Parameters

dist	Drift length (cm).
layer	Layer ID.
lr	Left/Right
alpha	incident angle (in rphi plane) w.r.t. the cell (rad).
theta	incident angle (polar angle) (rad).

Definition at line 2583 of file CDCGeometryPar.cc.

{
  if (iCLayer < m_firstLayerOffset || iCLayer >= c_maxNSenseLayers) {
    return 0.;
  }
 
  //to be replaced with a smarter algorithm...
 
  const double eps = 2.5e-1;
  const double maxTrials = 100;
 
  //  int ialpha = getAlphaBin(alpha);
  //  int itheta = getThetaBin(theta);
 
  //convert incoming- to outgoing-lr
  //  unsigned short lrp = getOutgoingLR(lr, alpha);
 
  double maxTime = 2000.; //in ns (n.b. further reduction, 2->1us could be ok)
  //  if (m_XT[iCLayer][lrp][ialpha][itheta][7] == 0.) {
  //    maxTime = m_XT[iCLayer][lrp][ialpha][itheta][6];
  //  }
 
  double minTime = getMinDriftTime(iCLayer, lr, alpha, theta);
  double t0 = minTime;
  //  std::cout << "minTime,x= " << t0 <<" "<< getDriftLength(t0, iCLayer, lr, alpha, theta) << std::endl;
  const bool calMinTime = false;
  //  double d0 = getDriftLength(t0, iCLayer, lr, alpha, theta, calMinTime, minTime) - dist;
  double d0 = - dist;
 
  unsigned i = 0;
  double t1 = maxTime;
  double time = dist * m_nominalDriftVInv;
  while (((t1 - t0) > eps) && (i < maxTrials)) {
    time = 0.5 * (t0 + t1);
    double d1 = getDriftLength(time, iCLayer, lr, alpha, theta, calMinTime, minTime) - dist;
    //    std::cout <<"i,dist,t0,t1,d0,d1= " << i <<" "<< dist <<" "<< t0 <<" "<< t1 <<" "<< d0 <<" "<< d1 << std::endl;
    if (d0 * d1 > 0.) {
      t0 = time;
    } else {
      t1 = time;
    }
    ++i;
  }
 
  if (i >= maxTrials - 1 || time > maxTime) {
    B2WARNING("CDCGeometryPar::getDriftTime " << dist << " " << iCLayer << " " << alpha << " " << lr << " " << t0 << " " << t1 << " " <<
              time << " " << d0);
  }
 
  //  std::cout <<"dist0,dist1= " <<  dist <<" "<< getDriftLength(time, iCLayer, lr, alpha, theta) <<" "<< getDriftLength(time, iCLayer, lr, alpha, theta) - dist << std::endl;
  //  std::cout <<"dist0,dist1= " <<  dist <<" "<< getDriftLength(time, iCLayer, lr, 0., theta) <<" "<< getDriftLength(time, iCLayer, lr, 0., theta) - dist << std::endl;
  return time;
 
}

getDriftV()

double getDriftV	(	double	dt,
		unsigned short	layer,
		unsigned short	lr,
		double	alpha = 0.,
		double	theta = 0.5 * M_PI
	)		const

Get the realistic drift velocity.

Parameters

[in]	dt	Drift time (ns).
[in]	layer	Layer ID.
[in]	lr	Left/Right
[in]	alpha	incident angle (in rphi plane) w.r.t. the cell (rad).
[in]	theta	incident angle (polar angle) (rad).

Definition at line 2116 of file CDCGeometryPar.cc.

{
  if (iCLayer < m_firstLayerOffset || iCLayer >= c_maxNSenseLayers) {
    return 0.;
  }
 
  double dDdt = 0.;
 
  //calculate min. drift time
  double minTime = getMinDriftTime(iCLayer, lr, alpha, theta);
  double delta = time - minTime;
 
  //convert incoming- to outgoing-lr
  unsigned short lro = getOutgoingLR(lr, alpha);
 
  if (!m_linearInterpolationOfXT) {
    B2FATAL("linearInterpolationOfXT = false is not allowed now !");
  } else {
    double wal(0.);
    unsigned short ial[2] = {0};
    unsigned short ilr[2] = {lro, lro};
    getClosestAlphaPoints(alpha, wal, ial, ilr);
    double wth(0.);
    unsigned short ith[2] = {0};
    getClosestThetaPoints(alpha, theta, wth, ith);
 
    unsigned short jal(0), jlr(0), jth(0);
    double w = 0.;
 
    //use xt reversed at (x=0,t=tmin) for delta<0 ("negative drifttime")
    double timep = delta < 0. ? minTime - delta : time;
 
    //compute linear interpolation (=weithed average over 4 points) in (alpha-theta) space
    for (unsigned k = 0; k < 4; ++k) {
      if (k == 0) {
        jal = ial[0];
        jlr = ilr[0];
        jth = ith[0];
        w = (1. - wal) * (1. - wth);
      } else if (k == 1) {
        jal = ial[0];
        jlr = ilr[0];
        jth = ith[1];
        w = (1. - wal) * wth;
      } else if (k == 2) {
        jal = ial[1];
        jlr = ilr[1];
        jth = ith[0];
        w = wal * (1. - wth);
      } else if (k == 3) {
        jal = ial[1];
        jlr = ilr[1];
        jth = ith[1];
        w = wal * wth;
      }
 
      double boundary = m_XT[iCLayer][jlr][jal][jth][6];
 
      if (timep < boundary) {
        if (m_xtParamMode == 1) {
          const double& c1 = m_XT[iCLayer][jlr][jal][jth][1];
          const double& c2 = m_XT[iCLayer][jlr][jal][jth][2];
          const double& c3 = m_XT[iCLayer][jlr][jal][jth][3];
          const double& c4 = m_XT[iCLayer][jlr][jal][jth][4];
          const double& c5 = m_XT[iCLayer][jlr][jal][jth][5];
          dDdt += w * ROOT::Math::Chebyshev4(timep, c1 + 3.*c3 + 5.*c5, 4.*c2 + 8.*c4, 6.*c3 + 10.*c5, 8.*c4, 10.*c5);
        } else {
          dDdt += w * (m_XT[iCLayer][jlr][jal][jth][1] + timep
                       * (2.*m_XT[iCLayer][jlr][jal][jth][2] + timep
                          * (3.*m_XT[iCLayer][jlr][jal][jth][3] + timep
                             * (4.*m_XT[iCLayer][jlr][jal][jth][4] + timep
                                * (5.*m_XT[iCLayer][jlr][jal][jth][5])))));
        }
      } else {
        dDdt += w * m_XT[iCLayer][jlr][jal][jth][7];
      }
    } //end of weighted mean loop
  }
 
  dDdt = fabs(dDdt);
  //n.b. following line not needed since dDdt > 0 even for delta < 0
  //  if (delta < 0.) dDdt *= -1.;
  return dDdt;
 
}

getEDepToADCConvFactor()

double getEDepToADCConvFactor	(	unsigned short	layer,
		unsigned short	cell,
		double	edep,
		double	dx,
		double	costh
	)

Return edep-to-ADC conversion factor.

Parameters

layer	no. (0-55)
cell	no. (0-)
edep	energy-deposit in the cell(keV).
dx	path length (cm) of the track in the cell.
costh	cos(theta) of track.

Definition at line 1650 of file CDCGeometryPar.cc.

{
  //  double convF = (100.0 / 3.2); //keV -> count
  //Model assumed here is from CLEO-c:
  //Igen = Imea * [1 + alf*Imea/cth] / [1 + gam*Imea/cth];
  //cth = |costh| + dlt;
  //Igen: original dE/dx; Imea: measured dE/dx with space-charge effect
  const double  mainF = (iCL < m_firstLayerOffset) ? 0. : m_eDepToADCParams[iCL][iW][0];
  const double& alf   = (iCL < m_firstLayerOffset) ? 0. : m_eDepToADCParams[iCL][iW][1];
  const double& gam   = (iCL < m_firstLayerOffset) ? 0. : m_eDepToADCParams[iCL][iW][2];
  const double& dlt   = (iCL < m_firstLayerOffset) ? 0. : m_eDepToADCParams[iCL][iW][3];
  const double& a     = (iCL < m_firstLayerOffset) ? 0. : m_eDepToADCParams[iCL][iW][4];
  const double& b     = (iCL < m_firstLayerOffset) ? 0. : m_eDepToADCParams[iCL][iW][5];
  const double cth  = fabs(costh) + dlt;
  const double iGen = edep / dx; // keV/cm
  const double tmp  = cth - gam * iGen;
  const double disc = tmp * tmp + 4.*alf * cth * iGen;
 
  double iMea = 0.;
  if (alf == 0.) {
    iMea = cth * iGen / tmp;
  } else if (disc >= 0.) {
    iMea = (-tmp + sqrt(disc)) / (2.*alf);
    //    if (alf < 0.) {
    //      B2INFO("alf<0:CHECK");
    //      B2INFO(-tmp + sqrt(disc)) / (2.*alf));
    //      B2INFO(-tmp - sqrt(disc)) / (2.*alf));
    //    }
  }
 
  double convF = mainF;
  if (iMea > 0.) {
    convF = mainF * std::min(iMea / iGen, 1.);
    //    if (iMea > iGen) B2DEBUG(29, "iMea > iGen " << iMea <<" "<< iGen);
  } else {
    //TODO: check the following issue more
    //    B2WARNING("CDCGeometryPar: Measured dE/dx <= 0!");
    //    B2DEBUG(29, "CDCGeometryPar: Measured dE/dx <= 0!");
    //    B2DEBUG(29, "iGen,iMea= " << std::setw(15) << std::scientific << std::setprecision(8) << iGen <<" "<< iMea);
    //    B2DEBUG(29, "dx,mainF,alf,gam,dlt,cth,tmp,disc= " << dx <<" "<< mainF <<" "<< alf <<" "<< gam <<" "<< dlt <<" "<<" "<< tmp <<" "<< disc);
  }
  convF *= 1. + a * (costh - b);
  return convF;
}

getEDepToADCMainFactor()

double getEDepToADCMainFactor ( unsigned short  layer, unsigned short  cell, double  costh = 0  )

inline

Return edep-to-ADC conversion main factor (in count/keV)

Parameters

layer	no. (0-55)
cell	no. (0-)
costh	cosine of incident angle (theta) of particle

Definition at line 262 of file CDCGeometryPar.h.

      {
        return m_eDepToADCParams[layer][cell][0] + m_eDepToADCParams[layer][cell][4] * (costh - m_eDepToADCParams[layer][cell][5]);
      };

getEDepToADCSigma()

double getEDepToADCSigma ( unsigned short  layer, unsigned short  cell  )

inline

Return sigma for extra smearing of edep to ADC conversion.

Parameters

layer	no. (0-55)
cell	no. (0-)

Definition at line 271 of file CDCGeometryPar.h.

      {
        return m_eDepToADCParams[layer][cell][6];
      };

getFudgeFactorForSigma()

double getFudgeFactorForSigma ( unsigned short  target ) const

inline

Return the fuge factor for space resol.

Parameters

target

target sigma: =0: for sigma in data reconstruction; =1: for sigma in MC recon.; =2: for sigma in digitization in MC

Definition at line 947 of file CDCGeometryPar.h.

      {
        return m_fudgeFactorForSigma[target];
      }

getFwdDeltaZ()

double getFwdDeltaZ ( unsigned short  layerID ) const

inline

Return forward 'deltaZ'.

Parameters

[in]

layerID

(0-55)

Definition at line 804 of file CDCGeometryPar.h.

      {
        return m_dzSForwardLayer[layerID];
      }

getMaterialDefinitionMode()

int getMaterialDefinitionMode ( ) const

inline

Return mode for material definition.

Return value = 0: define a mixture of gases and wires in the entire tracking volume; =1: define two different mixtures: one for the inner volume (small cell), and the other for the outer volume (normal cell).

Definition at line 771 of file CDCGeometryPar.h.

      {
        return m_materialDefinitionMode;
      }

getMaxNumberOfCellsPerLayer()

ushort getMaxNumberOfCellsPerLayer ( ) const

inline

Get the maximum number of cells in one layer.

Definition at line 1085 of file CDCGeometryPar.h.

{ return m_maxNCellsPerLayer;}

getMaxNumberOfSuperLayers()

ushort getMaxNumberOfSuperLayers ( ) const

inline

Get the maximum number of super layers.

Definition at line 1070 of file CDCGeometryPar.h.

{ return m_maxNSuperLayers;}

getMeanT0()

double getMeanT0 ( ) const

inline

Returns the mean t0 over all wires.

Returns

mean t0.

Definition at line 1374 of file CDCGeometryPar.h.

    {
      return m_meanT0;
    }

getMinDriftTime()

double getMinDriftTime	(	unsigned short	layer,
		unsigned short	lr,
		double	alpha = 0.,
		double	theta = 0.5 * M_PI
	)		const

Return the min.

drift time (ns).

Parameters

[in]	layer	Layer ID.
[in]	lr	Left/Right
[in]	alpha	incident angle (in rphi plane) w.r.t. the cell (rad).
[in]	theta	incident angle (polar angle) (rad).

Definition at line 2389 of file CDCGeometryPar.cc.

{
  if (iCLayer < m_firstLayerOffset || iCLayer >= c_maxNSenseLayers) {
    return 0.;
  }
 
  double minTime = 0.;
 
  //convert incoming- to outgoing-lr
  unsigned short lro = getOutgoingLR(lr, alpha);
 
  if (!m_linearInterpolationOfXT) {
    B2FATAL("linearInterpolationOfXT = false is not allowed now !");
  } else {
    double wal(0.);
    unsigned short ial[2] = {0};
    unsigned short ilr[2] = {lro, lro};
    getClosestAlphaPoints(alpha, wal, ial, ilr);
    double wth(0.);
    unsigned short ith[2] = {0};
    getClosestThetaPoints(alpha, theta, wth, ith);
 
    unsigned short jal(0), jlr(0), jth(0);
    double w = 0.;
 
    double c[6] = {0.}, a[6] = {0.};
    for (unsigned k = 0; k < 4; ++k) {
      if (k == 0) {
        jal = ial[0];
        jlr = ilr[0];
        jth = ith[0];
        w = (1. - wal) * (1. - wth);
      } else if (k == 1) {
        jal = ial[0];
        jlr = ilr[0];
        jth = ith[1];
        w = (1. - wal) * wth;
      } else if (k == 2) {
        jal = ial[1];
        jlr = ilr[1];
        jth = ith[0];
        w = wal * (1. - wth);
      } else if (k == 3) {
        jal = ial[1];
        jlr = ilr[1];
        jth = ith[1];
        w = wal * wth;
      }
 
      for (int i = 0; i < 5; ++i) {
        c[i] += w * m_XT[iCLayer][jlr][jal][jth][i];
      }
    }
 
    if (m_xtParamMode == 1) { //convert c to coeff for normal-poly if Chebyshev
      a[0] = c[0] -    c[2] +    c[4];
      a[1] = c[1] - 3.*c[3] + 5.*c[5];
      a[2] =        2.*c[2] - 8.*c[4];
      a[3] =        4.*c[3] - 20.*c[5];
      a[4] =        8.*c[4];
      a[5] =       16.*c[5];
    } else { //normal-poly
      for (int i = 0; i < 5; ++i) a[i] = c[i];
    }
 
    //estimate an initial value
    //    bool check = false;
    //    bool nointersection = false;
    if (a[2] != 0.) {  //2nd-order approx. near t=0
      const double det = a[1] * a[1] - 4.*a[2] * a[0];
      if (det >= 0.) {
        //Choose the solution with dx/dt > 0 which gives x=0
        minTime = (-a[1] + sqrt(det)) / (2.*a[2]);
      } else {
        //Choose the solution with smallest x
        //  nointersection = true;
        minTime = -a[1]  / (2.*a[2]);
        //  cout <<"smallest-x solution= " << minTime << endl;
      }
    } else if (a[1] != 0.) {
      minTime = -a[0] / a[1];  //1st-order approx.
    } else {
      B2WARNING("CDCGeometryPar::getMinDriftTime: minDriftTime not determined; assume zero.\n" << "layer(#0-55),lr,alpha(rad),theta= " <<
                iCLayer << " " << lr << " " << alpha << " " << theta);
      return minTime;
    }
 
    //    double minTime0 = minTime;
    //higher-order corr. using Newton method; trial to minimize x^2
    double  edm; //  = 10.;   //(cm)  (SG: fix to avoid cpp-check warning)
    //      const double epsi4t = 0.01; //(ns)
    //    const double epsi4x = 1.e-5; //(cm)
    const double epsi4x = 5.e-6; //(cm)
    //    const unsigned short maxIter = 4;
    const unsigned short maxIter = 8;
    const double maxDt = 20.; //(ns)
    unsigned short nIter = 0;
    double minXsq = 1.e10; //(cm^2)
    double minMinTime = minTime;
    //      double told = minTime + 1000.*epsi4t;
    //      while (fabs(minTime - told) > epsi && nIter <= maxIter) {
    for (nIter = 0; nIter <= maxIter; ++nIter) {
      //  told = minTime;
      double t = minTime;
      double x   = a[0] + t * (a[1] + t * (a[2] + t * (a[3] + t * (a[4] + t * a[5]))));
      double x2 = x * x;
      if (x2 < minXsq) {
        minXsq = x2;
        minMinTime = t;
      }
      double xp  = a[1] + t * (2 * a[2] + t * (3 * a[3] + t * (4 * a[4] + t * 5 * a[5])));
      double xpp = 2 * a[2] + t * (6 * a[3] + t * (12 * a[4] + t * 20 * a[5]));
      double den = xp * xp + x * xpp;
      if (den <= 0.) {
        den = xp * xp;
      }
 
      if (den > 0.) {
        //estimated distance to min.
        edm = fabs(x * xp) / sqrt(den); //not in distance^2 but in distance
        if (edm < epsi4x) break; //converged
      }
 
      double dt = 1.; //dt for den=0 (ns)
      if (den != 0.) {
        dt = x * xp / den;
        if (dt >= 0.) {
          dt = std::min(dt,  maxDt);
        } else {
          dt = std::max(dt, -maxDt);
        }
      } else {
        B2WARNING("CDCGeometryPar::getMinDriftTime: den = 0\n" << "layer(#0-55),lr,alpha(rad),theta= " <<
                  iCLayer << " "
                  << lr <<
                  " " << alpha << " " << theta);
      }
      minTime -= dt;
    } //end of iteration loop
 
    //choose minMinTime for not-converged case
    if (nIter == (maxIter + 1)) minTime = minMinTime;
 
    /*
    if (fabs(minTime) > 20.) {
      B2WARNING("CDCGeometryPar::getMinDriftTime: |minDriftTime| > 20ns. Ok ?\n" << "layer(#0-55),lr,alpha(rad),theta,minTime(ns)= " <<
                iCLayer << " "
                << lr <<
                " " << alpha << " " << theta << " " << minTime);
    }
    if (nointersection) {
      cout <<"final minTime= " << minTime << endl;
      cout <<"final minx   = " << a[0] + a[1] * minTime + a[2] *pow(minTime,2) + a[3] *pow(minTime,3) + a[4] *pow(minTime,4) + a[5] *pow(minTime,5) << endl;
    }
    */
    /*
    if (check) {
      double dmin = 999.;
      double tmin = 999.;
      for (int i = -10000; i < 10000; ++i) {
        double ti = 0.01 * i;
        double dl = fabs(getDriftLength0(ti, iCLayer, lr, alpha, theta));
        if (dl < dmin) {
          dmin = dl;
          tmin = ti;
        }
      }
 
      double smartd = getDriftLength0(minTime, iCLayer, lr, alpha, theta);
      if (check) {
    //      if (fabs(smartd) > dmin && minTime < tmin && fabs(minTime - tmin) > 0.1) {
        B2WARNING("CDCGeometryPar::getMinDriftTime \n" << "layer(#0-55),lr,alpha(rad),theta= " <<
                  iCLayer << " "
                  << lr <<
                  " " << alpha << " " << theta);
        B2INFO("det, minTime0= " << det << " " << minTime0);
        B2INFO("direct search n,tmin,dmin= " << nIter << " " << tmin << " " << dmin);
        B2INFO(" smart search n,tmin,dmin= " << nIter << " " << minTime << " " << getDriftLength0(minTime, iCLayer, lr, alpha, theta));
 
        for (int i=-200; i < 200; ++i) {
          double ti = 0.25*i;
          double dl = getDriftLength0(ti, iCLayer, lr, alpha, theta);
          std::cout << ti <<" "<< dl << std::endl;
        }
        exit(-1);
      }
    }
    */
  }
 
  return minTime;
}

getMinTrackLength()

double getMinTrackLength ( ) const

inline

Returns the minimum track length required in one G4 step (only secondary particles which pass this criterion are to be saved in MCParticle)

Returns

length (cm)

Definition at line 528 of file CDCGeometryPar.h.

      {
        return m_minTrackLength;
      }

getNewLeftRightRaw()

unsigned short getNewLeftRightRaw	(	const B2Vector3D &	posOnWire,
		const B2Vector3D &	posOnTrack,
		const B2Vector3D &	momentum
	)		const

Returns new left/right_raw.

Parameters

posOnWire	Position on the wire at the closest point.
posOnTrack	Position on the track at the closest point.
momentum	Track 3-momentum.

Definition at line 2786 of file CDCGeometryPar.cc.

{
  const double distanceCrossP = ((posOnWire - posOnTrack).Cross(momentum)).Z();
  unsigned short int lr = (distanceCrossP > 0.) ? 1 : 0;
  return lr;
}

getNominalDriftV()

double getNominalDriftV ( ) const

inline

Return the nominal drift velocity of He-ethane gas (default: 4.0x10^-3 cm/nsec).

Definition at line 736 of file CDCGeometryPar.h.

      {
        return m_nominalDriftV;
      }

getNominalPropSpeed()

double getNominalPropSpeed ( ) const

inline

Return the nominal propagation speed of the sense wire (default: 27.25 cm/nsec).

Definition at line 746 of file CDCGeometryPar.h.

      {
        return m_nominalPropSpeed;
      }

getNominalSpaceResol()

double getNominalSpaceResol ( ) const

inline

Return the nominal spatial resolution.

(default: 130 um defined in CDC.xml).

Definition at line 756 of file CDCGeometryPar.h.

      {
        return m_nominalSpaceResol;
      }

getNumberOfFieldLayers()

ushort getNumberOfFieldLayers ( ) const

inline

Get the number of field layers.

Definition at line 1065 of file CDCGeometryPar.h.

{ return m_maxNFieldLayers;}

getNumberOfFieldWires()

ushort getNumberOfFieldWires ( ) const

inline

Get the number of field wires.

Definition at line 1055 of file CDCGeometryPar.h.

{ return m_nFieldWires;}

getNumberOfSenseLayers()

ushort getNumberOfSenseLayers ( ) const

inline

Get the number of sense layers.

Definition at line 1060 of file CDCGeometryPar.h.

{ return m_maxNSenseLayers;}

getNumberOfSenseWires()

ushort getNumberOfSenseWires ( ) const

inline

Get the number of sense wires.

Definition at line 1050 of file CDCGeometryPar.h.

{ return m_nSenseWires;}

getOffsetOfFirstLayer()

ushort getOffsetOfFirstLayer ( ) const

inline

Get the offset of the first layer.

Definition at line 1075 of file CDCGeometryPar.h.

{ return m_firstLayerOffset;}

getOffsetOfFirstSuperLayer()

ushort getOffsetOfFirstSuperLayer ( ) const

inline

Get the offset of the first super layer.

Definition at line 1080 of file CDCGeometryPar.h.

{ return m_firstSuperLayerOffset;}

getOldLeftRight()

unsigned short getOldLeftRight	(	const B2Vector3D &	posOnWire,
		const B2Vector3D &	posOnTrack,
		const B2Vector3D &	momentum
	)		const

Returns old left/right.

Parameters

posOnWire	Position on the wire at the closest point.
posOnTrack	Position on the track at the closest point.
momentum	Track 3-momentum.

Definition at line 2751 of file CDCGeometryPar.cc.

{
  unsigned short lr = 0;
  double wCrossT = (posOnWire.Cross(posOnTrack)).Z();
 
  if (wCrossT < 0.) {
    lr = 0;
  } else if (wCrossT > 0.) {
    lr = 1;
  } else {
    if ((posOnTrack - posOnWire).Perp() != 0.) {
      double wCrossP = (posOnWire.Cross(momentum)).Z();
      if (wCrossP > 0.) {
        if (posOnTrack.Perp() > posOnWire.Perp()) {
          lr = 0;
        } else {
          lr = 1;
        }
      } else if (wCrossP < 0.) {
        if (posOnTrack.Perp() < posOnWire.Perp()) {
          lr = 0;
        } else {
          lr = 1;
        }
      } else {
        lr = 0;
      }
    } else {
      lr = 0;
    }
  }
  return lr;
}

getOutgoingAlpha()

double getOutgoingAlpha

(

const double

alpha

)

const

Converts incoming- to outgoing-alpha.

Parameters

alpha

in rad.

Definition at line 2821 of file CDCGeometryPar.cc.

{
  //convert incoming- to outgoing-alpha
  double alphao = alpha;
  if (alpha >  0.5 * M_PI) {
    alphao -= M_PI;
  } else if (alpha < -0.5 * M_PI) {
    alphao += M_PI;
  }
 
  return alphao;
}

getOutgoingLR()

unsigned short getOutgoingLR	(	const unsigned short	lr,
		const double	alpha
	)		const

Converts incoming-lr to outgoing-lr.

Parameters

lr	Left/Right flag.
alpha	Track incident angle in rphi-plane (rad).

Definition at line 2814 of file CDCGeometryPar.cc.

{
  unsigned short lro = (fabs(alpha) <= 0.5 * M_PI) ? lr : abs(lr - 1);
  return lro;
}

getOutgoingTheta()

double getOutgoingTheta	(	const double	alpha,
		const double	theta
	)		const

Converts incoming- to outgoing-theta.

Parameters

alpha	in rad.
theta	in rad.

Definition at line 2834 of file CDCGeometryPar.cc.

{
  //convert incoming- to outgoing-theta
  double thetao = fabs(alpha) >  0.5 * M_PI  ?  M_PI - theta  :  theta;
  //  std::cout << alpha <<" "<< thetao << std::endl;
  return thetao;
}

getPropSpeedInv()

double getPropSpeedInv ( const unsigned int  layerID ) const

inline

Get the inversel of propagation speed in the sense wire.

Parameters

[in]

layerID

layer ID (0-55)

Definition at line 826 of file CDCGeometryPar.h.

      {
        return m_propSpeedInv[layerID];
      }

getSenseWireZposMode()

int getSenseWireZposMode ( ) const

inline

Return mode for sense wire z position.

Return value =0: define at the end-plate (gas side) with old design; =1: define at the bush inside the feedthrough with correction for the diff. betw. final- and old-design.

Definition at line 784 of file CDCGeometryPar.h.

      {
        return m_senseWireZposMode;
      }

getShiftInSuperLayer()

signed short getShiftInSuperLayer	(	unsigned short	iSuperLayer,
		unsigned short	iLayer
	)		const

Returns shift in the super-layer.

Parameters

iSuperLayer	The super-layer id.
iLayer	The layer id. in the super-layer

Definition at line 3010 of file CDCGeometryPar.cc.

{
  return m_shiftInSuperLayer[iSuperLayer][iLayer];
}

getSigma()

double getSigma	(	double	dist,
		unsigned short	layer,
		unsigned short	lr,
		double	alpha = 0.,
		double	theta = 0.5 * M_PI
	)		const

Return the basic resolution of drift length (cm).

N.B. A fudge factor may be multiplied at the place where this is called; be careful.

Parameters

dist	Drift length (cm); negative dist is treated as |dist|.
layer	Layer id.
lr	Left/Right.
alpha	incident angle (in rphi plane) w.r.t. the cell (rad).
theta	incident angle (polar angle) (rad).

Definition at line 2639 of file CDCGeometryPar.cc.

{
  if (iCLayer < m_firstLayerOffset || iCLayer >= c_maxNSenseLayers) {
    return 0.;
  }
 
 
  double sigma = 0.;
  //DriftL0 < 0 for the hit w/driftTime < 0; use |DriftL0| to avoid sigma=nan
  const double driftL = fabs(DriftL0);
 
  //convert incoming- to outgoing-lr
  unsigned short lro = getOutgoingLR(lr, alpha);
 
  if (!m_linearInterpolationOfSgm) {
    B2FATAL("linearInterpolationOfSgm = false is not allowed now !");
  }
  if (m_linearInterpolationOfSgm) {
    double wal(0.);
    unsigned short ial[2] = {0};
    unsigned short ilr[2] = {lro, lro};
    getClosestAlphaPoints4Sgm(alpha, wal, ial, ilr);
    double wth(0.);
    unsigned short ith[2] = {0};
    getClosestThetaPoints4Sgm(alpha, theta, wth, ith);
 
    //compute linear interpolation (=weithed average over 4 points) in (alpha-theta) space
    unsigned short jal(0), jlr(0), jth(0);
    double w = 0.;
    for (unsigned k = 0; k < 4; ++k) {
      if (k == 0) {
        jal = ial[0];
        jlr = ilr[0];
        jth = ith[0];
        w = (1. - wal) * (1. - wth);
      } else if (k == 1) {
        jal = ial[0];
        jlr = ilr[0];
        jth = ith[1];
        w = (1. - wal) * wth;
      } else if (k == 2) {
        jal = ial[1];
        jlr = ilr[1];
        jth = ith[0];
        w = wal * (1. - wth);
      } else if (k == 3) {
        jal = ial[1];
        jlr = ilr[1];
        jth = ith[1];
        w = wal * wth;
      }
      //      std::cout << "k,w= " << k <<" "<< w << std::endl;
      //      std::cout << "ial[0],[1],jal,wal= " << ial[0] <<" "<< ial[1] <<" "<< jal <<" "<< wal << std::endl;
      //      std::cout << "ith[0],[1],jth,wth= " << ith[0] <<" "<< ith[1] <<" "<< jth <<" "<< wth << std::endl;
      /*
      std::cout <<"iCLayer= " << iCLayer << std::endl;
      std::cout <<"lr= " << lr << std::endl;
      std::cout <<"jal,jth= " << jal <<" "<< jth << std::endl;
      std::cout <<"wal,wth= " << wal <<" "<< wth << std::endl;
      for (int i=0; i<9; ++i) {
      std::cout <<"a= "<< i <<" "<< m_XT[iCLayer][lro][jal][jth][i] << std::endl;
      }
      */
      const double& P0 = m_Sigma[iCLayer][jlr][jal][jth][0];
      const double& P1 = m_Sigma[iCLayer][jlr][jal][jth][1];
      const double& P2 = m_Sigma[iCLayer][jlr][jal][jth][2];
      const double& P3 = m_Sigma[iCLayer][jlr][jal][jth][3];
      const double& P4 = m_Sigma[iCLayer][jlr][jal][jth][4];
      const double& P5 = m_Sigma[iCLayer][jlr][jal][jth][5];
      const double& P6 = m_Sigma[iCLayer][jlr][jal][jth][6];
 
#if defined(CDC_DEBUG)
      cout << "driftL= " << driftL << endl;
      cout << "iCLayer= " << iCLayer << " " << jlr << " " << jal << " " << jth << endl;
      cout << "P0= " << P0 << endl;
      cout << "P1= " << P1 << endl;
      cout << "P2= " << P2 << endl;
      cout << "P3= " << P3 << endl;
      cout << "P4= " << P4 << endl;
      cout << "P5= " << P5 << endl;
      cout << "P6= " << P6 << endl;
#endif
      const double P7 = m_sigmaParamMode == 0 ? DBL_MAX : m_Sigma[iCLayer][jlr][jal][jth][7];
 
      if (driftL < P7) {
        sigma += w * sqrt(P0 / (driftL * driftL + P1) + P2 * driftL + P3 +
                          P4 * exp(P5 * (driftL - P6) * (driftL - P6)));
      } else {
        double forthTermAtP7 = P4 * exp(P5 * (P7 - P6) * (P7 - P6));
        const double& P8 = m_Sigma[iCLayer][jlr][jal][jth][8];
        if (m_sigmaParamMode == 1) {
          double sigmaAtP7 = sqrt(P0 / (P7 * P7 + P1) + P2 * P7 + P3 + forthTermAtP7);
          sigma += w * (P8 * (driftL - P7) + sigmaAtP7);
        } else if (m_sigmaParamMode == 2) {
          double onePls4AtP7 = sqrt(P0 / (P7 * P7 + P1) + forthTermAtP7);
          const double onePls4 = P8 * (driftL - P7) + onePls4AtP7;
          sigma += w * sqrt(P2 * driftL + P3 + onePls4 * onePls4);
        } else if (m_sigmaParamMode == 3) {
          forthTermAtP7 = sqrt(forthTermAtP7);
          const double forthTerm = P8 * (driftL - P7) + forthTermAtP7;
          sigma += w * sqrt(P0 / (driftL * driftL + P1) + P2 * driftL + P3 +
                            forthTerm * forthTerm);
        } //end of mode
      } // end of driftL
    } //end of for loop
  }
 
  sigma = std::min(sigma, m_maxSpaceResol);
  return sigma;
}

getT0()

float getT0 ( const WireID &  wireID ) const

inline

Returns t0 parameter of the specified sense wire.

Parameters

wireID

Wire id.

Returns

t0.

Definition at line 555 of file CDCGeometryPar.h.

      {
        //  std::cout << wireID.getICLayer() <<" "<< wireID.getIWire() << std::endl;
        unsigned int iclayer = wireID.getICLayer();
        unsigned int iwire = wireID.getIWire();
        if (iclayer >= c_maxNSenseLayers) iclayer = c_maxNSenseLayers - 1;
        if (iwire >= c_maxNDriftCells) iwire = c_maxNDriftCells - 1;
        return m_t0[iclayer][iwire];
      }

getTdcBinWidth()

double getTdcBinWidth ( ) const

inline

Return TDC bin width (nsec).

Definition at line 726 of file CDCGeometryPar.h.

      {
        return m_tdcBinWidth;
      }

getTdcOffset()

unsigned short getTdcOffset ( ) const

inline

Return TDC offset value (default = 0 ch).

Definition at line 717 of file CDCGeometryPar.h.

      {
        return m_tdcOffset;
      }

getTheta()

double getTheta

(

const B2Vector3D &

momentum

)

const

Returns track incident angle (theta in rad.).

Parameters

momentum

Track momentum at the closest point.

Definition at line 2808 of file CDCGeometryPar.cc.

{
  return atan2(momentum.Perp(), momentum.Z());
}

getThresholdEnerguDeposit()

double getThresholdEnerguDeposit ( ) const

inline

Returns threshold for energy deposit in one G4 step.

Returns

threshold (GeV)

Definition at line 519 of file CDCGeometryPar.h.

      {
        return m_thresholdEnergyDeposit;
      }

getTimeWalk()

double getTimeWalk ( const WireID &  wID, unsigned short  adcCount  ) const

inline

Returns time-walk.

Parameters

wID	wire id
adcCount	ADC count

Returns

time-walk (in ns)

Definition at line 606 of file CDCGeometryPar.h.

      {
        std::map<WireID, unsigned short>::const_iterator it = m_wireToBoard.find(wID);
        //  std::cout <<"SL,L,W, bd#= " << wID.getISuperLayer() <<" "<< wID.getILayer() <<" "<< wID.getIWire() <<" "<< it->second << std::endl;
        double tw = 0.;
        if (it != m_wireToBoard.end() && adcCount > 0) {
          if (m_twParamMode == 0) {
            tw = m_timeWalkCoef[it->second][0] / sqrt(adcCount);
          } else if (m_twParamMode == 1) {
            double p0 = m_timeWalkCoef[it->second][0];
            double p1 = m_timeWalkCoef[it->second][1];
            tw = p0 * exp(-p1 * adcCount);
          }
        }
        //  std::cout <<"bd#,coef,adc,tw= " << it->second <<" "<< m_timeWalkCoef[it->second] <<" "<< adcCount <<" "<< tw << std::endl;
        return tw;
      }

getWireID()

const WireID getWireID ( unsigned short  bd, unsigned short  ch  ) const

inline

Returns wire id. corresponding to the board-and-cannel ids.

Parameters

bd	board id. (1-300)
ch	channel id. (0-47)

Returns

wire id.

Definition at line 595 of file CDCGeometryPar.h.

      {
        return WireID(m_boardAndChannelToWire[bd][ch]);
      }

getWireSagCoef()

double getWireSagCoef	(	EWirePosition	set,
		uint	layerId,
		int	cellId
	)		const

Returns coefficient for the sense wire sag.

Parameters

set	Wire position set; =c_Base, c_Misaligned or c_Aligned
layerId	The layer id.
cellId	The cell id.

Returns

Coefficient for the sense wire sag.

Definition at line 1796 of file CDCGeometryPar.cc.

{
  double coef =    m_WireSagCoef[layerID][cellID];
  if (set == c_Misaligned) {
    coef = m_WireSagCoefMisalign[layerID][cellID];
  } else if (set == c_Aligned) {
    coef = m_WireSagCoefAlign   [layerID][cellID];
  }
  return coef;
}

getWireSagEffect()

void getWireSagEffect	(	EWirePosition	set,
		unsigned	layerID,
		unsigned	cellID,
		double	zw,
		double &	ywb_sag,
		double &	ywf_sag
	)		const

Compute effects of the sense wire sag.

Parameters

[in]	set	Wire position set; =c_Base, c_Misaligned or c_Aligned
[in]	layerID	Layer ID
[in]	cellID	Cell ID in the layer
[in]	zw	Z-coord. (cm) at which the sense wire sag is computed
[out]	ywb_sag	Y-corrd. (cm) of intersection between a tangent and the backward endplate.
[out]	ywf_sag	Y-corrd. (cm) of intersection between a tangent and the forward endplate.

Attention

The tangent is computed from the first derivative of a paraboric wire (due to gravity) defined at Z.

Definition at line 1960 of file CDCGeometryPar.cc.

{
  //Input
  //       set    : c_Base, c_Misaligned or c_Aligned
  //       layerID: layer id (0 - 55);
  //       cellID: cell  id in the layer;
  //            Z: Z-coord. (cm) at which sense wire sag is computed.
  //
  //Output Yb_sag: Y-corrd. (cm) of intersection of a tangent and the backward endplate.
  //               Here the tangent is computed from the 1'st derivative of
  //               a paraboric wire (due to gravity) defined at Z.
  //       Yf_sag: ibid. but for forward.
  //
  //N.B.- Maybe replaced with a bit more accurate formula.
  //    - The electrostatic force effect is not included.
 
  // return early in case of empty layer, i.e. layerID < m_firstLayerOffset
  if (layerID < m_firstLayerOffset) {
    Yb_sag = 0.;
    Yf_sag = 0.;
    return;
  }
 
  double Xb = 0.;
  double Xf = 0.;
  double Yb = 0.;
  double Yf = 0.;
  double Zb = 0.;
  double Zf = 0.;
  double Coef = 0.;
 
  if (set == c_Aligned) {
    Coef = m_WireSagCoefAlign[layerID][cellID];
    Yb = m_BWirPosAlign[layerID][cellID][1];
    Yf = m_FWirPosAlign[layerID][cellID][1];
    if (Coef == 0.) {
      Yb_sag = Yb;
      Yf_sag = Yf;
      return;
    }
    Xb = m_BWirPosAlign[layerID][cellID][0];
    Xf = m_FWirPosAlign[layerID][cellID][0];
    Zb = m_BWirPosAlign[layerID][cellID][2];
    Zf = m_FWirPosAlign[layerID][cellID][2];
 
  } else if (set == c_Misaligned) {
    Coef = m_WireSagCoefMisalign[layerID][cellID];
    Yb = m_BWirPosMisalign[layerID][cellID][1];
    Yf = m_FWirPosMisalign[layerID][cellID][1];
    if (Coef == 0.) {
      Yb_sag = Yb;
      Yf_sag = Yf;
      return;
    }
    Xb = m_BWirPosMisalign[layerID][cellID][0];
    Xf = m_FWirPosMisalign[layerID][cellID][0];
    Zb = m_BWirPosMisalign[layerID][cellID][2];
    Zf = m_FWirPosMisalign[layerID][cellID][2];
 
  } else if (set == c_Base) {
    Coef = m_WireSagCoef[layerID][cellID];
    Yb = m_BWirPos[layerID][cellID][1];
    Yf = m_FWirPos[layerID][cellID][1];
    if (Coef == 0.) {
      Yb_sag = Yb;
      Yf_sag = Yf;
      return;
    }
    Xb = m_BWirPos[layerID][cellID][0];
    Xf = m_FWirPos[layerID][cellID][0];
    Zb = m_BWirPos[layerID][cellID][2];
    Zf = m_FWirPos[layerID][cellID][2];
 
  } else {
    B2FATAL("CDCGeometryPar::getWireSagEffect: called with an invalid set: " << " " << set);
  }
 
  const double dx = Xf - Xb;
  const double dy = Yf - Yb;
  const double dz = Zf - Zb;
 
  const double Zfp = sqrt(dz * dz + dx * dx); // Wire length in z-x plane since Zbp==0
  const double Zp  = (Z - Zb) * Zfp / dz;
 
  const double Y_sag = (Coef * (Zp - Zfp) + dy / Zfp) * Zp + Yb;
  const double dydz = (Coef * (2.*Zp - Zfp) * Zfp + dy) / dz;
 
  Yb_sag = Y_sag + dydz * (Zb - Z);
  Yf_sag = Y_sag + dydz * (Zf - Z);
 
}

innerRadiusInnerWall()

double innerRadiusInnerWall ( ) const

inline

Returns the inner radius of the inner wall.

Returns

The inner radius of the inner wall.

Definition at line 1319 of file CDCGeometryPar.h.

    {
      return m_rWall[0];
    }

innerRadiusOuterWall()

double innerRadiusOuterWall ( ) const

inline

Returns the inner radius of the outer wall.

Returns

The inner radius of the outer wall.

Definition at line 1304 of file CDCGeometryPar.h.

    {
      return m_rWall[2];
    }

innerRadiusWireLayer()

const double * innerRadiusWireLayer

(

)

const

Returns an array of inner radius of wire layers.

Returns

An array of inner radius of wire layers.

Definition at line 1807 of file CDCGeometryPar.cc.

{
  static double IRWL[c_maxNSenseLayers] = {0};
 
  IRWL[0] = outerRadiusInnerWall();
  for (unsigned i = 1; i < nWireLayers(); i++)
    //IRWL[i] = (m_rSLayer[i - 1] + m_rSLayer[i]) / 2.;
    IRWL[i] = (i == m_firstLayerOffset) ? outerRadiusInnerWall() : m_rFLayer[i - 1];
 
  return IRWL;
}

Instance()

CDCGeometryPar & Instance ( const CDCGeometry *  geom = nullptr )

static

Static method to get a reference to the CDCGeometryPar instance.

Returns

A reference to an instance of this class.

Definition at line 32 of file CDCGeometryPar.cc.

{
  if (!m_B4CDCGeometryParDB) m_B4CDCGeometryParDB = new CDCGeometryPar(geom);
  return *m_B4CDCGeometryParDB;
}

isBadWire()

bool isBadWire ( const WireID &  wid )

inline

Inquire if the wire is totally-dead.

Definition at line 834 of file CDCGeometryPar.h.

      {
        //        std::map<unsigned short, float>::iterator it = m_badWire.find(wid.getEWire());
        //        bool torf = (it != m_badWire.end()) ? true : false;
        //        return torf;
        bool torf = *m_badWireFromDB ? (*m_badWireFromDB)->isBadWire(wid) : false;
        return torf;
 
      }

isDeadWire()

bool isDeadWire ( const WireID &  wid, double &  eff  )

inline

Inquire if the wire is dead.

Definition at line 847 of file CDCGeometryPar.h.

      {
        bool torf = *m_badWireFromDB ? (*m_badWireFromDB)->isDeadWire(wid, eff) : false;
        return torf;
      }

isHotWire()

bool isHotWire ( const WireID &  wid )

inline

Inquire if the wire is hot.

Definition at line 856 of file CDCGeometryPar.h.

      {
        bool torf = *m_badWireFromDB ? (*m_badWireFromDB)->isHotWire(wid) : false;
        return torf;
      }

isModifiedLeftRightFlagOn()

bool isModifiedLeftRightFlagOn ( ) const

inline

Returns on/off for modified left/right calculation in FullSim.

Definition at line 544 of file CDCGeometryPar.h.

      {
        return  m_modLeftRightFlag;
      }

isWireSagOn()

bool isWireSagOn ( ) const

inline

Returns on/off for sense wire sag in FullSim.

Definition at line 536 of file CDCGeometryPar.h.

      {
        return m_wireSag;
      }

momBound()

int momBound

(

)

const

to get the number of boundary position of the CDC mother volume

Returns

The number of boundary position of the CDC mother volume.

momRmin()

double momRmin ( int  iBound ) const

inline

Returns inner radius of the CDC mother volume.

Parameters

iBound

: The boundary id.

Returns

The inner radius of the specified baoundary position in the CDC mother volume

Definition at line 1239 of file CDCGeometryPar.h.

    {
      return m_momRmin[iBound];
    }

momZ()

double momZ ( int  iBound ) const

inline

Returns boundary position in Z axis of the CDC mother volume.

Parameters

iBound

: The boundary id.

Returns

The z component of the specified baoundary position in the CDC mother volume

Definition at line 1234 of file CDCGeometryPar.h.

    {
      return m_momZ[iBound];
    }

motherInnerR()

double motherInnerR

(

)

const

The method to get cdc mother volume inner R.

Returns

The inner radius of the cdc mother volume.

motherLength()

double motherLength

(

)

const

The method to get cdc mother volume length.

Returns

The length of the cdc mother volume.

motherOuterR()

double motherOuterR

(

)

const

The method to get cdc mother volume outer R.

Returns

The outer radius of the cdc mother volume.

newReadSigma()

void newReadSigma	(	const GearDir &	gbxParams,
		int	mode = 0
	)

Read spatial resolution table in new format.

Parameters

gbxParams	Gear Dir.
mode	0: read simulation file, 1: read reconstruction file.

Definition at line 957 of file CDCGeometryPar.cc.

{
  m_linearInterpolationOfSgm = true; //must be true now
 
  std::string fileName0 = CDCGeoControlPar::getInstance().getSigmaFile();
  if (mode == 1) {
    fileName0 = gbxParams.getString("sigma4ReconFileName");
  }
 
  ifstream ifs;
  //  openFile(ifs, fileName0);
  openFileA(ifs, fileName0);
 
  //read alpha bin info.
  unsigned short nAlphaBins = 0;
  if (ifs >> nAlphaBins) {
    if (nAlphaBins == 0 || nAlphaBins > c_maxNAlphaPoints) B2FATAL("Fail to read alpha bins !");
  } else {
    B2FATAL("Fail to read alpha bins !");
  }
  m_nAlphaPoints4Sgm = nAlphaBins;
  //  std:: cout << nAlphaBins << std::endl;
  double alpha0, alpha1, alpha2;
  for (unsigned short i = 0; i < nAlphaBins; ++i) {
    ifs >> alpha0 >> alpha1 >> alpha2;
    m_alphaPoints4Sgm[i] = alpha2;
    //    std:: cout << alpha2 << std::endl;
  }
 
  //read theta bin info.
  unsigned short nThetaBins = 0;
  if (ifs >> nThetaBins) {
    if (nThetaBins == 0 || nThetaBins > c_maxNThetaPoints) B2FATAL("CDCGeometryPar: fail to read theta bins !");
  } else {
    B2FATAL("CDCGeometryPar: fail to read theta bins !");
  }
  m_nThetaPoints4Sgm = nThetaBins;
  //  std:: cout << nThetaBins << std::endl;
  double theta0, theta1, theta2;
 
  for (unsigned short i = 0; i < nThetaBins; ++i) {
    ifs >> theta0 >> theta1 >> theta2;
    m_thetaPoints4Sgm[i] = theta2;
    //    std:: cout << theta2 << std::endl;
  }
 
  unsigned short np = 0;
  unsigned short iCL, iLR;
  double sigma[c_nSigmaParams]; // cppcheck-suppress constVariable
  double theta, alpha;
 
  ifs >> m_sigmaParamMode >> np;
  //  std:: cout << m_sigmaParamMode <<" "<< np << std::endl;
  if (m_sigmaParamMode < 0 || m_sigmaParamMode > 4) B2FATAL("CDCGeometryPar: invalid sigma-parameterization mode read !");
 
  if (np > c_nSigmaParams) B2FATAL("CDCGeometryPar: no. of sigma-params. outside limits !");
 
  ifs >> m_maxSpaceResol;
 
  const double epsi = 0.1;
 
  while (ifs >> iCL) {
 
    if (iCL < m_firstLayerOffset) {
      continue;
    }
 
    ifs >> theta >> alpha >> iLR;
    //    std::cout << iCL <<" "<< theta <<" "<< alpha <<" "<< iLR << std::endl;
    for (int i = 0; i < np; ++i) {
      ifs >> sigma[i];
    }
 
    int itheta = -99;
    for (unsigned short i = 0; i < nThetaBins; ++i) {
      if (fabs(theta - m_thetaPoints4Sgm[i]) < epsi) {
        itheta = i;
        break;
      }
    }
    if (itheta < 0) B2FATAL("CDCGeometryPar: thetas in sigma.dat are inconsistent !");
 
    int ialpha = -99;
    for (unsigned short i = 0; i < nAlphaBins; ++i) {
      if (fabs(alpha - m_alphaPoints4Sgm[i]) < epsi) {
        ialpha = i;
        break;
      }
    }
    if (ialpha < 0) B2FATAL("CDCGeometryPar: alphas in sigma.dat are inconsistent !");
 
    for (int i = 0; i < np; ++i) {
      m_Sigma[iCL][iLR][ialpha][itheta][i] = sigma[i];
    }
  }  //end of while loop
 
  ifs.close();
 
  //convert unit
  const double degrad = M_PI / 180.;
  for (unsigned i = 0; i < nAlphaBins; ++i) {
    m_alphaPoints4Sgm[i] *= degrad;
  }
  for (unsigned i = 0; i < nThetaBins; ++i) {
    m_thetaPoints4Sgm[i] *= degrad;
  }
 
  //  std::cout << "end of newreadsigma " << std::endl;
}

newReadXT()

void newReadXT	(	const GearDir &	gbxParams,
		int	mode = 0
	)

Read XT-relation table in new format.

Parameters

[in]	gbxParams	Gear Dir.
[in]	mode	0: read simulation file, 1: read reconstruction file.

Definition at line 811 of file CDCGeometryPar.cc.

{
  m_linearInterpolationOfXT = true;  //must be true now
 
  std::string fileName0 = CDCGeoControlPar::getInstance().getXtFile();
  if (mode == 1) {
    fileName0 = gbxParams.getString("xt4ReconFileName");
  }
 
  boost::iostreams::filtering_istream ifs;
  openFileB(ifs, fileName0);
  //TODO: use openFile() in cdc/utilities instead of the following 18 lines <- done
  /*
  std::string fileName1 = "/data/cdc/" + fileName0;
  std::string fileName = FileSystem::findFile(fileName1);
 
  if (fileName == "") {
    fileName = FileSystem::findFile(fileName0);
  }
 
  if (fileName == "") {
    B2FATAL("CDCGeometryPar: " << fileName1 << " not exist!");
  } else {
    B2INFO("CDCGeometryPar: open " << fileName1);
    if ((fileName.rfind(".gz") != string::npos) && (fileName.length() - fileName.rfind(".gz") == 3)) {
      ifs.push(boost::iostreams::gzip_decompressor());
    }
    ifs.push(boost::iostreams::file_source(fileName));
    if (!ifs) B2FATAL("CDCGeometryPar: cannot open " << fileName1 << " !");
  }
  */
 
  //read alpha bin info.
  unsigned short nAlphaBins = 0;
  if (ifs >> nAlphaBins) {
    if (nAlphaBins == 0 || nAlphaBins > c_maxNAlphaPoints) B2FATAL("Fail to read alpha bins !");
  } else {
    B2FATAL("Fail to read alpha bins !");
  }
  m_nAlphaPoints = nAlphaBins;
  double alpha0, alpha1, alpha2;
  for (unsigned short i = 0; i < nAlphaBins; ++i) {
    ifs >> alpha0 >> alpha1 >> alpha2;
    m_alphaPoints[i] = alpha2;
  }
 
  //read theta bin info.
  unsigned short nThetaBins = 0;
  if (ifs >> nThetaBins) {
    if (nThetaBins == 0 || nThetaBins > c_maxNThetaPoints) B2FATAL("CDCGeometryPar: fail to read theta bins !");
  } else {
    B2FATAL("CDCGeometryPar: fail to read theta bins !");
  }
  m_nThetaPoints = nThetaBins;
  double theta0, theta1, theta2;
 
  for (unsigned short i = 0; i < nThetaBins; ++i) {
    ifs >> theta0 >> theta1 >> theta2;
    m_thetaPoints[i] = theta2;
  }
 
  short np = 0;
  unsigned short iCL, iLR;
  const unsigned short npx = c_nXTParams - 1;
  double xtc[npx];
  double theta, alpha, dummy1;
 
  ifs >> m_xtParamMode >> np;
  if (m_xtParamMode < 0 || m_xtParamMode > 3) B2FATAL("CDCGeometryPar: invalid xt-parameterization mode read !");
 
  if (np <= 0 || np > npx) B2FATAL("CDCGeometryPar: no. of xt-params. outside limits !");
 
  const double epsi = 0.1;
 
  while (ifs >> iCL) {
 
    if (iCL < m_firstLayerOffset) {
      continue;
    }
 
    ifs >> theta >> alpha >> dummy1 >> iLR;
    for (int i = 0; i < np; ++i) {
      ifs >> xtc[i];
    }
 
    int itheta = -99;
    for (unsigned short i = 0; i < nThetaBins; ++i) {
      if (fabs(theta - m_thetaPoints[i]) < epsi) {
        itheta = i;
        break;
      }
    }
    if (itheta < 0) B2FATAL("CDCGeometryPar: thetas in xt.dat are inconsistent !");
 
    int ialpha = -99;
    for (unsigned short i = 0; i < nAlphaBins; ++i) {
      if (fabs(alpha - m_alphaPoints[i]) < epsi) {
        ialpha = i;
        break;
      }
    }
    if (ialpha < 0) B2FATAL("CDCGeometryPar: alphas in xt.dat are inconsistent !");
 
    for (int i = 0; i < np; ++i) {
      m_XT[iCL][iLR][ialpha][itheta][i] = xtc[i];
    }
 
    double boundT = xtc[6];
    if (m_xtParamMode == 1) {
      m_XT[iCL][iLR][ialpha][itheta][np] = ROOT::Math::Chebyshev5(boundT, xtc[0], xtc[1], xtc[2], xtc[3], xtc[4], xtc[5]);
    } else {
      m_XT[iCL][iLR][ialpha][itheta][np] =
        xtc[0] + boundT
        * (xtc[1] + boundT
           * (xtc[2] + boundT
              * (xtc[3] + boundT
                 * (xtc[4] + boundT
                    * (xtc[5])))));
    }
  }  //end of while loop
 
  //  ifs.close();
  boost::iostreams::close(ifs);
 
  //convert unit
  const double degrad = M_PI / 180.;
  for (unsigned i = 0; i < nAlphaBins; ++i) {
    m_alphaPoints[i] *= degrad;
  }
  for (unsigned i = 0; i < nThetaBins; ++i) {
    m_thetaPoints[i] *= degrad;
  }
 
}

nShifts()

int nShifts ( int  layerId ) const

inline

Returns number shift.

Parameters

layerId

The layer id of sense wires.

Returns

The shifted cell number in layer layerId.

Definition at line 1244 of file CDCGeometryPar.h.

    {
      return m_nShifts[layerID];
    }

nWireLayers()

unsigned nWireLayers ( ) const

inline

Returns a number of wire layers.

Returns

The number of wire layers.

Definition at line 1354 of file CDCGeometryPar.h.

    {
      return c_maxNSenseLayers;
    }

nWiresInLayer()

unsigned nWiresInLayer ( int  layerId ) const

inline

Returns wire numbers in a layer.

Parameters

layerId

The layer id.

Returns

Wire number in layer layerId.

Definition at line 1254 of file CDCGeometryPar.h.

    {
      return m_nWires[layerID];
    }

offset()

double offset ( int  layerID ) const

inline

Return wire offset in phi direction at endplate.

Parameters

layerID

layerID(0-55).

Returns

offset value.

Definition at line 1249 of file CDCGeometryPar.h.

    {
      return m_offSet[layerID];
    }

outerRadiusInnerWall()

double outerRadiusInnerWall ( ) const

inline

Returns the outer radius of the inner wall.

Returns

The outer radius of the inner wall.

Definition at line 1324 of file CDCGeometryPar.h.

    {
      return m_rWall[1];
    }

outerRadiusOuterWall()

double outerRadiusOuterWall ( ) const

inline

Returns the outer radius of the outer wall.

Returns

The outer radius of the outer wall.

Definition at line 1309 of file CDCGeometryPar.h.

    {
      return m_rWall[3];
    }

outerRadiusWireLayer()

const double * outerRadiusWireLayer

(

)

const

Returns an array of outer radius of wire layers.

Returns

A array of outer radius of wire layers.

Definition at line 1819 of file CDCGeometryPar.cc.

{
  static double ORWL[c_maxNSenseLayers] = {0};
 
  ORWL[nWireLayers() - 1] = innerRadiusOuterWall();
  for (unsigned i = 0; i < nWireLayers() - 1; i++)
    //ORWL[i] = (m_rSLayer[i] + m_rSLayer[i + 1]) / 2.;
    ORWL[i] = m_rFLayer[i];
 
  return ORWL;
}

outputDesignWirParam()

void outputDesignWirParam	(	unsigned	layerID,
		unsigned	cellID
	)		const

Write the designed wire parameters to the alignment.dat (default).

Parameters

[in]	layerID	Layer ID
[in]	cellID	Cell ID

Definition at line 2090 of file CDCGeometryPar.cc.

{
 
  const unsigned L = layerID;
  const unsigned C =  cellID;
 
  static bool first = true;
  static ofstream ofs;
  if (first) {
    first = false;
    ofs.open("alignment.dat");
  }
 
  ofs << L << "  " << C;
 
  ofs << setiosflags(ios::showpoint | ios::uppercase);
 
  for (int i = 0; i < 3; ++i) ofs << "  " <<  setw(15) << setprecision(8) << m_BWirPos[L][C][i];
 
  for (int i = 0; i < 3; ++i) ofs << "  " <<  setw(15) << setprecision(8) << m_FWirPos[L][C][i];
  ofs << setiosflags(ios::fixed);
  ofs << "  " <<  setw(4) << setprecision(1) << m_senseWireTension;
 
  ofs << endl;
}

Print()

void Print

(

)

const

Print some debug information.

Definition at line 1696 of file CDCGeometryPar.cc.

{}

readChMap()

void readChMap

(

)

Read channel map between wire-id and electronics-id.

Definition at line 1270 of file CDCGeometryPar.cc.

{
  std::string fileName0 = CDCGeoControlPar::getInstance().getChMapFile();
 
  ifstream ifs;
  //  openFile(ifs, fileName0);
  openFileA(ifs, fileName0);
 
  unsigned short iSL, iL, iW, iB, iC;
  unsigned nRead = 0;
 
  while (true) {
    // Read a relation
    ifs >> iSL >> iL >> iW >> iB >> iC;
    if (ifs.eof()) break;
    if (iSL >= c_nSuperLayers or iSL < m_firstSuperLayerOffset) continue;
 
    ++nRead;
    WireID wID(iSL, iL, iW);
    m_wireToBoard.insert(pair<WireID, unsigned short>(wID, iB));
  }
 
  if (nRead != m_nSenseWires) B2FATAL("CDCGeometryPar::readChMap: #lines read-in (=" << nRead <<
                                        ") is inconsistent with #sense-wires (="
                                        << m_nSenseWires << ") !");
 
  ifs.close();
}

readEDepToADC()

void readEDepToADC	(	const GearDir &	gbxParams,
		int	mode = 0
	)

Read spatial edep-to-adc conv.

factors.

Parameters

gbxParams	Gear Dir.
mode	dummy now..

Definition at line 1301 of file CDCGeometryPar.cc.

{
  //  B2WARNING("CDCGeometryPar: readEDepToADC is not ready!");
  std::string fileName0 = CDCGeoControlPar::getInstance().getEDepToADCFile();
  if (mode == 1) {
    fileName0 = gbxParams.getString("fudgeFactorFileName");
  }
 
  ifstream ifs;
  //  openFileA(ifs, fileName0);
  std::string fileName1 = "/data/cdc/" + fileName0;
  std::string fileName = FileSystem::findFile(fileName1, true);
 
  if (fileName == "") {
    fileName = FileSystem::findFile(fileName0, true);
  }
 
  if (fileName == "") {
    B2FATAL("CDC::openFile: " << fileName0 << " not exist!");
  } else {
    //    B2INFO("CDC::openFile: open " << fileName);
    B2DEBUG(29, "CDC::openFile: open " << fileName);
    ifs.open(fileName.c_str());
    if (!ifs) B2FATAL("CDC::openFile: cannot open " << fileName << " !");
  }
 
  unsigned short paramMode(0), nParams(0);
  ifs >> paramMode >> nParams;
  if (paramMode > 1) B2FATAL("Param mode > 1!");
  if (nParams > 7)   B2FATAL("No. of params. > 7!");
  unsigned short groupId(0);
  ifs >> groupId;
  B2DEBUG(29, paramMode << " " << nParams << " " << groupId);
  if (groupId > 0) B2FATAL("GgroupId > 0!");
 
 
  unsigned short cLMin[c_nSuperLayers], cLMax[c_nSuperLayers]; //min and max clayer per super-layer
  cLMin[0] = 0;
  cLMax[0] = 7;
  for (unsigned int sl = 1; sl < c_nSuperLayers; ++sl) {
    cLMin[sl] = cLMax[0] + 6 * sl - 5;
    cLMax[sl] = cLMax[0] + 6 * sl;
  }
 
  unsigned short id = 0;
  double coef = 0.;
  unsigned short nRead = 0;
  while (ifs >> id) {
    for (unsigned short i = 0; i < nParams; ++i) {
      ifs  >> coef;
      for (unsigned short cL = cLMin[id]; cL <= cLMax[id]; ++cL) { //clayer loop
        for (unsigned short cell = 0; cell < m_nWires[cL]; ++cell) { //cell loop
          m_eDepToADCParams[cL][cell][i] = (cL < m_firstLayerOffset) ? 0 : coef;
          //    B2DEBUG(29, "cL,cell,i,coef= "<< cL <<" "<< cell <<" "<< i <<" "<< coef);
        }
      }
    }
    ++nRead;
    if (nRead > c_nSuperLayers) B2FATAL("No. of read in lines > " << c_nSuperLayers << " !");
  }
 
  ifs.close();
}

readFFactor()

void readFFactor	(	const GearDir &	gbxParams,
		int	mode = 0
	)

Read fudge factors.

Parameters

gbxParams	Gear Dir.
mode	dummy now.

Definition at line 1069 of file CDCGeometryPar.cc.

{
  std::string fileName0 = CDCGeoControlPar::getInstance().getFFactorFile();
  if (mode == 1) {
    fileName0 = gbxParams.getString("fudgeFactorFileName");
  }
  B2WARNING("readFFactor is not ready! " << fileName0);
  //TODO; implement the following part.
}

readFromDB()

void readFromDB

(

const CDCGeometry &

geom

)

Gets geometry parameters from database.

Definition at line 253 of file CDCGeometryPar.cc.

{
  m_globalPhiRotation = geom.getGlobalPhiRotation();
  //  m_globalPhiRotation = geom.getGlobalOffsetC();
 
  // Get inner wall parameters
  m_rWall[0]    = geom.getInnerWall(2).getRmin();
  m_zWall[0][0] = geom.getInnerWall(0).getZbwd();
  m_zWall[0][1] = geom.getInnerWall(0).getZfwd();
 
  m_rWall[1] = geom.getInnerWall(0).getRmax();
  m_zWall[1][0] = geom.getInnerWall(0).getZbwd();
  m_zWall[1][1] = geom.getInnerWall(0).getZbwd();
 
  // Get outer wall parameters
  m_rWall[2] = geom.getOuterWall(0).getRmin();
  m_zWall[2][0] = geom.getOuterWall(0).getZbwd();
  m_zWall[2][1] = geom.getOuterWall(0).getZfwd();
 
  m_rWall[3] = geom.getOuterWall(1).getRmax();
  m_zWall[3][0] = geom.getOuterWall(0).getZbwd();
  m_zWall[3][1] = geom.getOuterWall(0).getZfwd();
 
  // Get sense layers parameters
  m_debug = CDCGeoControlPar::getInstance().getDebug();
  m_nSLayer = geom.getNSenseLayers();
 
  m_materialDefinitionMode = CDCGeoControlPar::getInstance().getMaterialDefinitionMode();
  //  std::cout << m_materialDefinitionMode << std::endl;
  if (m_materialDefinitionMode == 0) {
    B2DEBUG(100, "CDCGeometryPar: Define a mixture of gases and wires in the tracking volume.");
  } else if (m_materialDefinitionMode == 2) {
    //    B2INFO("CDCGeometryPar: Define all sense and field wires explicitly in the tracking volume.");
    B2FATAL("CDCGeometryPar: Materialdefinition=2 is disabled for now.");
  } else {
    B2FATAL("CDCGeometryPar: Materialdefinition mode you specify is invalid.");
  }
 
  // Get mode for wire z-position
  m_senseWireZposMode = CDCGeoControlPar::getInstance().getSenseWireZposMode();
  //Set z corrections (from input data)
  B2DEBUG(100, "CDCGeometryPar: Sense wire z mode:" << m_senseWireZposMode);
 
  //
  // The DB version should be implemented ASAP.
  //
  GearDir content = GearDir("/Detector/DetectorComponent[@name=\"CDC\"]/Content/");
  GearDir gbxParams(content);
  //  if (m_senseWireZposMode == 1) readDeltaz(gbxParams);
 
 
  //
  // Sense wires.
  //
  for (const auto& sense : geom.getSenseLayers()) {
    uint layerId = sense.getId();
 
    m_rSLayer[layerId]          = sense.getR();
    m_zSBackwardLayer[layerId]  = sense.getZbwd();
    m_zSForwardLayer[layerId]   = sense.getZfwd();
    m_nWires[layerId]           = sense.getNWires();
    m_nShifts[layerId]          = sense.getNShifts();
    m_offSet[layerId]           = sense.getOffset();
    m_cellSize[layerId]         = 2 * M_PI * m_rSLayer[layerId] / (double) m_nWires[layerId];
    m_dzSBackwardLayer[layerId] = sense.getDZbwd();
    m_dzSForwardLayer[layerId]  = sense.getDZfwd();
 
    //correction to z-position
    if (m_senseWireZposMode == 0) {
    } else if (m_senseWireZposMode == 1) {
      //      m_zSBackwardLayer[layerId] += m_bwdDz[layerId];
      //      m_zSForwardLayer [layerId] += m_fwdDz[layerId];
      m_zSBackwardLayer[layerId] += m_dzSBackwardLayer[layerId];
      m_zSForwardLayer [layerId] -= m_dzSForwardLayer [layerId];
    } else {
      B2FATAL("CDCGeometryPar: invalid wire z definition mode specified");
    }
 
    //Set design sense-wire related params.
    const int nWires = m_nWires[layerId];
    for (int iCell = 0; iCell < nWires; ++iCell) {
      setDesignWirParam(layerId, iCell);
    }
 
  }
 
  // Get field layers parameters
  for (const auto& field : geom.getFieldLayers()) {
    uint layerId = field.getId();
 
    m_rFLayer[layerId]          = field.getR();
    m_zFBackwardLayer[layerId]  = field.getZbwd();
    m_zFForwardLayer[layerId]   = field.getZfwd();
  }
 
  // Get sense wire diameter
  m_senseWireDiameter = geom.getSenseDiameter();
 
  // Get sense wire tension
  m_senseWireTension = geom.getSenseTension();
 
  //  // Get sense wire density
  m_senseWireDensity = 19.3; // g/cm3  <- tentatively hard-coded here
 
  // Get field wire diameter
  m_fieldWireDiameter = geom.getFieldDiameter();
 
  // Get information on the number of (super) layers etc.
  m_nSenseWires           = geom.getNSenseWires();
  m_nFieldWires           = geom.getNFieldWires();
  m_maxNSenseLayers       = geom.getNumberOfSenseLayers();
  m_maxNFieldLayers       = geom.getNumberOfFieldLayers();
  m_maxNSuperLayers       = geom.getMaxNumberOfSuperLayers();
  m_firstLayerOffset      = geom.getOffsetOfFirstLayer();
  m_firstSuperLayerOffset = geom.getOffsetOfFirstSuperLayer();
  m_maxNCellsPerLayer     = geom.getMaxNumberOfCellsPerLayer();
 
  //Set various quantities (should be moved to CDC.xml later...)
  m_clockFreq4TDC = geom.getClockFrequency();
  if (not m_clockSettings.isValid())
    B2FATAL("HardwareClockSettings payloads are not valid.");
  const double officialClockFreq4TDC = 2 * m_clockSettings->getAcceleratorRF(); // in GHz
  if (abs(m_clockFreq4TDC - officialClockFreq4TDC) / m_clockFreq4TDC > 1.e-4) {
    B2WARNING("ClockFreq4TDC changed from cdclocal " << scientific << setprecision(6) << m_clockFreq4TDC << " to official " <<
              officialClockFreq4TDC << " (GHz) (difference larger than 0.01%)");
    m_clockFreq4TDC = officialClockFreq4TDC;
  }
  B2DEBUG(100, "CDCGeometryPar: Clock freq. for TDC= " << m_clockFreq4TDC << " (GHz).");
  m_tdcBinWidth = 1. / m_clockFreq4TDC;  //in ns
  B2DEBUG(100, "CDCGeometryPar: TDC bin width= " << m_tdcBinWidth << " (ns).");
 
  m_nominalDriftV    = 4.e-3;  //in cm/ns
  m_nominalDriftVInv = 1. / m_nominalDriftV; //in ns/cm
  m_nominalPropSpeed = 27.25;  //in cm/nsec (Belle's result, provided by iwasaki san)
 
  m_nominalSpaceResol = geom.getNominalSpaceResolution();
  CDCGeoControlPar& gcp = CDCGeoControlPar::getInstance();
 
  //Set displacement params. (from input data)
  m_displacement = CDCGeoControlPar::getInstance().getDisplacement();
  B2DEBUG(100, "CDCGeometryPar: Load displacement params. (=1); not load (=0):" << m_displacement);
  if (m_displacement) {
    if (gcp.getDisplacementInputType()) {
      B2DEBUG(100, "CDCGeometryPar: Read displacement from DB");
      setDisplacement();
    } else {
      readWirePositionParams(c_Base, &geom);
    }
  }
 
  //Set alignment params. (from input data)
  m_alignment = CDCGeoControlPar::getInstance().getAlignment();
  B2DEBUG(100, "CDCGeometryPar: Load alignment params. (=1); not load (=0):" <<
          m_alignment);
  if (m_alignment) {
    if (gcp.getAlignmentInputType()) {
      B2DEBUG(100, "CDCGeometryPar: Read alignment from DB");
      setWirPosAlignParams();
    } else {
      readWirePositionParams(c_Aligned, &geom);
    }
  }
 
  //Set misalignment params. (from input data)
  m_misalignment = CDCGeoControlPar::getInstance().getMisalignment();
  B2DEBUG(100, "CDCGeometryPar: Load misalignment params. (=1); not load (=0):" <<
          m_misalignment);
  if (m_misalignment) {
    if (gcp.getMisalignmentInputType()) {
      B2DEBUG(100, "CDCGeometryPar: Read misalignment from DB");
      setWirPosMisalignParams();
    } else {
      readWirePositionParams(c_Misaligned, &geom);
    }
  }
 
  // Get control params. for CDC FullSim
  m_thresholdEnergyDeposit = CDCSimControlPar::getInstance().getThresholdEnergyDeposit();
  m_minTrackLength = CDCSimControlPar::getInstance().getMinTrackLength();
  m_wireSag = CDCSimControlPar::getInstance().getWireSag();
  m_modLeftRightFlag = CDCSimControlPar::getInstance().getModLeftRightFlag();
  if (m_modLeftRightFlag) {
    B2FATAL("ModifiedLeftRightFlag = true is disabled for now; need to update a G4-related code in framework...");
  }
  //N.B. The following two lines are hard-coded since only =1 are used now.
  m_xtFileFormat = 1;
  m_sigmaFileFormat = 1;
 
  m_XTetc = true;
  if (m_XTetc) {
    if (gcp.getXtInputType()) {
      B2DEBUG(100, "CDCGeometryPar: Read xt from DB");
      setXtRel();  //Set xt param. (from DB)
    } else {
      readXT(gbxParams);  //Read xt params. (from file)
    }
 
    if (gcp.getSigmaInputType()) {
      B2DEBUG(100, "CDCGeometryPar: Read sigma from DB");
      setSResol();  //Set sigma param. (from DB)
    } else {
      readSigma(gbxParams);  //Read sigma params. (from file)
    }
 
    if (gcp.getFFactorInputType()) {
      B2DEBUG(100, "CDCGeometryPar: Read fudge factors from DB");
      setFFactor();  //Set fudge factors (from DB)
    } else {
      readFFactor(gbxParams);  //Read fudge factors (from file)
    }
 
    if (gcp.getPropSpeedInputType()) {
      B2DEBUG(100, "CDCGeometryPar: Read prop-speed from DB");
      setPropSpeed();  //Set prop-speed (from DB)
    } else {
      readPropSpeed(gbxParams);  //Read propagation speed
    }
 
    if (gcp.getT0InputType()) {
      B2DEBUG(100, "CDCGeometryPar: Read t0 from DB");
      setT0();  //Set t0 (from DB)
    } else {
      readT0(gbxParams);  //Read t0 (from file)
    }
 
    if (gcp.getBwInputType()) {
      B2DEBUG(100, "CDCGeometryPar: Read badwire from DB");
      setBadWire();  //Set bad-wire (from DB)
    } else {
      //      readBadWire(gbxParams);  //Read bad-wire (from file)
      B2FATAL("Text file input mode for bdwires is disabled now!");
    }
 
    if (gcp.getChMapInputType()) {
      B2DEBUG(100, "CDCGeometryPar: Read ch-map from DB");
      setChMap();  //Set ch-map (from DB)
    } else {
      readChMap();  //Read ch-map
    }
 
    if (gcp.getTwInputType()) {
      B2DEBUG(100, "CDCGeometryPar: Read time-walk from DB");
      setTW();  //Set time-walk coeffs. (from DB)
    } else {
      readTW(gbxParams);  //Read time-walk coeffs. (from file)
    }
    B2DEBUG(100, "CDCGeometryPar: Time-walk param. mode= " << m_twParamMode);
 
    if (gcp.getEDepToADCInputType()) {
      B2DEBUG(29, "CDCGeometryPar: Read EDepToADC from DB");
      if ((*m_eDepToADCConversionsFromDB).isValid()) {
        setEDepToADCConversions(); //Set edep-to-adc (from DB)
      }
    } else {
      readEDepToADC(gbxParams);  //Read edep-to-adc params. (from file)
    }
  }
 
  m_XTetc4Recon = 0;
  //  B2INFO("CDCGeometryPar: Load x-t etc. params. for reconstruction (=1); not load and use the same ones for digitization (=0):" <<
  //  B2INFO("CDCGeometryPar: Use the same x-t etc. for reconstruction as those used for digitization");
  if (m_XTetc4Recon) {
    readXT(gbxParams, 1);
    readSigma(gbxParams, 1);
    readPropSpeed(gbxParams, 1);
    readT0(gbxParams, 1);
    readTW(gbxParams, 1);
  }
 
  //calculate and save shifts in super-layers
  setShiftInSuperLayer();
 
}

readPropSpeed()

void readPropSpeed	(	const GearDir &	gbxParams,
		int	mode = 0
	)

Read the propagation speed along the sense wire.

Parameters

gbxParams	Gear Dir.
mode	0: read simulation file, 1: read reconstruction file.

Definition at line 1081 of file CDCGeometryPar.cc.

{
  std::string fileName0 = CDCGeoControlPar::getInstance().getPropSpeedFile();
  if (mode == 1) {
    fileName0 = gbxParams.getString("propSpeed4ReconFileName");
  }
 
  ifstream ifs;
  //  openFile(ifs, fileName0);
  openFileA(ifs, fileName0);
 
  uint iL;
  double speed;
  unsigned nRead = 0;
 
  while (true) {
    ifs >> iL >> speed;
    if (ifs.eof()) break;
 
    ++nRead;
 
    m_propSpeedInv[iL] = (iL < m_firstLayerOffset) ? 0 : 1. / speed;
 
    if (m_debug) B2DEBUG(150, iL << " " << speed);
  }
 
  if (nRead != c_maxNSenseLayers) B2FATAL("CDCGeometryPar::readPropSpeed: #lines read-in (=" << nRead <<
                                            ") is inconsistent with total #layers (=" << c_maxNSenseLayers << ") !");
 
  ifs.close();
}

readSigma()

void readSigma	(	const GearDir &	gbxParams,
		int	mode = 0
	)

Read spatial resolution table.

Parameters

gbxParams	Gear Dir.
mode	0: read simulation file, 1: read reconstruction file.

Definition at line 948 of file CDCGeometryPar.cc.

{
  if (m_sigmaFileFormat == 0) {
    //    oldReadSigma(gbxParams, mode);
  } else {
    newReadSigma(gbxParams, mode);
  }
}

readT0()

void readT0	(	const GearDir &	gbxParams,
		int	mode = 0
	)

Read t0 parameters (from a file).

Parameters

gbxParams	Gear Dir.
mode	0: read simulation file, 1: read reconstruction file.

Definition at line 1149 of file CDCGeometryPar.cc.

{
  std::string fileName0 = CDCGeoControlPar::getInstance().getT0File();
  if (mode == 1) {
    fileName0 = gbxParams.getString("t04ReconFileName");
  }
 
  ifstream ifs;
  //  openFile(ifs, fileName0);
  openFileA(ifs, fileName0);
 
  uint iL(0), iC(0);
  float t0(0);
  unsigned nRead = 0;
 
  while (true) {
    ifs >> iL >> iC >> t0;
 
    if (iL < m_firstLayerOffset) {
      continue;
    }
 
    if (ifs.eof()) break;
 
    ++nRead;
 
    m_t0[iL][iC] = (iL < m_firstLayerOffset) ? 0. : t0;
 
    if (m_debug) {
      B2DEBUG(150, iL << " " << iC << " " << t0);
    }
  }
 
  if (nRead != m_nSenseWires) B2FATAL("CDCGeometryPar::readT0: #lines read-in (=" << nRead <<
                                        ") is inconsistent with total #sense wires (=" << m_nSenseWires << ") !");
 
  ifs.close();
 
  calcMeanT0();
}

readTW()

void readTW	(	const GearDir &	gbxParams,
		int	mode = 0
	)

Read time-walk parameter.

Parameters

gbxParams	Gear Dir.
mode	0: read simulation file, 1: read reconstruction file.

Definition at line 1230 of file CDCGeometryPar.cc.

{
  std::string fileName0 = CDCGeoControlPar::getInstance().getTwFile();
  if (mode == 1) {
    fileName0 = gbxParams.getString("tw4ReconFileName");
  }
 
  ifstream ifs;
  //  openFile(ifs, fileName0);
  openFileA(ifs, fileName0);
 
  unsigned short nPars(0);
  ifs >> m_twParamMode >> nPars;
  if (m_twParamMode > 1) {
    B2FATAL("CDCGeometryPar::readTW: invalid mode specified!");
  }
  if (nPars > 2) {
    B2FATAL("CDCGeometryPar::readTW: invalid #params specified!");
  }
 
  unsigned iBoard = 0;
  unsigned nRead = 0;
  // Read board id and coefficients
  while (ifs >> iBoard) {
    for (unsigned short i = 0; i < nPars; ++i) {
      ifs >> m_timeWalkCoef[iBoard][i];
    }
    ++nRead;
  }
 
  if (nRead != c_nBoards) B2FATAL("CDCGeometryPar::readTW: #lines read-in (=" << nRead << ") is inconsistent with #boards (=" <<
                                    c_nBoards
                                    << ") !");
 
  ifs.close();
}

readWirePositionParams()

void readWirePositionParams	(	EWirePosition	set,
		const CDCGeometry *	geom
	)

Read displacement or (mis)alignment params from text file.

Parameters

[in]	set	Wire position set, i.e. c_Base, c_Misaliged or c_Aligned.
[in]	geom	Pointer to DB CDCGeometry db object.

Definition at line 572 of file CDCGeometryPar.cc.

{
 
  std::string fileName0;
  CDCGeoControlPar& gcp = CDCGeoControlPar::getInstance();
  if (geom) {
    if (set == c_Base) {
      fileName0 = gcp.getDisplacementFile();
    } else if (set == c_Misaligned) {
      fileName0 = gcp.getMisalignmentFile();
    } else if (set == c_Aligned) {
      fileName0 = gcp.getAlignmentFile();
    }
  } else {
    if (set == c_Base) {
      fileName0 = gcp.getDisplacementFile();
    } else if (set == c_Misaligned) {
      fileName0 = gcp.getMisalignmentFile();
    } else if (set == c_Aligned) {
      fileName0 = gcp.getAlignmentFile();
    }
  }
 
  //  ifstream ifs;
  //  openFile(ifs, fileName0);
  boost::iostreams::filtering_istream ifs;
  openFileB(ifs, fileName0);
 
  uint iL(0), iC(0);
  const int np = 3;
  double back[np], fwrd[np], tension;
  unsigned nRead = 0;
 
  while (true) {
    ifs >> iL >> iC;
    for (int i = 0; i < np; ++i) {
      ifs >> back[i];
    }
    for (int i = 0; i < np; ++i) {
      ifs >> fwrd[i];
    }
    //    if (set != c_Base)  ifs >> tension;
    ifs >> tension;
 
    if (ifs.eof()) break;
 
    if (iL < m_firstLayerOffset) {
      continue;
    }
 
    ++nRead;
 
    for (int i = 0; i < np; ++i) {
      if (set == c_Base) {
        m_BWirPos[iL][iC][i] += (iL < m_firstLayerOffset) ? 0 : back[i];
        m_FWirPos[iL][iC][i] += (iL < m_firstLayerOffset) ? 0 : fwrd[i];
      } else if (set == c_Misaligned) {
        m_BWirPosMisalign[iL][iC][i] = m_BWirPos[iL][iC][i] + ((iL < m_firstLayerOffset) ? 0 : back[i]);
        m_FWirPosMisalign[iL][iC][i] = m_FWirPos[iL][iC][i] + ((iL < m_firstLayerOffset) ? 0 : fwrd[i]);
      } else if (set == c_Aligned) {
        m_BWirPosAlign[iL][iC][i] = m_BWirPos[iL][iC][i] + ((iL < m_firstLayerOffset) ? 0 : back[i]);
        m_FWirPosAlign[iL][iC][i] = m_FWirPos[iL][iC][i] + ((iL < m_firstLayerOffset) ? 0 : fwrd[i]);
      }
    }
 
    //    double baseTension = 0.;
 
    if (set == c_Base) {
      m_WireSagCoef[iL][iC] = (iL < m_firstLayerOffset) ? 0 : M_PI * m_senseWireDensity * m_senseWireDiameter * m_senseWireDiameter /
                              (8.*(m_senseWireTension + tension));
      //      std::cout <<"base iL, iC, m_senseWireTension, tension= " << iL <<" " << iC <<" "<< m_senseWireTension <<" "<< tension << std::endl;
    } else if (set == c_Misaligned) {
      double baseTension = M_PI * m_senseWireDensity * m_senseWireDiameter * m_senseWireDiameter / (8.* m_WireSagCoef[iL][iC]);
      m_WireSagCoefMisalign[iL][iC] = (iL < m_firstLayerOffset) ? 0 : M_PI * m_senseWireDensity * m_senseWireDiameter *
                                      m_senseWireDiameter / (8.* (baseTension + tension));
      //      std::cout <<"misa iL, iC,basetension, tension= " << iL <<" " << iC <<" "<< baseTension <<" "<< tension << std::endl;
    } else if (set == c_Aligned) {
      double baseTension = M_PI * m_senseWireDensity * m_senseWireDiameter * m_senseWireDiameter / (8.* m_WireSagCoef[iL][iC]);
      m_WireSagCoefAlign[iL][iC] = (iL < m_firstLayerOffset) ? 0 : M_PI * m_senseWireDensity * m_senseWireDiameter *
                                   m_senseWireDiameter / (8.*(baseTension + tension));
      //      std::cout <<"algn iL, iC,basetension, tension= " << iL <<" " << iC <<" "<< baseTension <<" "<< tension << std::endl;
    }
    //    std::cout << "baseTension,tension= " << baseTension <<" "<< tension << std::endl;
 
    /*
    if (m_debug) {
      std::cout << iL << " " << iC;
      for (int i = 0; i < np; ++i) cout << " " << back[i];
      for (int i = 0; i < np; ++i) cout << " " << fwrd[i];
      std::cout << " " << tension << std::endl;
    }
    */
 
  }
 
  if (nRead != m_nSenseWires) B2FATAL("CDCGeometryPar::readWirePositionParams: #lines read-in (=" << nRead <<
                                        ") is inconsistent with total #sense wires (=" << m_nSenseWires << ") !");
 
  //  ifs.close();
  boost::iostreams::close(ifs);
}

readXT()

void readXT	(	const GearDir &	gbxParams,
		int	mode = 0
	)

Read XT-relation table.

Parameters

[in]	gbxParams	Gear Dir.
[in]	mode	0: read simulation file, 1: read reconstruction file.

Definition at line 800 of file CDCGeometryPar.cc.

{
  if (m_xtFileFormat == 0) {
    //    oldReadXT(gbxParams, mode);
  } else {
    newReadXT(gbxParams, mode);
  }
}

senseWireBZ()

double senseWireBZ ( int  layerId ) const

inline

Returns backward z position of sense wire in each layer.

Parameters

layerId

The layer id.

Returns

The backward z position of sense wire in layer layerId.

Definition at line 1284 of file CDCGeometryPar.h.

    {
      return m_zSBackwardLayer[layerID];
    }

senseWireDiameter()

double senseWireDiameter ( ) const

inline

Returns diameter of the sense wire.

Returns

Diameter of the sense wire.

Definition at line 1344 of file CDCGeometryPar.h.

    {
      return m_senseWireDiameter;
    }

senseWireFZ()

double senseWireFZ ( int  layerId ) const

inline

Returns forward z position of sense wire in each layer.

Parameters

layerId

The layer id.

Returns

The forward z position of sense wire in layer layerId.

Definition at line 1279 of file CDCGeometryPar.h.

    {
      return m_zSForwardLayer[layerID];
    }

senseWireR()

double senseWireR ( int  layerId ) const

inline

Returns radius of sense wire in each layer.

Parameters

layerId

The layer id.

Returns

The radius of sense wire in layer layerId.

Definition at line 1274 of file CDCGeometryPar.h.

    {
      return m_rSLayer[layerID];
    }

setBadWire()

void setBadWire

(

)

Set bad-wires (from DB)

Definition at line 1427 of file CDCGeometryPar.cc.

{
  //  m_badWire = (*m_badWireFromDB)->getWires();
  calcMeanT0();
}

setChMap()

void setChMap

(

)

Set channel map (from DB)

Definition at line 1588 of file CDCGeometryPar.cc.

{
  for (const auto& cm : (*m_chMapFromDB)) {
    const unsigned short isl = cm.getISuperLayer();
    if (isl >= c_nSuperLayers or isl < m_firstSuperLayerOffset) continue;
    const uint il  = cm.getILayer();
    const int iw  = cm.getIWire();
    const int iBd = cm.getBoardID();
    const WireID wID(isl, il, iw);
    m_wireToBoard.insert(pair<WireID, unsigned short>(wID, iBd));
    const int iCh = cm.getBoardChannel();
    m_wireToChannel.insert(pair<WireID, unsigned short>(wID, iCh));
    m_boardAndChannelToWire[iBd][iCh] = wID.getEWire();
  }
}

setDesignWirParam()

void setDesignWirParam	(	unsigned	layerID,
		unsigned	cellID
	)

Set the desizend wire parameters.

Parameters

[in]	layerID	Layer ID
[in]	cellID	Cell ID

Definition at line 2053 of file CDCGeometryPar.cc.

{
  const unsigned L = layerID;
  const unsigned C =  cellID;
 
  const double offset = m_offSet[L];
  //...Offset modification to be aligned to axial at z=0...
  const double phiSize = 2 * M_PI / double(m_nWires[L]);
 
  const double phiF = phiSize * (double(C) + offset)
                      + phiSize * 0.5 * double(m_nShifts[L]) + m_globalPhiRotation;
 
  m_FWirPos[L][C][0] = (L < m_firstLayerOffset) ? 0. : m_rSLayer[L] * cos(phiF);
  m_FWirPos[L][C][1] = (L < m_firstLayerOffset) ? 0. : m_rSLayer[L] * sin(phiF);
  m_FWirPos[L][C][2] = (L < m_firstLayerOffset) ? 0. : m_zSForwardLayer[L];
 
  const double phiB = phiSize * (double(C) + offset) + m_globalPhiRotation;
 
  m_BWirPos[L][C][0] = (L < m_firstLayerOffset) ? 0. : m_rSLayer[L] * cos(phiB);
  m_BWirPos[L][C][1] = (L < m_firstLayerOffset) ? 0. : m_rSLayer[L] * sin(phiB);
  m_BWirPos[L][C][2] = (L < m_firstLayerOffset) ? 0. : m_zSBackwardLayer[L];
 
  for (int i = 0; i < 3; ++i) {
    m_FWirPosMisalign[L][C][i] = (L < m_firstLayerOffset) ? 0. : m_FWirPos[L][C][i];
    m_BWirPosMisalign[L][C][i] = (L < m_firstLayerOffset) ? 0. : m_BWirPos[L][C][i];
    m_FWirPosAlign   [L][C][i] = (L < m_firstLayerOffset) ? 0. : m_FWirPos[L][C][i];
    m_BWirPosAlign   [L][C][i] = (L < m_firstLayerOffset) ? 0. : m_BWirPos[L][C][i];
  }
 
  m_WireSagCoef[L][C] = (L < m_firstLayerOffset) ? 0. : M_PI * m_senseWireDensity * m_senseWireDiameter * m_senseWireDiameter /
                        (8. * m_senseWireTension);
  //  m_WireSagCoef        [L][C] = 0.;
  m_WireSagCoefMisalign[L][C] = (L < m_firstLayerOffset) ? 0. : m_WireSagCoef[L][C];
  m_WireSagCoefAlign   [L][C] = (L < m_firstLayerOffset) ? 0. : m_WireSagCoef[L][C];
 
}

setDisplacement()

void setDisplacement

(

)

Set displacement of sense wire.

Definition at line 2951 of file CDCGeometryPar.cc.

{
  //    std::cout <<"setDisplacement called" << std::endl;
  for (const auto& disp : (*m_displacementFromDB)) {
    //    const int iLayer0 = disp.getICLayer();
    //    const int iWire0 = disp.getIWire();
    const int iLayer = WireID(disp.getEWire()).getICLayer();
    const int iWire = WireID(disp.getEWire()).getIWire();
    //    if (iLayer0 != iLayer) B2FATAL("Layer0 != Layer");
    //    if (iWire0  != iWire) B2FATAL("Wire0 != Wire");
    m_FWirPos[iLayer][iWire][0] += (iLayer < m_firstLayerOffset) ? 0. : disp.getXFwd();
    m_FWirPos[iLayer][iWire][1] += (iLayer < m_firstLayerOffset) ? 0. : disp.getYFwd();
    m_FWirPos[iLayer][iWire][2] += (iLayer < m_firstLayerOffset) ? 0. : disp.getZFwd();
    m_BWirPos[iLayer][iWire][0] += (iLayer < m_firstLayerOffset) ? 0. : disp.getXBwd();
    m_BWirPos[iLayer][iWire][1] += (iLayer < m_firstLayerOffset) ? 0. : disp.getYBwd();
    m_BWirPos[iLayer][iWire][2] += (iLayer < m_firstLayerOffset) ? 0. : disp.getZBwd();
    m_WireSagCoef[iLayer][iWire] = (iLayer < m_firstLayerOffset) ? 0. : M_PI * m_senseWireDensity * m_senseWireDiameter *
                                   m_senseWireDiameter / (8.*
                                                          (m_senseWireTension + disp.getTension()));
    //    std::cout <<"setdisp iL, iC, nominaltension, tension= " << iLayer <<" " << iWire <<" "<< m_senseWireTension <<" "<< disp.getTension() << std::endl;
  }
}

setEDepToADCConversions()

void setEDepToADCConversions

(

)

Set edep-to-ADC conversion params.

(from DB)

Definition at line 1605 of file CDCGeometryPar.cc.

{
  unsigned short groupId = (*m_eDepToADCConversionsFromDB)->getGroupID();
  unsigned short nEnt    = (*m_eDepToADCConversionsFromDB)->getEntries();
  if (groupId == 0) { //per super-layer mode
    if (nEnt > c_nSuperLayers) B2FATAL("CDCGeometryPar:: group-id " << groupId << " and #entries " << nEnt << " are inconsistent!");
  } else if (groupId == 1) { //per layer mode
    if (nEnt > c_maxNSenseLayers) B2FATAL("CDCGeometryPar:: group-id " << groupId << " and #entries " << nEnt << " are inconsistent!");
  } else {
    B2FATAL("CDCGeometryPar:: Invalid group-id " << groupId << " specified !");
  }
 
  unsigned short cLMin[c_nSuperLayers], cLMax[c_nSuperLayers]; //min and max clayer per super-layer
  cLMin[0] = 0;
  cLMax[0] = 7;
  for (unsigned int sl = 1; sl < c_nSuperLayers; ++sl) {
    cLMin[sl] = cLMax[0] + 6 * sl - 5;
    cLMax[sl] = cLMax[0] + 6 * sl;
  }
 
  for (unsigned short id = 0; id < nEnt; ++id) {
    unsigned short np = ((*m_eDepToADCConversionsFromDB)->getParams(id)).size();
    if (np > 7) B2FATAL("CDCGeometryPar:: No. of edep-to-ADC conversion params. > 7");
    if (groupId == 0) { //per super-layer; id=super-layer
      for (unsigned short cL = cLMin[id]; cL <= cLMax[id]; ++cL) { //clayer loop
        for (unsigned short cell = 0; cell < m_nWires[cL]; ++cell) { //cell loop
          for (unsigned short i = 0; i < np; ++i) {
            m_eDepToADCParams[cL][cell][i] = (cL < m_firstLayerOffset) ? 0. : ((*m_eDepToADCConversionsFromDB)->getParams(id))[i];
          }
        }
      }
    } else if (groupId == 1) { //per clayer; id=clayer
      for (unsigned short cell = 0; cell < m_nWires[id]; ++cell) { //cell loop
        for (unsigned short i = 0; i < np; ++i) {
          m_eDepToADCParams[id][cell][i] = (id < m_firstLayerOffset) ? 0. : ((*m_eDepToADCConversionsFromDB)->getParams(id))[i];
        }
      }
    } else if (groupId == 2) { //per wire
      //not ready
      B2FATAL("CDCGeometryPar::setEDepToADCConversions(): groupId=2 not ready!");
    }
  }
}

setFFactor()

void setFFactor

(

)

Set fudge factors (from DB).

Definition at line 1560 of file CDCGeometryPar.cc.

{
  unsigned short groupId = (*m_fFactorFromDB)->getGroupID();
  unsigned short nEnt    = (*m_fFactorFromDB)->getEntries();
  B2DEBUG(29, "setFFactor called: groupId,nEnt= " << groupId << " " << nEnt);
 
  if (groupId == 0) { //per all-layers mode
  } else {
    B2FATAL("CDCGeometryPar:: Invalid group-id " << groupId << " specified!");
  }
 
  for (unsigned short id = 0; id < nEnt; ++id) {
    unsigned short np = ((*m_fFactorFromDB)->getFactors(id)).size();
    if (np != 3) B2FATAL("CDCGeometryPar:: No. of fudge factors != 3!");
    for (unsigned short i = 0; i < np; ++i) {
      m_fudgeFactorForSigma[i] = ((*m_fFactorFromDB)->getFactors(id))[i];
      B2DEBUG(29, i << " " << m_fudgeFactorForSigma[i]);
    }
  }
 
  CDCGeoControlPar& gcp = CDCGeoControlPar::getInstance();
  m_fudgeFactorForSigma[0] *= gcp.getAddFudgeFactorForSigmaForData();
  m_fudgeFactorForSigma[1] *= gcp.getAddFudgeFactorForSigmaForMC();
  B2DEBUG(29, "fudge factors= " << m_fudgeFactorForSigma[0] << " " << m_fudgeFactorForSigma[1] << " " << m_fudgeFactorForSigma[2]);
}

setNominalSpaceResol()

void setNominalSpaceResol ( double  resol )

inline

Set the nominal spatial resolution in the unit of um.

Parameters

[in]

resol

spatial resolution (um)

Definition at line 815 of file CDCGeometryPar.h.

      {
        m_nominalSpaceResol = resol;
      }

setPropSpeed()

void setPropSpeed

(

)

Set prop.

-speeds (from DB).

Definition at line 1435 of file CDCGeometryPar.cc.

{
  for (unsigned short iCL = 0; iCL < (*m_propSpeedFromDB)->getEntries(); ++iCL) {
    m_propSpeedInv[iCL] = (iCL < m_firstLayerOffset) ? 0. : 1. / (*m_propSpeedFromDB)->getSpeed(iCL);
  }
}

setSenseWireBZ()

void setSenseWireBZ ( int  layerId, double  bz  )

inline

set backward z position of sense wires.

Parameters

layerId	The layer id of sense wire.
bz	The backward position of sense wires in layer layerId.

Definition at line 1269 of file CDCGeometryPar.h.

    {
      m_zSBackwardLayer[layerId] = bz;
    }

setSenseWireFZ()

void setSenseWireFZ ( int  layerId, double  fz  )

inline

Set forward z position of sense wires.

Parameters

layerId	The layer id of sense wire.
fz	The forward position of sense wires in layer layerId.

Definition at line 1264 of file CDCGeometryPar.h.

    {
      m_zSForwardLayer[layerId] = fz;
    }

setSenseWireR()

void setSenseWireR ( int  layerId, double  r  )

inline

Set radius of sense wire in each layer.

Parameters

layerId	The layer id of sense wires.
r	The radius of sense wires in layer layerId.

Definition at line 1259 of file CDCGeometryPar.h.

    {
      m_rSLayer[layerId] = r;
    }

setShiftInSuperLayer()

void setShiftInSuperLayer

(

)

Calculates and saves shifts in super-layers (to be used in searching hits in neighboring cells)

Definition at line 2975 of file CDCGeometryPar.cc.

{
  const unsigned short nLayers[c_nSuperLayers] = {8, 6, 6, 6, 6, 6, 6, 6, 6}; //tentative
 
  for (unsigned short SLayer = 0; SLayer < c_nSuperLayers; ++SLayer) {
    unsigned short firstCLayer = 0;
    for (unsigned short i = 0; i < SLayer; ++i) {
      firstCLayer += nLayers[i];
    }
    //    std::cout <<"SLayer,firstCLayer= " << SLayer <<" "<< firstCLayer << std::endl;
 
    B2Vector3D firstBPos = wireBackwardPosition(firstCLayer, 0);
    for (unsigned short Layer = 0; Layer < nLayers[SLayer]; ++Layer) {
      unsigned short CLayer = firstCLayer + Layer;
 
      if (CLayer == firstCLayer) {
        m_shiftInSuperLayer[SLayer][Layer] = 0;
 
      } else if (CLayer == firstCLayer + 1) {
        B2Vector3D BPos = wireBackwardPosition(CLayer, 0);
        m_shiftInSuperLayer[SLayer][Layer] = (BPos.Cross(firstBPos)).Z() > 0. ? -1 : 1;
        //  std::cout <<"CLayer,Layer,shift= " << CLayer <<" "<< Layer <<" "<< m_shiftInSuperLayer[SLayer][Layer] <<" "<< (BPos.Cross(firstBPos)).Z() << std::endl;
 
      } else {
        if (Layer % 2 == 0) {
          m_shiftInSuperLayer[SLayer][Layer] = 0;
        } else {
          m_shiftInSuperLayer[SLayer][Layer] = m_shiftInSuperLayer[SLayer][1];
        }
      }
      //      std::cout <<"CLayer,Layer,shift= " << CLayer <<" "<< Layer <<" "<< m_shiftInSuperLayer[SLayer][Layer] << std::endl;
    }
  }
}

setSResol()

void setSResol

(

)

Set spatial resolution (from DB).

Definition at line 1517 of file CDCGeometryPar.cc.

{
  m_linearInterpolationOfSgm = true; //must be true now
 
  //  std::cout <<"setSResol called" << std::endl;
  m_nAlphaPoints4Sgm = (*m_sResolFromDB)->getNoOfAlphaBins();
  for (unsigned short i = 0; i < m_nAlphaPoints4Sgm; ++i) {
    m_alphaPoints4Sgm[i] = (*m_sResolFromDB)->getAlphaPoint(i);
    //    std::cout << m_alphaPoints4Sgm[i]*180./M_PI << std::endl;
  }
 
  m_nThetaPoints4Sgm = (*m_sResolFromDB)->getNoOfThetaBins();
  for (unsigned short i = 0; i < m_nThetaPoints4Sgm; ++i) {
    m_thetaPoints4Sgm[i] = (*m_sResolFromDB)->getThetaPoint(i);
    //    std::cout << m_thetaPoints4Sgm[i]*180./M_PI << std::endl;
  }
 
  //  std::cout << "m_nAlphaPoints4Sgm= " << m_nAlphaPoints4Sgm << std::endl;
  //  std::cout << "m_nThetaPoints4Sgm= " << m_nThetaPoints4Sgm << std::endl;
 
  m_sigmaParamMode = (*m_sResolFromDB)->getSigmaParamMode();
 
  m_maxSpaceResol = (*m_sResolFromDB)->getMaxSpaceResol();
 
  for (unsigned short iCL = 0; iCL < c_maxNSenseLayers; ++iCL) {
    for (unsigned short iLR = 0; iLR < 2; ++iLR) {
      for (unsigned short iA = 0; iA < m_nAlphaPoints4Sgm; ++iA) {
        for (unsigned short iT = 0; iT < m_nThetaPoints4Sgm; ++iT) {
          const std::vector<float> params = (*m_sResolFromDB)->getSigmaParams(iCL, iLR, iA, iT);
          unsigned short np = params.size();
          //    std::cout <<"np4sigma= " << np << std::endl;
          for (unsigned short i = 0; i < np; ++i) {
            m_Sigma[iCL][iLR][iA][iT][i] = (iCL < m_firstLayerOffset) ? 0. : params[i];
          }
        }
      }
    }
  }
 
}

setT0()

void setT0

(

)

Set t0 parameters (from DB)

Definition at line 1367 of file CDCGeometryPar.cc.

{
  for (unsigned short iCL = 0; iCL < c_maxNSenseLayers; ++iCL) {
    for (unsigned short iW = 0; iW < c_maxNDriftCells; ++iW) {
      m_t0[iCL][iW] = 0.;
    }
  }
 
  for (auto const& ent : (*m_t0FromDB)->getT0s()) {
    const WireID wid = WireID(ent.first);
    const unsigned short iCL = wid.getICLayer();
    const unsigned short iW  = wid.getIWire();
    m_t0[iCL][iW]            = (iCL < m_firstLayerOffset) ? 0. : ent.second;
  }
 
  calcMeanT0();
}

setTW()

void setTW

(

)

Set time-walk parameters.

Definition at line 1444 of file CDCGeometryPar.cc.

{
  //  (*m_timeWalkFromDB)->dump();
  m_twParamMode = (*m_timeWalkFromDB)->getTwParamMode();
 
  for (unsigned short iBd = 0; iBd < (*m_timeWalkFromDB)->getEntries(); ++iBd) {
    int np = ((*m_timeWalkFromDB)->getTimeWalkParams(iBd)).size();
    for (int i = 0; i < np; ++i) {
      m_timeWalkCoef[iBd][i] = ((*m_timeWalkFromDB)->getTimeWalkParams(iBd))[i];
    }
  }
}

setWirPosAlignParams()

void setWirPosAlignParams

(

)

Set wire alignment params.

from DB.

Definition at line 676 of file CDCGeometryPar.cc.

{
  // Layer alignment
  for (unsigned iL = 0; iL < c_maxNSenseLayers; ++iL) {
 
    if (iL < m_firstLayerOffset) {
      continue;
    }
 
    // wire number 511 = no wire
    auto layerID = WireID(iL, 511);
 
    // Alignment parameters for layer iL
    double d_layerXbwd = (*m_alignmentFromDB)->get(layerID, CDCAlignment::layerX);
    double d_layerYbwd = (*m_alignmentFromDB)->get(layerID, CDCAlignment::layerY);
    double d_layerPhiBwd = (*m_alignmentFromDB)->get(layerID, CDCAlignment::layerPhi);
 
    double d_layerXfwd = (*m_alignmentFromDB)->get(layerID, CDCAlignment::layerDx) + d_layerXbwd;
    double d_layerYfwd = (*m_alignmentFromDB)->get(layerID, CDCAlignment::layerDy) + d_layerYbwd;
    double d_layerPhiFwd = (*m_alignmentFromDB)->get(layerID, CDCAlignment::layerDPhi) + d_layerPhiBwd;
 
    for (unsigned iC = 0; iC < m_nWires[iL]; ++iC) {
      // Positions (nominal+displacement) of wire-ends of wire iC in layer iL
      double wireXbwd = m_BWirPos[iL][iC][0];
      double wireYbwd = m_BWirPos[iL][iC][1];
      double wireZbwd = m_BWirPos[iL][iC][2];
 
      double wireXfwd = m_FWirPos[iL][iC][0];
      double wireYfwd = m_FWirPos[iL][iC][1];
      double wireZfwd = m_FWirPos[iL][iC][2];
 
      // Aligned positions of wire-ends are obtained by rotating "nominal+displacement" positions and shifting them using
      // common parameters for layer rotation and shifts (at corresponding end-caps)
      m_BWirPosAlign[iL][iC][0] = d_layerXbwd + cos(d_layerPhiBwd) * wireXbwd + sin(d_layerPhiBwd) * wireYbwd;
      m_BWirPosAlign[iL][iC][1] = d_layerYbwd - sin(d_layerPhiBwd) * wireXbwd + cos(d_layerPhiBwd) * wireYbwd;
      m_BWirPosAlign[iL][iC][2] = wireZbwd;
 
      m_FWirPosAlign[iL][iC][0] = d_layerXfwd + cos(d_layerPhiFwd) * wireXfwd + sin(d_layerPhiFwd) * wireYfwd;
      m_FWirPosAlign[iL][iC][1] = d_layerYfwd - sin(d_layerPhiFwd) * wireXfwd + cos(d_layerPhiFwd) * wireYfwd;
      m_FWirPosAlign[iL][iC][2] = wireZfwd;
    } //end of  cell loop
  } //end of layer loop
 
  const int np = 3;
  double back[np], fwrd[np];
 
  for (unsigned iL = 0; iL < c_maxNSenseLayers; ++iL) {
 
    if (iL < m_firstLayerOffset) {
      continue;
    }
 
    for (unsigned iC = 0; iC < m_nWires[iL]; ++iC) {
      //      std::cout << "iLiC= " << iL <<" "<< iC << std::endl;
      WireID wire(iL, iC);
      back[0] = (*m_alignmentFromDB)->get(wire, CDCAlignment::wireBwdX);
      back[1] = (*m_alignmentFromDB)->get(wire, CDCAlignment::wireBwdY);
      back[2] = (*m_alignmentFromDB)->get(wire, CDCAlignment::wireBwdZ);
 
      fwrd[0] = (*m_alignmentFromDB)->get(wire, CDCAlignment::wireFwdX);
      fwrd[1] = (*m_alignmentFromDB)->get(wire, CDCAlignment::wireFwdY);
      fwrd[2] = (*m_alignmentFromDB)->get(wire, CDCAlignment::wireFwdZ);
 
      for (int i = 0; i < np; ++i) {
        // On top of the wire-end positions corrected for layer alignment, we apply possible
        // fine corrections per wire
        m_BWirPosAlign[iL][iC][i] += back[i];
        m_FWirPosAlign[iL][iC][i] += fwrd[i];
      }
 
      //      double baseTension = 0.;
      double baseTension = M_PI * m_senseWireDensity * m_senseWireDiameter * m_senseWireDiameter / (8.* m_WireSagCoef[iL][iC]);
      double tension = (*m_alignmentFromDB)->get(wire, CDCAlignment::wireTension);
      //      std::cout << back[0] <<" "<< back[1] <<" "<< back[2] <<" "<< fwrd[0] <<" "<< fwrd[1] <<" "<< fwrd[2] <<" "<< tension << std::endl;
      m_WireSagCoefAlign[iL][iC] = M_PI * m_senseWireDensity *
                                   m_senseWireDiameter * m_senseWireDiameter / (8.*(baseTension + tension));
      //    std::cout << "baseTension,tension= " << baseTension <<" "<< tension << std::endl;
    } //end of  layer loop
  } //end of cell loop
}

setWirPosMisalignParams()

void setWirPosMisalignParams

(

)

Set wire misalignment params.

from DB.

Definition at line 760 of file CDCGeometryPar.cc.

{
  const int np = 3;
  double back[np], fwrd[np];
 
  for (unsigned iL = 0; iL < c_maxNSenseLayers; ++iL) {
 
    if (iL < m_firstLayerOffset) {
      continue;
    }
 
    for (unsigned iC = 0; iC < m_nWires[iL]; ++iC) {
      //      std::cout << "iLiC= " << iL <<" "<< iC << std::endl;
      WireID wire(iL, iC);
      back[0] = (*m_misalignmentFromDB)->get(wire, CDCMisalignment::wireBwdX);
      back[1] = (*m_misalignmentFromDB)->get(wire, CDCMisalignment::wireBwdY);
      back[2] = (*m_misalignmentFromDB)->get(wire, CDCMisalignment::wireBwdZ);
 
      fwrd[0] = (*m_misalignmentFromDB)->get(wire, CDCMisalignment::wireFwdX);
      fwrd[1] = (*m_misalignmentFromDB)->get(wire, CDCMisalignment::wireFwdY);
      fwrd[2] = (*m_misalignmentFromDB)->get(wire, CDCMisalignment::wireFwdZ);
 
      for (int i = 0; i < np; ++i) {
        m_BWirPosMisalign[iL][iC][i] = m_BWirPos[iL][iC][i] + back[i];
        m_FWirPosMisalign[iL][iC][i] = m_FWirPos[iL][iC][i] + fwrd[i];
      }
 
      //      double baseTension = 0.;
      double baseTension = M_PI * m_senseWireDensity * m_senseWireDiameter * m_senseWireDiameter / (8.* m_WireSagCoef[iL][iC]);
      double tension = (*m_misalignmentFromDB)->get(wire, CDCMisalignment::wireTension);
      //      std::cout << back[0] <<" "<< back[1] <<" "<< back[2] <<" "<< fwrd[0] <<" "<< fwrd[1] <<" "<< fwrd[2] <<" "<< tension << std::endl;
      m_WireSagCoefMisalign[iL][iC] = M_PI * m_senseWireDensity *
                                      m_senseWireDiameter * m_senseWireDiameter / (8.*(baseTension + tension));
      //    std::cout << "baseTension,tension= " << baseTension <<" "<< tension << std::endl;
    } //end of  layer loop
  } //end of cell loop
}

setXtRel()

void setXtRel

(

)

Set XT-relation table (from DB) (new).

Definition at line 1459 of file CDCGeometryPar.cc.

{
  m_linearInterpolationOfXT = true;  //must be true now
 
  //  std::cout <<"setXtRelation called" << std::endl;
  m_nAlphaPoints = (*m_xtRelFromDB)->getNoOfAlphaBins();
  for (unsigned short i = 0; i < m_nAlphaPoints; ++i) {
    m_alphaPoints[i] = (*m_xtRelFromDB)->getAlphaPoint(i);
    //    std::cout << m_alphaPoints[i]*180./M_PI << std::endl;
  }
 
  m_nThetaPoints = (*m_xtRelFromDB)->getNoOfThetaBins();
  for (unsigned short i = 0; i < m_nThetaPoints; ++i) {
    m_thetaPoints[i] = (*m_xtRelFromDB)->getThetaPoint(i);
    //    std::cout << m_thetaPoints[i]*180./M_PI << std::endl;
  }
 
  m_xtParamMode = (*m_xtRelFromDB)->getXtParamMode();
 
  for (unsigned short iCL = 0; iCL < c_maxNSenseLayers; ++iCL) {
    if (iCL < m_firstLayerOffset) {
      // m_XT is initialized to 0, but reading
      // (*m_xtRelFromDB)->getXtParams(iCL, iLR, iA, iT)
      // could fail if iCL < m_firstLayerOffset, thus continue as m_XT would be set to 0 in this case anyway
      continue;
    }
    for (unsigned short iLR = 0; iLR < 2; ++iLR) {
      for (unsigned short iA = 0; iA < m_nAlphaPoints; ++iA) {
        for (unsigned short iT = 0; iT < m_nThetaPoints; ++iT) {
          const std::vector<float> params = (*m_xtRelFromDB)->getXtParams(iCL, iLR, iA, iT);
          unsigned short np = params.size();
          //    std::cout <<"np4xt= " << np << std::endl;
          for (unsigned short i = 0; i < np; ++i) {
            m_XT[iCL][iLR][iA][iT][i] = params[i];
          }
 
          double boundT = m_XT[iCL][iLR][iA][iT][6];
          if (m_xtParamMode == 1) {
            m_XT[iCL][iLR][iA][iT][np] = ROOT::Math::Chebyshev5(boundT, m_XT[iCL][iLR][iA][iT][0], m_XT[iCL][iLR][iA][iT][1],
                                                                m_XT[iCL][iLR][iA][iT][2], m_XT[iCL][iLR][iA][iT][3], m_XT[iCL][iLR][iA][iT][4], m_XT[iCL][iLR][iA][iT][5]);
          } else {
            m_XT[iCL][iLR][iA][iT][np] =
              m_XT[iCL][iLR][iA][iT][0] + boundT
              * (m_XT[iCL][iLR][iA][iT][1] + boundT
                 * (m_XT[iCL][iLR][iA][iT][2] + boundT
                    * (m_XT[iCL][iLR][iA][iT][3] + boundT
                       * (m_XT[iCL][iLR][iA][iT][4] + boundT
                          * (m_XT[iCL][iLR][iA][iT][5])))));
          }
        }
      }
    }
  }
 
}

version()

std::string version ( ) const

inline

Returns the version of cdc geometry parameters.

Returns

The version of the cdc geometry parameters.

Definition at line 1229 of file CDCGeometryPar.h.

    {
      return m_version;
    }

wireBackwardPosition() [1/4]

const B2Vector3D wireBackwardPosition ( const WireID &  wireID, double  z, EWirePosition  set = c_Base  ) const

inline

The same function but in a different input format.

Definition at line 500 of file CDCGeometryPar.h.

      {
        return wireBackwardPosition(wireID.getICLayer(), wireID.getIWire(), z, set);
      }

wireBackwardPosition() [2/4]

const B2Vector3D wireBackwardPosition ( const WireID &  wireID, EWirePosition  set = c_Base  ) const

inline

The same function but in a different input format.

Definition at line 485 of file CDCGeometryPar.h.

      {
        return wireBackwardPosition(wireID.getICLayer(), wireID.getIWire(), set);
      }

wireBackwardPosition() [3/4]

const B2Vector3D wireBackwardPosition	(	uint	layerId,
		int	cellId,
		double	z,
		EWirePosition	set = c_Base
	)		const

Returns a virtual backward position corresp. to a tangent to the wire at the input z-position.

Parameters

layerId	The layer id. of the wire
cellId	The wire id. of the wire
z	z-position
set	Wire position set; =c_Base, c_Misaligned or c_Aligned

Returns

The virtual backward position of the wire.

Definition at line 1772 of file CDCGeometryPar.cc.

{
  // return early in case of empty layer, i.e. layerID < m_firstLayerOffset
  if (layerID < m_firstLayerOffset) {
    return B2Vector3D(0, 0, 0);
  }
 
  double yb_sag = 0.;
  double yf_sag = 0.;
  getWireSagEffect(set, layerID, cellID, z, yb_sag, yf_sag);
 
  B2Vector3D wPos(m_BWirPosAlign[layerID][cellID][0], yb_sag,
                  m_BWirPosAlign[layerID][cellID][2]);
  if (set == c_Misaligned) {
    wPos.SetX(m_BWirPosMisalign[layerID][cellID][0]);
    wPos.SetZ(m_BWirPosMisalign[layerID][cellID][2]);
  } else if (set == c_Base) {
    wPos.SetX(m_BWirPos        [layerID][cellID][0]);
    wPos.SetZ(m_BWirPos        [layerID][cellID][2]);
  }
 
  return wPos;
}

wireBackwardPosition() [4/4]

const B2Vector3D wireBackwardPosition	(	uint	layerId,
		int	cellId,
		EWirePosition	set = c_Base
	)		const

Returns the backward position of the input sense wire.

Parameters

layerId	The layer id. of the wire
cellId	The wire id. of the wire
set	Wire position set; =c_Base, c_Misaligned or c_Aligned

Returns

The backward position of the wire.

Definition at line 1748 of file CDCGeometryPar.cc.

{
  // return early in case of empty layer, i.e. layerID < m_firstLayerOffset
  if (layerID < m_firstLayerOffset) {
    return B2Vector3D(0, 0, 0);
  }
 
  B2Vector3D wPos(m_BWirPosAlign[layerID][cellID][0],
                  m_BWirPosAlign[layerID][cellID][1],
                  m_BWirPosAlign[layerID][cellID][2]);
 
  if (set == c_Misaligned) {
    wPos.SetX(m_BWirPosMisalign[layerID][cellID][0]);
    wPos.SetY(m_BWirPosMisalign[layerID][cellID][1]);
    wPos.SetZ(m_BWirPosMisalign[layerID][cellID][2]);
  } else if (set == c_Base) {
    wPos.SetX(m_BWirPos        [layerID][cellID][0]);
    wPos.SetY(m_BWirPos        [layerID][cellID][1]);
    wPos.SetZ(m_BWirPos        [layerID][cellID][2]);
  }
 
  return wPos;
}

wireForwardPosition() [1/4]

const B2Vector3D wireForwardPosition ( const WireID &  wireID, double  z, EWirePosition  set = c_Base  ) const

inline

The same function but in a different input format.

Definition at line 469 of file CDCGeometryPar.h.

      {
        return wireForwardPosition(wireID.getICLayer(), wireID.getIWire(), z, set);
      }

wireForwardPosition() [2/4]

const B2Vector3D wireForwardPosition ( const WireID &  wireID, EWirePosition  set = c_Base  ) const

inline

The same function but in a different input format.

Definition at line 454 of file CDCGeometryPar.h.

      {
        return wireForwardPosition(wireID.getICLayer(), wireID.getIWire(), set);
      }

wireForwardPosition() [3/4]

const B2Vector3D wireForwardPosition	(	uint	layerId,
		int	cellId,
		double	z,
		EWirePosition	set = c_Base
	)		const

Returns a virtual forward position corresp. to a tangent to the wire at the input z-position.

Parameters

layerId	The layer id. of the wire
cellId	The wire id. of the wire
z	z-position
set	Wire position set; =c_Base, c_Misaligned or c_Aligned

Returns

The virtual forward position of the wire.

Definition at line 1724 of file CDCGeometryPar.cc.

{
  // return early in case of empty layer, i.e. layerID < m_firstLayerOffset
  if (layerID < m_firstLayerOffset) {
    return B2Vector3D(0, 0, 0);
  }
 
  double yb_sag = 0.;
  double yf_sag = 0.;
  getWireSagEffect(set, layerID, cellID, z, yb_sag, yf_sag);
 
  B2Vector3D wPos(m_FWirPosAlign[layerID][cellID][0], yf_sag,
                  m_FWirPosAlign[layerID][cellID][2]);
  if (set == c_Misaligned) {
    wPos.SetX(m_FWirPosMisalign[layerID][cellID][0]);
    wPos.SetZ(m_FWirPosMisalign[layerID][cellID][2]);
  } else if (set == c_Base) {
    wPos.SetX(m_FWirPos        [layerID][cellID][0]);
    wPos.SetZ(m_FWirPos        [layerID][cellID][2]);
  }
 
  return wPos;
}

wireForwardPosition() [4/4]

const B2Vector3D wireForwardPosition	(	uint	layerId,
		int	cellId,
		EWirePosition	set = c_Base
	)		const

Returns the forward position of the input sense wire.

Parameters

layerId	The layer id. of the wire
cellId	The wire id. of the wire
set	Wire position set; =c_Base, c_Misaligned or c_Aligned

Returns

The forward position of the wire.

Definition at line 1699 of file CDCGeometryPar.cc.

{
  // return early in case of empty layer, i.e. layerID < m_firstLayerOffset
  if (layerID < m_firstLayerOffset) {
    return B2Vector3D(0, 0, 0);
  }
 
  //  std::cout <<"cdcgeopar::fwdpos set= " << set << std::endl;
  B2Vector3D wPos(m_FWirPosAlign[layerID][cellID][0],
                  m_FWirPosAlign[layerID][cellID][1],
                  m_FWirPosAlign[layerID][cellID][2]);
 
  if (set == c_Misaligned) {
    wPos.SetX(m_FWirPosMisalign[layerID][cellID][0]);
    wPos.SetY(m_FWirPosMisalign[layerID][cellID][1]);
    wPos.SetZ(m_FWirPosMisalign[layerID][cellID][2]);
  } else if (set == c_Base) {
    wPos.SetX(m_FWirPos        [layerID][cellID][0]);
    wPos.SetY(m_FWirPos        [layerID][cellID][1]);
    wPos.SetZ(m_FWirPos        [layerID][cellID][2]);
  }
 
  return wPos;
}

zBackwardWireLayer()

const double * zBackwardWireLayer ( ) const

inline

Returns an array of backward z of wire layers.

Returns

An array of backward z.

Definition at line 1364 of file CDCGeometryPar.h.

    {
      return m_zSBackwardLayer;
    }

zForwardWireLayer()

const double * zForwardWireLayer ( ) const

inline

Returns an array of forward z of wire layers.

Returns

An array of forward z.

Definition at line 1359 of file CDCGeometryPar.h.

    {
      return m_zSForwardLayer;
    }

zInnerWall()

double zInnerWall ( ) const

inline

Returns the length of the inner wall in Z.

Returns

The length of the inner wall.

Definition at line 1329 of file CDCGeometryPar.h.

    {
      return (m_zWall[0][1] - m_zWall[0][0]);
    }

zOffsetInnerWall()

double zOffsetInnerWall ( ) const

inline

Returns the offset of the outer wall in z direction.

Returns

The z offset of the outer wall.

Definition at line 1339 of file CDCGeometryPar.h.

    {
      return (m_zWall[0][0] + zInnerWall() / 2);
    }

zOffsetOuterWall()

double zOffsetOuterWall ( ) const

inline

Returns the offset of the outer wall in z direction.

Returns

The z offset of the outer wall.

Definition at line 1334 of file CDCGeometryPar.h.

    {
      return (m_zWall[2][0] + zOuterWall() / 2);
    }

zOffsetWireLayer()

double zOffsetWireLayer ( unsigned  i ) const

inline

Returns the offset of z of the wire layer i.

Parameters

i	The layer id.

Returns

The z offset of wire layer i.

Definition at line 1369 of file CDCGeometryPar.h.

    {
      return (m_zSBackwardLayer[i] + (m_zSForwardLayer[i] - m_zSBackwardLayer[i]) / 2);
    }

zOuterWall()

double zOuterWall ( ) const

inline

Returns the length of the outer wall in Z.

Returns

The length of the outer wall.

Definition at line 1314 of file CDCGeometryPar.h.

    {
      return (m_zWall[2][1] - m_zWall[2][0]);
    }

Member Data Documentation

m_alignment

bool m_alignment

private

Switch for alignment.

Definition at line 1101 of file CDCGeometryPar.h.

m_alignmentFromDB

DBObjPtr<CDCAlignment>* m_alignmentFromDB

private

alignment params.

retrieved from DB.

Definition at line 1207 of file CDCGeometryPar.h.

m_alphaPoints

float m_alphaPoints[c_maxNAlphaPoints]

private

alpha sampling points for xt (rad)

Definition at line 1168 of file CDCGeometryPar.h.

m_alphaPoints4Sgm

float m_alphaPoints4Sgm[c_maxNAlphaPoints]

private

alpha sampling points for sigma (rad)

Definition at line 1170 of file CDCGeometryPar.h.

m_B4CDCGeometryParDB

CDCGeometryPar * m_B4CDCGeometryParDB = 0

staticprivate

Pointer that saves the instance of this class.

Definition at line 1213 of file CDCGeometryPar.h.

m_badWireFromDB

DBObjPtr<CDCBadWires>* m_badWireFromDB

private

bad-wires retrieved from DB.

Definition at line 1199 of file CDCGeometryPar.h.

m_boardAndChannelToWire

unsigned short m_boardAndChannelToWire[c_nBoards][48]

private

array relating board-channel-id and wire-id.

Definition at line 1184 of file CDCGeometryPar.h.

m_BWirPos

float m_BWirPos[c_maxNSenseLayers][c_maxNDriftCells][3]

private

Wire position incl.

displacement at the backward endplate for each cell; ibid.

Definition at line 1156 of file CDCGeometryPar.h.

m_BWirPosAlign

float m_BWirPosAlign[c_maxNSenseLayers][c_maxNDriftCells][3]

private

Wire position incl.

alignment at the backward endplate for each cell; ibid.

Definition at line 1164 of file CDCGeometryPar.h.

m_BWirPosMisalign

float m_BWirPosMisalign[c_maxNSenseLayers][c_maxNDriftCells][3]

private

Wire position incl.

misalignment at the backward endplate for each cell; ibid.

Definition at line 1160 of file CDCGeometryPar.h.

m_cellSize

double m_cellSize[c_maxNSenseLayers]

private

The array to store cell size in each sense wire layer.

Definition at line 1135 of file CDCGeometryPar.h.

m_chMapFromDB

DBArray<CDCChannelMap>* m_chMapFromDB

private

channel map retrieved from DB.

Definition at line 1205 of file CDCGeometryPar.h.

m_clockFreq4TDC

double m_clockFreq4TDC

private

Clock frequency used for TDC (GHz).

Definition at line 1189 of file CDCGeometryPar.h.

m_clockSettings

DBObjPtr<HardwareClockSettings> m_clockSettings

private

hardware clock settings

Definition at line 1211 of file CDCGeometryPar.h.

m_debug

bool m_debug

private

Switch for debug printing.

Definition at line 1095 of file CDCGeometryPar.h.

m_displacement

bool m_displacement

private

Switch for displacement.

Definition at line 1099 of file CDCGeometryPar.h.

m_displacementFromDB

DBArray<CDCDisplacement>* m_displacementFromDB

private

displacement params.

retrieved from DB.

Definition at line 1206 of file CDCGeometryPar.h.

m_dzSBackwardLayer

double m_dzSBackwardLayer[c_maxNSenseLayers]

private

Corrections for backward z position of sense wire layers.

Definition at line 1130 of file CDCGeometryPar.h.

m_dzSForwardLayer

double m_dzSForwardLayer[c_maxNSenseLayers]

private

Corrections for forward z position of sense wire layers.

Definition at line 1128 of file CDCGeometryPar.h.

m_eDepToADCConversionsFromDB

DBObjPtr<CDCEDepToADCConversions>* m_eDepToADCConversionsFromDB

private

Pointer to edep-to-ADC conv.

params. from DB.

Definition at line 1209 of file CDCGeometryPar.h.

m_eDepToADCParams

float m_eDepToADCParams[c_maxNSenseLayers][c_maxNDriftCells][7] = {}

private

edep-to-ADC conv.

params.

Definition at line 1166 of file CDCGeometryPar.h.

m_fFactorFromDB

DBObjPtr<CDCFudgeFactorsForSigma>* m_fFactorFromDB

private

fudge factors retrieved from DB.

Definition at line 1204 of file CDCGeometryPar.h.

m_fieldWireDiameter

double m_fieldWireDiameter

private

The diameter of field wires.

Definition at line 1142 of file CDCGeometryPar.h.

m_firstLayerOffset

ushort m_firstLayerOffset = 0

private

Offset of the first layer (for reduced CDC studies)

Definition at line 1220 of file CDCGeometryPar.h.

m_firstSuperLayerOffset

ushort m_firstSuperLayerOffset = 0

private

Offset of the first super layer (for reduced CDC studies)

Definition at line 1221 of file CDCGeometryPar.h.

m_fudgeFactorForSigma

double m_fudgeFactorForSigma[3]

private

Fuge factor for space resol.

Definition at line 1196 of file CDCGeometryPar.h.

m_FWirPos

float m_FWirPos[c_maxNSenseLayers][c_maxNDriftCells][3]

private

Wire position incl.

displacement at the forward endplate for each cell; to be implemented in a smarter way.

Definition at line 1155 of file CDCGeometryPar.h.

m_FWirPosAlign

float m_FWirPosAlign[c_maxNSenseLayers][c_maxNDriftCells][3]

private

Wire position incl.

alignment at the forward endplate for each cell; ibid.

Definition at line 1163 of file CDCGeometryPar.h.

m_FWirPosMisalign

float m_FWirPosMisalign[c_maxNSenseLayers][c_maxNDriftCells][3]

private

Wire position incl.

misalignment at the forward endplate for each cell; ibid.

Definition at line 1159 of file CDCGeometryPar.h.

m_globalPhiRotation

double m_globalPhiRotation

private

Global ratation in phi (rad.); only for sense wires now.

Definition at line 1144 of file CDCGeometryPar.h.

m_linearInterpolationOfSgm

bool m_linearInterpolationOfSgm

private

Switch for linear interpolation of sigma.

Definition at line 1097 of file CDCGeometryPar.h.

m_linearInterpolationOfXT

bool m_linearInterpolationOfXT

private

Switch for linear interpolation of xt.

Definition at line 1096 of file CDCGeometryPar.h.

m_materialDefinitionMode

int m_materialDefinitionMode

private

Control switch for gas and wire material definition.

Definition at line 1108 of file CDCGeometryPar.h.

m_maxNCellsPerLayer

ushort m_maxNCellsPerLayer = c_maxNDriftCells

private

Maximum number wires within a layer.

Definition at line 1222 of file CDCGeometryPar.h.

m_maxNFieldLayers

ushort m_maxNFieldLayers = c_maxNFieldLayers

private

Maximum number of Field Wire Layers.

Definition at line 1218 of file CDCGeometryPar.h.

m_maxNSenseLayers

ushort m_maxNSenseLayers = c_maxNSenseLayers

private

Maximum number of Sense Wire Layers.

Definition at line 1217 of file CDCGeometryPar.h.

m_maxNSuperLayers

ushort m_maxNSuperLayers = c_nSuperLayers

private

Maximum number of Super Layers.

Definition at line 1219 of file CDCGeometryPar.h.

m_maxSpaceResol

double m_maxSpaceResol

private

max space resolution allowed (cm).

Definition at line 1195 of file CDCGeometryPar.h.

m_meanT0

double m_meanT0

private

mean t0 over all wires; should be double.

Definition at line 1180 of file CDCGeometryPar.h.

m_minTrackLength

double m_minTrackLength

private

Minimum track length for G4 step.

Definition at line 1153 of file CDCGeometryPar.h.

m_misalignment

bool m_misalignment

private

Switch for misalignment.

Definition at line 1100 of file CDCGeometryPar.h.

m_misalignmentFromDB

DBObjPtr<CDCMisalignment>* m_misalignmentFromDB

private

misalignment params.

retrieved from DB.

Definition at line 1208 of file CDCGeometryPar.h.

m_modLeftRightFlag

bool m_modLeftRightFlag

private

Switch for modified left/right flag.

Definition at line 1105 of file CDCGeometryPar.h.

m_momRmin

double m_momRmin[7]

private

R_min of the cdc mother volume (7 segments).

Definition at line 1147 of file CDCGeometryPar.h.

m_momZ

double m_momZ[7]

private

Z-cordinates of the cdc mother volume (7 segments).

Definition at line 1146 of file CDCGeometryPar.h.

m_nAlphaPoints

unsigned short m_nAlphaPoints

private

No.

of alpha points for xt.

Definition at line 1117 of file CDCGeometryPar.h.

m_nAlphaPoints4Sgm

unsigned short m_nAlphaPoints4Sgm

private

No.

of alpha points for sigma.

Definition at line 1119 of file CDCGeometryPar.h.

m_nFieldWires

ushort m_nFieldWires = c_nFieldWires

private

Maximum number of Field Wires.

Definition at line 1216 of file CDCGeometryPar.h.

m_nFLayer

int m_nFLayer

private

The number of field wire layer.

Definition at line 1116 of file CDCGeometryPar.h.

m_nominalDriftV

double m_nominalDriftV

private

Nominal drift velocity (4.0x10^-3 cm/nsec).

Definition at line 1191 of file CDCGeometryPar.h.

m_nominalDriftVInv

double m_nominalDriftVInv

private

Inverse of the nominal drift velocity.

Definition at line 1192 of file CDCGeometryPar.h.

m_nominalPropSpeed

double m_nominalPropSpeed

private

Nominal propagation speed of the sense wire (27.25 cm/nsec).

Definition at line 1193 of file CDCGeometryPar.h.

m_nominalSpaceResol

double m_nominalSpaceResol

private

Nominal spatial resolution (0.0130 cm).

Definition at line 1194 of file CDCGeometryPar.h.

m_nSenseWires

ushort m_nSenseWires = c_nSenseWires

private

Maximum number of Sense Wires.

Definition at line 1215 of file CDCGeometryPar.h.

m_nShifts

int m_nShifts[c_maxNSenseLayers]

private

The array to store shifted cell number in each sense wire layer.

Definition at line 1136 of file CDCGeometryPar.h.

m_nSLayer

int m_nSLayer

private

The number of sense wire layer.

Definition at line 1115 of file CDCGeometryPar.h.

m_nThetaPoints

unsigned short m_nThetaPoints

private

No.

of theta points for xt.

Definition at line 1118 of file CDCGeometryPar.h.

m_nThetaPoints4Sgm

unsigned short m_nThetaPoints4Sgm

private

No.

of theta points for sigma.

Definition at line 1120 of file CDCGeometryPar.h.

m_nWires

unsigned m_nWires[c_maxNSenseLayers]

private

The array to store the wire number in each sense wire layre.

Definition at line 1137 of file CDCGeometryPar.h.

m_offSet

double m_offSet[c_maxNSenseLayers]

private

The array to store z offset of sense wire layers.

Definition at line 1134 of file CDCGeometryPar.h.

m_propSpeedFromDB

DBObjPtr<CDCPropSpeeds>* m_propSpeedFromDB

private

prop.

-speeds retrieved from DB.

Definition at line 1200 of file CDCGeometryPar.h.

m_propSpeedInv

float m_propSpeedInv[c_maxNSenseLayers]

private

Inverse of propagation speed of the sense wire.

Definition at line 1175 of file CDCGeometryPar.h.

m_rFLayer

double m_rFLayer[c_maxNFieldLayers]

private

The array to store radius of field wire layers.

Definition at line 1131 of file CDCGeometryPar.h.

m_rSLayer

double m_rSLayer[c_maxNSenseLayers]

private

The array to store radius of sense wire layers.

Definition at line 1126 of file CDCGeometryPar.h.

m_rWall

double m_rWall[4]

private

The array to store radius of inner wall and outer wall.

Definition at line 1123 of file CDCGeometryPar.h.

m_senseWireDensity

double m_senseWireDensity

private

The density of sense wires.

Definition at line 1141 of file CDCGeometryPar.h.

m_senseWireDiameter

double m_senseWireDiameter

private

The diameter of sense wires.

Definition at line 1139 of file CDCGeometryPar.h.

m_senseWireTension

double m_senseWireTension

private

The tension of sense wires.

Definition at line 1140 of file CDCGeometryPar.h.

m_senseWireZposMode

int m_senseWireZposMode

private

Mode for sense wire z position corr.

Definition at line 1109 of file CDCGeometryPar.h.

m_shiftInSuperLayer

signed short m_shiftInSuperLayer[c_nSuperLayers][8]

private

shift in phi-direction wrt the 1st layer in each super layer

Definition at line 1121 of file CDCGeometryPar.h.

m_Sigma

float m_Sigma[c_maxNSenseLayers][2][c_maxNAlphaPoints][c_maxNThetaPoints][c_nSigmaParams]

private

position resolution for each layer.

Definition at line 1174 of file CDCGeometryPar.h.

m_sigmaFileFormat

int m_sigmaFileFormat

private

Format of sigma input file.

Definition at line 1112 of file CDCGeometryPar.h.

m_sigmaParamMode

int m_sigmaParamMode

private

Mode for sigma parameterization.

Definition at line 1113 of file CDCGeometryPar.h.

m_sResolFromDB

DBObjPtr<CDCSpaceResols>* m_sResolFromDB

private

sigma params.

retrieved from DB.

Definition at line 1203 of file CDCGeometryPar.h.

m_t0

float m_t0[c_maxNSenseLayers][c_maxNDriftCells] = {}

private

t0 for each sense-wire (in nsec).

Definition at line 1176 of file CDCGeometryPar.h.

m_t0FromDB

DBObjPtr<CDCTimeZeros>* m_t0FromDB

private

t0s retrieved from DB.

Definition at line 1198 of file CDCGeometryPar.h.

m_tdcBinWidth

double m_tdcBinWidth

private

TDC bin width (nsec/bin).

Definition at line 1190 of file CDCGeometryPar.h.

m_tdcOffset

unsigned short m_tdcOffset

private

Not used; to be removed later.

Definition at line 1188 of file CDCGeometryPar.h.

m_thetaPoints

float m_thetaPoints[c_maxNThetaPoints]

private

theta sampling points for xt (rad)

Definition at line 1169 of file CDCGeometryPar.h.

m_thetaPoints4Sgm

float m_thetaPoints4Sgm[c_maxNThetaPoints]

private

theta sampling points for sigma (rad)

Definition at line 1171 of file CDCGeometryPar.h.

m_thresholdEnergyDeposit

double m_thresholdEnergyDeposit

private

Energy thresh.

for G4 step

Definition at line 1152 of file CDCGeometryPar.h.

m_timeWalkCoef

float m_timeWalkCoef[c_nBoards][2]

private

coefficients for time walk.

Definition at line 1177 of file CDCGeometryPar.h.

m_timeWalkFromDB

DBObjPtr<CDCTimeWalks>* m_timeWalkFromDB

private

time-walk coeffs.

retrieved from DB.

Definition at line 1201 of file CDCGeometryPar.h.

m_twParamMode

int m_twParamMode

private

Mode for tw parameterization.

Definition at line 1114 of file CDCGeometryPar.h.

m_version

std::string m_version

private

The version of geometry parameters.

Definition at line 1107 of file CDCGeometryPar.h.

m_wireSag

bool m_wireSag

private

Switch for sense wire sag.

Definition at line 1104 of file CDCGeometryPar.h.

m_WireSagCoef

float m_WireSagCoef[c_maxNSenseLayers][c_maxNDriftCells]

private

Wire sag coefficient for each cell; ibid.

Definition at line 1157 of file CDCGeometryPar.h.

m_WireSagCoefAlign

float m_WireSagCoefAlign[c_maxNSenseLayers][c_maxNDriftCells]

private

Wire sag coefficient incl.

alignment for each cell; ibid.

Definition at line 1165 of file CDCGeometryPar.h.

m_WireSagCoefMisalign

float m_WireSagCoefMisalign[c_maxNSenseLayers][c_maxNDriftCells]

private

Wire sag coefficient incl.

misalignment for each cell; ibid.

Definition at line 1161 of file CDCGeometryPar.h.

m_wireToBoard

std::map<WireID, unsigned short> m_wireToBoard

private

map relating wire-id and board-id.

Definition at line 1182 of file CDCGeometryPar.h.

m_wireToChannel

std::map<WireID, unsigned short> m_wireToChannel

private

map relating wire-id and channel-id.

Definition at line 1183 of file CDCGeometryPar.h.

m_XT

float m_XT[c_maxNSenseLayers][2][c_maxNAlphaPoints][c_maxNThetaPoints][c_nXTParams]

private

XT-relation coefficients for each layer, Left/Right, entrance angle and polar angle.

Definition at line 1173 of file CDCGeometryPar.h.

m_XTetc

bool m_XTetc

private

Switch for reading x-t etc.

params..

Definition at line 1098 of file CDCGeometryPar.h.

m_XTetc4Recon

bool m_XTetc4Recon

private

Switch for selecting xt etc.

Definition at line 1102 of file CDCGeometryPar.h.

m_xtFileFormat

int m_xtFileFormat

private

Format of xt input file.

Definition at line 1110 of file CDCGeometryPar.h.

m_xtParamMode

int m_xtParamMode

private

Mode for xt parameterization.

Definition at line 1111 of file CDCGeometryPar.h.

m_xtRelFromDB

DBObjPtr<CDCXtRelations>* m_xtRelFromDB

private

xt params.

retrieved from DB (new).

Definition at line 1202 of file CDCGeometryPar.h.

m_zFBackwardLayer

double m_zFBackwardLayer[c_maxNFieldLayers]

private

The array to store backward z position of field wire layers.

Definition at line 1133 of file CDCGeometryPar.h.

m_zFForwardLayer

double m_zFForwardLayer[c_maxNFieldLayers]

private

The array to store forward z position of field wire layers.

Definition at line 1132 of file CDCGeometryPar.h.

m_zSBackwardLayer

double m_zSBackwardLayer[c_maxNSenseLayers]

private

The array to store backward z position of sense wire layers.

Definition at line 1129 of file CDCGeometryPar.h.

m_zSForwardLayer

double m_zSForwardLayer[c_maxNSenseLayers]

private

The array to store forward z position of sense wire layers.

Definition at line 1127 of file CDCGeometryPar.h.

m_zWall

double m_zWall[4][2]

private

The array to store z position of inner wall and outer wall.

Definition at line 1124 of file CDCGeometryPar.h.

---

The documentation for this class was generated from the following files:

• cdc/geometry/include/CDCGeometryPar.h
• cdc/geometry/src/CDCGeometryPar.cc