#ifndef PandoraPFAProcessor_h #define PandoraPFAProcessor_h 1 #include "Pandora.h" #include "marlin/Processor.h" #include "MyCaloHitExtended.h" #include "ProtoCluster.h" #include "MyTrackExtended.h" #include "ProtoClusterFactory.h" #include "PhotonIDLikelihoodCalculator.h" #include #include #include #include #include "EVENT/LCIO.h" #include #include #include // root stuff #include "TH1.h" #include "TH2.h" #include "TH1F.h" #include "TH2F.h" #include "TFile.h" using namespace lcio; using namespace marlin; class MyCaloHitExtended; class MyRecoDisplay; class MyTrackExtended; class MCTree; class MyMCTree; typedef struct { float x; float y; float z; } vec3; typedef struct { float chi2; float chi; int ntrackmatch; int cluster0; float chi0; int cluster1; float chi1; } ReclusterResult_t; typedef struct { int icluster; ProtoCluster* candidateDaughterProtoCluster; ProtoCluster* candidateParentProtoCluster; float trackEnergy; float clusterEnergy; float chi; int contactLayers; bool leavingCluster; int muonCount; float contactFraction; float trackHelixExtrapolationDistance; float trackHelixExtrapolationAverage; float coneFraction25; float coneFraction18; float coneFraction10; float angularSeparation; float minimumDistance; float clusterFractionWithin100; float clusterFractionWithin50; float projectedDistanceTPCCage; } fragmentContact_t; typedef enum { DETECTOR_UNKNOWN =0, DETECTOR_LDC00, DETECTOR_LDC01, DETECTOR_LDC01_05, DETECTOR_LDCPRIME, DETECTOR_GLD, DETECTOR_SID, DETECTOR_ILD } DetectorType; /** Example processor for marlin. If compiled with MARLIN_USE_AIDA * it creates a histogram (cloud) of the MCParticle energies. */ class PandoraPFAProcessor : public Processor { public: virtual Processor* newProcessor() { return new PandoraPFAProcessor ; } PandoraPFAProcessor() ; /** Called at the begin of the job before anything is read. * Use to initialize the processor, e.g. book histograms. */ virtual void init() ; /** Called for every run. */ virtual void processRunHeader( LCRunHeader* run ) ; /** Called for every event - the working horse. */ virtual void processEvent( LCEvent * evt ) ; virtual void check( LCEvent * evt ) ; /** Called after data processing for clean up. */ virtual void end() ; protected: // Protected member functions void processGearInformation( ) ; void PerfectPFA(LCEvent * evt); void initialiseEvent(LCEvent * evt); void stripIsolatedHits(); void hitEnergyCorrections(); void defineIntersection( MyTrackExtended * track); void defineAltIntersection( MyTrackExtended * track); void removeAssociatedHits(); void removeTmpAssociatedHits(); float closestApproach(fitResult fit1, fitResult fit2); float scalarProduct(fitResult fit1, fitResult fit2); void associateFromStart(ProtoClusterVec &pClusters); void associateLoopingTracks(ProtoClusterVec &pClusters, int pass=0); void associateTrackSegments(ProtoClusterVec &pClusters); void associateByProximity(ProtoClusterVec &pClusters); void associateByShowerCone(ProtoClusterVec &pClusters); void associateSoftClusters(ProtoClusterVec &pClusters,bool firstPass); void associateIsolatedHits(ProtoClusterVec &pClusters,bool firstPass); void associateBackScatters(ProtoClusterVec &pClusters); void finalisePhotons(ProtoClusterVec &pClusters); void mergeSplitPhotons(ProtoClusterVec &pClusters); void mergeSplitPhotons2(ProtoClusterVec &pClusters); void findPhotonsIDedAsHadrons(ProtoClusterVec &pClusters); void associateMipStubsToShowers(ProtoClusterVec &pClusters); void associateShowersToMips(ProtoClusterVec &pClusters); void associateShowersToMipsII(ProtoClusterVec &pClusters); void trackDrivenAssociation(ProtoClusterVec &pClusters,unsigned int ipass); void ExitingTrackReclustering(ProtoClusterVec &pClusters); void trackDrivenAssociationSingle(ProtoClusterVec &pClusters,unsigned int icluster,unsigned int ipass); void newTrackDrivenAssociationSingle(ProtoClusterVec &pClusters,unsigned int icluster,unsigned int ipass); void trackDrivenAssociationMultiple(ProtoClusterVec &pClusters,unsigned int icluster,unsigned int ipass); void trackDrivenSplitMergedClusters(ProtoClusterVec &pClusters); void associateProtoClusters(ProtoClusterVec &inputClusters, MyTrackExtendedVec &tracks, ProtoClusterVec &outputClusters, bool firstPass); float Recluster(ProtoCluster* pCluster, MyTrackExtendedVec& tracks, float scale, ProtoClusterVec &finalClusters); float Recluster(ProtoCluster* pCluster, MyTrackExtendedVec& tracks, protoClusterDesign_t design, ProtoClusterVec &finalClusters); ReclusterResult_t ReclusterMultiple(ProtoClusterVec& clusters, MyTrackExtendedVec& tracks, protoClusterDesign_t design, ProtoClusterVec &finalClusters); ProtoCluster* ReclusterForced(ProtoCluster* oldCluster,ProtoCluster* pCluster, MyTrackExtendedVec& tracks, ProtoClusterVec &finalClusters); ProtoCluster* ReclusterForced(ProtoCluster* pCluster, MyTrackExtendedVec& tracks, ProtoClusterVec &finalClusters); int AssociatedMuonHits(ProtoCluster* pC); void AnalyseClusters(ProtoClusterVec &pClusters); void AnalysePFAPerformance(LCEvent * evt); void associateFragments(); void fragmentRemoval(ProtoClusterVec &input, MyTrackExtendedVec &tracks, ProtoClusterVec &output); void identifyElectrons(ProtoClusterVec &input, MyTrackExtendedVec &tracks); void finalFragmentRemoval(ProtoClusterVec &input, MyTrackExtendedVec &tracks); void perfectFragmentRemoval(ProtoClusterVec &input, MyTrackExtendedVec &tracks); void finalSoftFragmentRemoval(ProtoClusterVec &input, MyTrackExtendedVec &tracks); void neutralHadronFragmentMerging(ProtoClusterVec &input, MyTrackExtendedVec &tracks); fragmentContact_t CalculateFragmentContactInfo(ProtoCluster*, ProtoCluster*); fragmentContact_t CalculateFragmentContactInfo(MyTrackExtended*, MyTrackExtended*); void finalMipFragmentRemoval(ProtoClusterVec &input, MyTrackExtendedVec &tracks); void searchForBackScatterTracks(); void searchForProngs(); void searchForV0s(); void searchForKinks(); void searchForSplitTracks(); void findPhotonsMergedWithMips(ProtoClusterVec &pClusters); void splitMipsFromPhotons(ProtoClusterVec &pClusters); void combineProtoClusters(ProtoClusterVec &original, ProtoClusterVec &combined); void makeFinalProtoClusters(ProtoClusterVec &original, ProtoClusterVec &combined); void performPFA(); void scaleHotHadrons(); float protoClusterDr(ProtoCluster* p1, ProtoCluster* p2); float protoClusterDrF(ProtoCluster* p1, ProtoCluster* p2); void CreatePFOCollection(LCEvent * evt); void CreatePerfectPFOCollection(LCEvent * evt); void CreateClusterCollection(LCEvent * evt); bool GoodPFOTrack(MyTrackExtended*); // void (); //*********** Algorithm Process parameters ************* int _perfectPFA; int _perfectClustering; int _perfectPhotonClustering; int _photonClustering; int _makingPhotonIDLikelihoodHistograms; int _useLikelihoodPhotonID; int _perfectFragmentRemoval; int _perfectNeutralHadronClustering; int _perfectTrackClusterMatching; int _perfectMuonClusterMatching; int _cfCheck; int _cheatedDeDx; int _cheatedTracks; int _checkForMCBug; int _usingVertexBackgroundCuts; unsigned int _maxLayer; unsigned int _maxMuonLayer; /** Vector of strings specifying ECAL * collections of CalorimeterHits **/ std::vector _ecalCollections; std::vector _muonCollections; std::vector _lcalCollections; std::vector _bcalCollections; std::vector _lhcalCollections; std::vector _v0VertexCollections; std::string _relationCaloString; std::string _relationMuonString; std::string _relationTrackString; /** Vector of strings specifying HCAL * collections of CalorimeterHits **/ std::vector _hcalCollections; /** Vector of strings specifying Reconstructed Track * collections **/ std::vector _trackCollections; std::vector _tpcHitCollections; std::vector _curlKilledHitCollections; /** String specifying coding of cell ID ** Mokka (default) ** MokkaNew ** Jupiter ** SLIC **/ std::string _cellIDCoding; /** String specifying coding of name of output cluster collection **/ std::string _clusterCollectionName; /** String specifying output Particle * collection **/ std::string _particleCollectionName; /** ECAL and HCAL calibrations (energy to MIP) * and threshold to apply to hits in MIPs **/ int _digitalHCAL; int _digitalECAL; float _ecalToMIP; float _hcalToMIP; float _lcalToMIP; float _ecalMIPThreshold; float _hcalMIPThreshold; float _maxHcalHitEnergy; float _maximumRatioToCutHcalHit; float _lcalMIPThreshold; float _ecalEMMIPToGeV; float _hcalEMMIPToGeV; float _lcalEMMIPToGeV; float _ecalHadMIPToGeV; float _hcalHadMIPToGeV; float _muonHitEnergy; float _muonClusterCoilCorrection; int _maxHCALLayer; /** algorithm configuration **/ int _isolationType; int _layersForIsolationECAL; float _distanceForIsolationECAL; int _layersForIsolationHCAL; float _distanceForIsolationHCAL; int _nSmallestClusterSizeForIsolation; float _isolationDistanceForReCombination; int _layersForDensityWeighting; int _densityWeightingPower; float _densityWeightCutECAL; float _densityWeightCutHCAL; int _minimumHitsInCluster; int _maximumHitsInSoftCluster; float _maximumDistanceForSoftMerge; int _typeOfOrdering; int _layersToStepBackECAL; int _layersToStepBackHCAL; int _seedClustersWithTracks; int _usingTrackEndIntersection; int _usingNonVertexTracks; int _usingFTDOnlyTracks; int _minHitsFTDOnlyTracks; float _clusterFTDOnlyTrackDistance; float _trackClusterAssociationDistance; int _ignoreTracks; int _usingUnmatchedNonVertexTracks; int _usingUnmatchedVertexTracks; float _unmatchedVertexTrackMaxEnergy; float _energyCutForVeryLowEnergyTracks; int _extraLooperMatching; int _allowPhotonFragmentation; int _photonRecovery; float _hadEnergyRes; float _photonFragPhotonDeltaChi2Cut; float _photonFragNonPhotonDeltaChi2Cut; int _useAdvancedPhotonID; int _allowReclustering; float _mipLikeMipCut; int _canUseClusterForExitingTracks; float _mipsPerHitForHotHadron; float _scaledMipsPerHitForHotHadron; int _associateLoopingTracks; int _associateTrackSegments; int _associateShowersToMips; int _associateShowersToMipsII; int _associateBackScatters; int _associateMipStubsToShowers; int _associateFromStart; int _associateByProximity; int _associateByShowerCone; int _associateSoftClusters; int _fragmentRemoval; int _neutralHadronMerging; int _mergeSplitPhotons; float _fragmentRemovalContactCut; int _fragmentRemovalContactLayersCut; float _fragmentRemovalMaxChi2ForMerge; float _fragmentRemovalDeltaChi2ForMerge; float _fragmentRemovalChi2Base; float _fragmentRemovalGlobalPenalty; float _fragmentRemovalContactWeight; float _fragmentRemovalConeWeight; float _fragmentRemovalDistanceWeight; float _fragmentRemovalTrackExtrapolationWeight; float _chiToAttemptReclustering; float _chiToForceReclustering; int _outerHcalRegionLayer; float _looperClosestApproachCutECAL; float _looperClosestApproachCutHCAL; float _looperTrackSeparationCut; int _clusterFormationStrategy; float _photonClusterFormationConeTanECAL; float _clusterFormationConeTanECAL; float _clusterFormationConeTanHCAL; float _clusterFormationPadsECAL; float _clusterFormationPadsHCAL; float _sameLayerPadCutECAL; float _sameLayerPadCutHCAL; int _trackingWeight; int _trackingCutOff; float _trackingTube; float _minimumClusterEnergyEM; float _minimumClusterEnergyHAD; float _softClusterEnergyHAD; float _coneAssociationCosine; float _maximumDistanceForConeAssociationECAL; float _maximumDistanceForConeAssociationHCAL; float _kToMuMassWindowWidth; float _piToMuMassWindowWidth; int _tailCatcher; float _proximityClosestApproachCut; float _trackBackMergeCut; float _trackForwardMergeCut; float _trackMergeCutEcal; float _trackMergeCutHcal; float _trackMergePerpCutEcal; float _trackMergePerpCutHcal; float _z0TrackCut; float _d0TrackCut; int _minimumTrackHits; float _energyChiForCrudeMerging; int _mergeSoftPhotons; float _softPhotonEnergyForMerging; int _mergeHardPhotons; float _energyDeltaChi2ForCrudeMerging; float _chiToKillTrack; int _searchForBackScatters; int _searchForProngs; int _searchForV0s; int _v0Finder; int _searchForKinks; int _searchForSplitTracks; int _clusterCleaning; int _usingMuonHitsToAidClustering; bool _foundMuonCollection; private: void Clear(); void CylinderAssignToPseudoLayer(MyCaloHitExtended* pH); void ProtoAssignToPseudoLayer(MyCaloHitExtended* pH); void PolygonAssignToPseudoLayer(MyCaloHitExtended* pH); int GetPseudoLayer(float* pos ); void MakeDensityWeights( ); bool TruncateHCAL(MyCaloHitExtended* pH); void MakeProtoClusters(MyTrackExtendedVec &tracks, ProtoClusterVec &pClusters); void PerfectPhotonClustering(); void PhotonClustering(); void PerfectNeutralHadronClustering(); void MakeMuonProtoClusters(MyTrackExtendedVec &tracks); void MakePerfectMuonProtoClusters(MyTrackExtendedVec &tracks); void MakeHCALBarrelLookup(); void SeedProtoClustersWithTracks(MyTrackExtendedVec &tracks, ProtoClusterVec &pClusters); void OrderHitsInEachLayer(); int LayersFromEdge(ProtoCluster* pCluster); int LayersFromEdge(float* pos); int LayersFromEdge(MyCaloHitExtended* pH); void ExtractMcPfoInfo(); // track cluster association void TrackAsMIPs(MyTrackExtendedVec &tracks, ProtoClusterVec &pClusters); void ClusterTrackAssociation(ProtoClusterVec &protoClusters, MyTrackExtendedVec &extendedTracks, bool print ); void CleanClusters(ProtoClusterVec &protoClusters); void ResolveTwoTrackAssociations(ProtoClusterVec &protoClusters, MyTrackExtendedVec &extendedTracks, bool print ); void NewMergedPhotonSearch(ProtoClusterVec &protoClusters, MyTrackExtendedVec &extendedTracks, bool print ); void PhotonRecovery(ProtoClusterVec &protoClusters, MyTrackExtendedVec &extendedTracks, bool print ); void FinalPhotonRecovery(ProtoClusterVec &protoClusters, MyTrackExtendedVec &extendedTracks, bool print ); void FinalPhotonExtraction(ProtoClusterVec &protoClusters); void AddPerfectPhotonClusters(ProtoClusterVec &protoClusters); void AddPhotonClusters(ProtoClusterVec &protoClusters); void AddPerfectNeutralHadronClusters(ProtoClusterVec &protoClusters); void AddMuonClustersToPFOs(ProtoClusterVec &protoClusters, MyTrackExtendedVec &extendedTracks); void ClusterRecoveryFromMips(ProtoClusterVec &protoClusters, MyTrackExtendedVec &extendedTracks, bool print ); void SplitMultipleTrackAssociations(ProtoClusterVec &protoClusters, MyTrackExtendedVec &extendedTracks, bool print); void NewResolveTwoTrackAssociations(ProtoClusterVec &protoClusters, MyTrackExtendedVec &extendedTracks, bool print ); void NewTrackDrivenAssociation(ProtoClusterVec &protoClusters, MyTrackExtendedVec &extendedTracks, bool print ); void NewResolveThreeTrackAssociations(ProtoClusterVec &protoClusters, MyTrackExtendedVec &extendedTracks, bool print ); void NewResolveSingleTrackAssociations(ProtoClusterVec &protoClusters, MyTrackExtendedVec &extendedTracks, bool print ); void ClusterLoopingTrackAssociation(ProtoClusterVec &protoClusters, MyTrackExtendedVec &extendedTracks, bool print ); void ClassifyTracks(ProtoClusterVec &protoClusters, MyTrackExtendedVec &extendedTracks, bool print ); void AltClusterTrackAssociation(ProtoClusterVec &protoClusters, MyTrackExtendedVec &extendedTracks, bool print ); void ClusterNonVertexTrackAssociation(ProtoClusterVec &protoClusters, MyTrackExtendedVec &extendedTracks, bool print); void FinalTrackRecovery(ProtoClusterVec &protoClusters, MyTrackExtendedVec &extendedTracks, bool print); void FinalTrackRecoveryHelix(ProtoClusterVec &protoClusters,MyTrackExtendedVec &extendedTracks, bool print); void FinalTrackRecoveryInteractions(ProtoClusterVec &protoClusters,MyTrackExtendedVec &extendedTracks, bool print); void BubbleSort(MyCaloHitExtendedVec & input); void Quicksort(MyCaloHitExtendedVec & input, int left, int right); ProtoCluster* Arbitrate(const MyCaloHitExtended* hit, const std::vector & clusters, const unsigned int ilayer); int ExpectedLayersCrossed(float* xyzs, float* xyze); int ExpectedLayersCrossed(float zs, float ze, HelixClass* helix); float ChiClusterTrack(ProtoCluster* pC, float eExtra); float ChiClusterTrack(ProtoCluster* pC); float ChiClusterTrack(MyTrackExtended* pT); float ChiClusterTrack(MyTrackExtended* pT, float eExtra); float ChiClusterTrack(float ECluster, float ETrack); float EOverP(ProtoCluster* pC); float EOverP(MyTrackExtended* pT); bool IsClusterLeavingDetector(ProtoCluster* pC); float EnergyLeavingDetector(ProtoCluster* pC); bool ElectronID(MyTrackExtended* track, ProtoCluster* pC); float kinkMass(MyTrackExtended* parent, MyTrackExtended* daughter, float daughterMass, float neutralMass); MyRecoDisplay* _recoDisplay; //*********** Internal Workspace LCCollection* _tracks; LCCollection* _tpcTrackerHits; LCCollection* _curlKilledHits; std::vector _unusedTpcTrackerHits; std::vector _curlKilledTpcTrackerHits; std::vector _externalV0s; std::vector _muonHits; std::vector _muonHitsByLayer[MAX_NUMBER_OF_LAYERS]; std::vector _allCalHitsByPseudoLayer[MAX_NUMBER_OF_LAYERS]; std::vector _calHitsByPseudoLayer[MAX_NUMBER_OF_LAYERS]; std::vector _tmpCalHitsByPseudoLayer[MAX_NUMBER_OF_LAYERS]; std::vector _calHitsBySectorAndPseudoLayer[NUMBER_OF_SECTORS][MAX_NUMBER_OF_LAYERS]; std::vector _hitsForRemoval; std::vector _isolatedCalHitsByPseudoLayer[MAX_NUMBER_OF_LAYERS]; std::vector _barrelCalHitsByStaveLayer[MAX_NUMBER_OF_STAVES][MAX_NUMBER_OF_LAYERS]; std::vector _endcapCalHitsByStaveLayer[MAX_NUMBER_OF_STAVES][MAX_NUMBER_OF_LAYERS]; std::vector _tracksAR; ProtoClusterVec _muonProtoClusters; ProtoClusterVec _protoClusters; ProtoClusterVec _photonClusters; ProtoClusterVec _perfectPhotonClusters; ProtoClusterVec _perfectNeutralHadronClusters; ProtoClusterVec _finalProtoClusters; std::vector _unusedIsolatedHits; std::vector _mcPFOs; //*********** Internal Algorithm Parameters ************* MCTree* _mcTree; MyMCTree* _myMcTree; LCCollection* _relationCaloCollection; LCCollection* _relationTrackCollection; LCCollection* _relationMuonCollection; LCRelationNavigator* _caloNavigator; LCRelationNavigator* _muonNavigator; LCRelationNavigator* _trackNavigator; int _nRun ; int _nEvt ; int _protoClustersMade; std::string _detectorName; DetectorType _detector; std::string _rootFile; /** Geometry used in reconstruction **/ // number of physical layers in calorimeter int _nEcalLayers; int _nHcalLayers; // number of pseudolayers in calorimeter int _nPseudoLayers; int _nBarrelPseudoLayers; int _nEndcapPseudoLayers; // Azimuthal structure int _symmetry; int _ECALsymmetry; int _HCALsymmetry; int _HCALEndcapSymmetry; int _HCALInnerSymmetry; float _rOfBarrel; float _outerRadiusOfBarrelHCAL; float _outerRadiusOfEndcapHCAL; float _rearOfEndcapHCAL; float _barrelHCALLayerThickness; float _endcapHCALLayerThickness; float _maxTrackEnergy; float _phiOfBarrel; float _zOfEndcap; float _zOfHcalEndcap; float _rOfEndcap; float _rInnerEcalEndcap; float _zOfBarrel; float _bField; float _tpcInnerR; float _tpcOuterR; float _tpcZmax; float _tpcMaxRow; float _overlapCorrection; float _cosTPC; std::vector _barrelStaveDir; std::vector _barrelStaveDirHCAL; std::vector _endcapStaveDirHCAL; float _barrelPixelSizeT[MAX_NUMBER_OF_LAYERS]; float _barrelPixelSizeZ[MAX_NUMBER_OF_LAYERS]; // Layer Structure std::vector _ecalStructure; std::vector _ecalPadSizes; std::vector _hcalStructure; std::vector _hcalPadSizes; float _positionBarrelLayer[MAX_NUMBER_OF_LAYERS]; float _positionEndcapLayer[MAX_NUMBER_OF_LAYERS]; float _thicknessBarrelLayer[MAX_NUMBER_OF_LAYERS]; float _thicknessEndcapLayer[MAX_NUMBER_OF_LAYERS]; float _absThicknessBarrelLayer[MAX_NUMBER_OF_LAYERS]; float _absThicknessEndcapLayer[MAX_NUMBER_OF_LAYERS]; float _padSizeEcal[MAX_NUMBER_OF_LAYERS]; float _padSizeHcal[MAX_NUMBER_OF_LAYERS]; int _mipCells; int _mipMaxCellsHit; int _display; float _plotRange; int _displayUnusedTpcHits; int _showProtoClusterFormation; int _showProtoClusterAssociation; int _printing; int _analyseClusters; int _formClusterFromUnusedIsolatedHits; int _leakageCorrection; float _leavingHitWeightingFactor; int _leavingHitLayersFromEdge; // maximum layer in event int _layerMax; // HCAL lookup int _hcalLayerForIntRadius[10000]; // some monitoring quantities/histograms float _etotal; float _etotalnu; float _etotalnufwd; /** Analysis Histograms **/ // HISTOGRAMS // define vectors to hold histograms for ease of writing out std::vectorHistograms1D; std::vectorHistograms2D; TH2F* fLong1; TH2F* fLong1_2; TH2F* fLong2_5; TH2F* fLong5; TH2F* fLong1H; TH2F* fLong1_2H; TH2F* fLong2_5H; TH2F* fLong5H; TH1F* fEhad; TH2F* fMipDcos; TH1F* fEhadU; TH1F* fMipFrac; TH2F* fMipDcosU; TH1F* fEhadBT; TH2F* fMipDcosBT; TH2F* fPhotonEP; TH2F* fPhotonEPU; TH1F* fETot; TH1F* fETotI; TH1F* fETotN; TH1F* fETotL; TH1F* fETotLC; TH1F* fMKink; TH2F* eLong1; TH2F* eLong1_2; TH2F* eLong2_5; TH2F* eLong5; TH2F* eLong1H; TH2F* eLong1_2H; TH2F* eLong2_5H; TH2F* eLong5H; TH1F* eEhad; TH2F* eMipDcos; TH1F* eEhadU; TH2F* eMipDcosU; TH1F* eEhadBT; TH2F* eMipDcosBT; TH2F* ePhotonEP; TH2F* ePhotonEPU; TH1F* eETot; TH1F* eETotI; TH1F* eETotN; TH1F* eETotL; TH1F* eETotLC; TH1F* eMKink; TH2F* bLong1; TH2F* bLong1_2; TH2F* bLong2_5; TH2F* bLong5; TH2F* bLong1H; TH2F* bLong1_2H; TH2F* bLong2_5H; TH2F* bLong5H; TH1F* bEhad; TH2F* bMipDcos; TH1F* bEhadU; TH2F* bMipDcosU; TH1F* bEhadBT; TH2F* bMipDcosBT; TH2F* bPhotonEP; TH2F* bPhotonEPU; TH1F* bETot; TH1F* bETotI; TH1F* bETotN; TH1F* bETotL; TH1F* bETotLC; TH1F* bMKink; TH2F* fEhadLayerU; TH2F* eEhadLayerU; TH2F* bEhadLayerU; TH2F* fEhadLayer; TH2F* eEhadLayer; TH2F* bEhadLayer; TH2F* fEhadLayerBT; TH2F* eEhadLayerBT; TH2F* bEhadLayerBT; TH2F* fEhadLayersU; TH2F* eEhadLayersU; TH2F* bEhadLayersU; TH2F* fEhadLayers; TH2F* eEhadLayers; TH2F* bEhadLayers; TH2F* fEhadLayersBT; TH2F* eEhadLayersBT; TH2F* bEhadLayersBT; TH2F* fEhadHitsU; TH2F* eEhadHitsU; TH2F* bEhadHitsU; TH2F* fEhadHits; TH2F* eEhadHits; TH2F* bEhadHits; TH2F* fEhadHitsBT; TH2F* eEhadHitsBT; TH2F* bEhadHitsBT; TH1F* backhistrms[10]; TH1F* backhistfrac[10]; TH1F* backhiststart[10]; TH1F* sighistrms[10]; TH1F* sighistfrac[10]; TH1F* sighiststart[10]; } ; #endif