TofCuts/TofNucleiZCut/TofNucleiZCut.h

/*
 * TofNucleiZCut.h
 *
 *  Created on: 21-apr-2009
 *      Author: Nicola Mori
 */

/*! @file TofNucleiZCut.h The TofNucleiZCut class definition file */

#ifndef NO_TOFNUCLEI

#ifndef TOFNUCLEIZCUT_H_
#define TOFNUCLEIZCUT_H_

#include "../../PamCutBase/PamCutBase.h"
#include <ToFNuclei.h>

#ifdef DEBUGPAMCUT
#include <TH2F.h>
#endif

/*! @enum TofNucleiZ_Return Return values for rejected events. */
enum TofNucleiZ_Return {
  TOFNUCLEIZ_OUTOFBOUNDS, ///< Discarded because charge is out of bounds in a layer.
  TOFNUCLEIZ_TOOFEWLAYERS, ///< Discarded because charge can be measured in too few layers.
  TOFNUCLEIZ_ILLEGALZ
///< Discarded because charge is not between 1 and 8
};

/*! @enum TofNucleiZ_Layers Flags to identify layers. */
enum TofNucleiZ_Layers {
  TOFNUCLEIZ_S11 = 1, ///< S11.
  TOFNUCLEIZ_S12 = 2, ///< S12.
  TOFNUCLEIZ_S21 = 4, ///< S21.
  TOFNUCLEIZ_S22 = 8, ///< S22.
  TOFNUCLEIZ_S31 = 16, ///< S31.
  TOFNUCLEIZ_S32 = 32
///< S32.
};

/*! @brief The TofNuclei charge cut.
 *
 * This cut uses the TofNuclei library to cut events depending on particle's charge value.
 *
 */

class TofNucleiZCut: public PamCut {

public:
  /*! @brief Constructor.
   *
   * The charge to look for is passed to the TofNucleiZCut object as Z. For each charge, there is an associated distribution of
   * events, with mean Zmean and standard deviation sigmaZ. These values will be used to check the events.
   *
   * @param cutName The cut's name.
   * @param Z The charge value.
   * @param lowerLimit The lower bound (in units of sigmaZ) of the desired charge range, defined as Zmean - lowerBound*sigmaZ.
   * @param upperLimit The upper bound (in units of sigmaZ) of the desired charge range, defined as Zmean + upperBound*sigmaZ.
   * @param minLayers The minimum number of layers for which Z must have been measured.
   * @param layersMask The masked layers (see #TofNucleiZ_Layers). These will be ignored throughout all the TofNucleiZCut analysis.
   * @see Check
   */
  TofNucleiZCut(const char *cutName, unsigned int Z, float lowerLimit, float upperLimit, unsigned int minLayers = 6,
      unsigned int layersMask = 0);

  /*! @brief Destructor. */
  ~TofNucleiZCut() {
    delete _tofNuclei;

#ifdef DEBUGPAMCUT

    for (UInt_t j = 0; j < 12; j++) {
      h_tof_z_beta[j]->Write();
    }

#endif

  }

  /*! @brief The TofNucleiZ check.
   *
   * The routine selects events whose value of Zmean obtained from the ToF is in the range [Zmean - sigma*lowerBound, Zmean + sigma*upperBound].
   * Zmean and sigma are defined respectively as the mean and the standard deviation of the charge distributions obtained using ToFNuclei.
   * The calibration values used in this routine (for all energies) are:
   *
   *   Z=1 |   Zmean     sigma
   *   ------------------------
   *   S11 |  0.987      0.11
   *   S12 |  0.988      0.12
   *   S21 |  0.961      0.083
   *   S22 |  0.966      0.10
   *   S31 |  0.981      0.092
   *   S32 |  0.979      0.095
   *
   *   Z=2 |   Zmean     sigma
   *   ------------------------
   *   S11 |  1.96       0.12
   *   S12 |  1.95       0.14
   *   S21 |  1.95       0.13
   *   S22 |  1.96       0.14
   *   S31 |  1.99       0.14
   *   S32 |  2.00       0.15
   *
   * In current implementation, heavier nuclei up to oxygen are partially calibrated; means are taken equal to the particle's charge (Zmean = Z)
   * and a single sigma is used for all ToF layers:
   *
   *   Z |  sigma
   *   -----------
   *   3 |  0.20
   *   4 |  0.25
   *   5 |  0.32
   *   6 |  0.40
   *   7 |  0.45
   *   8 |  0.50
   *
   * The charge of the particle is detrmined by calling ToFNuclei::Get_Charge_ToF_std_layer().
   * First of all, the number of non-masked layers giving a valid charge information is checked to be greater than minLayers; then the bound
   * on the charge value is checked for all valid planes. If at least one of the valid, non-masked planes gives a charge outside the bounds
   * the routine will return #TOFNUCLEIZ_OUTOFBOUNDS. Note that this happens even if more than minLayers give a charge inside boundaries;
   * for example, if minLayers = 5 and we have 6 good charge measurement of which only 5 are inside the boundaries, the check will fail.
   * Notice that masking a layer has the net effect of reducing the number of layers: asking minLayers = 5 and masking two planes
   * will result in return value of #TOFNUCLEIZ_TOOFEWLAYERS for all events, since the "effective ToF" has only 4 layers.
   *
   * @param event The event to analyze.
   * @return #CUTOK if the charge obtained from TofNuclei is in the range [Z - sigma*lowerBound, Z + sigma*upperBound] in at least minLayers
   *          (apart from eventual masked layers).
   * @return #TOFNUCLEIZ_OUTOFBOUNDS if charge is out of bounds in at least one non-masked layer.
   * @return #TOFNUCLEIZ_TOOFEWLAYERS if charge information is available for a number of layers lesser than minLayers.
   * @return #TRKNUCLEIZ_OUTOFBOUNDS if Z < 1 or Z > 8.
   */
  int Check(PamLevel2 *event);

private:

#ifdef DEBUGPAMCUT

