Cathode Strip Chambers

Offline Analysis Tools


This page describes offline handling of data recorded from the CSC (cathode strip chambers). The chambers cover the forward and backward eta regions from 2.0 to 2.7 and serve as the first muon station over that eta range. This station provides four measurements in both eta and phi. The eta strips are relatively narrow ( 5.5566 mm for the Small Chambers, 5.308 mm for the Large) and charge sharing between adjacent strips can be used to measure positions with a precision of better than 100 microns. The phi strips are wider (12.922 mm for the Small chambers, and 21.004 mm for the Large) and signals are typically induced on only two strips yielding measurements with worst resolution or, if high precision is assumed, long residual tails.

The default reconstruction includes steps to construct each of the following in turn: digits, 1D clusters, 2D segments (i.e. one position and one direction), and 4D segments. Different track finding and fitting algorithms may use any of these elements; most typical at present is to use the clusters.

A description of the CSC Monte Carlo is also given.

Detector Characteristics

Momentum resolution

The CSC radial (eta) position measurement is essential to the muon spectrometer momentum measurement in the region |eta|>2.0. MDT's following the forward toroid can be used to predict the CSC position for a straight track and the deviation x from that prediction provides a measurement of the momentum. The toroid provides a field integral of approximately 6 T-m over a path of 4 m. The relation between the position deviation and momentum is approximately

  x = H 1/p

where H = 3.6 TeV-mm. E.g. a p = 3.6 TeV muon (pT = 1.0-0.5 TeV for eta = 2.0-2.7) will deviate by 1.0 mm from a straight trajectory. Thus, if we want 10% resolution for such muons (0.027 /TeV in 1/p) for such muons we must keep the combined position resolution and misalignment under 100 um.

Timing resolution

The CSC timing measurement is another important one especially for EF trigger and beam halo events veto. The time measurement is relative to the start of the readout window, i.e., sample 0. This time is determined by the latency setting which is adjusted so that times peak in the middle of the window. We have 4 samples at 50ns, covering 150ns, so the center is at 75ns. This is our T0 which will be subtracted.

Still, if the first sample is the largest and the interpolation indicates peaking before the first sample, then the time is set to 0 as a flag and as an aproximation. Same for the peaking times after the last sample.

If the trigger comes between two 50ns samples, then we subtract 25 ns from the measured time because our window is shifted relative to the trigger by that amount. This is called trigger phase = 1. Unfortunatly the flag values of 0 and 150 are also shifted. As a result, we have valid times starting from -25 ns for phase 1, but the flag of phase 0 is still at 0ns.

Parabola interpolation of ADC samples followed by bipolar correction provides a time measurement of each channel (strip). For the cluster, we consider the measured time of peak charge strip as a time of cluster. Each 2d segment (eta/phi) has 3 or 4 hits (clusters) associated. The unweighted average of the 3 or 4 cluster times can be used as a time of segment.

To use the time measurement correctly, t0 values should be subtracted. T0 is the average peaking time for segments from the IP. It is the sum of the T0 base value of the channel and 12.5ns times the T0 phase of the readout fiber of the channel. The T0 base value depends on the shaping time of the analog electronics and is expected to be constant over time. The T0 phase, however, can change from one run to the next. It takes on the possible values of 0 or 1 and shifts the times by 0 or 12.5 ns. In one chamber, there are 5 T0 phases to be calibrated: 4 precision layers (eta) and 1 non-precision layer (phi). Note that the 4 precision layers are however split in the middle and combined. This gives us ch1-92 for layers 1(2) and 3(4) in one constant, ch93-192 of layers 1(2) and 3(4) in the next, etc. These t0 constants needs to be saved in COOL db.

Geometry and readout

The CSC detector consists of 32 chambers, 16 on each endcap. The 16 are arranged in eight phi-sectors on each of two wheels with an azimuthal overlap to provide hermetic coverage in phi. The two wheels are named CSS (*Small Chambers) and CSL (*Large chambers) following the overall ATLAS geometry of and a chamber is identified by specifying the wheel, eta side (- or +) and phi sector (1-8). There are four planes of wires within each chamber with orthogonal strips on the two cathode planes providing measurements in the eta and phi directions. Thus a readout plane may be identified by the wire plane number (1-4) an orientation (eta, phi). Strips are numbered consecutively starting from one in each plane. There are 192 strips in the eta planes and 48 in the phi planes.

