MadTVAnalysis.h

Go to the documentation of this file.

//
// MadTVAnalysis
//
// Tricia's MadAnalysis.  Copied from the Feb 3 version of the jan06 branch of 
// MadMKAnalysis
//

#ifndef MADTVANALYSIS
#define MADTVANALYSIS

#include <string>

#include "Mad/MadAnalysis.h"
#include "Conventions/PlaneCoverage.h"
#include "Conventions/PlaneView.h"
#include "Conventions/Detector.h"
#include "Registry/Registry.h"

//#include "MCReweight/BeamType.h"
#include "Conventions/BeamType.h"
#include "PhysicsNtuple/Store/Interface.h"

#include "Mad/MadNsID.h"
#include "Mad/MadDpID.h"
#include "Mad/MadQEID.h"
#include "Mad/MadAbID.h"

class TFile;
class VldContext;

class MadTVAnalysis : public MadAnalysis {

 public:  
  void CreatePAN(std::string s, const char* bmonpath="");
  MadTVAnalysis(TChain *chainSR=0,TChain *chainMC=0,
              TChain *chainTH=0,TChain *chainEM=0);
  MadTVAnalysis(JobC *,string,int);
  virtual ~MadTVAnalysis();

  Float_t ClosestPointToLine(const Float_t& x1, 
                             const Float_t& y1,
                             const Float_t& x2,
                             const Float_t& y2,
                             const Float_t& xpt,
                             const Float_t& ypt,
                             Float_t& x, Float_t& y);

  // fiducial volume and track containment as defined by pitt group
  static Bool_t PittInFidVol(Float_t x, Float_t y, 
                             Float_t z, Float_t u, Float_t v);
  static Int_t PittTrkContained(Float_t x, Float_t y, 
                                Float_t z, Float_t u, Float_t v);

  // is this strip in the partially instrumented region of the ND?
  static Int_t InPartialRegion(UShort_t plane, UShort_t strip);
  
  // pass back an bitfield with bits corresponding to radial cuts
  // Float_t rings[5]={0.1,0.25,0.5,1.0,1.5}; // in meters
  static Int_t NDRadialFidVol(Float_t x,Float_t y, Float_t z);

  void ForceMCBeam(const BeamType::BeamType_t& beam) {fMCBeam=beam;}
  const BeamType::BeamType_t& GetForcedMCBeam() {return fMCBeam;}
  void SetDataUseMCBeam(bool x) {fDataUseMCBeam=x;}

  void FillMCHists(TFile* fout);

  static int FarTrkContained(Float_t x, Float_t y, Float_t z);
  
  void SetRustemNearPID(string fname) {rustempidfile_near=fname;}
  void SetRustemFarPID(string fname) {rustempidfile_far=fname;}
  void SetRustemConfig(string fname) {rustemconfigfile=fname;}


  // PID calculator objects
  MadNsID nsid;
  MadDpID dpid;
  MadQEID qeid;
  MadAbID abid;
  bool openedabpidfile;
  
 protected:
  // signal inside and outside of the partial plane region
  // for whole event and just for track portion
  // uses currently loaded event and track  
  void SigInOut(Float_t& sigfull, Float_t& sigpart, Float_t& trkfull, Float_t& trkpart);
  void SigInOut(Int_t trkidx, Float_t& sigfull, Float_t& sigpart, Float_t& trkfull, Float_t& trkpart);


  // from base class
//  Float_t RecoAnalysisEnergy(Int_t event);
//  Float_t RecoShwEnergy(int ishw, const Detector::Detector_t& det, int mode=1, bool isdata=true);
  //  Float_t RecoMKMuEnergy(Int_t& opt, Int_t itrk, bool isdata=true, Detector::Detector_t det=Detector::kNear);

  //  virtual Bool_t PassBasicCuts(Int_t event);

  // muon angle with respect to neutrino angle
  // it's detector dependant!
  virtual Float_t RecoMuDCosNeuND(Int_t itr=0, Float_t* vtx=0);
  virtual Float_t RecoMuDCosNeuFD(Int_t itr=0, Float_t* vtx=0);
  
  //  virtual Float_t RecoKinematics(Int_t event);

  virtual bool InFidVol(Int_t evidx);
  virtual bool InFidVol(); // assumes event already loaded,
                           //and that we're interested in event vertex
  bool InFidVol(float vx, float vy, float vz); //looks to see if vx,vy,vz 
                                               //is in fid. vol

  void SetBECFile(const char* f);
  Registry& GetBECRegistry() { return fBECConfig; }

  // number of planes in the reconstructed object
  // possibly with a ph cut in pes
  // return the sigcor, after the ph cut, in sumph
  Int_t NPlanesInObj(TObject *rec, TObject *obj, float phcut, float& sumph);
  Int_t NStripsInObj(TObject *rec, TObject *obj, float phcut, float& sumph);
  //GetEvtTimeChar assumesevent is already loaded
  void GetEvtTimeChar(double &timemin, double &timemax, double &timeln);
  void GetEvtTimeCharPHC(double &timemin, double &timemax, double &timeln);

  int FindBatchNumber(double mintimediff);

  float MuonShowerEnergy(const NtpSREvent* evt, const NtpSRTrack* trk);
  
  void EarlyActivity(int evidx, float &earlywph, float &earlywphpw, 
                     float &earlywphsphere, float &ph1000, 
                     float &ph500, float &ph100,
                     float &lateph1000, 
                     float &lateph500, float &lateph100,
                     float &lateph50);

  //a function to count the number of reconstructed strips 
  //that are in this event and in some other event
  //(by reconstructed strips I mean CandStripSR)
  void DupRecoStrips(int evidx, int &nduprs, float &dupphrs);
  
  float ComputeLowPHRatio();
  //  bool FDRCBoundary(int p1, int p2);
  Int_t FDRCBoundary();
  
  Float_t GetNDCoilCurrent(const VldContext& vc);


 private:
  
  // Z (m) locations in the ND (for fiducial cuts)
  static const Float_t kVetoEndZ;
  static const Float_t kTargEndZ;
  static const Float_t kCalorEndZ;
  static const Float_t kHalfCalorEndZ;
  static const Float_t kSpecEndZ;
  // xy beam center in ND
  static const Float_t kXcenter;
  static const Float_t kYcenter;

  //constants for EarlyActivity estimation
  static const Double_t fEarlyActivityWindowSize;
  static const Double_t fPMTTimeConstant;
  static const Int_t fNPlaneEarlyAct;
  static const Double_t fEarlyPlaneSphere;


  //  std::string fBECFile; // file for beam energy reweighting
  Registry fBECConfig; // config for beam energy reweighting
  BeamType::BeamType_t fMCBeam;
  bool fDataUseMCBeam;
  
  Anp::Interface *phnti;
  string rustempidfile_near;
  string rustempidfile_far;
  string rustemconfigfile;

};

#endif

---