BOSS 8.0.0
BESIII Offline Software System
Loading...
Searching...
No Matches
DQADtagAlg.cxx
Go to the documentation of this file.
1#include "CLHEP/Geometry/Point3D.h"
2#include "CLHEP/Vector/LorentzVector.h"
3#include "CLHEP/Vector/ThreeVector.h"
4#include "CLHEP/Vector/TwoVector.h"
5#include "GaudiKernel/Bootstrap.h"
6#include "GaudiKernel/IDataProviderSvc.h"
7#include "GaudiKernel/IHistogramSvc.h"
8#include "GaudiKernel/INTupleSvc.h"
9#include "GaudiKernel/ISvcLocator.h"
10#include "GaudiKernel/ITHistSvc.h"
11#include "GaudiKernel/MsgStream.h"
12#include "GaudiKernel/NTuple.h"
13#include "GaudiKernel/PropertyMgr.h"
14#include "GaudiKernel/SmartDataPtr.h"
15#include "TH1F.h"
16#include "TMath.h"
17#include <vector>
18
19#include "DstEvent/TofHitStatus.h"
20#include "EventModel/Event.h"
21#include "EventModel/EventHeader.h"
22#include "EventModel/EventModel.h"
23#include "EvtRecEvent/EvtRecDTag.h"
24#include "EvtRecEvent/EvtRecEvent.h"
25#include "EvtRecEvent/EvtRecTrack.h"
26#include "McTruth/McParticle.h"
27#include "ParticleID/ParticleID.h"
28#include "VertexDbSvc/IVertexDbSvc.h"
29#include "VertexFit/Helix.h"
30#include "VertexFit/KinematicFit.h"
31#include "VertexFit/VertexFit.h"
32
33using CLHEP::Hep2Vector;
34using CLHEP::Hep3Vector;
35using CLHEP::HepLorentzVector;
36#ifndef ENABLE_BACKWARDS_COMPATIBILITY
37typedef HepGeom::Point3D<double> HepPoint3D;
38#endif
39
40#include "DQADtag.h"
41#include "util/MyConst.h"
42#include "util/MyUtil.h"
43
44using namespace Event;
45// const double mpi = 0.13957;
46// const double mk = 0.493677;
47// const double mD0 = 1.86484;
48// const double xmass[5] = {0.000511, 0.105658, 0.139570,0.493677, 0.938272};
49////const double velc = 29.9792458; tof_path unit in cm.
50// const double velc = 299.792458; // tof path unit in mm
51// typedef std::vector<int> Vint;
52// typedef std::vector<HepLorentzVector> Vp4;
53const double mpsipp = 3.770;
54// double beamE = mpsipp/2;
55const HepLorentzVector ecms( 0.011 * mpsipp, 0, 0, mpsipp );
56const Hep3Vector u_cms = -ecms.boostVector();
57
58int Ncut_DQADTagAlg[10];
59
60/////////////////////////////////////////////////////////////////////////////
61DECLARE_COMPONENT( DQADtag )
62DQADtag::DQADtag( const std::string& name, ISvcLocator* pSvcLocator )
63 : Algorithm( name, pSvcLocator ) {
64
65 // Declare the properties
66 declareProperty( "Vr0cut", m_vr0cut = 1.0 );
67 declareProperty( "Vz0cut", m_vz0cut = 10.0 );
68 declareProperty( "Vctcut", m_cthcut = 0.93 );
69 declareProperty( "mpi0Max", m_mpi0Min = 0.1 );
70 declareProperty( "mpi0Min", m_mpi0Max = 0.16 );
71 declareProperty( "EnergyThreshold", m_energyThreshold = 0.04 );
72 declareProperty( "BarrelEmc_th", m_Barrel_th = 0.82 );
73 declareProperty( "EndcapEmc_th_1", m_Endcap_th_1 = 0.85 );
74 declareProperty( "EndcapEmc_th_2", m_Endcap_th_2 = 0.93 );
75 declareProperty( "EnergyThreshold_b", m_energyThreshold_b = 0.025 );
76 declareProperty( "EnergyThreshold_e", m_energyThreshold_e = 0.05 );
77 declareProperty( "GammaAngCut", m_gammaAngCut = 25.0 );
78 declareProperty( "ReadBeamEFromDB", m_ReadBeamEFromDB = false );
79 declareProperty( "BeamE", m_beamE = 1.885 );
80 declareProperty( "CheckDedx", m_checkDedx = 0 );
81 declareProperty( "CheckTof", m_checkTof = 0 );
82 declareProperty( "CheckVtx", m_checkVtx = 0 );
83 declareProperty( "CheckEvt", m_checkEvt = 0 );
84 declareProperty( "WriteTuple", m_writeTuple = 1 );
85 declareProperty( "Debug", m_debug = 0 );
86 declareProperty( "deltECut", m_deltECut = 0.03 );
87 declareProperty( "mpi0MaxCut", m_mpi0MinCut = 0.117 );
88 declareProperty( "mpi0MinCut", m_mpi0MaxCut = 0.145 );
89 declareProperty( "mKsMaxCut", m_mKsMaxCut = 0.505 );
90 declareProperty( "mKsMinCut", m_mKsMinCut = 0.49 );
91 declareProperty( "KsDLengthCut", m_KsDLengthCut = 12.0 );
92 declareProperty( "CheckDecayMode", m_checkDecayMode = 2 );
93 declareProperty( "ReadVertex", m_readVertex = true );
94 declareProperty( "RegHist", m_regHist = 1 );
95 m_vtxFit = VertexFit::instance();
96 m_2ndVtxFit = SecondVertexFit::instance();
97 HepPoint3D vx( 0., 0., 0. );
98 HepSymMatrix Evx( 3, 0 );
99 double bx = 1E+6;
100 double by = 1E+6;
101 double bz = 1E+6;
102 Evx[0][0] = bx * bx;
103 Evx[1][1] = by * by;
104 Evx[2][2] = bz * bz;
105 m_vxpar.setVx( vx );
106 m_vxpar.setEvx( Evx );
107 m_privxpar.setVx( vx );
108 m_privxpar.setEvx( Evx );
109 // log = MsgStream(msgSvc(), name());
110 TString strDecayModeName[6] = { "mBC", "deltE", "p", "charm", "mass", "e" };
111 m_decayModeHistName[0] = "mBC";
112 m_decayModeHistName[1] = "deltE";
113 m_decayModeHistName[2] = "mass";
114 for ( int i = 0; i != 6; i++ ) { m_DecayModeItemName[i] = strDecayModeName[i]; }
115 // for (int i=0;i!=6;i++)
116 //{
117 // cout<<"m_DecayModeItemName: "<<m_DecayModeItemName[i]<<endl;
118 // }
119 TString strTrkName[10] = { "px", "py", "pz", "pp", "vx", "vy", "vz", "vr0", "cos", "E" };
120 m_TrackItemName[10] = "Id";
121 for ( int i = 0; i != 10; i++ )
122 {
123 m_trackHistName[i] = strTrkName[i];
124 m_TrackItemName[i] = strTrkName[i];
125 }
126 TString strPhotonName[5] = { "numHits", "secondmoment", "x", "y", "z" };
127 m_PhotonItemName[5] = "Id_Emc";
128 for ( int i = 0; i != 5; i++ )
129 {
130 m_photonHistName[i] = strPhotonName[i];
131 m_PhotonItemName[i] = strPhotonName[i];
132 }
133 TString strTrkDedxName[6] = { "chik", "chipi", "ghit", "thit", "probPH", "normPH" };
134 for ( int i = 0; i != 6; i++ )
135 {
136 m_trackDedxHistName[i] = strTrkDedxName[i];
137 m_TrackDedxItemName[i] = strTrkDedxName[i];
138 }
139 m_TrackDedxItemName[6] = "Id_Dedx";
140 TString strTrkTofName[6] = { "br_toff_mu", "br_toff_pi", "br_toff_k",
141 "ec_toff_mu", "ec_toff_pi", "ec_toff_k" };
142 for ( int i = 0; i != 6; i++ )
143 {
144 m_trackTofHistName[i] = strTrkTofName[i];
145 m_TrackTofItemName[i] = strTrkTofName[i];
146 }
147 m_TrackTofItemName[6] = "Id_tof";
148 m_TrackTofItemName[7] = "ec_toff_isEast";
149 TString strKsName[4] = { "vfitmass", "mass", "dLength", "dLengthErrorRatio" };
150 for ( int i = 0; i != 4; i++ )
151 {
152 m_KsHistName[i] = strKsName[i];
153 m_KsItemName[i] = strKsName[i];
154 }
155 m_KsItemName[4] = "pvchi2";
156 m_KsItemName[5] = "svchi2";
157 TString strPi0Name[7] = { "pi0mass", "photon1_E", "photon1_cos", "photon2_E",
158 "photon2_cos", "photon1_Id", "photon2_Id" };
159 for ( int i = 0; i != 5; i++ )
160 {
161 m_Pi0HistName[i] = strPi0Name[i];
162 m_Pi0ItemName[i] = strPi0Name[i];
163 }
164 m_Pi0ItemName[5] = "photon1_Id";
165 m_Pi0ItemName[6] = "photon2_Id";
166}
167
168// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
169StatusCode DQADtag::initialize() {
170 MsgStream log( msgSvc(), name() );
171
172 log << MSG::INFO << "in initialize()" << endmsg;
173
174 m_irun = -100;
175
176 StatusCode status;
177
178 NTuplePtr nt2( ntupleSvc(), "DQAFILE/CheckVtx" );
179 if ( nt2 ) m_tuple2 = nt2;
180 else
181 {
182 m_tuple2 =
183 ntupleSvc()->book( "DQAFILE/CheckVtx", CLID_ColumnWiseTuple, "ks N-Tuple example" );
184 if ( m_tuple2 )
185 {
186 status = m_tuple2->addItem( "vtxTrkId", m_vtxTrkId );
187 status = m_tuple2->addItem( "vx0", m_vx0 );
188 status = m_tuple2->addItem( "vy0", m_vy0 );
189 status = m_tuple2->addItem( "vz0", m_vz0 );
190 status = m_tuple2->addItem( "vr0", m_vr0 );
191 status = m_tuple2->addItem( "vct", m_Vct );
192 }
193 else
194 {
195 log << MSG::ERROR << " Cannot book N-tuple:" << long( m_tuple2 ) << endmsg;
196 return StatusCode::FAILURE;
197 }
198 }
199
200 NTuplePtr nt4( ntupleSvc(), "DQAFILE/Dtag" );
201 if ( nt4 ) m_tuple4 = nt4;
202 else
203 {
204 m_tuple4 = ntupleSvc()->book( "DQAFILE/Dtag", CLID_ColumnWiseTuple, "ks N-Tuple example" );
205 if ( m_tuple4 )
206 {
207 status = m_tuple4->addItem( "run", m_run );
208 status = m_tuple4->addItem( "rec", m_rec );
209 status = m_tuple4->addItem( "nch", m_nch );
210 status = m_tuple4->addItem( "nneu", m_nneu );
211 status = m_tuple4->addItem( "numD0Mode", m_numD0Mode );
212 status = m_tuple4->addItem( "D0_mBC", m_D0_mBC );
213 status = m_tuple4->addItem( "D0_deltE", m_D0_deltE );
214 status = m_tuple4->addItem( "D0_mass", m_D0_mass );
215 status = m_tuple4->addItem( "numDCMode", m_numDCMode );
216 status = m_tuple4->addItem( "DC_mBC", m_DC_mBC );
217 status = m_tuple4->addItem( "DC_deltE", m_DC_deltE );
218 status = m_tuple4->addItem( "DC_mass", m_DC_mass );
219 status = m_tuple4->addItem( "numAllMode", m_numAllMode );
220 status = m_tuple4->addItem( "DtagbeamE", m_dtagbeamE );
221 status = m_tuple4->addItem( "mode", m_mode );
222 status = m_tuple4->addItem( "charge", m_charge );
223 status = m_tuple4->addItem( "charm", m_charm );
224 status = m_tuple4->addItem( "numchildren", m_numofchildren );
225 status = m_tuple4->addItem( "mass", m_mass );
226 status = m_tuple4->addItem( "mBC", m_mBC );
227 status = m_tuple4->addItem( "rflag", m_rflag );
228 status = m_tuple4->addItem( "deltaE", m_deltae );
229 status = m_tuple4->addItem( "E", m_e );
230 status = m_tuple4->addItem( "p", m_p );
231 status = m_tuple4->addItem( "p_CMS", m_p_CMS );
232 status = m_tuple4->addItem( "p4_CMS", 4, m_p4_CMS );
233 status = m_tuple4->addItem( "notherTrk", m_nothertrk );
234 status = m_tuple4->addItem( "nTrk", m_ntrk );
235 status = m_tuple4->addItem( "nothershower", m_nothershower );
236 status = m_tuple4->addItem( "nshower", m_nshower );
237 status = m_tuple4->addItem( "recNumD02KPi", m_recNumD02KPi );
238 status = m_tuple4->addItem( "D02KPi_e", m_D02KPi_e );
239 status = m_tuple4->addItem( "D02KPi_p", m_D02KPi_p );
240 status = m_tuple4->addItem( "D02KPi_mBC", m_D02KPi_mBC );
241 status = m_tuple4->addItem( "D02KPi_mass", m_D02KPi_mass );
242 status = m_tuple4->addItem( "D02KPi_deltE", m_D02KPi_deltE );
243 status = m_tuple4->addItem( "D02KPi_charm", m_D02KPi_charm );
244 status = m_tuple4->addItem( "D02KPi_kaon_pp", m_D02KPi_kaon_pp );
245 status = m_tuple4->addItem( "D02KPi_pion_pp", m_D02KPi_pion_pp );
246 status = m_tuple4->addItem( "D02KPi_kaon_vx", m_D02KPi_kaon_vx );
247 status = m_tuple4->addItem( "D02KPi_kaon_vy", m_D02KPi_kaon_vy );
248 status = m_tuple4->addItem( "D02KPi_kaon_vz", m_D02KPi_kaon_vz );
249 status = m_tuple4->addItem( "D02KPi_kaon_vr0", m_D02KPi_kaon_vr0 );
250 status = m_tuple4->addItem( "D02KPi_kaon_px", m_D02KPi_kaon_px );
251 status = m_tuple4->addItem( "D02KPi_kaon_py", m_D02KPi_kaon_py );
252 status = m_tuple4->addItem( "D02KPi_kaon_pz", m_D02KPi_kaon_pz );
253 status = m_tuple4->addItem( "D02KPi_kaon_E", m_D02KPi_kaon_E );
254 status = m_tuple4->addItem( "D02KPi_kaon_cos", m_D02KPi_kaon_cos );
255 status = m_tuple4->addItem( "D02KPi_pion_vx", m_D02KPi_pion_vx );
256 status = m_tuple4->addItem( "D02KPi_pion_vy", m_D02KPi_pion_vy );
257 status = m_tuple4->addItem( "D02KPi_pion_vz", m_D02KPi_pion_vz );
258 status = m_tuple4->addItem( "D02KPi_pion_vr0", m_D02KPi_pion_vr0 );
259 status = m_tuple4->addItem( "D02KPi_pion_px", m_D02KPi_pion_px );
260 status = m_tuple4->addItem( "D02KPi_pion_py", m_D02KPi_pion_py );
261 status = m_tuple4->addItem( "D02KPi_pion_pz", m_D02KPi_pion_pz );
262 status = m_tuple4->addItem( "D02KPi_pion_E", m_D02KPi_pion_E );
263 status = m_tuple4->addItem( "D02KPi_pion_cos", m_D02KPi_pion_cos );
264 status = m_tuple4->addItem( "D02KPi_kaon_Id", m_D02KPi_kaon_Id );
265 status = m_tuple4->addItem( "D02KPi_pion_Id", m_D02KPi_pion_Id );
266 status = m_tuple4->addItem( "recNumD02KPiPi0", m_recNumD02KPiPi0 );
267 status = m_tuple4->addItem( "D02KPiPi0_e", m_D02KPiPi0_e );
268 status = m_tuple4->addItem( "D02KPiPi0_p", m_D02KPiPi0_p );
269 status = m_tuple4->addItem( "D02KPiPi0_mBC", m_D02KPiPi0_mBC );
270 status = m_tuple4->addItem( "D02KPiPi0_mass", m_D02KPiPi0_mass );
271 status = m_tuple4->addItem( "D02KPiPi0_deltE", m_D02KPiPi0_deltE );
272 status = m_tuple4->addItem( "D02KPiPi0_charm", m_D02KPiPi0_charm );
273 status = m_tuple4->addItem( "D02KPiPi0_kaon_pp", m_D02KPiPi0_kaon_pp );
274 status = m_tuple4->addItem( "D02KPiPi0_pion_pp", m_D02KPiPi0_pion_pp );
275 status = m_tuple4->addItem( "D02KPiPi0_kaon_Id", m_D02KPiPi0_kaon_Id );
276 status = m_tuple4->addItem( "D02KPiPi0_pion_Id", m_D02KPiPi0_pion_Id );
277 status = m_tuple4->addItem( "D02KPiPi0_kaon_vx", m_D02KPiPi0_kaon_vx );
278 status = m_tuple4->addItem( "D02KPiPi0_kaon_vy", m_D02KPiPi0_kaon_vy );
279 status = m_tuple4->addItem( "D02KPiPi0_kaon_vz", m_D02KPiPi0_kaon_vz );
280 status = m_tuple4->addItem( "D02KPiPi0_kaon_vr0", m_D02KPiPi0_kaon_vr0 );
281 status = m_tuple4->addItem( "D02KPiPi0_kaon_px", m_D02KPiPi0_kaon_px );
282 status = m_tuple4->addItem( "D02KPiPi0_kaon_py", m_D02KPiPi0_kaon_py );
283 status = m_tuple4->addItem( "D02KPiPi0_kaon_pz", m_D02KPiPi0_kaon_pz );
284 status = m_tuple4->addItem( "D02KPiPi0_kaon_E", m_D02KPiPi0_kaon_E );
285 status = m_tuple4->addItem( "D02KPiPi0_kaon_cos", m_D02KPiPi0_kaon_cos );
286 status = m_tuple4->addItem( "D02KPiPi0_pion_vx", m_D02KPiPi0_pion_vx );
287 status = m_tuple4->addItem( "D02KPiPi0_pion_vy", m_D02KPiPi0_pion_vy );
288 status = m_tuple4->addItem( "D02KPiPi0_pion_vz", m_D02KPiPi0_pion_vz );
289 status = m_tuple4->addItem( "D02KPiPi0_pion_vr0", m_D02KPiPi0_pion_vr0 );
290 status = m_tuple4->addItem( "D02KPiPi0_pion_px", m_D02KPiPi0_pion_px );
291 status = m_tuple4->addItem( "D02KPiPi0_pion_py", m_D02KPiPi0_pion_py );
292 status = m_tuple4->addItem( "D02KPiPi0_pion_pz", m_D02KPiPi0_pion_pz );
293 status = m_tuple4->addItem( "D02KPiPi0_pion_E", m_D02KPiPi0_pion_E );
294 status = m_tuple4->addItem( "D02KPiPi0_pion_cos", m_D02KPiPi0_pion_cos );
295 status = m_tuple4->addItem( "D02KPiPi0_pi0mass", m_D02KPiPi0_pi0mass );
296 status = m_tuple4->addItem( "D02KPiPi0_photon1_Id", m_D02KPiPi0_photon1_Id );
297 status = m_tuple4->addItem( "D02KPiPi0_photon2_Id", m_D02KPiPi0_photon2_Id );
298 status = m_tuple4->addItem( "D02KPiPi0_photon1_E", m_D02KPiPi0_photon1_E );
299 status = m_tuple4->addItem( "D02KPiPi0_photon2_E", m_D02KPiPi0_photon2_E );
300 status = m_tuple4->addItem( "D02KPiPi0_photon1_cos", m_D02KPiPi0_photon1_cos );
301 status = m_tuple4->addItem( "D02KPiPi0_photon2_cos", m_D02KPiPi0_photon2_cos );
302 status = m_tuple4->addItem( "recNumD02KPiPiPi", m_recNumD02KPiPiPi );
303 status = m_tuple4->addItem( "D02KPiPiPi_e", m_D02KPiPiPi_e );
304 status = m_tuple4->addItem( "D02KPiPiPi_p", m_D02KPiPiPi_p );
305 status = m_tuple4->addItem( "D02KPiPiPi_mBC", m_D02KPiPiPi_mBC );
306 status = m_tuple4->addItem( "D02KPiPiPi_mass", m_D02KPiPiPi_mass );
307 status = m_tuple4->addItem( "D02KPiPiPi_deltE", m_D02KPiPiPi_deltE );
308 status = m_tuple4->addItem( "D02KPiPiPi_charm", m_D02KPiPiPi_charm );
309 status = m_tuple4->addItem( "D02KPiPiPi_kaon_pp", m_D02KPiPiPi_kaon_pp );
310 status = m_tuple4->addItem( "D02KPiPiPi_pion1_pp", m_D02KPiPiPi_pion1_pp );
311 status = m_tuple4->addItem( "D02KPiPiPi_pion2_pp", m_D02KPiPiPi_pion2_pp );
312 status = m_tuple4->addItem( "D02KPiPiPi_pion3_pp", m_D02KPiPiPi_pion3_pp );
313 status = m_tuple4->addItem( "D02KPiPiPi_kaon_Id", m_D02KPiPiPi_kaon_Id );
314 status = m_tuple4->addItem( "D02KPiPiPi_pion1_Id", m_D02KPiPiPi_pion1_Id );
315 status = m_tuple4->addItem( "D02KPiPiPi_pion2_Id", m_D02KPiPiPi_pion2_Id );
316 status = m_tuple4->addItem( "D02KPiPiPi_pion3_Id", m_D02KPiPiPi_pion3_Id );
317 status = m_tuple4->addItem( "recNumD02KPiPiPiPi0", m_recNumD02KPiPiPiPi0 );
318 status = m_tuple4->addItem( "D02KPiPiPiPi0_e", m_D02KPiPiPiPi0_e );
319 status = m_tuple4->addItem( "D02KPiPiPiPi0_p", m_D02KPiPiPiPi0_p );
320 status = m_tuple4->addItem( "D02KPiPiPiPi0_mBC", m_D02KPiPiPiPi0_mBC );
321 status = m_tuple4->addItem( "D02KPiPiPiPi0_mass", m_D02KPiPiPiPi0_mass );
322 status = m_tuple4->addItem( "D02KPiPiPiPi0_deltE", m_D02KPiPiPiPi0_deltE );
323 status = m_tuple4->addItem( "D02KPiPiPiPi0_charm", m_D02KPiPiPiPi0_charm );
324 status = m_tuple4->addItem( "D02KPiPiPiPi0_kaon_pp", m_D02KPiPiPiPi0_kaon_pp );
325 status = m_tuple4->addItem( "D02KPiPiPiPi0_pion1_pp", m_D02KPiPiPiPi0_pion1_pp );
326 status = m_tuple4->addItem( "D02KPiPiPiPi0_pion2_pp", m_D02KPiPiPiPi0_pion2_pp );
327 status = m_tuple4->addItem( "D02KPiPiPiPi0_pion3_pp", m_D02KPiPiPiPi0_pion3_pp );
328 status = m_tuple4->addItem( "D02KPiPiPiPi0_kaon_Id", m_D02KPiPiPiPi0_kaon_Id );
329 status = m_tuple4->addItem( "D02KPiPiPiPi0_pion1_Id", m_D02KPiPiPiPi0_pion1_Id );
330 status = m_tuple4->addItem( "D02KPiPiPiPi0_pion2_Id", m_D02KPiPiPiPi0_pion2_Id );
331 status = m_tuple4->addItem( "D02KPiPiPiPi0_pion3_Id", m_D02KPiPiPiPi0_pion3_Id );
332 status = m_tuple4->addItem( "D02KPiPiPiPi0_pi0mass", m_D02KPiPiPiPi0_pi0mass );
333 status = m_tuple4->addItem( "D02KPiPiPiPi0_photon1_Id", m_D02KPiPiPiPi0_photon1_Id );
334 status = m_tuple4->addItem( "D02KPiPiPiPi0_photon2_Id", m_D02KPiPiPiPi0_photon2_Id );
335 status = m_tuple4->addItem( "D02KPiPiPiPi0_photon1_E", m_D02KPiPiPiPi0_photon1_E );
336 status = m_tuple4->addItem( "D02KPiPiPiPi0_photon2_E", m_D02KPiPiPiPi0_photon2_E );
337 status = m_tuple4->addItem( "D02KPiPiPiPi0_photon1_cos", m_D02KPiPiPiPi0_photon1_cos );
338 status = m_tuple4->addItem( "D02KPiPiPiPi0_photon2_cos", m_D02KPiPiPiPi0_photon2_cos );
339 status = m_tuple4->addItem( "recNumD02KsPiPi", m_recNumD02KsPiPi );
340 status = m_tuple4->addItem( "D02KsPiPi_e", m_D02KsPiPi_e );
341 status = m_tuple4->addItem( "D02KsPiPi_p", m_D02KsPiPi_p );
342 status = m_tuple4->addItem( "D02KsPiPi_mBC", m_D02KsPiPi_mBC );
343 status = m_tuple4->addItem( "D02KsPiPi_mass", m_D02KsPiPi_mass );
344 status = m_tuple4->addItem( "D02KsPiPi_deltE", m_D02KsPiPi_deltE );
345 status = m_tuple4->addItem( "D02KsPiPi_charm", m_D02KsPiPi_charm );
346 status = m_tuple4->addItem( "D02KsPiPi_pion1_pp", m_D02KsPiPi_pion1_pp );
347 status = m_tuple4->addItem( "D02KsPiPi_pion2_pp", m_D02KsPiPi_pion2_pp );
348 status = m_tuple4->addItem( "D02KsPiPi_pion3_pp", m_D02KsPiPi_pion3_pp );
349 status = m_tuple4->addItem( "D02KsPiPi_pion4_pp", m_D02KsPiPi_pion4_pp );
350 status = m_tuple4->addItem( "D02KsPiPi_pion1_Id", m_D02KsPiPi_pion1_Id );
351 status = m_tuple4->addItem( "D02KsPiPi_pion2_Id", m_D02KsPiPi_pion2_Id );
352 status = m_tuple4->addItem( "D02KsPiPi_pion3_Id", m_D02KsPiPi_pion3_Id );
353 status = m_tuple4->addItem( "D02KsPiPi_pion4_Id", m_D02KsPiPi_pion4_Id );
354 status = m_tuple4->addItem( "D02KsPiPi_pion1_vx", m_D02KsPiPi_pion1_vx );
355 status = m_tuple4->addItem( "D02KsPiPi_pion1_vy", m_D02KsPiPi_pion1_vy );
356 status = m_tuple4->addItem( "D02KsPiPi_pion1_vz", m_D02KsPiPi_pion1_vz );
357 status = m_tuple4->addItem( "D02KsPiPi_pion1_vr0", m_D02KsPiPi_pion1_vr0 );
358 status = m_tuple4->addItem( "D02KsPiPi_pion1_px", m_D02KsPiPi_pion1_px );
359 status = m_tuple4->addItem( "D02KsPiPi_pion1_py", m_D02KsPiPi_pion1_py );
360 status = m_tuple4->addItem( "D02KsPiPi_pion1_pz", m_D02KsPiPi_pion1_pz );
361 status = m_tuple4->addItem( "D02KsPiPi_pion1_pp", m_D02KsPiPi_pion1_pp );
362 status = m_tuple4->addItem( "D02KsPiPi_pion1_E", m_D02KsPiPi_pion1_E );
363 status = m_tuple4->addItem( "D02KsPiPi_pion1_cos", m_D02KsPiPi_pion1_cos );
364 status = m_tuple4->addItem( "D02KsPiPi_pion2_vx", m_D02KsPiPi_pion2_vx );
365 status = m_tuple4->addItem( "D02KsPiPi_pion2_vy", m_D02KsPiPi_pion2_vy );
366 status = m_tuple4->addItem( "D02KsPiPi_pion2_vz", m_D02KsPiPi_pion2_vz );
367 status = m_tuple4->addItem( "D02KsPiPi_pion2_vr0", m_D02KsPiPi_pion2_vr0 );
368 status = m_tuple4->addItem( "D02KsPiPi_pion2_px", m_D02KsPiPi_pion2_px );
369 status = m_tuple4->addItem( "D02KsPiPi_pion2_py", m_D02KsPiPi_pion2_py );
370 status = m_tuple4->addItem( "D02KsPiPi_pion2_pz", m_D02KsPiPi_pion2_pz );
371 status = m_tuple4->addItem( "D02KsPiPi_pion2_pp", m_D02KsPiPi_pion2_pp );
372 status = m_tuple4->addItem( "D02KsPiPi_pion2_E", m_D02KsPiPi_pion2_E );
373 status = m_tuple4->addItem( "D02KsPiPi_pion2_cos", m_D02KsPiPi_pion2_cos );
374 status = m_tuple4->addItem( "D02KsPiPi_pion3_vx", m_D02KsPiPi_pion3_vx );
375 status = m_tuple4->addItem( "D02KsPiPi_pion3_vy", m_D02KsPiPi_pion3_vy );
376 status = m_tuple4->addItem( "D02KsPiPi_pion3_vz", m_D02KsPiPi_pion3_vz );
377 status = m_tuple4->addItem( "D02KsPiPi_pion3_vr0", m_D02KsPiPi_pion3_vr0 );
378 status = m_tuple4->addItem( "D02KsPiPi_pion3_px", m_D02KsPiPi_pion3_px );
379 status = m_tuple4->addItem( "D02KsPiPi_pion3_py", m_D02KsPiPi_pion3_py );
380 status = m_tuple4->addItem( "D02KsPiPi_pion3_pz", m_D02KsPiPi_pion3_pz );
381 status = m_tuple4->addItem( "D02KsPiPi_pion3_pp", m_D02KsPiPi_pion3_pp );
382 status = m_tuple4->addItem( "D02KsPiPi_pion3_E", m_D02KsPiPi_pion3_E );
383 status = m_tuple4->addItem( "D02KsPiPi_pion3_cos", m_D02KsPiPi_pion3_cos );
384 status = m_tuple4->addItem( "D02KsPiPi_pion4_vx", m_D02KsPiPi_pion4_vx );
385 status = m_tuple4->addItem( "D02KsPiPi_pion4_vy", m_D02KsPiPi_pion4_vy );
386 status = m_tuple4->addItem( "D02KsPiPi_pion4_vz", m_D02KsPiPi_pion4_vz );
387 status = m_tuple4->addItem( "D02KsPiPi_pion4_vr0", m_D02KsPiPi_pion4_vr0 );
388 status = m_tuple4->addItem( "D02KsPiPi_pion4_px", m_D02KsPiPi_pion4_px );
389 status = m_tuple4->addItem( "D02KsPiPi_pion4_py", m_D02KsPiPi_pion4_py );
390 status = m_tuple4->addItem( "D02KsPiPi_pion4_pz", m_D02KsPiPi_pion4_pz );
391 status = m_tuple4->addItem( "D02KsPiPi_pion4_pp", m_D02KsPiPi_pion4_pp );
392 status = m_tuple4->addItem( "D02KsPiPi_pion4_E", m_D02KsPiPi_pion4_E );
393 status = m_tuple4->addItem( "D02KsPiPi_pion4_cos", m_D02KsPiPi_pion4_cos );
394 status = m_tuple4->addItem( "D02KsPiPi_ks_mass", m_D02KsPiPi_ks_mass );
395 status = m_tuple4->addItem( "D02KsPiPi_ks_vfitmass", m_D02KsPiPi_ks_vfitmass );
396 status = m_tuple4->addItem( "D02KsPiPi_ks_pvchi2", m_D02KsPiPi_ks_pvchi2 );
397 status = m_tuple4->addItem( "D02KsPiPi_ks_svchi2", m_D02KsPiPi_ks_svchi2 );
398 status = m_tuple4->addItem( "D02KsPiPi_ks_dLength", m_D02KsPiPi_ks_dLength );
399 status = m_tuple4->addItem( "D02KsPiPi_ks_dLengthErrorRatio",
400 m_D02KsPiPi_ks_dLengthErrorRatio );
401 status = m_tuple4->addItem( "recNumD02KsPiPiPi0", m_recNumD02KsPiPiPi0 );
402 status = m_tuple4->addItem( "D02KsPiPiPi0_e", m_D02KsPiPiPi0_e );
403 status = m_tuple4->addItem( "D02KsPiPiPi0_p", m_D02KsPiPiPi0_p );
404 status = m_tuple4->addItem( "D02KsPiPiPi0_mBC", m_D02KsPiPiPi0_mBC );
405 status = m_tuple4->addItem( "D02KsPiPiPi0_mass", m_D02KsPiPiPi0_mass );
406 status = m_tuple4->addItem( "D02KsPiPiPi0_deltE", m_D02KsPiPiPi0_deltE );
407 status = m_tuple4->addItem( "D02KsPiPiPi0_charm", m_D02KsPiPiPi0_charm );
408 status = m_tuple4->addItem( "D02KsPiPiPi0_pion1_pp", m_D02KsPiPiPi0_pion1_pp );
409 status = m_tuple4->addItem( "D02KsPiPiPi0_pion2_pp", m_D02KsPiPiPi0_pion2_pp );
410 status = m_tuple4->addItem( "D02KsPiPiPi0_pion3_pp", m_D02KsPiPiPi0_pion3_pp );
411 status = m_tuple4->addItem( "D02KsPiPiPi0_pion4_pp", m_D02KsPiPiPi0_pion4_pp );
412 status = m_tuple4->addItem( "D02KsPiPiPi0_pion1_Id", m_D02KsPiPiPi0_pion1_Id );
413 status = m_tuple4->addItem( "D02KsPiPiPi0_pion2_Id", m_D02KsPiPiPi0_pion2_Id );
414 status = m_tuple4->addItem( "D02KsPiPiPi0_pion3_Id", m_D02KsPiPiPi0_pion3_Id );
415 status = m_tuple4->addItem( "D02KsPiPiPi0_pion4_Id", m_D02KsPiPiPi0_pion4_Id );
416 status = m_tuple4->addItem( "D02KsPiPiPi0_pi0mass", m_D02KsPiPiPi0_pi0mass );
417 status = m_tuple4->addItem( "D02KsPiPiPi0_photon1_Id", m_D02KsPiPiPi0_photon1_Id );
418 status = m_tuple4->addItem( "D02KsPiPiPi0_photon2_Id", m_D02KsPiPiPi0_photon2_Id );
419 status = m_tuple4->addItem( "D02KsPiPiPi0_photon1_E", m_D02KsPiPiPi0_photon1_E );
420 status = m_tuple4->addItem( "D02KsPiPiPi0_photon2_E", m_D02KsPiPiPi0_photon2_E );
421 status = m_tuple4->addItem( "D02KsPiPiPi0_photon1_cos", m_D02KsPiPiPi0_photon1_cos );
422 status = m_tuple4->addItem( "D02KsPiPiPi0_photon2_cos", m_D02KsPiPiPi0_photon2_cos );
423 status = m_tuple4->addItem( "D02KsPiPiPi0_ks_mass", m_D02KsPiPiPi0_ks_mass );
424 status = m_tuple4->addItem( "D02KsPiPiPi0_ks_vfitmass", m_D02KsPiPiPi0_ks_vfitmass );
425 status = m_tuple4->addItem( "D02KsPiPiPi0_ks_pvchi2", m_D02KsPiPiPi0_ks_pvchi2 );
426 status = m_tuple4->addItem( "D02KsPiPiPi0_ks_svchi2", m_D02KsPiPiPi0_ks_svchi2 );
427 status = m_tuple4->addItem( "D02KsPiPiPi0_ks_dLength", m_D02KsPiPiPi0_ks_dLength );
428 status = m_tuple4->addItem( "D02KsPiPiPi0_ks_dLengthErrorRatio",
429 m_D02KsPiPiPi0_ks_dLengthErrorRatio );
430 status = m_tuple4->addItem( "recNumDC2KPiPi", m_recNumDC2KPiPi );
431 status = m_tuple4->addItem( "DC2KPiPi_e", m_DC2KPiPi_e );
432 status = m_tuple4->addItem( "DC2KPiPi_p", m_DC2KPiPi_p );
433 status = m_tuple4->addItem( "DC2KPiPi_mBC", m_DC2KPiPi_mBC );
434 status = m_tuple4->addItem( "DC2KPiPi_mass", m_DC2KPiPi_mass );
435 status = m_tuple4->addItem( "DC2KPiPi_deltE", m_DC2KPiPi_deltE );
436 status = m_tuple4->addItem( "DC2KPiPi_charge", m_DC2KPiPi_charge );
437 status = m_tuple4->addItem( "DC2KPiPi_charm", m_DC2KPiPi_charm );
438 status = m_tuple4->addItem( "DC2KPiPi_kaon_pp", m_DC2KPiPi_kaon_pp );
439 status = m_tuple4->addItem( "DC2KPiPi_pion1_pp", m_DC2KPiPi_pion1_pp );
440 status = m_tuple4->addItem( "DC2KPiPi_pion2_pp", m_DC2KPiPi_pion2_pp );
441 status = m_tuple4->addItem( "DC2KPiPi_kaon_Id", m_DC2KPiPi_kaon_Id );
442 status = m_tuple4->addItem( "DC2KPiPi_pion1_Id", m_DC2KPiPi_pion1_Id );
443 status = m_tuple4->addItem( "DC2KPiPi_pion2_Id", m_DC2KPiPi_pion2_Id );
444 status = m_tuple4->addItem( "DC2KPiPi_kaon_vx", m_DC2KPiPi_kaon_vx );
445 status = m_tuple4->addItem( "DC2KPiPi_kaon_vy", m_DC2KPiPi_kaon_vy );
446 status = m_tuple4->addItem( "DC2KPiPi_kaon_vz", m_DC2KPiPi_kaon_vz );
447 status = m_tuple4->addItem( "DC2KPiPi_kaon_vr0", m_DC2KPiPi_kaon_vr0 );
448 status = m_tuple4->addItem( "DC2KPiPi_kaon_px", m_DC2KPiPi_kaon_px );
449 status = m_tuple4->addItem( "DC2KPiPi_kaon_py", m_DC2KPiPi_kaon_py );
450 status = m_tuple4->addItem( "DC2KPiPi_kaon_pz", m_DC2KPiPi_kaon_pz );
451 status = m_tuple4->addItem( "DC2KPiPi_kaon_E", m_DC2KPiPi_kaon_E );
452 status = m_tuple4->addItem( "DC2KPiPi_kaon_cos", m_DC2KPiPi_kaon_cos );
453 status = m_tuple4->addItem( "DC2KPiPi_pion1_vx", m_DC2KPiPi_pion1_vx );
454 status = m_tuple4->addItem( "DC2KPiPi_pion1_vy", m_DC2KPiPi_pion1_vy );
455 status = m_tuple4->addItem( "DC2KPiPi_pion1_vz", m_DC2KPiPi_pion1_vz );
456 status = m_tuple4->addItem( "DC2KPiPi_pion1_vr0", m_DC2KPiPi_pion1_vr0 );
457 status = m_tuple4->addItem( "DC2KPiPi_pion1_px", m_DC2KPiPi_pion1_px );
458 status = m_tuple4->addItem( "DC2KPiPi_pion1_py", m_DC2KPiPi_pion1_py );
459 status = m_tuple4->addItem( "DC2KPiPi_pion1_pz", m_DC2KPiPi_pion1_pz );
460 status = m_tuple4->addItem( "DC2KPiPi_pion1_E", m_DC2KPiPi_pion1_E );
461 status = m_tuple4->addItem( "DC2KPiPi_pion1_cos", m_DC2KPiPi_pion1_cos );
462 status = m_tuple4->addItem( "DC2KPiPi_pion2_vx", m_DC2KPiPi_pion2_vx );
463 status = m_tuple4->addItem( "DC2KPiPi_pion2_vy", m_DC2KPiPi_pion2_vy );
464 status = m_tuple4->addItem( "DC2KPiPi_pion2_vz", m_DC2KPiPi_pion2_vz );
465 status = m_tuple4->addItem( "DC2KPiPi_pion2_vr0", m_DC2KPiPi_pion2_vr0 );
466 status = m_tuple4->addItem( "DC2KPiPi_pion2_px", m_DC2KPiPi_pion2_px );
467 status = m_tuple4->addItem( "DC2KPiPi_pion2_py", m_DC2KPiPi_pion2_py );
468 status = m_tuple4->addItem( "DC2KPiPi_pion2_pz", m_DC2KPiPi_pion2_pz );
469 status = m_tuple4->addItem( "DC2KPiPi_pion2_E", m_DC2KPiPi_pion2_E );
470 status = m_tuple4->addItem( "DC2KPiPi_pion2_cos", m_DC2KPiPi_pion2_cos );
471 status = m_tuple4->addItem( "recNumDC2KPiPiPi0", m_recNumDC2KPiPiPi0 );
472 status = m_tuple4->addItem( "DC2KPiPiPi0_e", m_DC2KPiPiPi0_e );
473 status = m_tuple4->addItem( "DC2KPiPiPi0_p", m_DC2KPiPiPi0_p );
474 status = m_tuple4->addItem( "DC2KPiPiPi0_mBC", m_DC2KPiPiPi0_mBC );
475 status = m_tuple4->addItem( "DC2KPiPiPi0_mass", m_DC2KPiPiPi0_mass );
476 status = m_tuple4->addItem( "DC2KPiPiPi0_deltE", m_DC2KPiPiPi0_deltE );
477 status = m_tuple4->addItem( "DC2KPiPiPi0_charge", m_DC2KPiPiPi0_charge );
478 status = m_tuple4->addItem( "DC2KPiPiPi0_charm", m_DC2KPiPiPi0_charm );
479 status = m_tuple4->addItem( "DC2KPiPiPi0_kaon_pp", m_DC2KPiPiPi0_kaon_pp );
480 status = m_tuple4->addItem( "DC2KPiPiPi0_pion1_pp", m_DC2KPiPiPi0_pion1_pp );
481 status = m_tuple4->addItem( "DC2KPiPiPi0_pion2_pp", m_DC2KPiPiPi0_pion2_pp );
482 status = m_tuple4->addItem( "DC2KPiPiPi0_kaon_Id", m_DC2KPiPiPi0_kaon_Id );
483 status = m_tuple4->addItem( "DC2KPiPiPi0_pion1_Id", m_DC2KPiPiPi0_pion1_Id );
484 status = m_tuple4->addItem( "DC2KPiPiPi0_pion2_Id", m_DC2KPiPiPi0_pion2_Id );
485 status = m_tuple4->addItem( "DC2KPiPiPi0_kaon_vx", m_DC2KPiPiPi0_kaon_vx );
486 status = m_tuple4->addItem( "DC2KPiPiPi0_kaon_vy", m_DC2KPiPiPi0_kaon_vy );
487 status = m_tuple4->addItem( "DC2KPiPiPi0_kaon_vz", m_DC2KPiPiPi0_kaon_vz );
488 status = m_tuple4->addItem( "DC2KPiPiPi0_kaon_vr0", m_DC2KPiPiPi0_kaon_vr0 );
489 status = m_tuple4->addItem( "DC2KPiPiPi0_kaon_px", m_DC2KPiPiPi0_kaon_px );
490 status = m_tuple4->addItem( "DC2KPiPiPi0_kaon_py", m_DC2KPiPiPi0_kaon_py );
491 status = m_tuple4->addItem( "DC2KPiPiPi0_kaon_pz", m_DC2KPiPiPi0_kaon_pz );
492 status = m_tuple4->addItem( "DC2KPiPiPi0_kaon_E", m_DC2KPiPiPi0_kaon_E );
493 status = m_tuple4->addItem( "DC2KPiPiPi0_kaon_cos", m_DC2KPiPiPi0_kaon_cos );
494 status = m_tuple4->addItem( "DC2KPiPiPi0_pion1_vx", m_DC2KPiPiPi0_pion1_vx );
495 status = m_tuple4->addItem( "DC2KPiPiPi0_pion1_vy", m_DC2KPiPiPi0_pion1_vy );
496 status = m_tuple4->addItem( "DC2KPiPiPi0_pion1_vz", m_DC2KPiPiPi0_pion1_vz );
497 status = m_tuple4->addItem( "DC2KPiPiPi0_pion1_vr0", m_DC2KPiPiPi0_pion1_vr0 );
498 status = m_tuple4->addItem( "DC2KPiPiPi0_pion1_px", m_DC2KPiPiPi0_pion1_px );
499 status = m_tuple4->addItem( "DC2KPiPiPi0_pion1_py", m_DC2KPiPiPi0_pion1_py );
500 status = m_tuple4->addItem( "DC2KPiPiPi0_pion1_pz", m_DC2KPiPiPi0_pion1_pz );
501 status = m_tuple4->addItem( "DC2KPiPiPi0_pion1_E", m_DC2KPiPiPi0_pion1_E );
502 status = m_tuple4->addItem( "DC2KPiPiPi0_pion1_cos", m_DC2KPiPiPi0_pion1_cos );
503 status = m_tuple4->addItem( "DC2KPiPiPi0_pion2_vx", m_DC2KPiPiPi0_pion2_vx );
504 status = m_tuple4->addItem( "DC2KPiPiPi0_pion2_vy", m_DC2KPiPiPi0_pion2_vy );
505 status = m_tuple4->addItem( "DC2KPiPiPi0_pion2_vz", m_DC2KPiPiPi0_pion2_vz );
506 status = m_tuple4->addItem( "DC2KPiPiPi0_pion2_vr0", m_DC2KPiPiPi0_pion2_vr0 );
507 status = m_tuple4->addItem( "DC2KPiPiPi0_pion2_px", m_DC2KPiPiPi0_pion2_px );
508 status = m_tuple4->addItem( "DC2KPiPiPi0_pion2_py", m_DC2KPiPiPi0_pion2_py );
509 status = m_tuple4->addItem( "DC2KPiPiPi0_pion2_pz", m_DC2KPiPiPi0_pion2_pz );
510 status = m_tuple4->addItem( "DC2KPiPiPi0_pion2_E", m_DC2KPiPiPi0_pion2_E );
511 status = m_tuple4->addItem( "DC2KPiPiPi0_pion2_cos", m_DC2KPiPiPi0_pion2_cos );
512 status = m_tuple4->addItem( "DC2KPiPiPi0_pi0mass", m_DC2KPiPiPi0_pi0mass );
513 status = m_tuple4->addItem( "DC2KPiPiPi0_photon1_Id", m_DC2KPiPiPi0_photon1_Id );
514 status = m_tuple4->addItem( "DC2KPiPiPi0_photon2_Id", m_DC2KPiPiPi0_photon2_Id );
515 status = m_tuple4->addItem( "DC2KPiPiPi0_photon1_E", m_DC2KPiPiPi0_photon1_E );
516 status = m_tuple4->addItem( "DC2KPiPiPi0_photon2_E", m_DC2KPiPiPi0_photon2_E );
517 status = m_tuple4->addItem( "DC2KPiPiPi0_photon1_cos", m_DC2KPiPiPi0_photon1_cos );
518 status = m_tuple4->addItem( "DC2KPiPiPi0_photon2_cos", m_DC2KPiPiPi0_photon2_cos );
519 status = m_tuple4->addItem( "recNumDC2KsPiPi0", m_recNumDC2KsPiPi0 );
520 status = m_tuple4->addItem( "DC2KsPiPi0_e", m_DC2KsPiPi0_e );
521 status = m_tuple4->addItem( "DC2KsPiPi0_p", m_DC2KsPiPi0_p );
522 status = m_tuple4->addItem( "DC2KsPiPi0_mBC", m_DC2KsPiPi0_mBC );
523 status = m_tuple4->addItem( "DC2KsPiPi0_mass", m_DC2KsPiPi0_mass );
524 status = m_tuple4->addItem( "DC2KsPiPi0_deltE", m_DC2KsPiPi0_deltE );
525 status = m_tuple4->addItem( "DC2KsPiPi0_charge", m_DC2KsPiPi0_charge );
526 status = m_tuple4->addItem( "DC2KsPiPi0_charm", m_DC2KsPiPi0_charm );
527 status = m_tuple4->addItem( "DC2KsPiPi0_pion1_pp", m_DC2KsPiPi0_pion1_pp );
528 status = m_tuple4->addItem( "DC2KsPiPi0_pion2_pp", m_DC2KsPiPi0_pion2_pp );
529 status = m_tuple4->addItem( "DC2KsPiPi0_pion3_pp", m_DC2KsPiPi0_pion3_pp );
530 status = m_tuple4->addItem( "DC2KsPiPi0_pion1_Id", m_DC2KsPiPi0_pion1_Id );
531 status = m_tuple4->addItem( "DC2KsPiPi0_pion2_Id", m_DC2KsPiPi0_pion2_Id );
532 status = m_tuple4->addItem( "DC2KsPiPi0_pion3_Id", m_DC2KsPiPi0_pion3_Id );
533 status = m_tuple4->addItem( "DC2KsPiPi0_pion1_vx", m_DC2KsPiPi0_pion1_vx );
534 status = m_tuple4->addItem( "DC2KsPiPi0_pion1_vy", m_DC2KsPiPi0_pion1_vy );
535 status = m_tuple4->addItem( "DC2KsPiPi0_pion1_vz", m_DC2KsPiPi0_pion1_vz );
536 status = m_tuple4->addItem( "DC2KsPiPi0_pion1_vr0", m_DC2KsPiPi0_pion1_vr0 );
537 status = m_tuple4->addItem( "DC2KsPiPi0_pion1_px", m_DC2KsPiPi0_pion1_px );
538 status = m_tuple4->addItem( "DC2KsPiPi0_pion1_py", m_DC2KsPiPi0_pion1_py );
539 status = m_tuple4->addItem( "DC2KsPiPi0_pion1_pz", m_DC2KsPiPi0_pion1_pz );
540 status = m_tuple4->addItem( "DC2KsPiPi0_pion1_E", m_DC2KsPiPi0_pion1_E );
541 status = m_tuple4->addItem( "DC2KsPiPi0_pion1_cos", m_DC2KsPiPi0_pion1_cos );
542 status = m_tuple4->addItem( "DC2KsPiPi0_pion2_vx", m_DC2KsPiPi0_pion2_vx );
543 status = m_tuple4->addItem( "DC2KsPiPi0_pion2_vy", m_DC2KsPiPi0_pion2_vy );
544 status = m_tuple4->addItem( "DC2KsPiPi0_pion2_vz", m_DC2KsPiPi0_pion2_vz );
545 status = m_tuple4->addItem( "DC2KsPiPi0_pion2_vr0", m_DC2KsPiPi0_pion2_vr0 );
546 status = m_tuple4->addItem( "DC2KsPiPi0_pion2_px", m_DC2KsPiPi0_pion2_px );
547 status = m_tuple4->addItem( "DC2KsPiPi0_pion2_py", m_DC2KsPiPi0_pion2_py );
548 status = m_tuple4->addItem( "DC2KsPiPi0_pion2_pz", m_DC2KsPiPi0_pion2_pz );
549 status = m_tuple4->addItem( "DC2KsPiPi0_pion2_E", m_DC2KsPiPi0_pion2_E );
550 status = m_tuple4->addItem( "DC2KsPiPi0_pion2_cos", m_DC2KsPiPi0_pion2_cos );
551 status = m_tuple4->addItem( "DC2KsPiPi0_pion3_vx", m_DC2KsPiPi0_pion3_vx );
552 status = m_tuple4->addItem( "DC2KsPiPi0_pion3_vy", m_DC2KsPiPi0_pion3_vy );
553 status = m_tuple4->addItem( "DC2KsPiPi0_pion3_vz", m_DC2KsPiPi0_pion3_vz );
554 status = m_tuple4->addItem( "DC2KsPiPi0_pion3_vr0", m_DC2KsPiPi0_pion3_vr0 );
555 status = m_tuple4->addItem( "DC2KsPiPi0_pion3_px", m_DC2KsPiPi0_pion3_px );
556 status = m_tuple4->addItem( "DC2KsPiPi0_pion3_py", m_DC2KsPiPi0_pion3_py );
557 status = m_tuple4->addItem( "DC2KsPiPi0_pion3_pz", m_DC2KsPiPi0_pion3_pz );
558 status = m_tuple4->addItem( "DC2KsPiPi0_pion3_E", m_DC2KsPiPi0_pion3_E );
559 status = m_tuple4->addItem( "DC2KsPiPi0_pion3_cos", m_DC2KsPiPi0_pion3_cos );
560 status = m_tuple4->addItem( "DC2KsPiPi0_pi0mass", m_DC2KsPiPi0_pi0mass );
561 status = m_tuple4->addItem( "DC2KsPiPi0_photon1_Id", m_DC2KsPiPi0_photon1_Id );
562 status = m_tuple4->addItem( "DC2KsPiPi0_photon2_Id", m_DC2KsPiPi0_photon2_Id );
563 status = m_tuple4->addItem( "DC2KsPiPi0_photon1_E", m_DC2KsPiPi0_photon1_E );
564 status = m_tuple4->addItem( "DC2KsPiPi0_photon2_E", m_DC2KsPiPi0_photon2_E );
565 status = m_tuple4->addItem( "DC2KsPiPi0_photon1_cos", m_DC2KsPiPi0_photon1_cos );
566 status = m_tuple4->addItem( "DC2KsPiPi0_photon2_cos", m_DC2KsPiPi0_photon2_cos );
567 status = m_tuple4->addItem( "DC2KsPiPi0_ks_mass", m_DC2KsPiPi0_ks_mass );
568 status = m_tuple4->addItem( "DC2KsPiPi0_ks_vfitmass", m_DC2KsPiPi0_ks_vfitmass );
569 status = m_tuple4->addItem( "DC2KsPiPi0_ks_pvchi2", m_DC2KsPiPi0_ks_pvchi2 );
570 status = m_tuple4->addItem( "DC2KsPiPi0_ks_svchi2", m_DC2KsPiPi0_ks_svchi2 );
571 status = m_tuple4->addItem( "DC2KsPiPi0_ks_dLength", m_DC2KsPiPi0_ks_dLength );
572 status = m_tuple4->addItem( "DC2KsPiPi0_ks_dLengthErrorRatio",
573 m_DC2KsPiPi0_ks_dLengthErrorRatio );
574 status = m_tuple4->addItem( "recNumDC2KsPiPiPi", m_recNumDC2KsPiPiPi );
575 status = m_tuple4->addItem( "DC2KsPiPiPi_e", m_DC2KsPiPiPi_e );
576 status = m_tuple4->addItem( "DC2KsPiPiPi_p", m_DC2KsPiPiPi_p );
577 status = m_tuple4->addItem( "DC2KsPiPiPi_mBC", m_DC2KsPiPiPi_mBC );
578 status = m_tuple4->addItem( "DC2KsPiPiPi_mass", m_DC2KsPiPiPi_mass );
579 status = m_tuple4->addItem( "DC2KsPiPiPi_deltE", m_DC2KsPiPiPi_deltE );
580 status = m_tuple4->addItem( "DC2KsPiPiPi_charge", m_DC2KsPiPiPi_charge );
581 status = m_tuple4->addItem( "DC2KsPiPiPi_charm", m_DC2KsPiPiPi_charm );
582 status = m_tuple4->addItem( "DC2KsPiPiPi_pion1_pp", m_DC2KsPiPiPi_pion1_pp );
583 status = m_tuple4->addItem( "DC2KsPiPiPi_pion2_pp", m_DC2KsPiPiPi_pion2_pp );
584 status = m_tuple4->addItem( "DC2KsPiPiPi_pion3_pp", m_DC2KsPiPiPi_pion3_pp );
585 status = m_tuple4->addItem( "DC2KsPiPiPi_pion4_pp", m_DC2KsPiPiPi_pion4_pp );
586 status = m_tuple4->addItem( "DC2KsPiPiPi_pion5_pp", m_DC2KsPiPiPi_pion5_pp );
587 status = m_tuple4->addItem( "DC2KsPiPiPi_pion1_Id", m_DC2KsPiPiPi_pion1_Id );
588 status = m_tuple4->addItem( "DC2KsPiPiPi_pion2_Id", m_DC2KsPiPiPi_pion2_Id );
589 status = m_tuple4->addItem( "DC2KsPiPiPi_pion3_Id", m_DC2KsPiPiPi_pion3_Id );
590 status = m_tuple4->addItem( "DC2KsPiPiPi_pion4_Id", m_DC2KsPiPiPi_pion4_Id );
591 status = m_tuple4->addItem( "DC2KsPiPiPi_pion5_Id", m_DC2KsPiPiPi_pion5_Id );
592 status = m_tuple4->addItem( "DC2KsPiPiPi_ks_mass", m_DC2KsPiPiPi_ks_mass );
593 status = m_tuple4->addItem( "DC2KsPiPiPi_ks_vfitmass", m_DC2KsPiPiPi_ks_vfitmass );
594 status = m_tuple4->addItem( "DC2KsPiPiPi_ks_pvchi2", m_DC2KsPiPiPi_ks_pvchi2 );
595 status = m_tuple4->addItem( "DC2KsPiPiPi_ks_svchi2", m_DC2KsPiPiPi_ks_svchi2 );
596 status = m_tuple4->addItem( "DC2KsPiPiPi_ks_dLength", m_DC2KsPiPiPi_ks_dLength );
597 status = m_tuple4->addItem( "DC2KsPiPiPi_ks_dLengthErrorRatio",
598 m_DC2KsPiPiPi_ks_dLengthErrorRatio );
599 status = m_tuple4->addItem( "recNumDC2KKPi", m_recNumDC2KKPi );
600 status = m_tuple4->addItem( "DC2KKPi_e", m_DC2KKPi_e );
601 status = m_tuple4->addItem( "DC2KKPi_p", m_DC2KKPi_p );
602 status = m_tuple4->addItem( "DC2KKPi_mBC", m_DC2KKPi_mBC );
603 status = m_tuple4->addItem( "DC2KKPi_mass", m_DC2KKPi_mass );
604 status = m_tuple4->addItem( "DC2KKPi_deltE", m_DC2KKPi_deltE );
605 status = m_tuple4->addItem( "DC2KKPi_charge", m_DC2KKPi_charge );
606 status = m_tuple4->addItem( "DC2KKPi_charm", m_DC2KKPi_charm );
607 status = m_tuple4->addItem( "DC2KKPi_kaon1_pp", m_DC2KKPi_kaon1_pp );
608 status = m_tuple4->addItem( "DC2KKPi_kaon2_pp", m_DC2KKPi_kaon2_pp );
609 status = m_tuple4->addItem( "DC2KKPi_pion_pp", m_DC2KKPi_pion_pp );
610 status = m_tuple4->addItem( "DC2KKPi_kaon1_Id", m_DC2KKPi_kaon1_Id );
611 status = m_tuple4->addItem( "DC2KKPi_kaon2_Id", m_DC2KKPi_kaon2_Id );
612 status = m_tuple4->addItem( "DC2KKPi_pion_Id", m_DC2KKPi_pion_Id );
613 status = m_tuple4->addItem( "D02KPi_kaon_Id_Dedx", m_D02KPi_kaon_Id_Dedx );
614 status = m_tuple4->addItem( "D02KPi_pion_Id_Dedx", m_D02KPi_pion_Id_Dedx );
615 status = m_tuple4->addItem( "D02KPi_kaon_chipi", m_D02KPi_kaon_chipi );
616 status = m_tuple4->addItem( "D02KPi_kaon_chik", m_D02KPi_kaon_chik );
617 status = m_tuple4->addItem( "D02KPi_kaon_ghit", m_D02KPi_kaon_ghit );
618 status = m_tuple4->addItem( "D02KPi_kaon_thit", m_D02KPi_kaon_thit );
619 status = m_tuple4->addItem( "D02KPi_kaon_probPH", m_D02KPi_kaon_probPH );
620 status = m_tuple4->addItem( "D02KPi_kaon_normPH", m_D02KPi_kaon_normPH );
621 status = m_tuple4->addItem( "D02KPi_pion_chipi", m_D02KPi_pion_chipi );
622 status = m_tuple4->addItem( "D02KPi_pion_chik", m_D02KPi_pion_chik );
623 status = m_tuple4->addItem( "D02KPi_pion_ghit", m_D02KPi_pion_ghit );
624 status = m_tuple4->addItem( "D02KPi_pion_thit", m_D02KPi_pion_thit );
625 status = m_tuple4->addItem( "D02KPi_pion_probPH", m_D02KPi_pion_probPH );
626 status = m_tuple4->addItem( "D02KPi_pion_normPH", m_D02KPi_pion_normPH );
627 status = m_tuple4->addItem( "D02KPiPi0_kaon_Id_Dedx", m_D02KPiPi0_kaon_Id_Dedx );
628 status = m_tuple4->addItem( "D02KPiPi0_pion_Id_Dedx", m_D02KPiPi0_pion_Id_Dedx );
629 status = m_tuple4->addItem( "D02KPiPi0_kaon_chipi", m_D02KPiPi0_kaon_chipi );
630 status = m_tuple4->addItem( "D02KPiPi0_kaon_chik", m_D02KPiPi0_kaon_chik );
631 status = m_tuple4->addItem( "D02KPiPi0_kaon_ghit", m_D02KPiPi0_kaon_ghit );
632 status = m_tuple4->addItem( "D02KPiPi0_kaon_thit", m_D02KPiPi0_kaon_thit );
633 status = m_tuple4->addItem( "D02KPiPi0_kaon_probPH", m_D02KPiPi0_kaon_probPH );
634 status = m_tuple4->addItem( "D02KPiPi0_kaon_normPH", m_D02KPiPi0_kaon_normPH );
635 status = m_tuple4->addItem( "D02KPiPi0_pion_chipi", m_D02KPiPi0_pion_chipi );
636 status = m_tuple4->addItem( "D02KPiPi0_pion_chik", m_D02KPiPi0_pion_chik );
637 status = m_tuple4->addItem( "D02KPiPi0_pion_ghit", m_D02KPiPi0_pion_ghit );
638 status = m_tuple4->addItem( "D02KPiPi0_pion_thit", m_D02KPiPi0_pion_thit );
639 status = m_tuple4->addItem( "D02KPiPi0_pion_probPH", m_D02KPiPi0_pion_probPH );
640 status = m_tuple4->addItem( "D02KPiPi0_pion_normPH", m_D02KPiPi0_pion_normPH );
641 status = m_tuple4->addItem( "D02KPi_kaon_Id_tof", m_D02KPi_kaon_Id_tof );
642 status = m_tuple4->addItem( "D02KPi_pion_Id_tof", m_D02KPi_pion_Id_tof );
643 status = m_tuple4->addItem( "D02KPi_kaon_ec_toff_mu", m_D02KPi_kaon_ec_toff_mu );
644 status = m_tuple4->addItem( "D02KPi_kaon_ec_toff_pi", m_D02KPi_kaon_ec_toff_pi );
645 status = m_tuple4->addItem( "D02KPi_kaon_ec_toff_k", m_D02KPi_kaon_ec_toff_k );
646 status = m_tuple4->addItem( "D02KPi_kaon_ec_toff_isEast", m_D02KPi_kaon_ec_toff_isEast );
647 status = m_tuple4->addItem( "D02KPi_kaon_br_toff_mu", 7, m_D02KPi_kaon_br_toff_mu );
648 status = m_tuple4->addItem( "D02KPi_kaon_br_toff_pi", 7, m_D02KPi_kaon_br_toff_pi );
649 status = m_tuple4->addItem( "D02KPi_kaon_br_toff_k", 7, m_D02KPi_kaon_br_toff_k );
650 status = m_tuple4->addItem( "D02KPi_pion_ec_toff_pi", m_D02KPi_pion_ec_toff_mu );
651 status = m_tuple4->addItem( "D02KPi_pion_ec_toff_mu", m_D02KPi_pion_ec_toff_pi );
652 status = m_tuple4->addItem( "D02KPi_pion_ec_toff_k", m_D02KPi_pion_ec_toff_k );
653 status = m_tuple4->addItem( "D02KPi_pion_ec_toff_isEast", m_D02KPi_pion_ec_toff_isEast );
654 status = m_tuple4->addItem( "D02KPi_pion_br_toff_mu", 7, m_D02KPi_pion_br_toff_mu );
655 status = m_tuple4->addItem( "D02KPi_pion_br_toff_pi", 7, m_D02KPi_pion_br_toff_pi );
656 status = m_tuple4->addItem( "D02KPi_pion_br_toff_k", 7, m_D02KPi_pion_br_toff_k );
657 status = m_tuple4->addItem( "D02KPiPi0_kaon_Id_tof", m_D02KPiPi0_kaon_Id_tof );
658 status = m_tuple4->addItem( "D02KPiPi0_pion_Id_tof", m_D02KPiPi0_pion_Id_tof );
659 status = m_tuple4->addItem( "D02KPiPi0_kaon_ec_toff_mu", m_D02KPiPi0_kaon_ec_toff_mu );
660 status = m_tuple4->addItem( "D02KPiPi0_kaon_ec_toff_pi", m_D02KPiPi0_kaon_ec_toff_pi );
661 status = m_tuple4->addItem( "D02KPiPi0_kaon_ec_toff_k", m_D02KPiPi0_kaon_ec_toff_k );
662 status = m_tuple4->addItem( "D02KPiPi0_kaon_ec_toff_isEast",
663 m_D02KPiPi0_kaon_ec_toff_isEast );
664 status =
665 m_tuple4->addItem( "D02KPiPi0_kaon_br_toff_mu", 7, m_D02KPiPi0_kaon_br_toff_mu );
666 status =
667 m_tuple4->addItem( "D02KPiPi0_kaon_br_toff_pi", 7, m_D02KPiPi0_kaon_br_toff_pi );
668 status = m_tuple4->addItem( "D02KPiPi0_kaon_br_toff_k", 7, m_D02KPiPi0_kaon_br_toff_k );
669 status = m_tuple4->addItem( "D02KPiPi0_pion_ec_toff_mu", m_D02KPiPi0_pion_ec_toff_mu );
670 status = m_tuple4->addItem( "D02KPiPi0_pion_ec_toff_pi", m_D02KPiPi0_pion_ec_toff_pi );
671 status = m_tuple4->addItem( "D02KPiPi0_pion_ec_toff_k", m_D02KPiPi0_pion_ec_toff_k );
672 status = m_tuple4->addItem( "D02KPiPi0_pion_ec_toff_isEast",
673 m_D02KPiPi0_pion_ec_toff_isEast );
674 status =
675 m_tuple4->addItem( "D02KPiPi0_pion_br_toff_mu", 7, m_D02KPiPi0_pion_br_toff_mu );
676 status =
677 m_tuple4->addItem( "D02KPiPi0_pion_br_toff_pi", 7, m_D02KPiPi0_pion_br_toff_pi );
678 status = m_tuple4->addItem( "D02KPiPi0_pion_br_toff_k", 7, m_D02KPiPi0_pion_br_toff_k );
679 status = m_tuple4->addItem( "DC2KPiPi_kaon_Id_tof", m_DC2KPiPi_kaon_Id_tof );
680 status = m_tuple4->addItem( "DC2KPiPi_pion1_Id_tof", m_DC2KPiPi_pion1_Id_tof );
681 status = m_tuple4->addItem( "DC2KPiPi_pion2_Id_tof", m_DC2KPiPi_pion2_Id_tof );
682 status = m_tuple4->addItem( "DC2KPiPi_kaon_ec_toff_mu", m_DC2KPiPi_kaon_ec_toff_mu );
683 status = m_tuple4->addItem( "DC2KPiPi_kaon_ec_toff_pi", m_DC2KPiPi_kaon_ec_toff_pi );
684 status = m_tuple4->addItem( "DC2KPiPi_kaon_ec_toff_k", m_DC2KPiPi_kaon_ec_toff_k );
685 status =
686 m_tuple4->addItem( "DC2KPiPi_kaon_ec_toff_isEast", m_DC2KPiPi_kaon_ec_toff_isEast );
687 status = m_tuple4->addItem( "DC2KPiPi_kaon_br_toff_mu", 7, m_DC2KPiPi_kaon_br_toff_mu );
688 status = m_tuple4->addItem( "DC2KPiPi_kaon_br_toff_pi", 7, m_DC2KPiPi_kaon_br_toff_pi );
689 status = m_tuple4->addItem( "DC2KPiPi_kaon_br_toff_k", 7, m_DC2KPiPi_kaon_br_toff_k );
690 status = m_tuple4->addItem( "DC2KPiPi_pion1_ec_toff_mu", m_DC2KPiPi_pion1_ec_toff_mu );
691 status = m_tuple4->addItem( "DC2KPiPi_pion1_ec_toff_pi", m_DC2KPiPi_pion1_ec_toff_pi );
692 status = m_tuple4->addItem( "DC2KPiPi_pion1_ec_toff_k", m_DC2KPiPi_pion1_ec_toff_k );
693 status = m_tuple4->addItem( "DC2KPiPi_pion1_ec_toff_isEast",
694 m_DC2KPiPi_pion1_ec_toff_isEast );
695 status =
696 m_tuple4->addItem( "DC2KPiPi_pion1_br_toff_mu", 7, m_DC2KPiPi_pion1_br_toff_mu );
697 status =
698 m_tuple4->addItem( "DC2KPiPi_pion1_br_toff_pi", 7, m_DC2KPiPi_pion1_br_toff_pi );
699 status = m_tuple4->addItem( "DC2KPiPi_pion1_br_toff_k", 7, m_DC2KPiPi_pion1_br_toff_k );
700 status = m_tuple4->addItem( "DC2KPiPi_pion2_ec_toff_mu", m_DC2KPiPi_pion2_ec_toff_mu );
701 status = m_tuple4->addItem( "DC2KPiPi_pion2_ec_toff_pi", m_DC2KPiPi_pion2_ec_toff_pi );
702 status = m_tuple4->addItem( "DC2KPiPi_pion2_ec_toff_k", m_DC2KPiPi_pion2_ec_toff_k );
703 status = m_tuple4->addItem( "DC2KPiPi_pion2_ec_toff_isEast",
704 m_DC2KPiPi_pion2_ec_toff_isEast );
705 status =
706 m_tuple4->addItem( "DC2KPiPi_pion2_br_toff_mu", 7, m_DC2KPiPi_pion2_br_toff_mu );
707 status =
708 m_tuple4->addItem( "DC2KPiPi_pion2_br_toff_pi", 7, m_DC2KPiPi_pion2_br_toff_pi );
709 status = m_tuple4->addItem( "DC2KPiPi_pion2_br_toff_k", 7, m_DC2KPiPi_pion2_br_toff_k );
710 status = m_tuple4->addItem( "D02KPiPi0_photon1_Id_Emc", m_D02KPiPi0_photon1_Id_Emc );
711 status = m_tuple4->addItem( "D02KPiPi0_photon1_numHits", m_D02KPiPi0_photon1_numHits );
712 status = m_tuple4->addItem( "D02KPiPi0_photon1_secondmoment",
713 m_D02KPiPi0_photon1_secondmoment );
714 status = m_tuple4->addItem( "D02KPiPi0_photon1_x", m_D02KPiPi0_photon1_x );
715 status = m_tuple4->addItem( "D02KPiPi0_photon1_y", m_D02KPiPi0_photon1_y );
716 status = m_tuple4->addItem( "D02KPiPi0_photon1_z", m_D02KPiPi0_photon1_z );
717 status = m_tuple4->addItem( "D02KPiPi0_photon2_Id_Emc", m_D02KPiPi0_photon2_Id_Emc );
718 status = m_tuple4->addItem( "D02KPiPi0_photon2_numHits", m_D02KPiPi0_photon2_numHits );
719 status = m_tuple4->addItem( "D02KPiPi0_photon2_secondmoment",
720 m_D02KPiPi0_photon2_secondmoment );
721 status = m_tuple4->addItem( "D02KPiPi0_photon2_x", m_D02KPiPi0_photon2_x );
722 status = m_tuple4->addItem( "D02KPiPi0_photon2_y", m_D02KPiPi0_photon2_y );
723 status = m_tuple4->addItem( "D02KPiPi0_photon2_z", m_D02KPiPi0_photon2_z );
724 status = m_tuple4->addItem( "DC2KPiPi_kaon_chipi", m_DC2KPiPi_kaon_chipi );
725 status = m_tuple4->addItem( "DC2KPiPi_kaon_chik", m_DC2KPiPi_kaon_chik );
726 status = m_tuple4->addItem( "DC2KPiPi_kaon_ghit", m_DC2KPiPi_kaon_ghit );
727 status = m_tuple4->addItem( "DC2KPiPi_kaon_thit", m_DC2KPiPi_kaon_thit );
728 status = m_tuple4->addItem( "DC2KPiPi_kaon_probPH", m_DC2KPiPi_kaon_probPH );
729 status = m_tuple4->addItem( "DC2KPiPi_kaon_normPH", m_DC2KPiPi_kaon_normPH );
730 status = m_tuple4->addItem( "DC2KPiPi_pion1_chipi", m_DC2KPiPi_pion1_chipi );
731 status = m_tuple4->addItem( "DC2KPiPi_pion1_chik", m_DC2KPiPi_pion1_chik );
732 status = m_tuple4->addItem( "DC2KPiPi_pion1_ghit", m_DC2KPiPi_pion1_ghit );
733 status = m_tuple4->addItem( "DC2KPiPi_pion1_thit", m_DC2KPiPi_pion1_thit );
734 status = m_tuple4->addItem( "DC2KPiPi_pion1_probPH", m_DC2KPiPi_pion1_probPH );
735 status = m_tuple4->addItem( "DC2KPiPi_pion1_normPH", m_DC2KPiPi_pion1_normPH );
736 status = m_tuple4->addItem( "DC2KPiPi_pion2_chipi", m_DC2KPiPi_pion2_chipi );
737 status = m_tuple4->addItem( "DC2KPiPi_pion2_chik", m_DC2KPiPi_pion2_chik );
738 status = m_tuple4->addItem( "DC2KPiPi_pion2_ghit", m_DC2KPiPi_pion2_ghit );
739 status = m_tuple4->addItem( "DC2KPiPi_pion2_thit", m_DC2KPiPi_pion2_thit );
740 status = m_tuple4->addItem( "DC2KPiPi_pion2_probPH", m_DC2KPiPi_pion2_probPH );
741 status = m_tuple4->addItem( "DC2KPiPi_pion2_normPH", m_DC2KPiPi_pion2_normPH );
742 status = m_tuple4->addItem( "DC2KPiPi_kaon_Id_Dedx", m_DC2KPiPi_kaon_Id_Dedx );
743 status = m_tuple4->addItem( "DC2KPiPi_pion1_Id_Dedx", m_DC2KPiPi_pion1_Id_Dedx );
744 status = m_tuple4->addItem( "DC2KPiPi_pion2_Id_Dedx", m_DC2KPiPi_pion2_Id_Dedx );
745 }
746 else
747 {
748 log << MSG::ERROR << " Cannot book N-tuple:" << long( m_tuple4 ) << endmsg;
749 return StatusCode::FAILURE;
750 }
751 }
752
753 NTuplePtr nt5( ntupleSvc(), "DQAFILE/Events" );
754 if ( nt5 ) m_tuple5 = nt5;
755 else
756 {
757 m_tuple5 =
758 ntupleSvc()->book( "DQAFILE/Events", CLID_ColumnWiseTuple, "ks N-Tuple example" );
759 if ( m_tuple5 )
760 {
761 status = m_tuple5->addItem( "evtrun", m_evtrun );
762 status = m_tuple5->addItem( "evtrec", m_evtrec );
763 status = m_tuple5->addItem( "evtnch", m_evtnch );
764 status = m_tuple5->addItem( "evtnneu", m_evtnneu );
765 status = m_tuple5->addItem( "evtbeamE", m_evtbeamE );
766 }
767 else
768 {
769 log << MSG::ERROR << " Cannot book N-tuple:" << long( m_tuple5 ) << endmsg;
770 return StatusCode::FAILURE;
771 }
772 }
773 NTuplePtr nt11( ntupleSvc(), "DQAFILE/CheckDedxAll" );
774 if ( nt11 ) m_tuple11 = nt11;
775 else
776 {
777 m_tuple11 = ntupleSvc()->book( "DQAFILE/CheckDedxAll", CLID_ColumnWiseTuple,
778 "ks N-Tuple example" );
779 if ( m_tuple11 )
780 {
781 status = m_tuple11->addItem( "ngch", m_ngch, 0, 10000 );
782 status = m_tuple11->addIndexedItem( "trkiddedx", m_ngch, m_trkiddedx );
783 status = m_tuple11->addIndexedItem( "mptrk", m_ngch, m_ptrk );
784 status = m_tuple11->addIndexedItem( "chie", m_ngch, m_chie );
785 status = m_tuple11->addIndexedItem( "chimu", m_ngch, m_chimu );
786 status = m_tuple11->addIndexedItem( "chipi", m_ngch, m_chipi );
787 status = m_tuple11->addIndexedItem( "chik", m_ngch, m_chik );
788 status = m_tuple11->addIndexedItem( "chip", m_ngch, m_chip );
789 status = m_tuple11->addIndexedItem( "probPH", m_ngch, m_probPH );
790 status = m_tuple11->addIndexedItem( "normPH", m_ngch, m_normPH );
791 status = m_tuple11->addIndexedItem( "ghit", m_ngch, m_ghit );
792 status = m_tuple11->addIndexedItem( "thit", m_ngch, m_thit );
793 }
794 else
795 {
796 log << MSG::ERROR << " Cannot book N-tuple:" << long( m_tuple11 ) << endmsg;
797 return StatusCode::FAILURE;
798 }
799 }
800
801 NTuplePtr nt12( ntupleSvc(), "DQAFILE/CheckTofChAll" );
802 if ( nt12 ) m_tuple12 = nt12;
803 else
804 {
805 m_tuple12 = ntupleSvc()->book( "DQAFILE/CheckTofChAll", CLID_ColumnWiseTuple,
806 "ks N-Tuple example" );
807 if ( m_tuple12 )
808 {
809 status = m_tuple12->addItem( "ngch2", m_ngch2, 0, 10000 );
810 status = m_tuple12->addIndexedItem( "trkidtof", m_ngch2, m_trkidtof );
811 status = m_tuple12->addIndexedItem( "ptot_etof", m_ngch2, m_ptot_etof );
812 status = m_tuple12->addIndexedItem( "cntr_etof", m_ngch2, m_cntr_etof );
813 status = m_tuple12->addIndexedItem( "te_etof", m_ngch2, m_te_etof );
814 status = m_tuple12->addIndexedItem( "tmu_etof", m_ngch2, m_tmu_etof );
815 status = m_tuple12->addIndexedItem( "tpi_etof", m_ngch2, m_tpi_etof );
816 status = m_tuple12->addIndexedItem( "tk_etof", m_ngch2, m_tk_etof );
817 status = m_tuple12->addIndexedItem( "tp_etof", m_ngch2, m_tp_etof );
818 status = m_tuple12->addIndexedItem( "ph_etof", m_ngch2, m_ph_etof );
819 status = m_tuple12->addIndexedItem( "rhit_etof", m_ngch2, m_rhit_etof );
820 status = m_tuple12->addIndexedItem( "qual_etof", m_ngch2, m_qual_etof );
821 status = m_tuple12->addIndexedItem( "ec_toff_e", m_ngch2, m_ec_toff_e );
822 status = m_tuple12->addIndexedItem( "ec_toff_mu", m_ngch2, m_ec_toff_mu );
823 status = m_tuple12->addIndexedItem( "ec_toff_pi", m_ngch2, m_ec_toff_pi );
824 status = m_tuple12->addIndexedItem( "ec_toff_k", m_ngch2, m_ec_toff_k );
825 status = m_tuple12->addIndexedItem( "ec_toff_p", m_ngch2, m_ec_toff_p );
826 status = m_tuple12->addIndexedItem( "ec_tsig_e", m_ngch2, m_ec_tsig_e );
827 status = m_tuple12->addIndexedItem( "ec_tsig_mu", m_ngch2, m_ec_tsig_mu );
828 status = m_tuple12->addIndexedItem( "ec_tsig_pi", m_ngch2, m_ec_tsig_pi );
829 status = m_tuple12->addIndexedItem( "ec_tsig_k", m_ngch2, m_ec_tsig_k );
830 status = m_tuple12->addIndexedItem( "ec_tsig_p", m_ngch2, m_ec_tsig_p );
831 status = m_tuple12->addIndexedItem( "ec_tof", m_ngch2, m_ec_tof );
832 status = m_tuple12->addIndexedItem( "ptot_btof1", m_ngch2, m_ptot_btof1 );
833 status = m_tuple12->addIndexedItem( "cntr_btof1", m_ngch2, m_cntr_btof1 );
834 status = m_tuple12->addIndexedItem( "te_btof1", m_ngch2, m_te_btof1 );
835 status = m_tuple12->addIndexedItem( "tmu_btof1", m_ngch2, m_tmu_btof1 );
836 status = m_tuple12->addIndexedItem( "tpi_btof1", m_ngch2, m_tpi_btof1 );
837 status = m_tuple12->addIndexedItem( "tk_btof1", m_ngch2, m_tk_btof1 );
838 status = m_tuple12->addIndexedItem( "tp_btof1", m_ngch2, m_tp_btof1 );
839 status = m_tuple12->addIndexedItem( "ph_btof1", m_ngch2, m_ph_btof1 );
840 status = m_tuple12->addIndexedItem( "zhit_btof1", m_ngch2, m_zhit_btof1 );
841 status = m_tuple12->addIndexedItem( "qual_btof1", m_ngch2, m_qual_btof1 );
842 status = m_tuple12->addIndexedItem( "b1_toff_e", m_ngch2, m_b1_toff_e );
843 status = m_tuple12->addIndexedItem( "b1_toff_mu", m_ngch2, m_b1_toff_mu );
844 status = m_tuple12->addIndexedItem( "b1_toff_pi", m_ngch2, m_b1_toff_pi );
845 status = m_tuple12->addIndexedItem( "b1_toff_k", m_ngch2, m_b1_toff_k );
846 status = m_tuple12->addIndexedItem( "b1_toff_p", m_ngch2, m_b1_toff_p );
847 status = m_tuple12->addIndexedItem( "b1_tsig_e", m_ngch2, m_b1_tsig_e );
848 status = m_tuple12->addIndexedItem( "b1_tsig_mu", m_ngch2, m_b1_tsig_mu );
849 status = m_tuple12->addIndexedItem( "b1_tsig_pi", m_ngch2, m_b1_tsig_pi );
850 status = m_tuple12->addIndexedItem( "b1_tsig_k", m_ngch2, m_b1_tsig_k );
851 status = m_tuple12->addIndexedItem( "b1_tsig_p", m_ngch2, m_b1_tsig_p );
852 status = m_tuple12->addIndexedItem( "b1_tof", m_ngch2, m_b1_tof );
853
854 status = m_tuple12->addIndexedItem( "mdedx_pid", m_ngch2, m_dedx_pid );
855 status = m_tuple12->addIndexedItem( "mtof1_pid", m_ngch2, m_tof1_pid );
856 status = m_tuple12->addIndexedItem( "mtof2_pid", m_ngch2, m_tof2_pid );
857 status = m_tuple12->addIndexedItem( "mprob_pid", m_ngch2, m_prob_pid );
858 status = m_tuple12->addIndexedItem( "mptrk_pid", m_ngch2, m_ptrk_pid );
859 status = m_tuple12->addIndexedItem( "mcost_pid", m_ngch2, m_cost_pid );
860 }
861 else
862 {
863 log << MSG::ERROR << " Cannot book N-tuple:" << long( m_tuple12 ) << endmsg;
864 return StatusCode::FAILURE;
865 }
866 }
867
868 NTuplePtr nt13( ntupleSvc(), "DQAFILE/CheckTofNeAll" );
869 if ( nt13 ) m_tuple13 = nt13;
870 else
871 {
872 m_tuple13 = ntupleSvc()->book( "DQAFILE/CheckTofNeAll", CLID_ColumnWiseTuple,
873 "ks N-Tuple example" );
874 if ( m_tuple13 )
875 {
876 status = m_tuple13->addItem( "ngneu", m_nggneu, 0, 10000 );
877 status = m_tuple13->addIndexedItem( "shwidtof", m_nggneu, m_shwidtof );
878 status =
879 m_tuple13->addIndexedItem( "numHits", m_nggneu, m_numHits ); // Total number of hits
880 status = m_tuple13->addIndexedItem( "secondmoment", m_nggneu, m_secondmoment );
881 status =
882 m_tuple13->addIndexedItem( "mx", m_nggneu, m_x ); // Shower coordinates and errors
883 status = m_tuple13->addIndexedItem( "my", m_nggneu, m_y );
884 status = m_tuple13->addIndexedItem( "mz", m_nggneu, m_z );
885 status = m_tuple13->addIndexedItem( "cosemc", m_nggneu,
886 m_cosemc ); // Shower Counter angles and errors
887 status = m_tuple13->addIndexedItem( "phiemc", m_nggneu, m_phiemc );
888 status = m_tuple13->addIndexedItem( "energy", m_nggneu,
889 m_energy ); // Total energy observed in Emc
890 status = m_tuple13->addIndexedItem( "eseed", m_nggneu, m_eSeed );
891 status = m_tuple13->addIndexedItem( "me9", m_nggneu, m_e3x3 );
892 status = m_tuple13->addIndexedItem( "me25", m_nggneu, m_e5x5 );
893 status = m_tuple13->addIndexedItem( "mlat", m_nggneu, m_lat );
894 status = m_tuple13->addIndexedItem( "ma20", m_nggneu, m_a20 );
895 status = m_tuple13->addIndexedItem( "ma42", m_nggneu, m_a42 );
896 }
897 else
898 {
899 log << MSG::ERROR << " Cannot book N-tuple:" << long( m_tuple13 ) << endmsg;
900 return StatusCode::FAILURE;
901 }
902 }
903
904 if ( service( "THistSvc", m_thsvc ).isFailure() )
905 {
906 log << MSG::ERROR << "Couldn't get THistSvc" << endmsg;
907 return StatusCode::FAILURE;
908 }
909
910 string strdecaymode[11] = { "D02KPi", "D02KPiPi0", "D02KPiPiPi", "D02KPiPiPiPi0",
911 "D02KsPiPi", "D02KsPiPiPi0", "DC2KPiPi", "DC2KPiPiPi0",
912 "DC2KsPiPi0", "DC2KsPiPiPi", "DC2KKPi" };
913 for ( int i = 0; i != 11; i++ ) { regDecayModeHistogram( m_thsvc, strdecaymode[i] ); }
914 string strDdecaymode[2] = { "D0", "DC" };
915 regDecayModeHistogram( m_thsvc, strDdecaymode[0] );
916 regDecayModeHistogram( m_thsvc, strDdecaymode[1] );
917 string strtrack[14] = { "D02KPi_kaon", "D02KPi_pion", "D02KPiPi0_kaon",
918 "D02KPiPi0_pion", "D02KsPiPi_pion1", "D02KsPiPi_pion2",
919 "D02KsPiPi_pion3", "D02KsPiPi_pion4", "DC2KPiPi_kaon",
920 "DC2KPiPi_pion1", "DC2KPiPi_pion2", "DC2KsPiPi0_pion1",
921 "DC2KsPiPi0_pion2", "DC2KsPiPi0_pion3" };
922 for ( int i = 0; i != 14; i++ ) { regTrackHistogram( m_thsvc, strtrack[i] ); }
923 string strphoton[2] = { "D02KPiPi0_photon1", "D02KPiPi0_photon2" };
924 regPhotonHistogram( m_thsvc, strphoton[0] );
925 regPhotonHistogram( m_thsvc, strphoton[1] );
926 string strtrackdedx[7] = { "D02KPi_kaon", "D02KPi_pion", "D02KPiPi0_kaon",
927 "D02KPiPi0_pion", "DC2KPiPi_kaon", "DC2KPiPi_pion1",
928 "DC2KPiPi_pion2" };
929 for ( int i = 0; i != 7; i++ ) { regTrackDedxHistogram( m_thsvc, strtrackdedx[i] ); }
930 string strtracktof[7] = { "D02KPi_kaon", "D02KPi_pion", "D02KPiPi0_kaon",
931 "D02KPiPi0_pion", "DC2KPiPi_kaon", "DC2KPiPi_pion1",
932 "DC2KPiPi_pion2" };
933 for ( int i = 0; i != 7; i++ ) { regTrackTofHistogram( m_thsvc, strtracktof[i] ); }
934 string strpi0[2] = { "D02KPiPi0", "DC2KsPiPi0" };
935 for ( int i = 0; i != 2; i++ ) { regPi0Histogram( m_thsvc, strpi0[i] ); }
936 string strks[2] = { "D02KsPiPi", "DC2KsPiPi0" };
937 for ( int i = 0; i != 2; i++ ) { regKsHistogram( m_thsvc, strks[i] ); }
938
939 StatusCode sc = service( "BestDTagSvc", m_bestDSvc );
940 if ( sc.isFailure() )
941 {
942 log << MSG::FATAL << "Could not load BestDTagSvc!" << endmsg;
943 return sc;
944 }
945 //
946 //--------end of book--------
947 //
948
949 log << MSG::INFO << "successfully return from initialize()" << endmsg;
950 return StatusCode::SUCCESS;
951}
952
953// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
954StatusCode DQADtag::execute() {
955
956 // std::cout << "execute()" << std::endl;
957
958 MsgStream log( msgSvc(), name() );
959 log << MSG::INFO << "in execute()" << endmsg;
960
961 setFilterPassed( false );
962
963 SmartDataPtr<Event::EventHeader> eventHeader( eventSvc(), "/Event/EventHeader" );
964 int run = eventHeader->runNumber();
965 int event = eventHeader->eventNumber();
966 log << MSG::DEBUG << "run, evtnum = " << run << " , " << event << endmsg;
967
968 m_run = eventHeader->runNumber();
969 m_rec = eventHeader->eventNumber();
970 m_evtrun = eventHeader->runNumber();
971 m_evtrec = eventHeader->eventNumber();
972
973 //////////////////
974 // get beam energy
975 //////////////////
976 if ( m_ReadBeamEFromDB && m_irun != run )
977 {
978 m_irun = run;
979 if ( m_readDb.isRunValid( m_irun ) ) m_beamE = m_readDb.getbeamE( m_irun );
980 }
981
982 double beamE = m_beamE;
983 m_evtbeamE = m_beamE;
984
985 if ( m_debug ) cout << "event " << event << endl;
986 Ncut_DQADTagAlg[0]++;
987 if ( Ncut_DQADTagAlg[0] % 10000 == 0 )
988 { cout << "Ncut_DQADTagAlg[0]: " << Ncut_DQADTagAlg[0] << endl; }
989 // if (Ncut_DQADTagAlg[0]<120000)
990 // return StatusCode::SUCCESS;
991 SmartDataPtr<EvtRecEvent> evtRecEvent( eventSvc(), EventModel::EvtRec::EvtRecEvent );
992 log << MSG::INFO << "get event tag OK" << endmsg;
993 log << MSG::DEBUG << "ncharg, nneu, tottks = " << evtRecEvent->totalCharged() << " , "
994 << evtRecEvent->totalNeutral() << " , " << evtRecEvent->totalTracks() << endmsg;
995
996 m_nch = evtRecEvent->totalCharged();
997 m_nneu = evtRecEvent->totalNeutral();
998 m_evtnch = evtRecEvent->totalCharged();
999 m_evtnneu = evtRecEvent->totalNeutral();
1000
1001 SmartDataPtr<EvtRecTrackCol> evtRecTrkCol( eventSvc(), EventModel::EvtRec::EvtRecTrackCol );
1002
1003 // get primay vetex from db
1004 Hep3Vector xorigin( 0, 0, 0 );
1005 IVertexDbSvc* vtxsvc;
1006 HepPoint3D vx( 0., 0., 0. );
1007 HepSymMatrix Evx( 3, 0 );
1008 Gaudi::svcLocator()->service( "VertexDbSvc", vtxsvc ).ignore();
1009 if ( vtxsvc->isVertexValid() )
1010 {
1011 double* vertex = vtxsvc->PrimaryVertex(); // vertex[0] = vx; vertex[1]= vy; vertex[2] = vz;
1012 double* vertexsigma = vtxsvc->SigmaPrimaryVertex();
1013 xorigin.setX( vertex[0] );
1014 xorigin.setY( vertex[1] );
1015 xorigin.setZ( vertex[2] );
1016 vx[0] = vertex[0];
1017 vx[1] = vertex[1];
1018 vx[2] = vertex[2];
1019 Evx[0][0] = vertexsigma[0] * vertexsigma[0];
1020 Evx[1][1] = vertexsigma[1] * vertexsigma[1];
1021 Evx[2][2] = vertexsigma[2] * vertexsigma[2];
1022 m_privxpar.setVx( vx );
1023 m_privxpar.setEvx( Evx );
1024 }
1025
1026 // Vp4 pDtagCand_cms;
1027 // pDtagCand_cms.clear();
1028 // int numDtagCand = 0;
1029 // vector<double> vmBC_D0, vmDCand_D0, vdeltE_D0, vpDCand_D0, vmpi0, vvmks, vmksp4,\
1030 // vvlks, vmBC_DC, vmDCand_DC, vdeltE_DC, vpDCand_DC;
1031 // vmBC_D0.clear();
1032 // vmDCand_D0.clear();
1033 // vdeltE_D0.clear();
1034 // vpDCand_D0.clear();
1035 // vmBC_DC.clear();
1036 // vmDCand_DC.clear();
1037 // vdeltE_DC.clear();
1038 // vpDCand_DC.clear();
1039 // vmpi0.clear();
1040 // vvmks.clear();
1041 // vmksp4.clear();
1042 // vvlks.clear();
1043
1044 SmartDataPtr<EvtRecDTagCol> evtRecDTagCol( eventSvc(), EventModel::EvtRec::EvtRecDTagCol );
1045 if ( !evtRecDTagCol )
1046 {
1047 cout << "Could not find EvtRecDTagCol" << endl;
1048 return StatusCode::SUCCESS;
1049 }
1050
1051 EvtRecDTag* bestDTag = NULL;
1052 bestDTag = m_bestDSvc->getSingleTag( -1 );
1053 if ( bestDTag == NULL ) return StatusCode::SUCCESS;
1054 Ncut_DQADTagAlg[1]++;
1055
1056 m_rflag = m_bestDSvc->isCosmicOrLepton();
1057 SmartRefVector<EvtRecTrack> tracks = ( bestDTag )->tracks();
1058 SmartRefVector<EvtRecTrack> othertracks = ( bestDTag )->otherTracks();
1059 SmartRefVector<EvtRecTrack> othershowers = ( bestDTag )->otherShowers();
1060 SmartRefVector<EvtRecTrack> showers = ( bestDTag )->showers();
1061 // m_bestD_mode=(bestDTag)->decayMode();
1062 // m_bestD_p=(bestDTag)->p4().rho();
1063 // m_bestD_charm=(bestDTag)->charm();
1064 // m_bestD_mass=(bestDTag)->mass();
1065 double g_mBC = ( bestDTag )->mBC();
1066 double g_deltE = ( bestDTag )->deltaE();
1067 // int DMode =(int)(bestDTag)->decayMode();
1068
1069 // use util tool to get dtaglist
1070
1071 int nCharge = 0;
1072
1073 const int numMode = 11;
1074 int indexD[numMode], indexTof[numMode], indexDedx[numMode], numDCand[numMode];
1075 for ( int i = 0; i != numMode; i++ )
1076 {
1077 indexD[i] = 0;
1078 indexTof[i] = 0;
1079 indexDedx[i] = 0;
1080 numDCand[i] = 0;
1081 }
1082 int indexDAll = 0;
1083 int indexD0All = 0;
1084 int indexDCAll = 0;
1085
1086 // for (DTagToolIterator bestDTag=iter_begin; bestDTag != iter_end; bestDTag++)
1087 {
1088 bool iswritten = 1;
1089 // decay mode name
1090
1091 // ***********************************************************************
1092 // m_checkDecayMode == 0 : allDecayMode donot check pi0 Ks
1093 // m_checkDecayMode == 1 : singleDecayMode D0 to KPi
1094 // m_checkDecayMode == 2 : fewDecayMode 10 decay modes check pi0 Ks
1095 // ***********************************************************************
1096 if ( m_checkDecayMode < 3 )
1097 {
1098 // general variables
1099 // HepLorentzVector p4=(bestDTag)->p4();
1100 // p4.boost(-0.011,0,0);
1101
1102 // Hep3Vector p3=p4.v();
1103 // double deltaEDCand = (bestDTag)->deltaE();
1104 // double mBCDCand =(bestDTag)->mBC();
1105 // if(fabs(deltaEDCand)>=0.1) continue;
1106 // if(mBCDCand<=1.8 || mBCDCand>=2.0) continue;
1107 m_dtagbeamE = m_beamE;
1108 m_mode = ( bestDTag )->decayMode();
1109 m_charge = ( bestDTag )->charge();
1110 m_charm = ( bestDTag )->charm();
1111 m_numofchildren = ( bestDTag )->numOfChildren();
1112 m_mass = ( bestDTag )->mass();
1113 m_mBC = ( bestDTag )->mBC();
1114 m_e = ( bestDTag )->beamE();
1115 HepLorentzVector p4D = ( bestDTag )->p4();
1116 m_p = p4D.rho();
1117 p4D.boost( -0.011, 0, 0 );
1118 m_p_CMS = p4D.rho();
1119 fill( m_p4_CMS, p4D );
1120 m_deltae = ( bestDTag )->deltaE();
1121 // pDtagCand_cms.push_back((bestDTag)->p4());
1122 SmartRefVector<EvtRecTrack> tracks = ( bestDTag )->tracks();
1123 SmartRefVector<EvtRecTrack> othertracks = ( bestDTag )->otherTracks();
1124 SmartRefVector<EvtRecTrack> othershowers = ( bestDTag )->otherShowers();
1125 SmartRefVector<EvtRecTrack> showers = ( bestDTag )->showers();
1126 // HepLorentzVector p4=(bestDTag)->p4();
1127 // p4.boost(-0.011,0,0);
1128 m_nshower = showers.size();
1129 m_ntrk = tracks.size();
1130 m_nothertrk = othertracks.size();
1131 m_nothershower = othershowers.size();
1132
1133 // if (m_checkDecayMode == 0 ) continue;
1134 // end general variables
1135 indexDAll++;
1136 if ( ( bestDTag )->decayMode() == EvtRecDTag::kD0toKPi )
1137 {
1138 const int MODE = 0;
1139 fillDecayModeItem( bestDTag, "D02KPi" );
1140 fillTrackItem( tracks[0], "D02KPi_kaon", 3, xorigin );
1141 fillTrackItem( tracks[1], "D02KPi_pion", 2, xorigin );
1142 indexD[MODE]++;
1143 if ( m_checkDedx )
1144 {
1145 // if (!tracks[0]->isMdcDedxValid()) continue;
1146 // if (!tracks[1]->isMdcDedxValid()) continue;
1147 fillTrackDedxItem( tracks[0], "D02KPi_kaon", 3 );
1148 fillTrackDedxItem( tracks[1], "D02KPi_pion", 2 );
1149 }
1150 if ( m_checkTof )
1151 {
1152 // if(!tracks[0]->isTofTrackValid()) continue;
1153 // if(!tracks[1]->isTofTrackValid()) continue;
1154 fillTrackTofItem( tracks[0], "D02KPi_kaon", 3 );
1155 fillTrackTofItem( tracks[1], "D02KPi_pion", 2 );
1156 }
1157 } // end of D0 to K Pi mode
1158 // if (m_checkDecayMode == 1 ) continue;
1159 if ( ( bestDTag )->decayMode() == EvtRecDTag::kD0toKPiPi0 )
1160 {
1161 const int MODE = 1;
1162 // pi0 mass
1163 DQAPi0Info pi0info;
1164 pi0info.setchilds( showers[0], showers[1] );
1165 if ( pi0info.calculate() )
1166 {
1167 if ( pi0info.m() > m_mpi0Max || pi0info.m() < m_mpi0Min ) iswritten = 0;
1168 // vmpi0.push_back(pi0info.m());
1169 fillPi0Item( showers, "D02KPiPi0", &pi0info );
1170 fillDecayModeItem( bestDTag, "D02KPiPi0" );
1171 fillTrackItem( tracks[0], "D02KPiPi0_kaon", 3, xorigin );
1172 fillTrackItem( tracks[1], "D02KPiPi0_pion", 2, xorigin );
1173 fillPhotonItem( showers[0], "D02KPiPi0_photon1" );
1174 fillPhotonItem( showers[1], "D02KPiPi0_photon2" );
1175 indexD[MODE]++;
1176 if ( m_checkDedx )
1177 {
1178 // if (!tracks[0]->isMdcDedxValid()) continue;
1179 // if (!tracks[1]->isMdcDedxValid()) continue;
1180 fillTrackDedxItem( tracks[0], "D02KPiPi0_kaon", 3 );
1181 fillTrackDedxItem( tracks[1], "D02KPiPi0_pion", 2 );
1182 }
1183 if ( m_checkTof )
1184 {
1185 // if(!tracks[0]->isTofTrackValid()) continue;
1186 // if(!tracks[1]->isTofTrackValid()) continue;
1187 fillTrackTofItem( tracks[0], "D02KPiPi0_kaon", 3 );
1188 fillTrackTofItem( tracks[1], "D02KPiPi0_pion", 2 );
1189 }
1190 }
1191 } // end of D0 to KPiPi0
1192
1193 //****************************************************
1194 // mode D0 to KPiPiPi only
1195 //****************************************************
1196 if ( ( bestDTag )->decayMode() == EvtRecDTag::kD0toKPiPiPi )
1197 {
1198 const int MODE = 2;
1199 fillDecayModeItem( bestDTag, "D02KPiPiPi" );
1200
1201 RecMdcKalTrack* mdcKalTrk1 = tracks[0]->mdcKalTrack();
1202 RecMdcKalTrack* mdcKalTrk2 = tracks[1]->mdcKalTrack();
1203 RecMdcKalTrack* mdcKalTrk3 = tracks[2]->mdcKalTrack();
1204 RecMdcKalTrack* mdcKalTrk4 = tracks[3]->mdcKalTrack();
1205 RecMdcKalTrack::setPidType( RecMdcKalTrack::kaon );
1206 HepLorentzVector p4kaon = mdcKalTrk1->p4( xmass[3] );
1207 RecMdcKalTrack::setPidType( RecMdcKalTrack::pion );
1208 HepLorentzVector p4pion1 = mdcKalTrk2->p4( xmass[2] );
1209 HepLorentzVector p4pion2 = mdcKalTrk3->p4( xmass[2] );
1210 HepLorentzVector p4pion3 = mdcKalTrk4->p4( xmass[2] );
1211 m_D02KPiPiPi_kaon_pp = p4kaon.rho();
1212 m_D02KPiPiPi_pion1_pp = p4pion1.rho();
1213 m_D02KPiPiPi_pion2_pp = p4pion2.rho();
1214 m_D02KPiPiPi_pion3_pp = p4pion3.rho();
1215 m_D02KPiPiPi_kaon_Id = tracks[0]->trackId();
1216 m_D02KPiPiPi_pion1_Id = tracks[1]->trackId();
1217 m_D02KPiPiPi_pion2_Id = tracks[2]->trackId();
1218 m_D02KPiPiPi_pion3_Id = tracks[3]->trackId();
1219 indexD[MODE]++;
1220 }
1221 //****************************************************
1222 // mode D0 to KPiPiPiPi0 only
1223 //****************************************************
1224 if ( ( bestDTag )->decayMode() == EvtRecDTag::kD0toKPiPiPiPi0 )
1225 {
1226 const int MODE = 3;
1227 DQAPi0Info pi0info;
1228 pi0info.setchilds( showers[0], showers[1] );
1229 if ( pi0info.calculate() )
1230 {
1231 if ( pi0info.m() > m_mpi0Max || pi0info.m() < m_mpi0Min ) iswritten = 0;
1232 fillPi0Item( showers, "D02KPiPiPiPi0", &pi0info );
1233 // vmpi0.push_back(pi0info.m());
1234
1235 fillDecayModeItem( bestDTag, "D02KPiPiPiPi0" );
1236
1237 RecMdcKalTrack* mdcKalTrk1 = tracks[0]->mdcKalTrack();
1238 RecMdcKalTrack* mdcKalTrk2 = tracks[1]->mdcKalTrack();
1239 RecMdcKalTrack* mdcKalTrk3 = tracks[2]->mdcKalTrack();
1240 RecMdcKalTrack* mdcKalTrk4 = tracks[3]->mdcKalTrack();
1241 RecMdcKalTrack::setPidType( RecMdcKalTrack::kaon );
1242 HepLorentzVector p4kaon = mdcKalTrk1->p4( xmass[3] );
1243 RecMdcKalTrack::setPidType( RecMdcKalTrack::pion );
1244 HepLorentzVector p4pion1 = mdcKalTrk2->p4( xmass[2] );
1245 HepLorentzVector p4pion2 = mdcKalTrk3->p4( xmass[2] );
1246 HepLorentzVector p4pion3 = mdcKalTrk4->p4( xmass[2] );
1247 m_D02KPiPiPiPi0_kaon_pp = p4kaon.rho();
1248 m_D02KPiPiPiPi0_pion1_pp = p4pion1.rho();
1249 m_D02KPiPiPiPi0_pion2_pp = p4pion2.rho();
1250 m_D02KPiPiPiPi0_pion3_pp = p4pion3.rho();
1251 m_D02KPiPiPiPi0_kaon_Id = tracks[0]->trackId();
1252 m_D02KPiPiPiPi0_pion1_Id = tracks[1]->trackId();
1253 m_D02KPiPiPiPi0_pion2_Id = tracks[2]->trackId();
1254 m_D02KPiPiPiPi0_pion3_Id = tracks[3]->trackId();
1255 indexD[MODE]++;
1256 }
1257 }
1258 //****************************************************
1259 // mode D0 to KsPiPi only
1260 //****************************************************
1261 if ( ( bestDTag )->decayMode() == EvtRecDTag::kD0toKsPiPi )
1262 {
1263 const int MODE = 4;
1264 DQAKsInfo ksinfo;
1265 ksinfo.setchilds( tracks[0], tracks[1] );
1266 ksinfo.setVtxPar( m_vxpar );
1267 ksinfo.setPrimaryVtxPar( m_privxpar );
1268 if ( ksinfo.calculate() )
1269 {
1270
1271 fillDecayModeItem( bestDTag, "D02KsPiPi" );
1272 fillTrackItem( tracks[0], "D02KsPiPi_pion1", 2, xorigin );
1273 fillTrackItem( tracks[1], "D02KsPiPi_pion2", 2, xorigin );
1274 fillTrackItem( tracks[2], "D02KsPiPi_pion3", 2, xorigin );
1275 fillTrackItem( tracks[3], "D02KsPiPi_pion4", 2, xorigin );
1276 fillKsItem( tracks, "D02KsPiPi", &ksinfo );
1277 indexD[MODE]++;
1278
1279 // if (iswritten) vvmks.push_back(ksinfo.m());
1280 // if (iswritten) vmksp4.push_back(ksinfo.mksp4());
1281 // if (iswritten) vvlks.push_back(ksinfo.decayLengthRatio());
1282 }
1283 } // end of D0 to KsPiPi
1284 //****************************************************
1285 // mode D0 to KsPiPiPi0 only
1286 //****************************************************
1287 if ( ( bestDTag )->decayMode() == EvtRecDTag::kD0toKsPiPiPi0 )
1288 {
1289 const int MODE = 5;
1290 DQAKsInfo ksinfo;
1291 ksinfo.setchilds( tracks[0], tracks[1] );
1292 ksinfo.setVtxPar( m_vxpar );
1293 ksinfo.setPrimaryVtxPar( m_privxpar );
1294 if ( ksinfo.calculate() )
1295 {
1296 DQAPi0Info pi0info;
1297 pi0info.setchilds( showers[0], showers[1] );
1298 if ( pi0info.calculate() )
1299 {
1300 if ( pi0info.m() > m_mpi0Max || pi0info.m() < m_mpi0Min ) iswritten = 0;
1301 fillPi0Item( showers, "D02KsPiPiPi0", &pi0info );
1302 // vmpi0.push_back(pi0info.m());
1303 fillKsItem( tracks, "D02KsPiPiPi0", &ksinfo );
1304 // if (iswritten) vvmks.push_back(ksinfo.m());
1305 // if (iswritten) vmksp4.push_back(ksinfo.mksp4());
1306 // if (iswritten) vvlks.push_back(ksinfo.decayLengthRatio());
1307 fillDecayModeItem( bestDTag, "D02KsPiPiPi0" );
1308
1309 RecMdcKalTrack* mdcKalTrk1 = tracks[0]->mdcKalTrack();
1310 RecMdcKalTrack* mdcKalTrk2 = tracks[1]->mdcKalTrack();
1311 RecMdcKalTrack* mdcKalTrk3 = tracks[2]->mdcKalTrack();
1312 RecMdcKalTrack* mdcKalTrk4 = tracks[3]->mdcKalTrack();
1313 RecMdcKalTrack::setPidType( RecMdcKalTrack::pion );
1314 HepLorentzVector p4pion1 = mdcKalTrk1->p4( xmass[2] );
1315 HepLorentzVector p4pion2 = mdcKalTrk2->p4( xmass[2] );
1316 HepLorentzVector p4pion3 = mdcKalTrk3->p4( xmass[2] );
1317 HepLorentzVector p4pion4 = mdcKalTrk4->p4( xmass[2] );
1318 m_D02KsPiPiPi0_pion1_pp = p4pion1.rho();
1319 m_D02KsPiPiPi0_pion2_pp = p4pion2.rho();
1320 m_D02KsPiPiPi0_pion3_pp = p4pion3.rho();
1321 m_D02KsPiPiPi0_pion4_pp = p4pion4.rho();
1322 m_D02KsPiPiPi0_pion1_Id = tracks[0]->trackId();
1323 m_D02KsPiPiPi0_pion2_Id = tracks[1]->trackId();
1324 m_D02KsPiPiPi0_pion3_Id = tracks[2]->trackId();
1325 m_D02KsPiPiPi0_pion4_Id = tracks[3]->trackId();
1326 indexD[MODE]++;
1327 }
1328 }
1329 } // end of D0 to KsPiPiPi0
1330 //****************************************************
1331 // mode Dp to KPiPi only
1332 //****************************************************
1333 if ( ( bestDTag )->decayMode() == EvtRecDTag::kDptoKPiPi )
1334 {
1335 const int MODE = 6;
1336 fillDecayModeItem( bestDTag, "DC2KPiPi" );
1337 fillTrackItem( tracks[0], "DC2KPiPi_kaon", 3, xorigin );
1338 fillTrackItem( tracks[1], "DC2KPiPi_pion1", 2, xorigin );
1339 fillTrackItem( tracks[2], "DC2KPiPi_pion2", 2, xorigin );
1340 if ( m_checkTof )
1341 {
1342 // if(!tracks[0]->isTofTrackValid()) continue;
1343 // if(!tracks[1]->isTofTrackValid()) continue;
1344 fillTrackTofItem( tracks[0], "DC2KPiPi_kaon", 3 );
1345 fillTrackTofItem( tracks[1], "DC2KPiPi_pion1", 2 );
1346 fillTrackTofItem( tracks[2], "DC2KPiPi_pion2", 2 );
1347 }
1348 if ( m_checkDedx )
1349 {
1350 fillTrackDedxItem( tracks[0], "DC2KPiPi_kaon", 3 );
1351 fillTrackDedxItem( tracks[1], "DC2KPiPi_pion1", 2 );
1352 fillTrackDedxItem( tracks[2], "DC2KPiPi_pion2", 2 );
1353 }
1354 indexD[MODE]++;
1355 }
1356
1357 //****************************************************
1358 // mode Dp to KPiPiPi0 only
1359 //****************************************************
1360 if ( ( bestDTag )->decayMode() == EvtRecDTag::kDptoKPiPiPi0 )
1361 {
1362 const int MODE = 7;
1363 DQAPi0Info pi0info;
1364 pi0info.setchilds( showers[0], showers[1] );
1365 if ( pi0info.calculate() )
1366 {
1367 if ( pi0info.m() > m_mpi0Max || pi0info.m() < m_mpi0Min ) iswritten = 0;
1368 fillPi0Item( showers, "DC2KPiPiPi0", &pi0info );
1369 // vmpi0.push_back(pi0info.m());
1370 fillDecayModeItem( bestDTag, "DC2KPiPiPi0" );
1371
1372 fillTrackItem( tracks[0], "DC2KPiPiPi0_kaon", 3, xorigin );
1373 fillTrackItem( tracks[1], "DC2KPiPiPi0_pion1", 2, xorigin );
1374 fillTrackItem( tracks[2], "DC2KPiPiPi0_pion2", 2, xorigin );
1375 indexD[MODE]++;
1376 }
1377 }
1378 //****************************************************
1379 // mode Dp to KsPiPi0 only
1380 //****************************************************
1381 if ( ( bestDTag )->decayMode() == EvtRecDTag::kDptoKsPiPi0 )
1382 {
1383 const int MODE = 8;
1384 DQAPi0Info pi0info;
1385 pi0info.setchilds( showers[0], showers[1] );
1386 if ( pi0info.calculate() )
1387 {
1388 DQAKsInfo ksinfo;
1389 ksinfo.setchilds( tracks[0], tracks[1] );
1390 ksinfo.setVtxPar( m_vxpar );
1391 ksinfo.setPrimaryVtxPar( m_privxpar );
1392 if ( ksinfo.calculate() )
1393 {
1394 if ( pi0info.m() > m_mpi0Max || pi0info.m() < m_mpi0Min ) iswritten = 0;
1395 fillPi0Item( showers, "DC2KsPiPi0", &pi0info );
1396 fillDecayModeItem( bestDTag, "DC2KsPiPi0" );
1397 fillTrackItem( tracks[0], "DC2KsPiPi0_pion1", 2, xorigin );
1398 fillTrackItem( tracks[1], "DC2KsPiPi0_pion2", 2, xorigin );
1399 fillTrackItem( tracks[2], "DC2KsPiPi0_pion3", 2, xorigin );
1400 fillKsItem( tracks, "DC2KsPiPi0", &ksinfo );
1401 // if (iswritten) vvmks.push_back(ksinfo.m());
1402 // if (iswritten) vmksp4.push_back(ksinfo.mksp4());
1403 // if (iswritten) vvlks.push_back(ksinfo.decayLengthRatio());
1404 indexD[MODE]++;
1405 }
1406 }
1407 } // end of Dp to Kspipi0
1408 //****************************************************
1409 // mode Dp to KKPi only
1410 //****************************************************
1411 if ( ( bestDTag )->decayMode() == EvtRecDTag::kDptoKsPiPiPi )
1412 {
1413 const int MODE = 9;
1414 DQAKsInfo ksinfo;
1415 ksinfo.setchilds( tracks[0], tracks[1] );
1416 ksinfo.setVtxPar( m_vxpar );
1417 ksinfo.setPrimaryVtxPar( m_privxpar );
1418 if ( ksinfo.calculate() )
1419 {
1420
1421 fillKsItem( tracks, "DC2KsPiPiPi", &ksinfo );
1422 // if (iswritten) vvmks.push_back(ksinfo.m());
1423 // if (iswritten) vmksp4.push_back(ksinfo.mksp4());
1424 // if (iswritten) vvlks.push_back(ksinfo.decayLengthRatio());
1425 fillDecayModeItem( bestDTag, "DC2KsPiPiPi" );
1426
1427 RecMdcKalTrack* mdcKalTrk1 = tracks[0]->mdcKalTrack();
1428 RecMdcKalTrack* mdcKalTrk2 = tracks[1]->mdcKalTrack();
1429 RecMdcKalTrack* mdcKalTrk3 = tracks[2]->mdcKalTrack();
1430 RecMdcKalTrack* mdcKalTrk4 = tracks[3]->mdcKalTrack();
1431 RecMdcKalTrack* mdcKalTrk5 = tracks[4]->mdcKalTrack();
1432 RecMdcKalTrack::setPidType( RecMdcKalTrack::pion );
1433 HepLorentzVector p4pion1 = mdcKalTrk1->p4( xmass[2] );
1434 HepLorentzVector p4pion2 = mdcKalTrk2->p4( xmass[2] );
1435 HepLorentzVector p4pion3 = mdcKalTrk3->p4( xmass[2] );
1436 HepLorentzVector p4pion4 = mdcKalTrk4->p4( xmass[2] );
1437 HepLorentzVector p4pion5 = mdcKalTrk5->p4( xmass[2] );
1438 m_DC2KsPiPiPi_pion1_pp = p4pion1.rho();
1439 m_DC2KsPiPiPi_pion2_pp = p4pion2.rho();
1440 m_DC2KsPiPiPi_pion3_pp = p4pion3.rho();
1441 m_DC2KsPiPiPi_pion4_pp = p4pion4.rho();
1442 m_DC2KsPiPiPi_pion5_pp = p4pion5.rho();
1443 m_DC2KsPiPiPi_pion1_Id = tracks[0]->trackId();
1444 m_DC2KsPiPiPi_pion2_Id = tracks[1]->trackId();
1445 m_DC2KsPiPiPi_pion3_Id = tracks[2]->trackId();
1446 m_DC2KsPiPiPi_pion4_Id = tracks[3]->trackId();
1447 m_DC2KsPiPiPi_pion5_Id = tracks[4]->trackId();
1448 indexD[MODE]++;
1449 }
1450 } // end of kDptoKsPiPiPi
1451 if ( ( bestDTag )->decayMode() == EvtRecDTag::kDptoKKPi )
1452 {
1453 const int MODE = 10;
1454 fillDecayModeItem( bestDTag, "DC2KKPi" );
1455
1456 RecMdcKalTrack* mdcKalTrk1 = tracks[0]->mdcKalTrack();
1457 RecMdcKalTrack* mdcKalTrk2 = tracks[1]->mdcKalTrack();
1458 RecMdcKalTrack* mdcKalTrk3 = tracks[2]->mdcKalTrack();
1459 RecMdcKalTrack::setPidType( RecMdcKalTrack::kaon );
1460 HepLorentzVector p4kaon1 = mdcKalTrk1->p4( xmass[3] );
1461 HepLorentzVector p4kaon2 = mdcKalTrk2->p4( xmass[3] );
1462 RecMdcKalTrack::setPidType( RecMdcKalTrack::pion );
1463 HepLorentzVector p4pion = mdcKalTrk3->p4( xmass[2] );
1464 m_DC2KKPi_kaon1_pp = p4kaon1.rho();
1465 m_DC2KKPi_kaon2_pp = p4kaon2.rho();
1466 m_DC2KKPi_pion_pp = p4pion.rho();
1467 m_DC2KKPi_kaon1_Id = tracks[0]->trackId();
1468 m_DC2KKPi_kaon2_Id = tracks[1]->trackId();
1469 m_DC2KKPi_pion_Id = tracks[2]->trackId();
1470 indexD[MODE]++;
1471 } // end of kDptoKKPi
1472 if ( ( bestDTag )->charge() == 0 )
1473 {
1474 m_D0_mBC = ( bestDTag )->mBC();
1475 m_D0_deltE = ( bestDTag )->deltaE();
1476 m_D0_mass = ( bestDTag )->mass();
1477 indexD0All++;
1478 }
1479 if ( ( bestDTag )->charge() != 0 )
1480 {
1481 m_DC_mBC = ( bestDTag )->mBC();
1482 m_DC_deltE = ( bestDTag )->deltaE();
1483 m_DC_mass = ( bestDTag )->mass();
1484 indexDCAll++;
1485 }
1486 }
1487 }
1488 m_numAllMode = indexDAll;
1489 m_numD0Mode = indexD0All;
1490 m_numDCMode = indexDCAll;
1491 m_recNumD02KPi = indexD[0];
1492 m_recNumD02KPiPi0 = indexD[1];
1493 m_recNumD02KPiPiPi = indexD[2];
1494 m_recNumD02KPiPiPiPi0 = indexD[3];
1495 m_recNumD02KsPiPi = indexD[4];
1496 m_recNumD02KsPiPiPi0 = indexD[5];
1497 m_recNumDC2KPiPi = indexD[6];
1498 m_recNumDC2KPiPiPi0 = indexD[7];
1499 m_recNumDC2KsPiPi0 = indexD[8];
1500 m_recNumDC2KsPiPiPi = indexD[9];
1501 m_recNumDC2KKPi = indexD[10];
1502 int taggedMode = -1; // 0 ~ 10
1503 for ( int i = 0; i != 11; i++ )
1504 {
1505 if ( indexD[i] == 1 ) { taggedMode = i; }
1506 }
1507
1508 Vint iGood;
1509 // int nCharge = 0;
1510 for ( int i = 0; i < evtRecEvent->totalCharged(); i++ )
1511 {
1512 EvtRecTrackIterator itTrk = evtRecTrkCol->begin() + i;
1513 if ( !( *itTrk )->isMdcTrackValid() ) continue;
1514 if ( !( *itTrk )->isMdcKalTrackValid() ) continue;
1515 RecMdcTrack* mdcTrk = ( *itTrk )->mdcTrack();
1516 RecMdcKalTrack* mdcKalTrk = ( *itTrk )->mdcKalTrack();
1517
1518 double pch = mdcTrk->p();
1519 double x0 = mdcTrk->x();
1520 double y0 = mdcTrk->y();
1521 double z0 = mdcTrk->z();
1522 double phi0 = mdcTrk->helix( 1 );
1523 double xv = xorigin.x();
1524 double yv = xorigin.y();
1525 double Rxy = fabs( ( x0 - xv ) * cos( phi0 ) + ( y0 - yv ) * sin( phi0 ) );
1526 m_vtxTrkId = ( *itTrk )->trackId();
1527 m_vx0 = x0;
1528 m_vy0 = y0;
1529 m_vz0 = z0 - xorigin.z();
1530 m_vr0 = Rxy;
1531 m_Vct = cos( mdcTrk->theta() );
1532 if ( m_writeTuple && m_checkVtx )
1533 // m_tuple2->write();
1534 if ( fabs( m_vz0 ) >= m_vz0cut ) continue;
1535 if ( m_vr0 >= m_vr0cut ) continue;
1536 if ( fabs( m_Vct ) >= m_cthcut ) continue;
1537
1538 iGood.push_back( ( *itTrk )->trackId() );
1539 nCharge += mdcTrk->charge();
1540 }
1541 int nGood = iGood.size();
1542
1543 ////
1544 //// Finish Good Charged Track Selection
1545 ////
1546
1547 if ( m_writeTuple && ( m_checkDedx || m_checkTof ) )
1548 {
1549 Vint iGam;
1550 iGam.clear();
1551 for ( int i = evtRecEvent->totalCharged(); i < evtRecEvent->totalTracks(); i++ )
1552 {
1553 EvtRecTrackIterator itTrk = evtRecTrkCol->begin() + i;
1554 if ( !( *itTrk )->isEmcShowerValid() ) continue;
1555 RecEmcShower* emcTrk = ( *itTrk )->emcShower();
1556 Hep3Vector emcpos( emcTrk->x(), emcTrk->y(), emcTrk->z() );
1557 // find the nearest charged track
1558 double dthe = 200.;
1559 double dphi = 200.;
1560 double dang = 200.;
1561 for ( int j = 0; j < evtRecEvent->totalCharged(); j++ )
1562 {
1563 EvtRecTrackIterator jtTrk = evtRecTrkCol->begin() + j;
1564 if ( !( *jtTrk )->isExtTrackValid() ) continue;
1565 RecExtTrack* extTrk = ( *jtTrk )->extTrack();
1566 if ( extTrk->emcVolumeNumber() == -1 ) continue;
1567 Hep3Vector extpos = extTrk->emcPosition();
1568 // double ctht = extpos.cosTheta(emcpos);
1569 double angd = extpos.angle( emcpos );
1570 double thed = extpos.theta() - emcpos.theta();
1571 double phid = extpos.deltaPhi( emcpos );
1572 thed = fmod( thed + CLHEP::twopi + CLHEP::twopi + pi, CLHEP::twopi ) - CLHEP::pi;
1573 phid = fmod( phid + CLHEP::twopi + CLHEP::twopi + pi, CLHEP::twopi ) - CLHEP::pi;
1574
1575 if ( fabs( thed ) < fabs( dthe ) ) dthe = thed;
1576 if ( fabs( phid ) < fabs( dphi ) ) dphi = phid;
1577 if ( angd < dang ) dang = angd;
1578 }
1579 if ( dang >= 200 ) continue;
1580 double eraw = emcTrk->energy();
1581 dthe = dthe * 180 / ( CLHEP::pi );
1582 dphi = dphi * 180 / ( CLHEP::pi );
1583 dang = dang * 180 / ( CLHEP::pi );
1584 double m_dthe = dthe;
1585 double m_dphi = dphi;
1586 double m_dang = dang;
1587 double m_eraw = eraw;
1588 double theta = cos( emcpos.theta() );
1589 if ( ( fabs( theta ) > m_Barrel_th && fabs( theta ) < m_Endcap_th_1 ) ||
1590 fabs( theta ) > m_Endcap_th_2 )
1591 continue;
1592 // put different cut on barrel and endcap!
1593 if ( ( emcTrk->module() == 0 || emcTrk->module() == 2 ) && eraw < m_energyThreshold_e )
1594 continue;
1595 else if ( emcTrk->module() == 1 && eraw < m_energyThreshold_b ) continue;
1596 // if(eraw < m_energyThreshold) continue;
1597 if ( dang < m_gammaAngCut ) continue;
1598 //
1599 // good photon cut will be set here
1600 //
1601 iGam.push_back( ( *itTrk )->trackId() );
1602 }
1603
1604 //
1605 // Finish Good Photon Selection
1606 //
1607 int nGam = iGam.size();
1608
1609 //
1610 // Assign 4-momentum to each photon
1611 //
1612
1613 Vp4 pGam;
1614 pGam.clear();
1615 for ( int i = 0; i < nGam; i++ )
1616 {
1617 EvtRecTrackIterator itTrk = evtRecTrkCol->begin() + iGam[i];
1618 RecEmcShower* emcTrk = ( *itTrk )->emcShower();
1619 double eraw = emcTrk->energy();
1620 double phi = emcTrk->phi();
1621 double the = emcTrk->theta();
1622 HepLorentzVector ptrk;
1623 ptrk.setPx( eraw * sin( the ) * cos( phi ) );
1624 ptrk.setPy( eraw * sin( the ) * sin( phi ) );
1625 ptrk.setPz( eraw * cos( the ) );
1626 ptrk.setE( eraw );
1627 // ptrk = ptrk.boost(-0.011,0,0);// boost to cms
1628 pGam.push_back( ptrk );
1629 }
1630
1631 //
1632 // check dedx infomation
1633 //
1634 if ( m_checkDedx )
1635 {
1636 m_ngch = nGood;
1637 for ( int ii = 0; ii < nGood; ii++ )
1638 {
1639 // dedx
1640 m_ptrk[ii] = 999.0;
1641 m_chie[ii] = 999.0;
1642 m_chimu[ii] = 999.0;
1643 m_chipi[ii] = 999.0;
1644 m_chik[ii] = 999.0;
1645 m_chip[ii] = 999.0;
1646 m_ghit[ii] = 999.0;
1647 m_thit[ii] = 999.0;
1648 m_probPH[ii] = 1999.0;
1649 m_normPH[ii] = 999.0;
1650 }
1651 int indx0 = 0;
1652 for ( int i = 0; i < nGood; i++ )
1653 {
1654 EvtRecTrackIterator itTrk = evtRecTrkCol->begin() + iGood[i];
1655 if ( !( *itTrk )->isMdcTrackValid() ) continue;
1656 if ( !( *itTrk )->isMdcDedxValid() ) continue;
1657 RecMdcTrack* mdcTrk = ( *itTrk )->mdcTrack();
1658 RecMdcDedx* dedxTrk = ( *itTrk )->mdcDedx();
1659 m_trkiddedx[indx0] = ( *itTrk )->trackId();
1660 m_ptrk[indx0] = mdcTrk->p();
1661 m_chie[indx0] = dedxTrk->chiE();
1662 m_chimu[indx0] = dedxTrk->chiMu();
1663 m_chipi[indx0] = dedxTrk->chiPi();
1664 m_chik[indx0] = dedxTrk->chiK();
1665 m_chip[indx0] = dedxTrk->chiP();
1666 m_ghit[indx0] = dedxTrk->numGoodHits();
1667 m_thit[indx0] = dedxTrk->numTotalHits();
1668 m_probPH[indx0] = dedxTrk->probPH();
1669 m_normPH[indx0] = dedxTrk->normPH();
1670 indx0++;
1671 }
1672 // m_tuple11->write();
1673 } // end chechDedx
1674 //
1675 // check TOF infomation
1676 //
1677 if ( m_checkTof )
1678 {
1679 m_ngch2 = nGood;
1680 for ( int ii = 0; ii < nGood; ii++ )
1681 {
1682 // endtof
1683 m_cntr_etof[ii] = 999.0;
1684 m_ptot_etof[ii] = 999.0;
1685 m_ph_etof[ii] = 999.0;
1686 m_rhit_etof[ii] = 999.0;
1687 m_qual_etof[ii] = 999.0;
1688 m_te_etof[ii] = 999.0;
1689 m_tmu_etof[ii] = 999.0;
1690 m_tpi_etof[ii] = 999.0;
1691 m_tk_etof[ii] = 999.0;
1692 m_tp_etof[ii] = 999.0;
1693 m_ec_tof[ii] = 999.0;
1694 m_ec_toff_e[ii] = 999.0;
1695 m_ec_toff_mu[ii] = 999.0;
1696 m_ec_toff_pi[ii] = 999.0;
1697 m_ec_toff_k[ii] = 999.0;
1698 m_ec_toff_p[ii] = 999.0;
1699 m_ec_tsig_e[ii] = 999.0;
1700 m_ec_tsig_mu[ii] = 999.0;
1701 m_ec_tsig_pi[ii] = 999.0;
1702 m_ec_tsig_k[ii] = 999.0;
1703 m_ec_tsig_p[ii] = 999.0;
1704
1705 // barrel tof
1706 m_cntr_btof1[ii] = 999.0;
1707 m_ptot_btof1[ii] = 999.0;
1708 m_ph_btof1[ii] = 999.0;
1709 m_zhit_btof1[ii] = 999.0;
1710 m_qual_btof1[ii] = 999.0;
1711 m_te_btof1[ii] = 999.0;
1712 m_tmu_btof1[ii] = 999.0;
1713 m_tpi_btof1[ii] = 999.0;
1714 m_tk_btof1[ii] = 999.0;
1715 m_tp_btof1[ii] = 999.0;
1716 m_b1_tof[ii] = 999.0;
1717 m_b1_toff_e[ii] = 999.0;
1718 m_b1_toff_mu[ii] = 999.0;
1719 m_b1_toff_pi[ii] = 999.0;
1720 m_b1_toff_k[ii] = 999.0;
1721 m_b1_toff_p[ii] = 999.0;
1722 m_b1_tsig_e[ii] = 999.0;
1723 m_b1_tsig_mu[ii] = 999.0;
1724 m_b1_tsig_pi[ii] = 999.0;
1725 m_b1_tsig_k[ii] = 999.0;
1726 m_b1_tsig_p[ii] = 999.0;
1727 // pid
1728 // m_dedx_pid[ii] = 999.0;
1729 // m_tof1_pid[ii] = 999.0;
1730 // m_tof2_pid[ii] = 999.0;
1731 // m_prob_pid[ii] = 999.0;
1732 // m_ptrk_pid[ii] = 999.0;
1733 // m_cost_pid[ii] = 999.0;
1734 }
1735 int indx1 = 0;
1736 for ( int i = 0; i < nGood; i++ )
1737 {
1738 EvtRecTrackIterator itTrk = evtRecTrkCol->begin() + iGood[i];
1739 if ( !( *itTrk )->isMdcTrackValid() ) continue;
1740 if ( !( *itTrk )->isTofTrackValid() ) continue;
1741
1742 RecMdcTrack* mdcTrk = ( *itTrk )->mdcTrack();
1743 SmartRefVector<RecTofTrack> tofTrkCol = ( *itTrk )->tofTrack();
1744
1745 double ptrk = mdcTrk->p();
1746 SmartRefVector<RecTofTrack>::iterator iter_tof = tofTrkCol.begin();
1747 for ( ; iter_tof != tofTrkCol.end(); iter_tof++ )
1748 {
1749 TofHitStatus* status = new TofHitStatus;
1750 status->setStatus( ( *iter_tof )->status() );
1751 if ( !( status->is_barrel() ) )
1752 { // endcap
1753 if ( !( status->is_counter() ) ) continue; // ?
1754 if ( status->layer() != 1 ) continue; // layer1
1755 double path = ( *iter_tof )->path(); // ?
1756 double tof = ( *iter_tof )->tof();
1757 double ph = ( *iter_tof )->ph();
1758 double rhit = ( *iter_tof )->zrhit();
1759 double qual = 0.0 + ( *iter_tof )->quality();
1760 double cntr = 0.0 + ( *iter_tof )->tofID();
1761 double texp[5];
1762 double tsig[5];
1763 for ( int j = 0; j < 5; j++ )
1764 { // 0 e, 1 mu, 2 pi, 3 K, 4 p
1765 texp[j] = ( *iter_tof )->texp( j );
1766 // tsig[j] = (*iter_tof)->sigma(j);
1767 // toffset[j] = (*iter_tof)->offset(j);
1768 }
1769 m_trkidtof[indx1] = ( *itTrk )->trackId();
1770 m_cntr_etof[indx1] = cntr;
1771 m_ptot_etof[indx1] = ptrk;
1772 m_ph_etof[indx1] = ph;
1773 m_rhit_etof[indx1] = rhit;
1774 m_qual_etof[indx1] = qual;
1775 m_te_etof[indx1] = tof - texp[0];
1776 m_tmu_etof[indx1] = tof - texp[1];
1777 m_tpi_etof[indx1] = tof - texp[2];
1778 m_tk_etof[indx1] = tof - texp[3];
1779 m_tp_etof[indx1] = tof - texp[4];
1780
1781 m_ec_tof[indx1] = tof;
1782
1783 m_ec_toff_e[indx1] = ( *iter_tof )->toffset( 0 );
1784 m_ec_toff_mu[indx1] = ( *iter_tof )->toffset( 1 );
1785 m_ec_toff_pi[indx1] = ( *iter_tof )->toffset( 2 );
1786 m_ec_toff_k[indx1] = ( *iter_tof )->toffset( 3 );
1787 m_ec_toff_p[indx1] = ( *iter_tof )->toffset( 4 );
1788
1789 m_ec_tsig_e[indx1] = ( *iter_tof )->sigma( 0 );
1790 m_ec_tsig_mu[indx1] = ( *iter_tof )->sigma( 1 );
1791 m_ec_tsig_pi[indx1] = ( *iter_tof )->sigma( 2 );
1792 m_ec_tsig_k[indx1] = ( *iter_tof )->sigma( 3 );
1793 m_ec_tsig_p[indx1] = ( *iter_tof )->sigma( 4 );
1794 }
1795 else
1796 { // barrel
1797 if ( !( status->is_cluster() ) ) continue; // ?
1798 double path = ( *iter_tof )->path(); // ?
1799 double tof = ( *iter_tof )->tof();
1800 double ph = ( *iter_tof )->ph();
1801 double rhit = ( *iter_tof )->zrhit();
1802 double qual = 0.0 + ( *iter_tof )->quality();
1803 double cntr = 0.0 + ( *iter_tof )->tofID();
1804 double texp[5];
1805 for ( int j = 0; j < 5; j++ ) { texp[j] = ( *iter_tof )->texp( j ); }
1806 m_cntr_btof1[indx1] = cntr;
1807 m_ptot_btof1[indx1] = ptrk;
1808 m_ph_btof1[indx1] = ph;
1809 m_zhit_btof1[indx1] = rhit;
1810 m_qual_btof1[indx1] = qual;
1811 m_te_btof1[indx1] = tof - texp[0];
1812 m_tmu_btof1[indx1] = tof - texp[1];
1813 m_tpi_btof1[indx1] = tof - texp[2];
1814 m_tk_btof1[indx1] = tof - texp[3];
1815 m_tp_btof1[indx1] = tof - texp[4];
1816
1817 m_b1_tof[indx1] = tof;
1818
1819 m_b1_toff_e[indx1] = ( *iter_tof )->toffset( 0 );
1820 m_b1_toff_mu[indx1] = ( *iter_tof )->toffset( 1 );
1821 m_b1_toff_pi[indx1] = ( *iter_tof )->toffset( 2 );
1822 m_b1_toff_k[indx1] = ( *iter_tof )->toffset( 3 );
1823 m_b1_toff_p[indx1] = ( *iter_tof )->toffset( 4 );
1824
1825 m_b1_tsig_e[indx1] = ( *iter_tof )->sigma( 0 );
1826 m_b1_tsig_mu[indx1] = ( *iter_tof )->sigma( 1 );
1827 m_b1_tsig_pi[indx1] = ( *iter_tof )->sigma( 2 );
1828 m_b1_tsig_k[indx1] = ( *iter_tof )->sigma( 3 );
1829 m_b1_tsig_p[indx1] = ( *iter_tof )->sigma( 4 );
1830 }
1831 delete status;
1832 }
1833 indx1++;
1834 } // loop all charged track
1835
1836 // m_tuple12->write();
1837 m_nggneu = nGam;
1838 int iphoton = 0;
1839 for ( int i = 0; i < nGam; i++ )
1840 {
1841 EvtRecTrackIterator itTrk = evtRecTrkCol->begin() + iGam[i];
1842 if ( !( *itTrk )->isEmcShowerValid() ) continue;
1843 RecEmcShower* emcTrk = ( *itTrk )->emcShower();
1844 m_shwidtof[iphoton] = ( *itTrk )->trackId();
1845 m_numHits[iphoton] = emcTrk->numHits();
1846 m_secondmoment[iphoton] = emcTrk->secondMoment();
1847 m_x[iphoton] = emcTrk->x();
1848 m_y[iphoton] = emcTrk->y();
1849 m_z[iphoton] = emcTrk->z();
1850 m_cosemc[iphoton] = cos( emcTrk->theta() );
1851 m_phiemc[iphoton] = emcTrk->phi();
1852 m_energy[iphoton] = emcTrk->energy();
1853 m_eSeed[iphoton] = emcTrk->eSeed();
1854 m_e3x3[iphoton] = emcTrk->e3x3();
1855 m_e5x5[iphoton] = emcTrk->e5x5();
1856 m_lat[iphoton] = emcTrk->latMoment();
1857 m_a20[iphoton] = emcTrk->a20Moment();
1858 m_a42[iphoton] = emcTrk->a42Moment();
1859 iphoton++;
1860 }
1861 // m_tuple13->write();
1862 } // end checkTof
1863 }
1864
1865 // DQAHist
1866 if ( m_regHist )
1867 {
1868 if ( taggedMode != -1 )
1869 {
1870 string strdecaymode[11] = { "D02KPi", "D02KPiPi0", "D02KPiPiPi", "D02KPiPiPiPi0",
1871 "D02KsPiPi", "D02KsPiPiPi0", "DC2KPiPi", "DC2KPiPiPi0",
1872 "DC2KsPiPi0", "DC2KsPiPiPi", "DC2KKPi" };
1873 int pi0cut[11] = { 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0 };
1874 int kscut[11] = { 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0 };
1875 string strtrack[14] = { "D02KPi_kaon", "D02KPi_pion", "D02KPiPi0_kaon",
1876 "D02KPiPi0_pion", "D02KsPiPi_pion1", "D02KsPiPi_pion2",
1877 "D02KsPiPi_pion3", "D02KsPiPi_pion4", "DC2KPiPi_kaon",
1878 "DC2KPiPi_pion1", "DC2KPiPi_pion2", "DC2KsPiPi0_pion1",
1879 "DC2KsPiPi0_pion2", "DC2KsPiPi0_pion3" };
1880 // for (int i=0;i!=11;i++)
1881 // {
1882 // fillHistogram(m_thsvc,strdecaymode[i],3,m_decayModeHistName,m_tuple4,pi0cut[i],kscut[i]);
1883 // }
1884 fillHistogram( m_thsvc, strdecaymode[taggedMode], 3, m_decayModeHistName, m_tuple4,
1885 pi0cut[taggedMode], kscut[taggedMode] );
1886 string strDdecaymode[2] = { "D0", "DC" };
1887 // fillHistogram(m_thsvc,strDdecaymode[0],3,m_decayModeHistName,m_tuple4);
1888 // fillHistogram(m_thsvc,strDdecaymode[1],3,m_decayModeHistName,m_tuple4);
1889 if ( taggedMode < 6 )
1890 fillHistogram( m_thsvc, strDdecaymode[0], 3, m_decayModeHistName, m_tuple4 );
1891 else fillHistogram( m_thsvc, strDdecaymode[1], 3, m_decayModeHistName, m_tuple4 );
1892
1893 string strtrackdedx[7] = { "D02KPi_kaon", "D02KPi_pion", "D02KPiPi0_kaon",
1894 "D02KPiPi0_pion", "DC2KPiPi_kaon", "DC2KPiPi_pion1",
1895 "DC2KPiPi_pion2" };
1896 string strtracktof[7] = { "D02KPi_kaon", "D02KPi_pion", "D02KPiPi0_kaon",
1897 "D02KPiPi0_pion", "DC2KPiPi_kaon", "DC2KPiPi_pion1",
1898 "DC2KPiPi_pion2" };
1899 string strphoton[2] = { "D02KPiPi0_photon1", "D02KPiPi0_photon2" };
1900 string strpi0[2] = { "D02KPiPi0", "DC2KsPiPi0" };
1901 string strks[2] = { "D02KsPiPi_ks", "DC2KsPiPi0_ks" };
1902 if ( taggedMode == 0 )
1903 {
1904 if ( g_mBC > 1.86 && g_mBC < 1.87 && fabs( g_deltE ) < 0.03 )
1905 {
1906 fillHistogram( m_thsvc, strtrack[0], 10, m_trackHistName, m_tuple4 );
1907 fillHistogram( m_thsvc, strtrack[1], 10, m_trackHistName, m_tuple4 );
1908 fillHistogram( m_thsvc, strtrackdedx[0], 6, m_trackDedxHistName, m_tuple4 );
1909 fillHistogram( m_thsvc, strtrackdedx[1], 6, m_trackDedxHistName, m_tuple4 );
1910 fillTofHistogram( m_thsvc, strtracktof[0] );
1911 fillTofHistogram( m_thsvc, strtracktof[1] );
1912 }
1913 }
1914 if ( taggedMode == 1 )
1915 {
1916 if ( g_mBC > 1.86 && g_mBC < 1.87 && g_deltE > -0.0583 && g_deltE < 0.035 )
1917 {
1918 fillHistogram( m_thsvc, strtrack[2], 10, m_trackHistName, m_tuple4 );
1919 fillHistogram( m_thsvc, strtrack[3], 10, m_trackHistName, m_tuple4 );
1920
1921 fillHistogram( m_thsvc, strtrackdedx[2], 6, m_trackDedxHistName, m_tuple4 );
1922 fillHistogram( m_thsvc, strtrackdedx[3], 6, m_trackDedxHistName, m_tuple4 );
1923 fillTofHistogram( m_thsvc, strtracktof[2] );
1924 fillTofHistogram( m_thsvc, strtracktof[3] );
1925 fillHistogram( m_thsvc, strphoton[0], 5, m_photonHistName, m_tuple4 );
1926 fillHistogram( m_thsvc, strphoton[1], 5, m_photonHistName, m_tuple4 );
1927
1928 fillHistogram( m_thsvc, strpi0[0], 5, m_Pi0HistName, m_tuple4 );
1929 }
1930 }
1931 if ( taggedMode == 4 )
1932 {
1933 if ( g_mBC > 1.86 && g_mBC < 1.87 && fabs( g_deltE ) < 0.03 )
1934 {
1935 fillHistogram( m_thsvc, strtrack[4], 10, m_trackHistName, m_tuple4 );
1936 fillHistogram( m_thsvc, strtrack[5], 10, m_trackHistName, m_tuple4 );
1937 fillHistogram( m_thsvc, strtrack[6], 10, m_trackHistName, m_tuple4 );
1938 fillHistogram( m_thsvc, strtrack[7], 10, m_trackHistName, m_tuple4 );
1939
1940 fillHistogram( m_thsvc, strks[0], 4, m_KsHistName, m_tuple4 );
1941 }
1942 }
1943 if ( taggedMode == 6 )
1944 {
1945 if ( g_mBC > 1.86 && g_mBC < 1.87 && fabs( g_deltE ) < 0.0218 )
1946 {
1947 fillHistogram( m_thsvc, strtrack[8], 10, m_trackHistName, m_tuple4 );
1948 fillHistogram( m_thsvc, strtrack[9], 10, m_trackHistName, m_tuple4 );
1949 fillHistogram( m_thsvc, strtrack[10], 10, m_trackHistName, m_tuple4 );
1950 fillTofHistogram( m_thsvc, strtracktof[4] );
1951 fillTofHistogram( m_thsvc, strtracktof[5] );
1952 fillTofHistogram( m_thsvc, strtracktof[6] );
1953 fillHistogram( m_thsvc, strtrackdedx[4], 6, m_trackDedxHistName, m_tuple4 );
1954 fillHistogram( m_thsvc, strtrackdedx[5], 6, m_trackDedxHistName, m_tuple4 );
1955 fillHistogram( m_thsvc, strtrackdedx[6], 6, m_trackDedxHistName, m_tuple4 );
1956 }
1957 }
1958 if ( taggedMode == 8 )
1959 {
1960 if ( g_mBC > 1.86 && g_mBC < 1.87 && g_deltE < 0.0423 && g_deltE > -0.0455 )
1961 {
1962 fillHistogram( m_thsvc, strtrack[11], 10, m_trackHistName, m_tuple4 );
1963 fillHistogram( m_thsvc, strtrack[12], 10, m_trackHistName, m_tuple4 );
1964 fillHistogram( m_thsvc, strtrack[13], 10, m_trackHistName, m_tuple4 );
1965
1966 fillHistogram( m_thsvc, strpi0[1], 5, m_Pi0HistName, m_tuple4 );
1967 fillHistogram( m_thsvc, strks[1], 4, m_KsHistName, m_tuple4 );
1968 }
1969 }
1970 }
1971 }
1972 if ( m_writeTuple ) { m_tuple4->write().ignore(); }
1973 if ( m_writeTuple && m_checkEvt )
1974 {
1975 // m_tuple5->write();
1976 }
1977 // if (m_checkDedx)
1978 // m_tuple16->write();
1979 // if (m_checkTof)
1980 // m_tuple17->write();
1981
1982 setFilterPassed( true );
1983
1984 return StatusCode::SUCCESS;
1985}
1986
1987void DQADtag::regTrackHistogram( ITHistSvc*&, string& str ) {
1988 MsgStream log( msgSvc(), name() );
1989 const int NUM = 10;
1990 TString hisname[NUM];
1991 TString strHisReg[NUM];
1992 TString strHisLog[NUM];
1993 for ( int i = 0; i != NUM; i++ )
1994 {
1995 hisname[i] = str + "_" + m_trackHistName[i]; // D02KPi_k_px ...
1996 strHisLog[i] = "Couldn't register " + hisname[i];
1997 strHisReg[i] = "/DQAHist/Dtag/" + hisname[i];
1998 if ( m_debug ) cout << "hisname: " << hisname[i] << endl;
1999 if ( m_debug ) cout << "strHisReg: " << strHisReg[i] << endl;
2000 }
2001 TH1F* hist[10];
2002 hist[0] = new TH1F( hisname[0], hisname[0], 100, -1.1, 1.1 );
2003 hist[1] = new TH1F( hisname[1], hisname[1], 100, -1.1, 1.1 );
2004 hist[2] = new TH1F( hisname[2], hisname[2], 100, -1.1, 1.1 );
2005 hist[3] = new TH1F( hisname[3], hisname[3], 200, 0., 1.2 );
2006 hist[4] = new TH1F( hisname[4], hisname[4], 100, -1., 1. );
2007 hist[5] = new TH1F( hisname[5], hisname[5], 100, -1., 1. );
2008 hist[6] = new TH1F( hisname[6], hisname[6], 100, -10., 10. );
2009 hist[7] = new TH1F( hisname[7], hisname[7], 100, -1., 1. );
2010 hist[8] = new TH1F( hisname[8], hisname[8], 100, -1., 1. );
2011 hist[9] = new TH1F( hisname[9], hisname[9], 200, 0., 1.4 );
2012 for ( int i = 0; i != NUM; i++ )
2013 {
2014 if ( m_thsvc->regHist( (string)strHisReg[i], hist[i] ).isFailure() )
2015 { log << MSG::ERROR << strHisLog[i] << endmsg; }
2016 }
2017}
2018void DQADtag::regPhotonHistogram( ITHistSvc*&, string& str ) {
2019 MsgStream log( msgSvc(), name() );
2020 const int NUM = 5;
2021 TString hisname[NUM];
2022 TString strHisReg[NUM];
2023 TString strHisLog[NUM];
2024 for ( int i = 0; i != NUM; i++ )
2025 {
2026 hisname[i] = str + "_" + m_photonHistName[i]; // D02KPi_k_px ...
2027 strHisLog[i] = "Couldn't register " + hisname[i];
2028 strHisReg[i] = "/DQAHist/Dtag/" + hisname[i];
2029 if ( m_debug ) cout << "hisname: " << hisname[i] << endl;
2030 if ( m_debug ) cout << "strHisReg: " << strHisReg[i] << endl;
2031 }
2032 TH1F* hist[5];
2033 hist[0] = new TH1F( hisname[0], hisname[0], 80, 0, 40 );
2034 hist[1] = new TH1F( hisname[1], hisname[1], 160, 0, 80 );
2035 hist[2] = new TH1F( hisname[2], hisname[2], 100, -100., 100. );
2036 hist[3] = new TH1F( hisname[3], hisname[3], 100, -100., 100. );
2037 hist[4] = new TH1F( hisname[4], hisname[4], 100, -150., 150. );
2038 for ( int i = 0; i != NUM; i++ )
2039 {
2040 if ( m_thsvc->regHist( (string)strHisReg[i], hist[i] ).isFailure() )
2041 { log << MSG::ERROR << strHisLog[i] << endmsg; }
2042 }
2043}
2044
2045void DQADtag::regTrackDedxHistogram( ITHistSvc*&, string& str ) {
2046 MsgStream log( msgSvc(), name() );
2047 const int NUM = 6;
2048 TString hisname[NUM];
2049 TString strHisReg[NUM];
2050 TString strHisLog[NUM];
2051 for ( int i = 0; i != NUM; i++ )
2052 {
2053 hisname[i] = str + "_" + m_trackDedxHistName[i]; // D02KPi_dedx_chik
2054 strHisLog[i] = "Couldn't register " + hisname[i];
2055 strHisReg[i] = "/DQAHist/Dtag/" + hisname[i];
2056 if ( m_debug ) cout << "hisname: " << hisname[i] << endl;
2057 if ( m_debug ) cout << "strHisReg: " << strHisReg[i] << endl;
2058 }
2059 TH1F* hist[6];
2060 hist[0] = new TH1F( hisname[0], hisname[0], 200, -3., 5. );
2061 hist[1] = new TH1F( hisname[1], hisname[1], 200, -2., 15. );
2062 hist[2] = new TH1F( hisname[2], hisname[2], 80, 0, 40 );
2063 hist[3] = new TH1F( hisname[3], hisname[3], 120, 0, 60 );
2064 hist[4] = new TH1F( hisname[4], hisname[4], 100, 200, 1400 );
2065 hist[5] = new TH1F( hisname[5], hisname[5], 100, 0.6, 1.5 );
2066 for ( int i = 0; i != NUM; i++ )
2067 {
2068 if ( m_thsvc->regHist( (string)strHisReg[i], hist[i] ).isFailure() )
2069 { log << MSG::ERROR << strHisLog[i] << endmsg; }
2070 }
2071}
2072void DQADtag::regTrackTofHistogram( ITHistSvc*&, string& str ) {
2073 MsgStream log( msgSvc(), name() );
2074 const int NUM = 24;
2075 TString hisname[NUM];
2076 TString strHisReg[NUM];
2077 TString strHisLog[NUM];
2078 string tofReadOutID[7] = { "1", "2", "3", "4", "12", "34", "1234" };
2079 int num( 0 );
2080 for ( int i = 0; i != 3; i++ )
2081 {
2082 for ( int j = 0; j != 7; j++ )
2083 {
2084 num = i * 7 + j;
2085 hisname[num] =
2086 str + "_" + m_trackTofHistName[i] + "_" + tofReadOutID[j]; // D02KPi_dedx_chik
2087 strHisLog[num] = "Couldn't register " + hisname[num];
2088 strHisReg[num] = "/DQAHist/Dtag/" + hisname[num];
2089 // strHisLog[num] = "Couldn't register " + hisname[num] + "_" + sprintf("%d",j);
2090 // strHisReg[num] = "/DQAHist/Dtag/" + hisname[num] + "_" + sprintf("%d",j);
2091 if ( m_debug ) cout << "hisname: " << hisname[num] << endl;
2092 if ( m_debug ) cout << "strHisReg: " << strHisReg[num] << endl;
2093 }
2094 }
2095 for ( int i = 3; i != 6; i++ )
2096 {
2097 num = 3 * 6 + i;
2098 hisname[num] = str + "_" + m_trackTofHistName[i]; // D02KPi_dedx_chik
2099 strHisLog[num] = "Couldn't register " + hisname[num];
2100 strHisReg[num] = "/DQAHist/Dtag/" + hisname[num];
2101 }
2102 TH1F* hist[24];
2103 for ( int i = 0; i != 24; i++ )
2104 { hist[i] = new TH1F( hisname[i], hisname[i], 100, -4.0, 4. ); }
2105 for ( int i = 0; i != NUM; i++ )
2106 {
2107 if ( m_thsvc->regHist( (string)strHisReg[i], hist[i] ).isFailure() )
2108 { log << MSG::ERROR << strHisLog[i] << endmsg; }
2109 }
2110}
2111void DQADtag::regDecayModeHistogram( ITHistSvc*&, string& str ) {
2112 MsgStream log( msgSvc(), name() );
2113 const int NUM = 3;
2114 TString hisname[NUM];
2115 TString strHisReg[NUM];
2116 TString strHisLog[NUM];
2117 for ( int i = 0; i != NUM; i++ )
2118 {
2119 hisname[i] = str + "_" + m_decayModeHistName[i]; // D02KPi_dedx_chik
2120 strHisLog[i] = "Couldn't register " + hisname[i];
2121 strHisReg[i] = "/DQAHist/Dtag/" + hisname[i];
2122 if ( m_debug ) cout << "hisname: " << hisname[i] << endl;
2123 if ( m_debug ) cout << "strHisReg: " << strHisReg[i] << endl;
2124 }
2125 TH1F* hist[3];
2126 hist[0] = new TH1F( hisname[0], hisname[0], 100, 1.83, 1.89 );
2127 hist[1] = new TH1F( hisname[1], hisname[1], 100, -0.1, 0.1 );
2128 hist[2] = new TH1F( hisname[2], hisname[2], 100, 1.83, 1.89 );
2129 for ( int i = 0; i != NUM; i++ )
2130 {
2131 if ( m_thsvc->regHist( (string)strHisReg[i], hist[i] ).isFailure() )
2132 { log << MSG::ERROR << strHisLog[i] << endmsg; }
2133 }
2134}
2135void DQADtag::regKsHistogram( ITHistSvc*&, string& str ) {
2136 MsgStream log( msgSvc(), name() );
2137 const int NUM = 4;
2138 TString hisname[NUM];
2139 TString strHisReg[NUM];
2140 TString strHisLog[NUM];
2141 TH1F* hist[4];
2142 for ( int i = 0; i != NUM; i++ )
2143 {
2144 hisname[i] = str + "_ks_" + m_KsHistName[i]; // D02KPi_dedx_chik
2145 strHisLog[i] = "Couldn't register " + hisname[i];
2146 strHisReg[i] = "/DQAHist/Dtag/" + hisname[i];
2147 if ( m_debug ) cout << "hisname: " << hisname[i] << endl;
2148 if ( m_debug ) cout << "strHisReg: " << strHisReg[i] << endl;
2149 }
2150 hist[0] = new TH1F( hisname[0], hisname[0], 100, 0.46, 0.54 );
2151 hist[1] = new TH1F( hisname[1], hisname[1], 100, 0.46, 0.54 );
2152 hist[2] = new TH1F( hisname[2], hisname[2], 100, 0, 30 );
2153 hist[3] = new TH1F( hisname[3], hisname[3], 100, 0, 30 );
2154 for ( int i = 0; i != NUM; i++ )
2155 {
2156 if ( m_thsvc->regHist( (string)strHisReg[i], hist[i] ).isFailure() )
2157 { log << MSG::ERROR << strHisLog[i] << endmsg; }
2158 }
2159}
2160void DQADtag::regPi0Histogram( ITHistSvc*&, string& str ) {
2161 MsgStream log( msgSvc(), name() );
2162 const int NUM = 5;
2163 TString hisname[NUM];
2164 TString strHisReg[NUM];
2165 TString strHisLog[NUM];
2166 TH1F* hist[5];
2167 for ( int i = 0; i != NUM; i++ )
2168 {
2169 hisname[i] = str + "_" + m_Pi0HistName[i]; // D02KPi_dedx_chik
2170 strHisLog[i] = "Couldn't register " + hisname[i];
2171 strHisReg[i] = "/DQAHist/Dtag/" + hisname[i];
2172 if ( m_debug ) cout << "hisname: " << hisname[i] << endl;
2173 if ( m_debug ) cout << "strHisReg: " << strHisReg[i] << endl;
2174 }
2175 hist[0] = new TH1F( hisname[0], hisname[0], 100, 0.08, 0.18 );
2176 hist[1] = new TH1F( hisname[1], hisname[1], 100, 0.0, 1.0 );
2177 hist[2] = new TH1F( hisname[2], hisname[2], 100, -1.0, 1.0 );
2178 hist[3] = new TH1F( hisname[3], hisname[3], 100, 0.0, 1.0 );
2179 hist[4] = new TH1F( hisname[4], hisname[4], 100, -1.0, 1.0 );
2180 for ( int i = 0; i != NUM; i++ )
2181 {
2182 if ( m_thsvc->regHist( (string)strHisReg[i], hist[i] ).isFailure() )
2183 { log << MSG::ERROR << strHisLog[i] << endmsg; }
2184 }
2185}
2186void DQADtag::fillHistogram( ITHistSvc*&, string str, int NUM, string* fillHistName,
2187 NTuple::Tuple*& m_tuple ) {
2188 MsgStream log( msgSvc(), name() );
2189 string* strVarName = new string[NUM];
2190 string* strHisGet = new string[NUM];
2191 string* strHisLog = new string[NUM];
2192 TH1* hist;
2193 for ( int i = 0; i != NUM; i++ )
2194 {
2195 strVarName[i] = str + "_" + fillHistName[i]; //
2196 strHisLog[i] = "Couldn't retrieve " + strVarName[i];
2197 strHisGet[i] = "/DQAHist/Dtag/" + strVarName[i];
2198 // cout<<"strVarName: "<<strVarName[i]<<endl;
2199 // cout<<"strHisGet: "<<strHisGet[i]<<endl;
2200 NTuple::Item<double> m_Variable;
2201 m_tuple->item( strVarName[i], m_Variable ).ignore();
2202 if ( m_thsvc->getHist( strHisGet[i], hist ).isSuccess() ) { hist->Fill( m_Variable ); }
2203 else { log << MSG::ERROR << strHisLog[i] << endmsg; }
2204 }
2205 // delete [] hist;
2206 delete[] strVarName;
2207 delete[] strHisGet;
2208 delete[] strHisLog;
2209}
2210void DQADtag::fillHistogram( ITHistSvc*&, string str, int NUM, string* fillHistName,
2211 NTuple::Tuple*& m_tuple, int pi0cut, int kscut ) {
2212 MsgStream log( msgSvc(), name() );
2213 string* strVarName = new string[NUM];
2214 string* strHisGet = new string[NUM];
2215 string* strHisLog = new string[NUM];
2216 TH1* hist;
2217 NTuple::Item<double> m_Variable0;
2218 NTuple::Item<double> m_Variable1;
2219 NTuple::Item<double> m_Variable2;
2220 NTuple::Item<double> m_Variable3;
2221 if ( pi0cut ) m_tuple->item( str + "_pi0mass", m_Variable0 ).ignore();
2222 if ( kscut ) m_tuple->item( str + "_ks_vfitmass", m_Variable1 ).ignore();
2223 m_tuple->item( str + "_deltE", m_Variable2 ).ignore();
2224 m_tuple->item( str + "_mBC", m_Variable3 ).ignore();
2225 for ( int i = 0; i != NUM; i++ )
2226 {
2227 strVarName[i] = str + "_" + fillHistName[i]; // D02KPi_kaon_px ...
2228 strHisLog[i] = "Couldn't retrieve " + strVarName[i];
2229 strHisGet[i] = "/DQAHist/Dtag/" + strVarName[i];
2230 // cout<<"strVarName: "<<strVarName[i]<<endl;
2231 // cout<<"strHisGet: "<<strHisGet[i]<<endl;
2232 NTuple::Item<double> m_Variable;
2233 m_tuple->item( strVarName[i], m_Variable ).ignore();
2234 if ( m_thsvc->getHist( strHisGet[i], hist ).isSuccess() )
2235 {
2236 bool isfill = 1;
2237 if ( pi0cut )
2238 {
2239 if ( m_Variable0 > m_mpi0MaxCut || m_Variable0 < m_mpi0MinCut ) isfill = 0;
2240 }
2241 if ( kscut )
2242 {
2243 if ( m_Variable1 > m_mKsMaxCut || m_Variable1 < m_mKsMinCut ) isfill = 0;
2244 }
2245 if ( i == 0 )
2246 {
2247 if ( fabs( m_Variable2 ) > 0.03 ) isfill = 0;
2248 }
2249 if ( i == 1 )
2250 {
2251 if ( m_Variable3 > 1.87 || m_Variable3 < 1.86 ) isfill = 0;
2252 }
2253 if ( i == 2 )
2254 {
2255 if ( m_Variable3 > 1.87 || m_Variable3 < 1.86 || fabs( m_Variable2 ) > 0.03 )
2256 isfill = 0;
2257 }
2258 if ( isfill == 1 ) { hist->Fill( m_Variable ); }
2259 }
2260 else { log << MSG::ERROR << strHisLog[i] << endmsg; }
2261 }
2262 // delete [] hist;
2263 delete[] strVarName;
2264 delete[] strHisGet;
2265 delete[] strHisLog;
2266}
2267void DQADtag::fillTofHistogram( ITHistSvc*&, string str ) {
2268 MsgStream log( msgSvc(), name() );
2269 string strVarName[6];
2270 string strHisGet[24];
2271 string strHisLog[24];
2272 TH1* hist;
2273 string tofReadOutID[7] = { "1", "2", "3", "4", "12", "34", "1234" };
2274 for ( int i = 0; i != 3; i++ )
2275 {
2276 strVarName[i] = str + "_" + m_trackTofHistName[i]; // D02KPi_kaon_px ...
2277 // cout<<"strVarName: "<<strVarName[i]<<endl;
2278 // cout<<"strHisGet: "<<strHisGet[i]<<endl;
2279 NTuple::Array<double> m_Variable;
2280 m_tuple4->item( strVarName[i], m_Variable ).ignore();
2281 for ( int j = 0; j != 7; j++ )
2282 {
2283 int num = i * 7 + j;
2284 strHisLog[num] = "Couldn't retrieve " + strVarName[i] + "_" + tofReadOutID[j];
2285 strHisGet[num] = "/DQAHist/Dtag/" + strVarName[i] + "_" + tofReadOutID[j];
2286 if ( m_thsvc->getHist( strHisGet[num], hist ).isSuccess() )
2287 { hist->Fill( m_Variable[j] ); }
2288 else { log << MSG::ERROR << strHisLog[num] << endmsg; }
2289 }
2290 }
2291 for ( int i = 3; i != 6; i++ )
2292 {
2293 int num = 3 * 6 + i;
2294 strVarName[i] = str + "_" + m_trackTofHistName[i]; // D02KPi_kaon_px ...
2295 strHisLog[num] = "Couldn't retrieve " + strVarName[i];
2296 strHisGet[num] = "/DQAHist/Dtag/" + strVarName[i];
2297 // cout<<"strVarName: "<<strVarName[i]<<endl;
2298 // cout<<"strHisGet: "<<strHisGet[num]<<endl;
2299 NTuple::Item<double> m_Variable;
2300 m_tuple4->item( strVarName[i], m_Variable ).ignore();
2301 if ( m_thsvc->getHist( strHisGet[num], hist ).isSuccess() ) { hist->Fill( m_Variable ); }
2302 else { log << MSG::ERROR << strHisLog[num] << endmsg; }
2303 }
2304 // delete [] hist;
2305}
2306void DQADtag::fillHistogram( ITHistSvc*&, string str, int NUM, string* fillHistName,
2307 int tuplenum, bool cut ) {
2308 MsgStream log( msgSvc(), name() );
2309 string* strVarName = new string[NUM];
2310 string* strHisGet = new string[NUM];
2311 string* strHisLog = new string[NUM];
2312 TH1* hist;
2313 string pi0VarName = str + "_pi0mass";
2314 NTuple::Item<double> m_pi0Variable;
2315 m_tuple4->item( pi0VarName, m_pi0Variable ).ignore();
2316 for ( int i = 0; i != NUM; i++ )
2317 {
2318 strVarName[i] = str + "_" + fillHistName[i]; // D02KPi_k_px ...
2319 strHisLog[i] = "Couldn't retrieve " + strVarName[i];
2320 strHisGet[i] = "/DQAHist/Dtag/" + strVarName[i];
2321 // cout<<"strVarName: "<<strVarName[i]<<endl;
2322 // cout<<"strHisGet: "<<strHisGet[i]<<endl;
2323 NTuple::Item<double> m_Variable;
2324 m_tuple4->item( strVarName[i], m_Variable ).ignore();
2325 if ( m_thsvc->getHist( strHisGet[i], hist ).isSuccess() )
2326 {
2327 if ( !( m_pi0Variable > m_mpi0Max || m_pi0Variable < m_mpi0Min ) )
2328 { hist->Fill( m_Variable ); }
2329 }
2330 else { log << MSG::ERROR << strHisLog[i] << endmsg; }
2331 }
2332 delete[] strVarName;
2333 delete[] strHisGet;
2334 delete[] strHisLog;
2335}
2336void DQADtag::fillDecayModeItem( EvtRecDTag* bestDTag, string str ) {
2337 string strVarName[6];
2338 // for (int i=0;i!=6;i++)
2339 //{
2340 ////cout<<"m_DecayModeItemName: "<<m_DecayModeItemName[i]<<endl;
2341 //}
2342 for ( int i = 0; i != 6; i++ )
2343 {
2344 strVarName[i] = str + "_" + m_DecayModeItemName[i];
2345 // cout<<" "<<strVarName[i]<<endl;
2346 }
2347 NTuple::Item<double> m_Variable0;
2348 NTuple::Item<double> m_Variable1;
2349 NTuple::Item<double> m_Variable2;
2350 NTuple::Item<double> m_Variable3;
2351 NTuple::Item<double> m_Variable4;
2352 NTuple::Item<double> m_Variable5;
2353 m_tuple4->item( strVarName[0], m_Variable0 ).ignore();
2354 m_tuple4->item( strVarName[1], m_Variable1 ).ignore();
2355 m_tuple4->item( strVarName[2], m_Variable2 ).ignore();
2356 m_tuple4->item( strVarName[3], m_Variable3 ).ignore();
2357 m_tuple4->item( strVarName[4], m_Variable4 ).ignore();
2358 m_tuple4->item( strVarName[5], m_Variable5 ).ignore();
2359 m_Variable0 = ( bestDTag )->mBC();
2360 m_Variable1 = ( bestDTag )->deltaE();
2361 m_Variable2 = ( bestDTag )->p4().rho();
2362 m_Variable3 = ( bestDTag )->charm();
2363 m_Variable4 = ( bestDTag )->mass();
2364 m_Variable5 = ( bestDTag )->beamE();
2365}
2366void DQADtag::fillTrackItem( EvtRecTrack* track, string str, int type, Hep3Vector& xorigin ) {
2367 string strVarName[11];
2368 for ( int i = 0; i != 11; i++ )
2369 {
2370 strVarName[i] = str + "_" + m_TrackItemName[i];
2371 // cout<<"strVarName: "<<strVarName[i]<<endl;
2372 }
2373 NTuple::Item<double> m_Variable0;
2374 NTuple::Item<double> m_Variable1;
2375 NTuple::Item<double> m_Variable2;
2376 NTuple::Item<double> m_Variable3;
2377 NTuple::Item<double> m_Variable4;
2378 NTuple::Item<double> m_Variable5;
2379 NTuple::Item<double> m_Variable6;
2380 NTuple::Item<double> m_Variable7;
2381 NTuple::Item<double> m_Variable8;
2382 NTuple::Item<double> m_Variable9;
2383 NTuple::Item<long> m_Variable10;
2384 m_tuple4->item( strVarName[0], m_Variable0 ).ignore();
2385 m_tuple4->item( strVarName[1], m_Variable1 ).ignore();
2386 m_tuple4->item( strVarName[2], m_Variable2 ).ignore();
2387 m_tuple4->item( strVarName[3], m_Variable3 ).ignore();
2388 m_tuple4->item( strVarName[4], m_Variable4 ).ignore();
2389 m_tuple4->item( strVarName[5], m_Variable5 ).ignore();
2390 m_tuple4->item( strVarName[6], m_Variable6 ).ignore();
2391 m_tuple4->item( strVarName[7], m_Variable7 ).ignore();
2392 m_tuple4->item( strVarName[8], m_Variable8 ).ignore();
2393 m_tuple4->item( strVarName[9], m_Variable9 ).ignore();
2394 m_tuple4->item( strVarName[10], m_Variable10 ).ignore();
2395 RecMdcKalTrack* mdcKalTrk = track->mdcKalTrack();
2396 if ( type == 2 ) RecMdcKalTrack::setPidType( RecMdcKalTrack::pion );
2397 else if ( type == 3 ) RecMdcKalTrack::setPidType( RecMdcKalTrack::kaon );
2398 HepLorentzVector p4trk = mdcKalTrk->p4( xmass[type] );
2399
2400 HepVector a = mdcKalTrk->helix();
2401 HepSymMatrix Ea = mdcKalTrk->err();
2402 HepPoint3D point0( 0., 0., 0. ); // the initial point for MDC recosntruction
2403 HepPoint3D IP( xorigin[0], xorigin[1], xorigin[2] );
2404 VFHelix helixip( point0, a, Ea );
2405 helixip.pivot( IP );
2406 HepVector vecipa = helixip.a();
2407
2408 m_Variable0 = p4trk.px();
2409 m_Variable1 = p4trk.py();
2410 m_Variable2 = p4trk.pz();
2411 m_Variable3 = p4trk.rho();
2412 m_Variable4 = mdcKalTrk->dr() * cos( mdcKalTrk->fi0() );
2413 m_Variable5 = mdcKalTrk->dr() * sin( mdcKalTrk->fi0() );
2414 m_Variable6 = mdcKalTrk->dz();
2415 m_Variable7 = fabs( vecipa[0] ); // the nearest distance to IP in xy plane
2416 m_Variable8 = p4trk.cosTheta();
2417 m_Variable9 = p4trk.e();
2418 m_Variable10 = track->trackId();
2419}
2420void DQADtag::fillPhotonItem( EvtRecTrack* shower, string str ) {
2421 string strVarName[6];
2422 for ( int i = 0; i != 6; i++ )
2423 {
2424 strVarName[i] = str + "_" + m_PhotonItemName[i];
2425 // cout<<"strVarName: "<<strVarName[i]<<endl;
2426 }
2427 NTuple::Item<double> m_Variable0;
2428 NTuple::Item<double> m_Variable1;
2429 NTuple::Item<double> m_Variable2;
2430 NTuple::Item<double> m_Variable3;
2431 NTuple::Item<double> m_Variable4;
2432 NTuple::Item<long> m_Variable5;
2433 m_tuple4->item( strVarName[0], m_Variable0 ).ignore();
2434 m_tuple4->item( strVarName[1], m_Variable1 ).ignore();
2435 m_tuple4->item( strVarName[2], m_Variable2 ).ignore();
2436 m_tuple4->item( strVarName[3], m_Variable3 ).ignore();
2437 m_tuple4->item( strVarName[4], m_Variable4 ).ignore();
2438 m_tuple4->item( strVarName[5], m_Variable5 ).ignore();
2439 RecEmcShower* emcTrk = shower->emcShower();
2440 m_Variable0 = emcTrk->numHits();
2441 m_Variable1 = emcTrk->secondMoment();
2442 m_Variable2 = emcTrk->x();
2443 m_Variable3 = emcTrk->y();
2444 m_Variable4 = emcTrk->z();
2445 m_Variable5 = shower->trackId();
2446}
2447void DQADtag::fillPi0Item( SmartRefVector<EvtRecTrack> showers, string str,
2448 DQAPi0Info* pi0info ) {
2449 string strVarName[7];
2450 for ( int i = 0; i != 7; i++ )
2451 {
2452 strVarName[i] = str + "_" + m_Pi0ItemName[i];
2453 // cout<<"strVarName: "<<strVarName[i]<<endl;
2454 }
2455 // DQAPi0Info pi0info;
2456 // pi0info.setchilds(showers[0],showers[1]);
2457 // if (!pi0info.calculate()) return false;
2458 // if (pi0info.m() >m_mpi0Max || pi0info.m() < m_mpi0Min)
2459 // iswritten = 0;
2460 NTuple::Item<double> m_Variable0;
2461 NTuple::Item<double> m_Variable1;
2462 NTuple::Item<double> m_Variable2;
2463 NTuple::Item<double> m_Variable3;
2464 NTuple::Item<double> m_Variable4;
2465 NTuple::Item<long> m_Variable5;
2466 NTuple::Item<long> m_Variable6;
2467 m_tuple4->item( strVarName[0], m_Variable0 ).ignore();
2468 m_tuple4->item( strVarName[1], m_Variable1 ).ignore();
2469 m_tuple4->item( strVarName[2], m_Variable2 ).ignore();
2470 m_tuple4->item( strVarName[3], m_Variable3 ).ignore();
2471 m_tuple4->item( strVarName[4], m_Variable4 ).ignore();
2472 m_tuple4->item( strVarName[5], m_Variable5 ).ignore();
2473 m_tuple4->item( strVarName[6], m_Variable6 ).ignore();
2474 m_Variable0 = pi0info->m();
2475 m_Variable1 = showers[0]->emcShower()->energy();
2476 m_Variable2 = cos( showers[0]->emcShower()->theta() );
2477 m_Variable3 = showers[1]->emcShower()->energy();
2478 m_Variable4 = cos( showers[1]->emcShower()->theta() );
2479 m_Variable5 = showers[0]->trackId();
2480 m_Variable6 = showers[1]->trackId();
2481}
2482void DQADtag::fillKsItem( SmartRefVector<EvtRecTrack> tracks, string str, DQAKsInfo* ksinfo ) {
2483 string strVarName[6];
2484 for ( int i = 0; i != 6; i++ )
2485 {
2486 strVarName[i] = str + "_ks_" + m_KsItemName[i];
2487 // cout<<"strVarName: "<<strVarName[i]<<endl;
2488 }
2489 // DQAKsInfo ksinfo;
2490 // ksinfo.setchilds(tracks[0],tracks[1]);
2491 // ksinfo.setVtxPar(m_vxpar);
2492 // ksinfo.setPrimaryVtxPar(m_privxpar);
2493 // if (!ksinfo.calculate()) return false;
2494 NTuple::Item<double> m_Variable0;
2495 NTuple::Item<double> m_Variable1;
2496 NTuple::Item<double> m_Variable2;
2497 NTuple::Item<double> m_Variable3;
2498 NTuple::Item<double> m_Variable4;
2499 NTuple::Item<double> m_Variable5;
2500 m_tuple4->item( strVarName[0], m_Variable0 ).ignore();
2501 m_tuple4->item( strVarName[1], m_Variable1 ).ignore();
2502 m_tuple4->item( strVarName[2], m_Variable2 ).ignore();
2503 m_tuple4->item( strVarName[3], m_Variable3 ).ignore();
2504 m_tuple4->item( strVarName[4], m_Variable4 ).ignore();
2505 m_tuple4->item( strVarName[5], m_Variable5 ).ignore();
2506 m_Variable0 = ksinfo->m();
2507 m_Variable1 = ksinfo->mksp4();
2508 m_Variable2 = ksinfo->vtxChi2();
2509 m_Variable3 = ksinfo->chi2();
2510 m_Variable4 = ksinfo->decayLength();
2511 m_Variable5 = ksinfo->decayLengthRatio();
2512}
2513
2514void DQADtag::fillTrackTofItem( EvtRecTrack* track, string str, int type ) {
2515 string strVarName[8];
2516 int numtag( 0 );
2517 for ( int i = 0; i != 8; i++ )
2518 {
2519 strVarName[i] = str + "_" + m_TrackTofItemName[i];
2520 // cout<<"strVarName: "<<strVarName[i]<<endl;
2521 }
2522 NTuple::Array<double> m_Variable0;
2523 NTuple::Array<double> m_Variable1;
2524 NTuple::Array<double> m_Variable2;
2525 NTuple::Item<double> m_Variable3;
2526 NTuple::Item<double> m_Variable4;
2527 NTuple::Item<double> m_Variable5;
2528 NTuple::Item<long> m_Variable6;
2529 NTuple::Item<long> m_Variable7;
2530 m_tuple4->item( strVarName[0], m_Variable0 ).ignore();
2531 m_tuple4->item( strVarName[1], m_Variable1 ).ignore();
2532 m_tuple4->item( strVarName[2], m_Variable2 ).ignore();
2533 m_tuple4->item( strVarName[3], m_Variable3 ).ignore();
2534 m_tuple4->item( strVarName[4], m_Variable4 ).ignore();
2535 m_tuple4->item( strVarName[5], m_Variable5 ).ignore();
2536 m_tuple4->item( strVarName[6], m_Variable6 ).ignore();
2537 m_tuple4->item( strVarName[7], m_Variable7 ).ignore();
2538 m_Variable6 = track->trackId();
2539 m_Variable7 = 10;
2540 for ( int i = 0; i != 7; i++ )
2541 {
2542 m_Variable0[i] = 999.9;
2543 m_Variable1[i] = 999.9;
2544 m_Variable2[i] = 999.9;
2545 }
2546 m_Variable3 = 999.9;
2547 m_Variable4 = 999.9;
2548 m_Variable5 = 999.9;
2549 if ( !track->isTofTrackValid() ) return;
2550 SmartRefVector<RecTofTrack> tofTrkCol = track->tofTrack();
2551 SmartRefVector<RecTofTrack>::iterator iter_tof = tofTrkCol.begin();
2552 for ( ; iter_tof != tofTrkCol.end(); iter_tof++ )
2553 {
2554 TofHitStatus* status = new TofHitStatus;
2555 status->setStatus( ( *iter_tof )->status() );
2556 if ( !( status->is_barrel() ) )
2557 { // endcap
2558 if ( !( status->is_counter() ) ) continue; // ?
2559 if ( status->layer() != 1 ) continue; // layer1
2560 m_Variable3 = ( *iter_tof )->tof() - ( *iter_tof )->texp( 1 );
2561 m_Variable4 = ( *iter_tof )->tof() - ( *iter_tof )->texp( 2 );
2562 m_Variable5 = ( *iter_tof )->tof() - ( *iter_tof )->texp( 3 );
2563 m_Variable7 = ( status->is_east() + 1 );
2564 }
2565 else
2566 { // barrel
2567 if ( status->is_cluster() ) numtag = 6;
2568 else if ( status->is_counter() && status->layer() != 1 ) numtag = 5;
2569 else if ( status->is_counter() && status->layer() == 1 ) numtag = 4;
2570 else if ( status->is_readout() && status->layer() == 1 && status->is_east() == 1 )
2571 numtag = 0;
2572 else if ( status->is_readout() && status->layer() == 1 && status->is_east() != 1 )
2573 numtag = 1;
2574 else if ( status->is_readout() && status->layer() != 1 && status->is_east() == 1 )
2575 numtag = 2;
2576 else if ( status->is_readout() && status->layer() != 1 && status->is_east() != 1 )
2577 numtag = 3;
2578 m_Variable0[numtag] = ( *iter_tof )->tof() - ( *iter_tof )->texp( 1 );
2579 m_Variable1[numtag] = ( *iter_tof )->tof() - ( *iter_tof )->texp( 2 );
2580 m_Variable2[numtag] = ( *iter_tof )->tof() - ( *iter_tof )->texp( 3 );
2581 }
2582 delete status;
2583 }
2584}
2585
2586void DQADtag::fillTrackDedxItem( EvtRecTrack* track, string str, int type ) {
2587 string strVarName[7];
2588 for ( int i = 0; i != 7; i++ )
2589 {
2590 strVarName[i] = str + "_" + m_TrackDedxItemName[i];
2591 // cout<<"strVarName: "<<strVarName[i]<<endl;
2592 }
2593 NTuple::Item<double> m_Variable0;
2594 NTuple::Item<double> m_Variable1;
2595 NTuple::Item<double> m_Variable2;
2596 NTuple::Item<double> m_Variable3;
2597 NTuple::Item<double> m_Variable4;
2598 NTuple::Item<double> m_Variable5;
2599 NTuple::Item<long> m_Variable6;
2600 m_tuple4->item( strVarName[0], m_Variable0 ).ignore();
2601 m_tuple4->item( strVarName[1], m_Variable1 ).ignore();
2602 m_tuple4->item( strVarName[2], m_Variable2 ).ignore();
2603 m_tuple4->item( strVarName[3], m_Variable3 ).ignore();
2604 m_tuple4->item( strVarName[4], m_Variable4 ).ignore();
2605 m_tuple4->item( strVarName[5], m_Variable5 ).ignore();
2606 m_tuple4->item( strVarName[6], m_Variable6 ).ignore();
2607 m_Variable0 = 999.9;
2608 m_Variable1 = 999.9;
2609 m_Variable2 = 1000;
2610 m_Variable3 = 1000;
2611 m_Variable4 = 9999.9;
2612 m_Variable5 = 999.9;
2613 m_Variable6 = 999.9;
2614 if ( !track->isMdcDedxValid() ) return;
2615 RecMdcDedx* dedxTrk = track->mdcDedx();
2616 m_Variable0 = dedxTrk->chiK();
2617 m_Variable1 = dedxTrk->chiPi();
2618 m_Variable2 = dedxTrk->numGoodHits();
2619 m_Variable3 = dedxTrk->numTotalHits();
2620 m_Variable4 = dedxTrk->probPH();
2621 m_Variable5 = dedxTrk->normPH();
2622 m_Variable6 = track->trackId();
2623}
2624
2625// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2626StatusCode DQADtag::finalize() {
2627 cout << "* * * * * * * Begin DQADTag * * * * * * * *" << endl;
2628 cout << "total number: " << Ncut_DQADTagAlg[0] << endl;
2629 cout << "Has DTag: " << Ncut_DQADTagAlg[1] << endl;
2630 cout << "* * * * * * * End DQADTag * * * * * * * *" << endl;
2631 MsgStream log( msgSvc(), name() );
2632 log << MSG::INFO << "in finalize()" << endmsg;
2633 return StatusCode::SUCCESS;
2634}
DECLARE_COMPONENT
DECLARE_COMPONENT(BesBdkRc)
mass
double mass
Definition CosmicGenerator.cxx:128
HepPoint3D
HepGeom::Point3D< double > HepPoint3D
Definition CosmicGenerator.h:36
Ncut_DQADTagAlg
int Ncut_DQADTagAlg[10]
Definition DQADtagAlg.cxx:58
mpsipp
const double mpsipp
Definition DQADtagAlg.cxx:53
u_cms
const Hep3Vector u_cms
Definition DQADtagAlg.cxx:56
EvtRecTrackIterator
EvtRecTrackCol::iterator EvtRecTrackIterator
Definition Event/EvtRecEvent/include/EvtRecEvent/EvtRecTrack.h:106
pi
double pi
Definition EvtPhokharaDef.hh:17
Vp4
std::vector< HepLorentzVector > Vp4
Definition Gam4pikp.cxx:38
xmass
const double xmass[5]
Definition Gam4pikp.cxx:35
Vint
std::vector< int > Vint
Definition Gam4pikp.cxx:37
sin
double sin(const BesAngle a)
Definition InstallArea/x86_64-el9-gcc13-dbg/include/MdcGeom/BesAngle.h:185
cos
double cos(const BesAngle a)
Definition InstallArea/x86_64-el9-gcc13-dbg/include/MdcGeom/BesAngle.h:187
cut
*********Class see also m_nmax DOUBLE PRECISION m_MasPhot DOUBLE PRECISION m_phsu DOUBLE PRECISION m_Xenph DOUBLE PRECISION m_r2 DOUBLE PRECISION m_WtMass INTEGER m_nmax INTEGER m_Nevgen INTEGER m_IsFSR INTEGER m_MarTot *COMMON c_KarFin $ !Output file $ !Event serial number $ !alpha QED at Thomson limit $ !minimum energy at CMS for remooval $ !infrared cut
Definition KarFin.h:27
fill
void fill(NTuple::Array< double > &nt_p4, const HepLorentzVector &p4)
Definition MyUtil.cxx:3
ntupleSvc
INTupleSvc * ntupleSvc()
Definition ServiceAccessor.h:51
msgSvc
IMessageSvc * msgSvc()
Definition ServiceAccessor.h:12
DQADtag::initialize
StatusCode initialize()
Definition DQADtagAlg.cxx:169
DQADtag::DQADtag
DQADtag(const std::string &name, ISvcLocator *pSvcLocator)
Definition DQADtagAlg.cxx:62
DQADtag::execute
StatusCode execute()
Definition DQADtagAlg.cxx:954
DQADtag::finalize
StatusCode finalize()
Definition DQADtagAlg.cxx:2626
DQAKsInfo::vtxChi2
double vtxChi2()
Definition DQAKsInfo.h:35
DQAKsInfo::chi2
double chi2()
Definition DQAKsInfo.h:36
DQAKsInfo::setVtxPar
void setVtxPar(VertexParameter vtxpar)
Definition DQAKsInfo.h:40
DQAKsInfo::calculate
bool calculate()
Definition DQAKsInfo.cxx:23
DQAKsInfo::decayLengthRatio
double decayLengthRatio()
Definition DQAKsInfo.h:38
DQAKsInfo::decayLength
double decayLength()
Definition DQAKsInfo.h:37
DQAKsInfo::m
double m()
Definition DQAKsInfo.h:33
DQAKsInfo::mksp4
double mksp4()
Definition DQAKsInfo.h:34
DQAKsInfo::setPrimaryVtxPar
void setPrimaryVtxPar(VertexParameter privtxpar)
Definition DQAKsInfo.h:41
DQAKsInfo::setchilds
void setchilds(EvtRecTrack *track0, EvtRecTrack *track1)
Definition DQAKsInfo.h:25
DQAPi0Info::setchilds
void setchilds(EvtRecTrack *shower0, EvtRecTrack *shower1)
Definition DQAPi0Info.h:20
DQAPi0Info::calculate
bool calculate()
Definition DQAPi0Info.h:39
DQAPi0Info::m
double m()
Definition DQAPi0Info.h:28
DstMdcKalTrack::p4
const HepLorentzVector p4() const
Definition DstMdcKalTrack.cxx:144
DstMdcTrack::helix
const HepVector helix() const
......
Definition DstMdcTrack.cxx:147
EvtRecTrack::tofTrack
SmartRefVector< RecTofTrack > tofTrack()
Definition Event/EvtRecEvent/include/EvtRecEvent/EvtRecTrack.h:57
IVertexDbSvc::isVertexValid
virtual bool isVertexValid()=0
IVertexDbSvc::SigmaPrimaryVertex
virtual double * SigmaPrimaryVertex()=0
IVertexDbSvc::PrimaryVertex
virtual double * PrimaryVertex()=0
SecondVertexFit::instance
static SecondVertexFit * instance()
Definition SecondVertexFit.cxx:45
TofHitStatus::setStatus
void setStatus(unsigned int status)
Definition TofHitStatus.cxx:115
VertexFit::instance
static VertexFit * instance()
Definition VertexFit.cxx:15
ecms
const double ecms
Definition inclkstar.cxx:26