The eta strips are relatively narrow (5~6mm) so that the signal induced by a single charged particle typical registers on three or more strips making it possible to distinguish isolated tracks from those overlapped by other tracks. The latter are called spoiled. In the former, unspoiled, cases (80-90% of the tracks) it is possible to use distribution of charges on adjacent strips to determine the track position to high precision, better than 100 microns. The phi-measuring strips are much wider (1~2cm) and the signal from a single track is generally confined to one or two strips, making this precision measurement less significant. The spoiled eta and most or all of the phi measurements have a resolution of a few mm. For this reason, the eta coordinate is called the precision coordinate.

The readout for each strip includes ADC sampling at regular intervals. Typically four samples are read out. The time distribution is used to determine the time at which the particle interacted with the detector. The shape of the signal may also be used to determine whether there are contributions from multiple particles at different times.

Data structures

The following describes the data structures


Hits, class name CSCSimHit, record the simulated (GEANT) interaction of a particle with the CSC detector. They hold the identity of the particle, the starting and end positions of the GEANT step, the mean time and the energy deposited in that step.


Three separate classes are used to describe the response of a single strip: the original digit class CscDigit, the prep data digit CsctripPrepData, and the RDO description CscRawData. The original digit class holds the total charge and time and is presently used only to hold the output from the first stage of digitization. Apparently the time is always left zero. The RDO description is obtained either by running the second step of digitization or by conversion from bytestream, the format of the data read from the detector. The prep data digit is an unpacked and calibrated form of this data. Both RDO and prep data descriptions include the charge for each time sample. Although the latter are prep data objects and hence can be used as input for track reconstruction, the nature of the detector suggests it is preferable to first cluster the strips.

All digit containers hold a separate collection of digits for each chamber. The time samples for each strip are combined to a single measurement of charge and time, the "strip fit".


A cluster is intended to provide a measurement of the coordinate where a charged particle crossed a wire plane. Existing algorithms construct 1D clusters which use information from one cathode plane to provide a single coordinate (i.e. that associated with the plane). In principle it is also possible to construct 2D clusters with include information from both planes and thus provide measurements of both coordinates but this is not currently done. We often drop the qualification when referencing 1D clusters.

Clusters are stored as prep data objects of type "CscPrepData". Each cluster holds identifiers for the digits from which it was constructed and a fit of the measured coordinate. The measurement is expressed as a 1D vector with a 1D error matrix with a surface specifying the orientation.


A CSC segment provides a measurement of position and direction within a chamber and is formed by combining one cluster from each of the planes in that chamber. Both 2D and 4D segments are supported: the former measure the position and direction for one orientation (eta or phi) and the latter provide a complete measurement of both coordinates and directions at a specified plane, typically at the center of the chamber.

The class describing CSC segments is the common muon segment class: MuonSegment. It holds the list of contributing prep data objects, typically clusters and fit, i.e. the above measurements and their error matrix. The ordering is the same as that for the clusters.

The muon segments for a chamber are stored in a collection of type MuonSegmentCombination and these are held in the collection of type MuonSegmentCombinationCollection. The muon segment combination is a collection of vectors of muon segments. For 4D segments, a single vector is used and, for 2D segments, the phi and eta segments are written to separate vectors if the algorithm looks for both. All is by convention or choice of the algorithm author. There is nothing in the classes to require or even encourage this organization. Unlike the digits and clusters, the current algorithms do not write empty containers (muon segment combinations) when no segments are found in a chamber. Instead one MuonSegmentCombination is written for each chamber that has one or more segments. If no segments are found in any chamber, then an empty MuonSegmentCombinationCollection should be written to affirm that the algorithm has been run.

Tools and helpers

A number of tools (AlgTools) and helper classes are available for working with CSC data objects.


The CscIdHelper and CscReadoutElement may be used to access geometry information including the identifier hierarchy and position and orientations of various elements.


The AlgTool CscCalibTool may be used performs calibration operations such as transforming back and forth between charge and ADC counts. The calibration constants are retrieved from cool using CscCoolStrSvc, as defined in CscCoolAccess

Pedestal Subtraction

Pedestal subtraction is done during the process of conversion from RDO to CscStripPrepData.

Charge Measurement Error for each channel

When time and charge are extracted for each channel, default error is considered as (F001-Pedestal)/3.251. Alternatively, RMS or Sigma can be used.

Strip Status Bit

It tells if channel is identified as noisy or dead or hot or stuckbit

Electronics Gain Constant (dummy constants)

ADC is calibrated by electronics gain constant ("pslope"). At this moment, we are using default value for all channel.

T0base and T0phase (in progress)

To get a calibrated time measurement, (T0base+12.5*T0phase ) should be subtracted from raw time measurement.

Strip Fitting