  TH2F* h_tof_z_beta[12];

#endif

  unsigned int _Z;
  SimpleMatrix<float> _mean; // Index structure: [Z-1][layer]
  SimpleMatrix<float> _sigma; // Index structure: [Z-1][layer]
  static const float _sigmaZdefault[8];

  float _lowerLimit;
  float _upperLimit;
  unsigned int _minLayers;
  unsigned int _layersMask;

  ToFNuclei *_tofNuclei;
  static const unsigned int _maskArray[6];

};

#endif /* TOFNUCLEIZCUT_H_ */

#endif /* NO_TOFNUCLEI */
1	/*
2	* TofNucleiZCut.h
3	*
4	* Created on: 21-apr-2009
5	* Author: Nicola Mori
6	*/
7
8	/! @file TofNucleiZCut.h The TofNucleiZCut class definition file /
9
10	#ifndef NO_TOFNUCLEI
11
12	#ifndef TOFNUCLEIZCUT_H_
13	#define TOFNUCLEIZCUT_H_
14
15	#include "../../PamCutBase/PamCutBase.h"
16	#include <ToFNuclei.h>
17
18	#ifdef DEBUGPAMCUT
19	#include <TH2F.h>
20	#endif
21
22	/! @enum TofNucleiZ_Return Return values for rejected events. /
23	enum TofNucleiZ_Return {
24	TOFNUCLEIZ_OUTOFBOUNDS, ///< Discarded because charge is out of bounds in a layer.
25	TOFNUCLEIZ_TOOFEWLAYERS, ///< Discarded because charge can be measured in too few layers.
26	TOFNUCLEIZ_ILLEGALZ
27	///< Discarded because charge is not between 1 and 8
28	};
29
30	/! @enum TofNucleiZ_Layers Flags to identify layers. /
31	enum TofNucleiZ_Layers {
32	TOFNUCLEIZ_S11 = 1, ///< S11.
33	TOFNUCLEIZ_S12 = 2, ///< S12.
34	TOFNUCLEIZ_S21 = 4, ///< S21.
35	TOFNUCLEIZ_S22 = 8, ///< S22.
36	TOFNUCLEIZ_S31 = 16, ///< S31.
37	TOFNUCLEIZ_S32 = 32
38	///< S32.
39	};
40
41	/*! @brief The TofNuclei charge cut.
42	*
43	* This cut uses the TofNuclei library to cut events depending on particle's charge value.
44	*
45	*/
46
47	class TofNucleiZCut: public PamCut {
48
49	public:
50	/*! @brief Constructor.
51	*
52	* The charge to look for is passed to the TofNucleiZCut object as Z. For each charge, there is an associated distribution of
53	* events, with mean Zmean and standard deviation sigmaZ. These values will be used to check the events.
54	*
55	* @param cutName The cut's name.
56	* @param Z The charge value.
57	* @param lowerLimit The lower bound (in units of sigmaZ) of the desired charge range, defined as Zmean - lowerBound*sigmaZ.
58	* @param upperLimit The upper bound (in units of sigmaZ) of the desired charge range, defined as Zmean + upperBound*sigmaZ.
59	* @param minLayers The minimum number of layers for which Z must have been measured.
60	* @param layersMask The masked layers (see #TofNucleiZ_Layers). These will be ignored throughout all the TofNucleiZCut analysis.
61	* @see Check
62	*/
63	TofNucleiZCut(const char *cutName, unsigned int Z, float lowerLimit, float upperLimit, unsigned int minLayers = 6,
64	unsigned int layersMask = 0);
65
66	/! @brief Destructor. /
67	~TofNucleiZCut() {
68	delete _tofNuclei;
69
70	#ifdef DEBUGPAMCUT
71
72	for (UInt_t j = 0; j < 12; j++) {
73	h_tof_z_beta[j]->Write();
74	}
75
76	#endif
77
78	}
79
80	/*! @brief The TofNucleiZ check.
81	*
82	* The routine selects events whose value of Zmean obtained from the ToF is in the range [Zmean - sigmalowerBound, Zmean + sigmaupperBound].
83	* Zmean and sigma are defined respectively as the mean and the standard deviation of the charge distributions obtained using ToFNuclei.
84	* The calibration values used in this routine (for all energies) are:
85	*
86	* Z=1 \| Zmean sigma
87	* ------------------------
88	* S11 \| 0.987 0.11
89	* S12 \| 0.988 0.12
90	* S21 \| 0.961 0.083
91	* S22 \| 0.966 0.10
92	* S31 \| 0.981 0.092
93	* S32 \| 0.979 0.095
94	*
95	* Z=2 \| Zmean sigma
96	* ------------------------
97	* S11 \| 1.96 0.12
98	* S12 \| 1.95 0.14
99	* S21 \| 1.95 0.13
100	* S22 \| 1.96 0.14
101	* S31 \| 1.99 0.14
102	* S32 \| 2.00 0.15
103	*
104	* In current implementation, heavier nuclei up to oxygen are partially calibrated; means are taken equal to the particle's charge (Zmean = Z)
105	* and a single sigma is used for all ToF layers:
106	*
107	* Z \| sigma
108	* -----------
109	* 3 \| 0.20
110	* 4 \| 0.25
111	* 5 \| 0.32
112	* 6 \| 0.40
113	* 7 \| 0.45
114	* 8 \| 0.50
115	*
116	* The charge of the particle is detrmined by calling ToFNuclei::Get_Charge_ToF_std_layer().
117	* First of all, the number of non-masked layers giving a valid charge information is checked to be greater than minLayers; then the bound
118	* on the charge value is checked for all valid planes. If at least one of the valid, non-masked planes gives a charge outside the bounds
119	* the routine will return #TOFNUCLEIZ_OUTOFBOUNDS. Note that this happens even if more than minLayers give a charge inside boundaries;
120	* for example, if minLayers = 5 and we have 6 good charge measurement of which only 5 are inside the boundaries, the check will fail.
121	* Notice that masking a layer has the net effect of reducing the number of layers: asking minLayers = 5 and masking two planes
122	* will result in return value of #TOFNUCLEIZ_TOOFEWLAYERS for all events, since the "effective ToF" has only 4 layers.
123	*
124	* @param event The event to analyze.
125	* @return #CUTOK if the charge obtained from TofNuclei is in the range [Z - sigmalowerBound, Z + sigmaupperBound] in at least minLayers
126	* (apart from eventual masked layers).
127	* @return #TOFNUCLEIZ_OUTOFBOUNDS if charge is out of bounds in at least one non-masked layer.
128	* @return #TOFNUCLEIZ_TOOFEWLAYERS if charge information is available for a number of layers lesser than minLayers.
129	* @return #TRKNUCLEIZ_OUTOFBOUNDS if Z < 1 or Z > 8.
130	*/
131	int Check(PamLevel2 *event);
132
133	private:
134
135	#ifdef DEBUGPAMCUT
136
137	TH2F* h_tof_z_beta[12];
138
139	#endif
140
141	unsigned int _Z;
142	SimpleMatrix<float> _mean; // Index structure: [Z-1][layer]
143	SimpleMatrix<float> _sigma; // Index structure: [Z-1][layer]
144	static const float _sigmaZdefault[8];
145
146	float _lowerLimit;
147	float _upperLimit;
148	unsigned int _minLayers;
149	unsigned int _layersMask;
150
151	ToFNuclei *_tofNuclei;
152	static const unsigned int _maskArray[6];
153
154	};
155
156	#endif /* TOFNUCLEIZCUT_H_ */
157
158	#endif /* NO_TOFNUCLEI */