| 1 |
mocchiut |
1.1 |
/** |
| 2 |
|
|
* \file CaloEnergy.h |
| 3 |
|
|
* \authors Emiliano Mocchiutti & Giovanna Jerse |
| 4 |
|
|
*/ |
| 5 |
|
|
#ifndef caloenergy_h |
| 6 |
|
|
#define caloenergy_h |
| 7 |
|
|
|
| 8 |
|
|
#include <PamLevel2.h> |
| 9 |
|
|
|
| 10 |
|
|
#include <TTree.h> |
| 11 |
|
|
#include <TFriendElement.h> |
| 12 |
|
|
#include <TChain.h> |
| 13 |
|
|
#include <TFile.h> |
| 14 |
|
|
#include <TList.h> |
| 15 |
|
|
#include <TKey.h> |
| 16 |
|
|
#include <TSystemFile.h> |
| 17 |
|
|
#include <TSystemDirectory.h> |
| 18 |
|
|
#include <TSQLServer.h> |
| 19 |
mocchiut |
1.6 |
|
| 20 |
mocchiut |
1.4 |
#include <CaloPreSampler.h> |
| 21 |
mocchiut |
1.6 |
#include <CaloProfile.h> |
| 22 |
mocchiut |
1.1 |
|
| 23 |
|
|
#include <iostream> |
| 24 |
|
|
|
| 25 |
|
|
using namespace std; |
| 26 |
|
|
|
| 27 |
|
|
/** |
| 28 |
|
|
* |
| 29 |
|
|
*/ |
| 30 |
|
|
class CaloEnergy : public TObject { |
| 31 |
|
|
|
| 32 |
|
|
private: |
| 33 |
|
|
// |
| 34 |
mocchiut |
1.5 |
PamLevel2 *L2; ///< PamLevel2 object |
| 35 |
mocchiut |
1.4 |
Bool_t debug; ///< debug flag |
| 36 |
mocchiut |
1.1 |
// |
| 37 |
|
|
// needed to avoid reprocessing the same event over and over to obtain the variables |
| 38 |
|
|
// |
| 39 |
mocchiut |
1.4 |
UInt_t OBT; ///< CPU OBT |
| 40 |
|
|
UInt_t PKT; ///< CPU packet number |
| 41 |
|
|
UInt_t atime; ///< event absolute time |
| 42 |
|
|
TString sntr; ///< string containing the list of section the user want to process |
| 43 |
|
|
UInt_t AOBT; ///< CPU OBT |
| 44 |
|
|
UInt_t APKT; ///< CPU packet number |
| 45 |
|
|
UInt_t aatime;///< event absolute time |
| 46 |
|
|
TString asntr;///< string containing the list of section the user want to process |
| 47 |
|
|
// |
| 48 |
mocchiut |
1.10 |
// margins, acceptance and containment |
| 49 |
|
|
// |
| 50 |
mocchiut |
1.4 |
Float_t fM; ///< margin in the strip direction |
| 51 |
|
|
Float_t fM1; ///< margin along the strip reading direction |
| 52 |
|
|
Int_t fPl; ///< number of dE/dx measurements over the maximum that are used to find the energy |
| 53 |
mocchiut |
1.10 |
Float_t fCount; ///< Number of sections inside the acceptance (only the section given by the user are checked) |
| 54 |
|
|
Int_t fRad; ///< Radius [strip] of the cylinder used to integrate the energy along the track, if negative radius is inf (the whole plane is used). Default: -1 |
| 55 |
|
|
Int_t fNumSec; ///< Number of sections given by the user |
| 56 |
|
|
Bool_t fXosel; ///< true if event is contained in section XO |
| 57 |
|
|
Bool_t fXesel; ///< true if event is contained in section XE |
| 58 |
|
|
Bool_t fYosel; ///< true if event is contained in section YO |
| 59 |
|
|
Bool_t fYesel; ///< true if event is contained in section YE |
| 60 |
|
|
Bool_t fSel; ///< true if event is contained in at least one of the given section (independet mode) or in all the given section (coherent mode) |
| 61 |
|
|
Bool_t fPartsel; ///< true if the event is contained only up to the last plane used for energy determination (can be used in conjunction with fXXmin) |
| 62 |
|
|
Int_t fXeout; ///< last plane [0,11] for which the trajectory is contained in section XE |
| 63 |
|
|
Int_t fYeout; ///< last plane [0,11] for which the trajectory is contained in section YE |
| 64 |
|
|
Int_t fXoout; ///< last plane [0,11] for which the trajectory is contained in section XO |
| 65 |
|
|
Int_t fYoout; ///< last plane [0,11] for which the trajectory is contained in section YO |
| 66 |
|
|
Int_t fXomin; ///< last plane [0,11] for which the trajectory MUST be contained in section XO. Default 1000 means all the planes, if less than 10 events can be only partially contained in a section (NB: THIS INTRODUCE AN ENERGY DEPENDENT SELECTION CONTAINMENT EFFICIENCY) |
| 67 |
|
|
Int_t fXemin; ///< last plane [0,11] for which the trajectory MUST be contained in section XE. Default 1000 means all the planes, if less than 10 events can be only partially contained in a section (NB: THIS INTRODUCE AN ENERGY DEPENDENT SELECTION CONTAINMENT EFFICIENCY) |
| 68 |
|
|
Int_t fYomin; ///< last plane [0,11] for which the trajectory MUST be contained in section YO. Default 1000 means all the planes, if less than 10 events can be only partially contained in a section (NB: THIS INTRODUCE AN ENERGY DEPENDENT SELECTION CONTAINMENT EFFICIENCY) |
| 69 |
|
|
Int_t fYemin; ///< last plane [0,11] for which the trajectory MUST be contained in section YE. Default 1000 means all the planes, if less than 10 events can be only partially contained in a section (NB: THIS INTRODUCE AN ENERGY DEPENDENT SELECTION CONTAINMENT EFFICIENCY) |
| 70 |
|
|
Bool_t indep; ///< flag to switch between INDEPENDENT or COHERENT mode, default false - COHERENT mode selected |
| 71 |
|
|
// |
| 72 |
|
|
// conversion factors |
| 73 |
|
|
// |
| 74 |
mocchiut |
1.4 |
Float_t fConv_rxe; ///< MIP - energy conversion factor for section XE |
| 75 |
|
|
Float_t fConv_rxo; ///< MIP - energy conversion factor for section XO |
| 76 |
|
|
Float_t fConv_rye; ///< MIP - energy conversion factor for section YE |
| 77 |
|
|
Float_t fConv_ryo; ///< MIP - energy conversion factor for section YO |
| 78 |
mocchiut |
1.10 |
// |
| 79 |
|
|
// Longitudinal fit |
| 80 |
|
|
// |
| 81 |
mocchiut |
1.4 |
Bool_t fLong; ///< if true use the integral of the longitudinal profile to measure the energy (NOT IMPLEMENTED YET), default FALSE |
| 82 |
mocchiut |
1.10 |
// |
| 83 |
|
|
// Energies (MIP) |
| 84 |
|
|
// |
| 85 |
|
|
Float_t fXOen_maxplane; ///< total energy [MIP] used for energy determination as given by section XO |
| 86 |
|
|
Float_t fYOen_maxplane; ///< total energy [MIP] used for energy determination as given by section YO |
| 87 |
|
|
Float_t fXEen_maxplane; ///< total energy [MIP] used for energy determination as given by section XE |
| 88 |
|
|
Float_t fYEen_maxplane; ///< total energy [MIP] used for energy determination as given by section YE |
| 89 |
|
|
Float_t xomax_en; ///< energy at plane of maximum of section XO |
| 90 |
|
|
Float_t xemax_en; ///< energy at plane of maximum of section XE |
| 91 |
|
|
Float_t yomax_en; ///< energy at plane of maximum of section YO |
| 92 |
|
|
Float_t yemax_en; ///< energy at plane of maximum of section YE |
| 93 |
|
|
Float_t energyxe; ///< 11 planes detected energy [MIP] for section XE |
| 94 |
|
|
Float_t energyyo; ///< 11 planes detected energy [MIP] for section YO |
| 95 |
|
|
Float_t energyxo; ///< 11 planes detected energy [MIP] for section XO |
| 96 |
|
|
Float_t energyye; ///< 11 planes detected energy [MIP] for section YE |
| 97 |
|
|
Float_t en_xep[11]; ///< detected energy [MIP] for each plane of section XE |
| 98 |
|
|
Float_t en_yop[11]; ///< detected energy [MIP] for each plane of section YO |
| 99 |
|
|
Float_t en_xop[11]; ///< detected energy [MIP] for each plane of section XO |
| 100 |
|
|
Float_t en_yep[11]; ///< detected energy [MIP] for each plane of section YE |
| 101 |
|
|
Float_t encol[2][3]; ///< detected energy [MIP] for each column of views x and y |
| 102 |
|
|
Float_t entot[2]; ///< detected energy [MIP] for views x and y |
| 103 |
|
|
// |
| 104 |
|
|
// Energies (GV) |
| 105 |
mocchiut |
1.4 |
// |
| 106 |
|
|
Float_t fEnergyxe; ///< Energy as measured by section XE |
| 107 |
|
|
Float_t fEnergyxo; ///< Energy as measured by section XO |
| 108 |
|
|
Float_t fEnergyye; ///< Energy as measured by section YE |
| 109 |
|
|
Float_t fEnergyyo; ///< Energy as measured by section YO |
| 110 |
|
|
Float_t fEnergy; ///< Energy as measured by the average of the used section in "Independent mode" or energy as measured by the used section in "Coherent mode" |
| 111 |
mocchiut |
1.10 |
// |
| 112 |
|
|
// Plane of maximum |
| 113 |
|
|
// |
| 114 |
mocchiut |
1.4 |
Int_t fMax_planexe; ///< plane of maximum energy release (independent mode) or last plane used for energy measurement (coherent mode) for section XE |
| 115 |
|
|
Int_t fMax_planexo; ///< plane of maximum energy release (independent mode) or last plane used for energy measurement (coherent mode) for section XO |
| 116 |
|
|
Int_t fMax_planeyo; ///< plane of maximum energy release (independent mode) or last plane used for energy measurement (coherent mode) for section YO |
| 117 |
|
|
Int_t fMax_planeye; ///< plane of maximum energy release (independent mode) or last plane used for energy measurement (coherent mode) for section YE |
| 118 |
|
|
Float_t fMax_plane; ///< average max plane [0,11] (independent mode) or last plane for energy measurement [0,43] (coherent mode) |
| 119 |
mocchiut |
1.10 |
Float_t x0max; ///< plane of maximum given externally (only test purpose) |
| 120 |
|
|
Bool_t fAllpl; ///< use all 96 strips for each plane to determine the maximum OR only the energy along the track as defined with fRad |
| 121 |
mocchiut |
1.4 |
// |
| 122 |
mocchiut |
1.10 |
// Geometry |
| 123 |
mocchiut |
1.6 |
// |
| 124 |
mocchiut |
1.4 |
Float_t xe1; ///< position of strip 1 section XE |
| 125 |
|
|
Float_t xe2; ///< position of strip 32 section XE |
| 126 |
|
|
Float_t xe3; ///< position of strip 33 section XE |
| 127 |
|
|
Float_t xe4; ///< position of strip 64 section XE |
| 128 |
|
|
Float_t xe5; ///< position of strip 65 section XE |
| 129 |
|
|
Float_t xe6; ///< position of strip 96 section XE |
| 130 |
|
|
Float_t yo1; ///< position of strip 1 section YO |
| 131 |
|
|
Float_t yo2; ///< position of strip 32 section YO |
| 132 |
|
|
Float_t yo3; ///< position of strip 33 section YO |
| 133 |
|
|
Float_t yo4; ///< position of strip 64 section YO |
| 134 |
|
|
Float_t yo5; ///< position of strip 65 section YO |
| 135 |
|
|
Float_t yo6; ///< position of strip 96 section YO |
| 136 |
|
|
Float_t xo1; ///< position of strip 1 section XO |
| 137 |
|
|
Float_t xo2; ///< position of strip 32 section XO |
| 138 |
|
|
Float_t xo3; ///< position of strip 33 section XO |
| 139 |
|
|
Float_t xo4; ///< position of strip 64 section XO |
| 140 |
|
|
Float_t xo5; ///< position of strip 65 section XO |
| 141 |
|
|
Float_t xo6; ///< position of strip 96 section XO |
| 142 |
|
|
Float_t ye1; ///< position of strip 1 section YE |
| 143 |
|
|
Float_t ye2; ///< position of strip 32 section YE |
| 144 |
|
|
Float_t ye3; ///< position of strip 33 section YE |
| 145 |
|
|
Float_t ye4; ///< position of strip 64 section YE |
| 146 |
|
|
Float_t ye5; ///< position of strip 65 section YE |
| 147 |
|
|
Float_t ye6; ///< position of strip 96 section YE |
| 148 |
mocchiut |
1.10 |
Float_t track_coordx[22][2]; ///< XO and XE views, position (x and y) of the trajectory according to the fit |
| 149 |
|
|
Float_t track_coordy[22][2]; ///< YO and YE views, position (x and y) of the trajectory according to the fit |
| 150 |
|
|
Float_t trk_z[22][2]; ///< Z position of calorimeter planes |
| 151 |
|
|
// |
| 152 |
|
|
// decode estrip |
| 153 |
mocchiut |
1.8 |
// |
| 154 |
mocchiut |
1.4 |
Float_t en; ///< energy [mip] for decodeestrip |
| 155 |
|
|
Int_t view; ///< view for decodeestrip |
| 156 |
|
|
Int_t plane; ///< plane for decodeestrip |
| 157 |
|
|
Int_t strip; ///< strip for decodeestrip |
| 158 |
|
|
Float_t enstrip[2][22][96]; ///< detected energy [MIP] for each strip of calorimeter |
| 159 |
mocchiut |
1.10 |
// y ^ |
| 160 |
|
|
// || 6 7 8 |
| 161 |
|
|
// Columns || 3 4 5 |
| 162 |
|
|
// || 0 1 2 |
| 163 |
|
|
Int_t fColumn; ///< Column number for the event [0,8] =============> x |
| 164 |
|
|
Int_t fColXE; ///< Column number for section XE |
| 165 |
|
|
Int_t fColXO; ///< Column number for section XO |
| 166 |
|
|
Int_t fColYE; ///< Column number for section YE |
| 167 |
|
|
Int_t fColYO; ///< Column number for section YO |
| 168 |
|
|
Bool_t multicol; ///< accept or not multicolumns events |
| 169 |
mocchiut |
1.6 |
// |
| 170 |
mocchiut |
1.10 |
// other stuff |
| 171 |
mocchiut |
1.4 |
// |
| 172 |
|
|
Bool_t fSimu; ///< true if we are using simulated data, default false |
| 173 |
|
|
CaloPreSampler *cp; ///< pointer to calopresampler object (object constructed only when invoking method UseCaloPreSampler() , default: use level2 data). |
| 174 |
mocchiut |
1.6 |
CaloLong *clong; ///< pointer to calolong object (object constructed only when invoking method UseLongFit(), default use energy up to maximum). |
| 175 |
mocchiut |
1.4 |
// |
| 176 |
mocchiut |
1.10 |
// private methods |
| 177 |
|
|
// |
| 178 |
mocchiut |
1.4 |
void DefineGeometry(); ///< called by constructors to fill geometrical variables (like xe1 etc). |
| 179 |
|
|
void Set(); ///< called by contructors to define default variables |
| 180 |
mocchiut |
1.1 |
|
| 181 |
|
|
public: |
| 182 |
|
|
// |
| 183 |
mocchiut |
1.10 |
// constructors and destructors |
| 184 |
|
|
// |
| 185 |
mocchiut |
1.4 |
CaloEnergy(); ///< default constructor (does nothing) |
| 186 |
|
|
CaloEnergy(PamLevel2 *L2); ///< constructor |
| 187 |
|
|
CaloEnergy(PamLevel2 *L2, Bool_t simulation); ///< constructor |
| 188 |
|
|
~CaloEnergy(){ Delete(); }; ///< default destructor |
| 189 |
|
|
// |
| 190 |
mocchiut |
1.10 |
// Setters and behaviour methods |
| 191 |
|
|
// |
| 192 |
mocchiut |
1.4 |
void SetDebug(Bool_t d){ debug=d; }; ///< set the debug flag (verbose print-out on STDOUT), default is false |
| 193 |
|
|
// |
| 194 |
mocchiut |
1.10 |
void UseCaloPreSampler(); ///< use pre-sampler routine to refit the track (level2 default fitting could be wrong, in this case we force "shower fitting" in the DV library). |
| 195 |
|
|
void UseLevel2(); ///< use level2 default fitting |
| 196 |
|
|
// |
| 197 |
|
|
void UseLongFit();///< use or not the longitudinal fit to determine the energy |
| 198 |
|
|
void UseMeasuredEnergyUpToMax(){ fLong = false;}; ///< use the measured energy to determine the maximum (default) |
| 199 |
|
|
// |
| 200 |
|
|
void IndependentMode(){ indep = true; }; ///< Set the independent mode |
| 201 |
|
|
void CoherentMode(){ indep = false; }; ///< Set the coherent mode |
| 202 |
|
|
// |
| 203 |
|
|
void MultiColumns(){multicol = true;}; ///< accept multicolumns events |
| 204 |
|
|
void SingleColumn(){multicol = false;}; ///< accept events only if contained in a single column |
| 205 |
|
|
// |
| 206 |
|
|
void UseAllPlane2FindMax(){ fAllpl = true;};///< find the maximum (not long fit) integrating over all the 96 strips of the planes even if SetRadius has been used [default] |
| 207 |
|
|
void UseMeasuredEnergy2FindMax(){ fAllpl = false;};///< find the maximum (not long fit) using the energy measured and used to calculate the result |
| 208 |
|
|
// |
| 209 |
|
|
void SetMargin(Float_t margin){fM = margin ; fM1 = margin - 0.122 - 0.096 + 0.096; if ( fM1 < 0. ) fM1 = 0.;}; ///< set the margin from the border of the silicon sensor (not from the first strip), set the same margin for both the directions |
| 210 |
|
|
void SetMarginStripDirection(Float_t margin){fM = margin ;}; ///< set the margin from the border of the silicon sensor (not from the first strip) in the strip direction |
| 211 |
|
|
void SetMarginStripReading(Float_t margin){fM1 = margin -0.122 - 0.096 + 0.096;}; ///< set the margin from the border of the silicon sensor (not from the first strip) in the strip reading direction |
| 212 |
|
|
// |
| 213 |
|
|
void SetRadius(Int_t strip){fRad = strip;}; ///< set the radius of the cylinder |
| 214 |
|
|
void SetMaxPlaneOffset(Int_t noplanes){fPl = noplanes;}; ///< set the number of dE/dx measurements to be used after the maximum |
| 215 |
|
|
// |
| 216 |
|
|
void SetX0max(Float_t xm){ x0max = xm;}; ///< set the plane of maximum from external source X0 (test purpose only) |
| 217 |
|
|
void SetRigX0max(Float_t rig){ x0max = -0.5+log(rig/0.0076);}; ///< set the plane of maximum from external source rigidity (GeV) (test purpose only) |
| 218 |
|
|
// |
| 219 |
|
|
void SetMinimumContainment(Int_t plane); ///< set the last plane [0,11] for which the trajectory MUST be contained in all the sections. Default 1000 means all the planes, if less than 10 events can be only partially contained in a section (NB: THIS INTRODUCE AN ENERGY DEPENDENT SELECTION CONTAINMENT EFFICIENCY) |
| 220 |
|
|
void SetMinimumContainment(TString section, Int_t plane); ///< set the last plane [0,11] for which the trajectory MUST be contained in section "section". Default 1000 means all the planes, if less than 10 events can be only partially contained in a section (NB: THIS INTRODUCE AN ENERGY DEPENDENT SELECTION CONTAINMENT EFFICIENCY) |
| 221 |
|
|
// |
| 222 |
|
|
void SetConversionFactor(Float_t conv_r); ///< Set the MIP-GV conversion factor for all the four sections. |
| 223 |
|
|
void SetConversionFactor(TString section, Float_t conv_r); ///< Set the MIP-GV conversion factor for section "section". |
| 224 |
|
|
// |
| 225 |
|
|
// Getters and checks methods |
| 226 |
mocchiut |
1.4 |
// |
| 227 |
mocchiut |
1.1 |
// |
| 228 |
mocchiut |
1.4 |
Bool_t IsInsideAcceptance(TString section); ///< returns true if event is inside acceptance of the given sections (all if coherent mode, at least one in independent mode) |
| 229 |
|
|
Bool_t IsInsideReducedAcceptance(){return fPartsel;}; ///< returns true if the event is inside acceptance only up to the last used plane (see fXomin etc) |
| 230 |
mocchiut |
1.1 |
// |
| 231 |
|
|
Bool_t IsInsideXE(){return(IsInsideAcceptance("XE"));}; |
| 232 |
|
|
Bool_t InsideXEcheck(){return fXesel;}; |
| 233 |
|
|
Bool_t IsInsideXO(){return(IsInsideAcceptance("XO"));}; |
| 234 |
|
|
Bool_t InsideXOcheck(){return fXosel;}; |
| 235 |
|
|
Bool_t IsInsideYE(){return(IsInsideAcceptance("YE"));}; |
| 236 |
|
|
Bool_t InsideYEcheck(){return fYesel;}; |
| 237 |
|
|
Bool_t IsInsideYO(){return(IsInsideAcceptance("YO"));}; |
| 238 |
|
|
Bool_t InsideYOcheck(){return fYosel;}; |
| 239 |
|
|
// |
| 240 |
mocchiut |
1.4 |
Float_t GetEnergy(){ Process(); return fEnergy;}; ///< returns the energy [GV] determined for this event |
| 241 |
|
|
Float_t GetEnergy(TString section){ Process(section); return fEnergy;}; ///< returns the energy [GV] determined for this event |
| 242 |
mocchiut |
1.10 |
// |
| 243 |
mocchiut |
1.4 |
Float_t GetCount(){ return fCount;}; ///< returns the number of section inside acceptance for this event (equal to the number of given section in coherent mode) |
| 244 |
|
|
// |
| 245 |
mocchiut |
1.10 |
Float_t GetEnergyAtMaxplane(TString section); ///< returns the energy [MIP] at the plane of maximum for section "section" |
| 246 |
|
|
Float_t GetMipEnergyAtMaxplane(TString section); ///< returns the energy [MIP] at the plane of maximum for section "section" |
| 247 |
mocchiut |
1.4 |
// |
| 248 |
mocchiut |
1.6 |
Float_t GetMaxEnergy(); ///< returns the total energy [MIP] before conversion |
| 249 |
mocchiut |
1.4 |
Float_t GetMaxEnergy(TString section); ///< returns the total energy [MIP] before conversion for section "section" |
| 250 |
mocchiut |
1.10 |
Float_t GetMipEnergy(); ///< returns the total energy [MIP] before conversion |
| 251 |
|
|
Float_t GetMipEnergy(TString section); ///< returns the total energy [MIP] before conversion for section "section" |
| 252 |
|
|
// |
| 253 |
mocchiut |
1.4 |
Int_t GetMaxplane(TString section); ///< returns the plane of maximum (independent mode) or the last used plane (coherent mode) for section "section" |
| 254 |
mocchiut |
1.10 |
Float_t GetMaxplane(){ return fMax_plane;}; ///< returns the average max plane [0,11] (independent mode) or last plane for energy measurement [0,43] (coherent mode) |
| 255 |
mocchiut |
1.4 |
// |
| 256 |
|
|
Int_t GetMinimumContainment(TString section); ///< get the last plane [0,11] for which the trajectory MUST be contained in section "section". |
| 257 |
|
|
// |
| 258 |
|
|
Float_t GetConversionFactor(TString section); ///< Get the MIP-GV conversion factor for section "section". |
| 259 |
|
|
// |
| 260 |
mocchiut |
1.9 |
Float_t *Get_track_coordx(){ return *track_coordx;}; ///< X position of the track for all the planes and views |
| 261 |
|
|
Float_t *Get_track_coordy(){ return *track_coordy;}; ///< Y position of the track for all the planes and views |
| 262 |
|
|
// |
| 263 |
|
|
Float_t Get_track_coordx(Int_t i, Int_t j){ return track_coordx[i][j];}; ///< X position of the track for plane i and view j |
| 264 |
|
|
Float_t Get_track_coordy(Int_t i, Int_t j){ return track_coordy[i][j];}; ///< X position of the track for plane i and view j |
| 265 |
|
|
// |
| 266 |
mocchiut |
1.10 |
Float_t *GetEncol(){ return *encol;}; ///< integrated energy over columns (encol[2][3]) [MIP] |
| 267 |
|
|
Float_t GetEncol(Int_t i, Int_t j){ return encol[i][j];}; ///< integrated energy over view i and column j [MIP] |
| 268 |
|
|
Float_t GetEncol(Int_t i); ///< integrated energy over view i given fColumn [MIP] |
| 269 |
|
|
Float_t *GetEntot(){ return entot;}; ///< integrated energy over views (entot[2]) [MIP] |
| 270 |
|
|
Float_t GetEntot(Int_t i){ return entot[i];}; ///< integrated energy over all view i [MIP] |
| 271 |
|
|
// |
| 272 |
|
|
Int_t GetColumn(){return fColumn;}; ///< number of column which contains the track |
| 273 |
|
|
Int_t GetColumn(TString section); ///< number of column which contains the track for section "section" |
| 274 |
|
|
// |
| 275 |
|
|
// Get pointers |
| 276 |
|
|
// |
| 277 |
|
|
CaloLong* GetCaloLong(){return clong;}; ///< Get calolong object. |
| 278 |
|
|
CaloPreSampler* GetCaloPreSampler(){return cp;}; ///< Get pre-sampler object. |
| 279 |
|
|
CaloEnergy* GetCaloEnergyPointer(){return this;}; ///< Get CaloEnergy pointer |
| 280 |
|
|
// |
| 281 |
|
|
// Other methods |
| 282 |
|
|
// |
| 283 |
|
|
void Clear(); ///< clear varibles |
| 284 |
|
|
void Clear(Option_t *option){Clear();}; ///< compatibility with TObject |
| 285 |
|
|
void Delete(); ///< delete object |
| 286 |
|
|
void Delete(Option_t *option){Delete();}; ///< compatibility with TObject |
| 287 |
mocchiut |
1.9 |
// |
| 288 |
mocchiut |
1.10 |
void Process(); ///< Process the event |
| 289 |
|
|
void Process(TString section); ///< Process the event for section "section" |
| 290 |
|
|
void Print(); ///< Print variables on STDOUT |
| 291 |
|
|
void Print(Option_t *option){Print();}; ///< compatibility with TObject |
| 292 |
mocchiut |
1.8 |
// |
| 293 |
mocchiut |
1.10 |
ClassDef(CaloEnergy,2); |
| 294 |
mocchiut |
1.1 |
}; |
| 295 |
|
|
|
| 296 |
|
|
#endif |
| 297 |
|
|
|
Parent Directory
| 
Revision Log