AlgTools providing the interface ICscStripFitter may be used to fit a strip (digit) and extract the peak charge and time. There is one implementation, CalibCscStripFitter that makes use of the parabolic fit in the CscCalibTool and adds code to assign errors and handle fit failures.

Cluster fitting

AlgTools providing the interface ICscClusterFitter may be used to fit a cluster to obtain the cluster position and error. There are two implementations: SimpleCscClusterFitter which simply uses the physical extent of the strips with a correction for the intrinsic cluster width and QratCscClusterFitter which does charge interpolation using adjacent charge ratios.

The simple cluster fitter assigns the position at the center of the cluster (no charge weighting) and assigns the error using the RMS of the effective width, i.e. this width divided by the square root of 12. The effective width is the full width (# strips times the pitch) minus the intrinsic signal width which is taken to be constant and provided as a job option.

The QRAT cluster fitter uses the ratio of charge in each adjacent channel to the peak charge to estimate the cluster position using an atanh fumction. If these estimates are consistent, they are combined to obtain the final position estimate and error. If they are inconsistent or any other problem is seen with the charge distribution, then the fit fails and the cluster is flagged as spoiled.



The first step in simulation is event generation. The interaction of two protons are simulated producing a list of particles. Generation instructions can be found at https://twiki.cern.ch/twiki/bin/viewauth/Atlas/WorkBookGeneration and https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/RunningGenerators .


The final state particles from the generator and their secondaries are propagated through the detector using GEANT. See AtlasG4Simulation. Interactions with sensitive volume are recorded as hits. For running locally the propagation use the command:

AtlasG4_trf.py inputEvgenFile=input.pool.root geometryVersion=ATLAS-GEO-20-00-01 physicsList=QGSP_BERT conditionsTag=OFLCOND-SDR-BS7T-05-07 maxEvents=-1 skipEvents=0 outputHitsFile=output.pool.root 


The first detector-specific stage of simulation is digitization. See the CscDigitization page for a description of the current status and plans.

Run the atlas digitization using the "transformation" job options:

Digi_trf.py inputHitsFile=./HITS.pool.root outputRDOFile=RDO.pool.root maxEvents=-1 geometryVersion=ATLAS-GEO-20-00-01 conditionsTag=OFLCOND-MC12-SDR-06

Run only the CSC digitization by checking out the package:

cmt co MuonSpectrometer/MuonDigitization/CSC_Digitization

Add in the "share" directory the script:

svn co svn+ssh://svn.cern.ch/reps/atlasusr/kalliopi/CSC_scripts/MasterRunDigitization.py

Run jobs using the script:

svn co svn+ssh://svn.cern.ch/reps/atlasusr/kalliopi/CSC_scripts/RunDigitizationJobs.py



Detector coming off the data is in bytestream format and is unpacked into raw data objects (RDO) using the same CscRdoContByteStreamCnv converter used to create simulated bytestream. Simulation data is typically stored in RDO format. Prep data digits describing the strips are constructed from the raw data objects using the CscRdoToCscPrepData algorithm. This step may be triggered with the following job options.

theApp.Dlls += ["MuonRdoToPrepData"]
include ("MuonRdoToPrepData/CscRdoToCscPrepData_jobOptions.py")


Initial clustering is performed with the CscThresholdClusterBuilder algorithm. Input are prep data digits and output are (also prep data) clusters.

A cluster is formed from all adjacent strips with charge above a threshold (current default is 20k electrons). For eta clusters, if the peak strip, i.e. the one with the greatest charge, is adjacent to a channel below threshold, then the latter is added to the cluster to enable the charge ratio calculation. This should cause clusters to merge when they are separated by a single strip below threshold and either has its peak strip at the edge nearest the other cluster. A splitting algorithm is run on selected eta clusters.

The clustering algorithm may be run with the following job options:


By default, clusters are written to a container named cscClusters.

The clusters are fit using the QratCscClusterFittingTool which provides a precise estimate (typically better than 100 micron) of the track position for unspoiled clusters. If that fitter or the finder itself detrmines that the cluster is spoiled, then the fit is done using the SimpleCscClusterFitting tool for which the error is calculated from the effective width of the cluster. Both are described in the section of fitting tools above.

Segment building

The building of 2D segments is accomplished with the Csc2dSegmentMaker algorithm. Input are clusters and output are 2D segments. It separately finds eta and phi segments within each chamber requiring a cluster from each of the four cathode planes. The following job options are used to run this segment maker:


By default the segments are written to a container named csc2dSegments.

The building of 4D segments is done with the Csc4dSegmentMaker algorithm. Input are 2D segments and output are 4D segments. There is a simple pairing of all combinations of all eta and phi segments within each chamber. The following job options are used to trigger this segment maker:


By default, the 4D segments are written to a container named csc4dSegments.


How to get MuonSegment

In ESD, CscSegments are a part of "MooreSegments". So, this key should be used in storegate as below.

const Trk::SegmentCollection* segmentCollection = 0;
StatusCode sc = evtStore()->retrieve(segmentCollection, "MooreSegments");

First, MuonSegment should be taken out of Trk::Segment by dynamic cast inside of loop:

Trk::SegmentCollection::const_iterator s;
int nSegments = segmentCollection->end() - segmentCollection->begin(); // 
if ( nSegments < 1 ) return sc;

for ( s = segmentCollection->begin(); s != segmentCollection->end(); ++s) {
       Muon::MuonSegment* mSeg               = dynamic_cast<Muon::MuonSegment*> (*s);

To get a chamber name among MDT and CSC, you need to subscribe a tool as:

ToolHandle          p_muonEDMHelperTool;

Then, you can get a identifier out of it as:

Identifier id=p_muonEDMHelperTool->chamberId(mSeg);

Detailed can be found here as well as how to match it with track.

For trigger chamber, one can use Robert's function.


Cluster and segments are validated both by examining their contents and by comparing these contents with truth information in Monte Carlo samples. The latter is a bit cumbersome because it requires accessing the hits files to obtain the predictions, accessing the RDO data to obtain the the measurements and then a comparison of the two. Validation packages extract ntuples summarizing truth or reconstructed data. Performance packages compare reconstructed and truth ntuples.

All validation software is in the MuonSpectrometer/MuonValidation/MuonCscValidation area. Common utilities and macros are in the package CscValidationUtil. For convenience, users will often check out the package used to create and examine the ntuple of interest. It may also be be desirable to check out and build this or other packages to get the most recent version, e.g. (in an ATLAS development area). For cluster validation, you want to check out CscHitValidation (you don't need this if you have csc_simpos.root file), CscClusterValidation and CscClusterPerformance. For segment validation, you want to check out CscHitValidation (you don't need this if you have csc_simpos.root file), CscSegmentValidation and CscSegmentPerformance. For cluster monitoring, you need to check out CscHitValidation (you don't need this if you have csc_simpos.root file), CscClusterValidation. (XXXX is one of CscHitValidation, CscClusterValidation, CscSegmentValidation, CscClusterPerformance, and CscSegmentPerformance)

Validation under 17.2.X

cmt co MuonSpectrometer/MuonValidation/MuonCscValidation/CscClusterValidation
cd MuonSpectrometer/MuonValidation/MuonCscValidation/CscClusterValidation/cmt

Produce validation ntuples using the "test6.py" script:

In case you need the L1ID in the ntuples take the package from :

svn co svn+ssh://svn.cern.ch/reps/atlasusr/kalliopi/CscClusterValidation

Monte Carlo predictions

Monte Carlo predictions are obtained looping over the hits in the CSC volumes. For clusters, an extrapolation is done between the points at which each track enters and exits each gas volume to obtain the true position for that wire plane and thus the expected coordinate in the associated eta and phi strip planes. This is done using the CscClusterValidator algorithm. Segment predictions are obtained in a similar way using the entrance and exit points for the chamber.

The CscHitValidation package contains the algorithm CscHitValidator which takes Monte Carlo hits as input and writes a root tree containing the hit data, cluster predictions or segment predictions. Check out and build this package and then run athena with the job options in the following table.

output job options output tree file Monte Carlo hits CscHitValidatorOptions.py csc_simhit.root Monte Carlo cluster predictions CscSimPosValidatorOptions.py csc_simpos.root
For example, if the software is installed in $HOME/MuonSpectrometer/MuonValidation/MuonCscValidation

> athena.py $HOME/MuonSpectrometer/MuonValidation/MuonCscValidation/CscHitValidation/share/CscSimPosValidatorOptions.py dataset.py

will produce a tree file with cluster predictions, i.e., csc_simpos.root . The file dataset.py lists the files you want to process.

Segment predictions may be produced directly from the cluster position predictions:

> csc_simseg_builder.exe csc_simpos.root   >& log.log & // creates csc_simseg.root

There is also an algorithm to produce the segment predictions directly from the hits, but (starting in February 2007) it provides less information and its use is no longer recommended. In particular, it does not carry the truth kinematic information used to make performance cuts.

Note that the hit, cluster and segment positions and directions int the trees are in the muon coordinate system where x is normal to the chamber, y in the direction measuring phi and z in the direction measuring eta.

Cluster measurements

Cluster measurements are obtained by reading an RDO file, running a clustering algorithm and then looping over the output of the latter. This is done by algorithm CscClusteringValidator in package CscClusterValidation. The output is the cluster tree file csc_clusters.root.

To run the validation algorithm, add the following to your job options:


after the lines to run a clustering algorithm.

Or the job options file CscClusterValidatorOptions.py may be used to both run the clustering and generate the cluster tree file.

Cluster performance

The package CscClusterPerformance contains an executable csc_cluster_performance.exe that reads a cluster prediction tree and a cluster measurement tree and, event by event, matches these and write the output to the cluster performance tree csc_perf.root.

Segment measurement

> athena.py $HOME/MuonSpectrometer/MuonValidation/MuonCscValidation/CscSegmentValidation/share/CscSegmentValidatorOptions.py dataset.py

Segment performance

The package CscSegmentPerformance contains an executable csc_segment_performance.exe and csc_4d_segment_performance.exe that read a segment prediction tree and a segment measurement tree and, event by event, matches these and write the output to the cluster performance tree csc_segperf.root and csc_4d_segperf.root.

Creating Ntuples


#export ATLAS_LOCAL_ROOT_BASE='/cvmfs/atlas.cern.ch/repo/ATLASLocalRootBase'
#alias setupATLAS='source ${ATLAS_LOCAL_ROOT_BASE}/user/atlasLocalSetup.sh'

kinit -5 ${USER}@CERN.CH
aklog -c CERN.CH -noprdb
cd ${WorkDir}
mkdir source build run
cd source
asetup 21.0.34,Athena,here
svnco MuonPrepRawData CscSegmentMakers MuonRIO_OnTrack MuonSegment MuonRecHelperTools MuonCalibITools
svnco -r CscClusterization-03-00-18 CscClusterization
git clone https://gitlab.cern.ch/CSC-reconstruction/CSCntuple.git
cd CSCntuple
cd ${WorkDir}/build
cmake ../source
make -j 32
source /build/x86_64-slc6-gcc62-opt/setup.sh
cd ${WorkDir}/source/CSCntuple/run
cp /afs/cern.ch/user/s/smaschek/public/runJobs/runJobs.py .
athena runJobs.py

20.6.X (Run II data)

Create a WorkDir directory
cd WorkDir

(suggested version 20.6.0)
asetup 20.6.X,here

cmt co -r CscClusterization-03-00-11 MuonSpectrometer/MuonReconstruction/MuonDataPrep/CscClusterization
cmt co -r MuonPrepRawData-05-00-06 MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonPrepRawData

cmt co -r MuonRIO_OnTrack-02-00-04 MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonRIO_OnTrack
cmt co -r MuonSegment-01-00-05 MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonSegment
cmt co -r MuonRecHelperTools-02-00-10 MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecHelperTools
cmt co -r MuonCalibITools-01-01-04 MuonSpectrometer/MuonCalib/MuonCalibITools
git clone https://gitlab.cern.ch/CSC-reconstruction/CSCntuple.git 

To compile the packages you can either go the cmt directory of each package and gmake (see instructions below) or you can
automatically compile all packages together by copying setupWorkArea.py in your WorkDir
(can be found online and in http://atlas-computing.web.cern.ch/atlas-computing/links/buildDirectory/AtlasDerivation/
and doing:
setupWorkArea.py (will create a directory named WorkArea)
cd WorkArea/cmt/
cmt br cmt config
cmt br gmake

To run a job locally:

1. Change the input file in CSCntuple/run/runJobs.py
2. Setup Athena (with asetup)
3. athena runJobs.py in the run directory

To run on the Grid:

1. Setup Athena (with asetup)
2. Setup voms
3. In CSCntuple/run/Grid_Run.sh add the file you want to run on in the list in the beginning and change the output name in the job submission command (pathena runJobs.py ....)
Make sure the file string in the submission command is correct (inFileX)
4. source Grid_Run.sh

17.2.X (Run I data)

(suggested version 17.2.7)
asetup 17.2.X 

cd 17.2.X

cmt co MuonSpectrometer/MuonReconstruction/MuonDataPrep/CscClusterization
cmt co MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonPrepRawData
cmt co MuonSpectrometer/MuonReconstruction/MuonSegmentMakers/MuonSegmentMakerAlgs/CscSegmentMakers

cd MuonSpectrometer/MuonReconstruction/MuonDataPrep/CscClusterization/cmt
cd MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonPrepRawData/cmt
cd MuonSpectrometer/MuonReconstruction/MuonSegmentMakers/MuonSegmentMakerAlgs/CscSegmentMakers/cmt

svn co svn+ssh://svn.cern.ch/reps/atlasusr/kalliopi/CSCntuple
cd CSCntuple/cmt

To produce ntuples go to CSCntuple/run and use the "runJobs.py" script : * Locally: download the file to your area and add the path to the script, then run "athena runJobs.py" * GRID: using the command "pathena runJobs.py --inDS dataset.name --outDS user.username.output.name --supStream GLOBAL --extOutFile ntuple.root" * To produce ntuples from MC use the option -c "ReadMC=True" 


 ---+Accessing /castor/cern.ch/grid/atlas/tzero/prod1 In order to gain access export:
export STAGE_HOST=castorpublic
export STAGE_SVCCLASS=amsuser
export CASTOR_INSTANCE=castorpublic
To see the content of a file:
nsls /castor/cern.ch/grid/atlas/tzero/prod1/perm/data12_8TeV
To copy a file:
xrdcp root://castoratlas//castor/cern.ch/grid/atlas/tzero/prod1/perm/data12_8TeV/file localFile
---+ Variables in the Ntuples | *csc_calib* | stored calibration values from DB | | *Variable* | *Meaning* | | zsec | z-sector: -1 for z<0, +1 for z>0 | | istation | 1=CSS, 2=CSL | | phisec | Phi-sector: 1-8 | | sector | zsec*(2*phisec-istation+1) | | wlay | Wire layer 1, 2, 3, 4 increasing with abs(z) | | measphi | 0 for eta-measurement, 1 for phi-measurement | | maxstrip | Number of strips in the layer, 48 or 192 | | nchan | number of channels per layer per measphi | | istrip[200] | strip Id (1-192 or 1-48) | | ped[200] |pedestal from DB in unit of charge | | sigma[200]| sigma from DB in unit of charge | | rms[200] | rms from DB in unit of charge| | f001[200] | f001 from DB in unit of charge (NOTE: it is not pedestal subtracted!!)| | pedADC[200] | same but in unit of ADC| |sigmaADC[200]| " | |rmsADC[200]| " | |f001ADC[200]| " | |thr[200]| threshold applied based on noise option and max(T0, k*noise)| |stat[200]| status bit from DB (0th: hot channel, 1st: dead channel, 2nd: stuck bit channel) | |address[200]| equivalent to the word from Bytestream data|  | *csc_strip* || | *Variable* | *Meaning* | | run | Run number | | evt | Event number | | bcid | Bunch Crossind id | | zsec | z-sector: -1 for z<0, +1 for z>0 | | istation | 1=CSS, 2=CSL | | phisec | Phi-sector: 1-8 | | sector | zsec*(2*phisec-istation+1) | | wlay | Wire layer 1, 2, 3, 4 increasing with abs(z) | | measphi | 0 for eta-measurement, 1 for phi-measurement | | maxstrip | Number of strips in the layer, 48 or 192 | | nstrip | Number of strips with charge above threshold | | istrip[200] | Indices for these strips | | qstrip[200] | Charges on these strips | | phase[200] | Sampling phase, 0 or 1 | | astrip[200] | true if calculated charge by parabola interpolation is above threshold Max(T0,k0*f001) | | tstrip[200] | Time at the maximum on these strips | | sfit[200] | strip fit return code | | stat[200] | status bit from DB (0th: hot channel, 1st: dead channel, 2nd: stuck bit channel) | | samples[200][4] | four sample charges in the unit of electrons (e-) |  | *csc_cluster* || | *Variable* | *Meaning* | | run | Run number | | evt | Event number | | lumiblock | Luminosity block | | bcid | Bunch Crossing id | | nentry | Number of entries (clusters) for this event | | phase[MAXENT] | Sampling phase per Segment | | pos[MAXENT] | Cluster position in local coordinates (mm) | | error[MAXENT] | Error assigned to the cluster position (mm) | | x[MAXENT] | Cluster global x-position from MuonGeoModel | | y[MAXENT] | Cluster global y-position from MuonGeoModel | | z[MAXENT] | Cluster global z-position from MuonGeoModel | | nstrip[MAXENT] | number of strips in the cluster | | qstrip[MAXENT][MAXSTRIP] | Charge on each strip in the cluster | | tstrip[MAXENT][MAXSTRIP] | Time on each strip in the cluster | | qsum[MAXENT] | Sum of three strip charges | | qpeak[MAXENT] | Peak strip charge | | speak[MAXENT] | Peak strip status | | qleft[MAXENT] | Charge on the strip left of the peak | | sleft[MAXENT] | Status of the strip left of the peak strip | | qright[MAXENT] | Charge on the strip right of the peak strip | | sright[MAXENT] | Status of the strip right of the peak strip | | tpeak[MAXENT] | Cluster time (peak strip) | | phase[MAXENT] | Sampling phase | | sfit[MAXENT] | Cluster status | | posrefit[MAXENT][MAXPOS] | Refit position (mm) | | errrefit[MAXENT][MAXPOS] | Refit position error (mm) | | srefit[MAXENT][MAXPOS] | Cluster refit status | | measphi[MAXENT] | 0 for eta-measurement, 1 for phi-measurement | | wlay[MAXENT] | Wire layer 1, 2, 3, 4 increasing with abs(z) | | istation[MAXENT] | 1=CSS, 2=CSL | | zsec[MAXENT] | z-sector: -1 for z<0, +1 for z>0 | | phisec[MAXENT] | Phi-sector: 1-8 | | sector[MAXENT] | zsec*(2*phisec-istation+1) | | pitch[MAXENT] | Strip pitch | | maxstrip[MAXENT] | Number of strips in this cathode plane | | strip0[MAXENT] | Channel number for the first strip in the cluster | | pstrip[MAXENT] | Offset of the peak strip from the first | | data[MAXDATA][]MAXENT] | Extra data from cluster fit |  | *csc_segment* || | *Variable* | *Meaning* | | run | Run number | | evt | Event number | | lumiblock | Luminosity block (not added yet) | | bcid | Bunch Crossing id | | nchamber | Number of chambers with segments in this event | | nseg [MAXCHAMBER] | Number of segments in each chamber | | nentry | Number of entries (segments) in this event | | iseg[MAXENT] | index of segment in each chamber | | nspoil[MAXENT]| # spoiled measurements on segment. | | nunspoil[MAXENT]| # not spoiled measurements on segment. | | x[MAXENT]| Segment global coordinate x | | y[MAXENT]| Segment global coordinate y | | z[MAXENT]| Segment global coordinate z | | s0[MAXENT]| Segment position | | s1[MAXENT]| Segment slope dy/dx | | sa[MAXENT]| Segment angle atan(dx/dy) degree (normal to chamber 0 deg)| | d0[MAXENT]| Position error. | | d1[MAXENT]| Slope error. | | da[MAXENT]| Angle error. | | d01[MAXENT]| Position-slope error correlation.| | d0a[MAXENT]| Position-angle error correlation.| | chsq[MAXENT]| Segment chi-square. | | phase[MAXENT]| sampling phase (in principle dependent on chamber (ROD)) | | qsum[MAXENT][4]| sum of qleft+qpeak+qright associated 2dsegment | | qpeak[MAXENT][4]| qpeak associated 2dsegment | | qleft[MAXENT][4]| qleft associated 2dsegment | | qright[MAXENT][4]| qright associated 2dsegment | | pos[MAXENT][4] | hit position associated 2dsegment | | dpos[MAXENT][4]| error of hit position associated 2dsegment | | sfit[MAXENT][4]| sfit (cluster quality) associated 2dsegment | | str0[MAXENT][4]| First strip id of cluster (strip#) | | nstr[MAXENT][4]| Cluster size (strip#) | | pstr[MAXENT][4]| Peak strip id (strip#) | | tstr[MAXENT][4]| Time of peak strip (ns) | | res[MAXENT][4]| Residual. | | dres[MAXENT][4]| Residual error. | | posAsSid[MAXENT][4]| position in unit of stripId (1-192/48) converted from position (mm) | | refAsSid[MAXENT][4]| position in unit of stripId (1-192/48) converted from position (mm) | | posInStr[MAXENT][4]| position in unit of strip UNIT (-0.5 - 0.5 in case of precision fit)| | refInStr[MAXENT][4]| Reference position from the other three hits in unit of strip UNIT | | - | (-0.5 - 0.5 in case of precision fit) | | rs2[MAXENT]| residual from the first 3 hits | | rs3[MAXENT]| residual from the second 3 hits | | drs2[MAXENT]| error of rs2 | | drs3[MAXENT]| error of rs3 | | measphi[MAXENT]|0 for r-measurement, 1 for phi-measurement | | sector[MAXENT]| zsec*(2*phisec-istation+1) | | hitmap[MAXENT]| hit3*2^3 + hit2*2^2 + hit1*2^1 + hit0*2^0 | | spoilmap[MAXENT]| hit3*2^3 + hit2*2^2 + hit1*2^1 + hit0*2^0 | | istation[MAXENT]| 1=CSS, 2=CSL | | zsec[MAXENT]| Z-sector: -1 for z<0, +1 for z>0 | | phisec[MAXENT]| Phi-sector: 1-8 |  | *csc_4d_segment* || | *Variable* | *Meaning* | | run| run# | | evt| event # | | bcid| beam crossing id | | nentry| # segments for this event | | nchamber| # chambers with segments for this event | | nseg[MAXCHAMBER]| # segments in the chamber | | gx[MAXENT]| Segment global coordinate x (mm) | | gy[MAXENT]| Segment global coordinate y (mm) | | gz[MAXENT]| Segment global coordinate z (mm) | | eta[MAXENT]| Segment global pseudorapidity | | theta[MAXENT]| Segment global azimuthal angle degree | | phi[MAXENT]| Segment global polar angle degree | | y[MAXENT]|Segment local position phi (mm) | | z[MAXENT]| Segment local position eta (mm) | | ay[MAXENT]|Segment angle degree (normal to chamber 0 deg) | | az[MAXENT]| | | dy[MAXENT]| Position error. | | dz[MAXENT]| | | day[MAXENT]| Angle error. degree | | daz[MAXENT]| | | eyz[MAXENT]| Error correlations. | | eyay[MAXENT]| | | eyaz[MAXENT]| | | ezay[MAXENT]| | | ezaz[MAXENT]| | | eayaz[MAXENT]| | | chsq[MAXENT]| Segment chi-square. | | nhit[MAXENT]| Number of hits either 6,7,8 | | ihit[MAXENT][8]|index of hit 0-7 | | str0[MAXENT][8]|First strip id of cluster (strip#) | | nstr[MAXENT][8]|Cluster size (strip#) | | pstr[MAXENT][8]|Peak strip id (strip#) | | sfit[MAXENT][8]|Cluster Status tag (strip#) | | qsum[MAXENT][8]| Sum over strip charges | | qleft[MAXENT][8]| Qleft | | qright[MAXENT][8]| Qright | | qpeak[MAXENT][8]|Qpeak | | tpeak[MAXENT][8]|Qpeak | | dqleft[MAXENT][8]| Qleft | | dqright[MAXENT][8]| Qright | | dqpeak[MAXENT][8]| Qpeak | | pos[MAXENT][8]| Strip position (mm) | | dpos[MAXENT][8]|Position error (mm) | | res[MAXENT][8]| Residual from 4 hits (mm)| | dres[MAXENT][8]|Residual error (mm) | | rs[MAXENT][8]| Residual from 3 hits (mm) | | drs[MAXENT][8]| Residual error (mm) | | posAsSid[MAXENT][8]| position in unit of stripId (1-192/48) converted from position (mm) | | refAsSid[MAXENT][8]| position in unit of stripId (1-192/48) converted from position (mm) | | posInStr[MAXENT][8]| position in unit of strip UNIT (-0.5 - 0.5 in case of precision fit)| | refInStr[MAXENT][8]| Reference position from the other three hits | | |-|in unit of strip UNIT (-0.5 - 0.5 in case of precision fit) | | istation[MAXENT]|1=CSS, 2=CSL | | zsec[MAXENT]| Z-sector: -1 for z<0, +1 for z>0 | | phisec[MAXENT]| Phi-sector: 1-8 | | sector[MAXENT]| zsec*(2*phisec-istation+1) | | hitmap[MAXENT]| hit3*2^3 + hit2*2^2 + hit1*2^1 + hit0*2^0 (X) | |-| hit7*2^7 + hit6*2^6 + hit5*2^5 + hit4*2^4 | | phase[MAXENT]| sampling phase (in principle dependent on chamber (ROD)) | ==================================================================== ----- *Major updates*:
-- Main.dadams - 29 Jan 2007 -- Main.StevenGoldfarb - 03 Jul 2007 (reviewed & certified) --Kalliopi Iordanidou - 6 Feb 2013 %RESPONSIBLE% Main.dadams
%REVIEW% Main.StevenGoldfarb - 03 Jul 2007
Edit | Attach | Watch | Print version | History: r18 | r11 < r10 < r9 < r8 | Backlinks | Raw View | Raw edit | More topic actions...
Topic revision: r9 - 2017-09-26 - StefanRaimundMaschek
    • Cern Search Icon Cern Search
    • TWiki Search Icon TWiki Search
    • Google Search Icon Google Search

    Main All webs login

This site is powered by the TWiki collaboration platform Powered by PerlCopyright & 2008-2020 by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
or Ideas, requests, problems regarding TWiki? use Discourse or Send feedback