StV0TofCorrection.h

Go to the documentation of this file.

// $Id: StV0TofCorrection.h,v 1.2 2014/01/20 16:55:50 geurts Exp $
// ---
// $Log: StV0TofCorrection.h,v $
// Revision 1.2  2014/01/20 16:55:50  geurts
// Major update by Patrick Huck:
// - fixed memory leaks, clean-up
// - switch from a custom closest-points-of-approach-finder to the StHelix::pathLengths()
// - added a public helper function calcM2() to calculate mass^2 after TOF correction
//
// Revision 1.1  2011/01/24 21:01:49  geurts
// *** empty log message ***
//
// ---
#ifndef STV0TOFCORRECTION_H
#define STV0TOFCORRECTION_H

#include <stdio.h>
#include <stdarg.h>

#include <TROOT.h>
#include "TMath.h"
#include "StPhysicalHelixD.hh"
#include "StarClassLibrary/StLorentzVectorD.hh"
#include "StarClassLibrary/StThreeVectorD.hh"
#include <iostream> 
#include "TVirtualStreamerInfo.h"

#include <vector>
#include <map>


template < class T, class container = std::vector<T> >
class StInlineContainer : public container {
 private:
  Int_t NrArgs; 
  StInlineContainer<T>* pContainer; 
  
 public:
  StInlineContainer() { NrArgs = 0; pContainer = NULL; }
  virtual ~StInlineContainer() {}
  explicit StInlineContainer(const T vec) : container(1,vec) { } 
  StInlineContainer<T> operator()(const T vec) {
    NrArgs++;
    pContainer->setNrArgs(NrArgs);
    pContainer->push_back(vec);
    return *pContainer;
  }
  void setNrArgs(const Int_t& c) { NrArgs = c; }
  Int_t getNrArgs() { return NrArgs; }
  void setPointer2Container(StInlineContainer<T>* p) { pContainer = p; }
};

typedef std::map< std::string, std::pair<float, float> > M2CutType;


class StV0TofCorrection {
 private:
  inline Float_t calcTof(const StLorentzVectorD&, const Float_t&);
  inline Bool_t inputOk();
  inline Bool_t cutOnMass2(const Float_t&, const std::string&);

  Float_t clight; 
  Bool_t cleared, cleared2; 
  Int_t NrDecays; 
  StInlineContainer<StThreeVectorD>* Vectors3D; 
  StInlineContainer<StLorentzVectorD>* tracks; 

  static M2CutType createM2CutMap() {
    M2CutType m;
    m["pi"] = std::make_pair(0.015, 0.025);
    m["K"] = std::make_pair(0.2, 0.3);
    m["p"] = std::make_pair(0.8085, 1.15);
    return m;
  }

 public:
  StV0TofCorrection() ; 
  virtual ~StV0TofCorrection() ; 

  StInlineContainer<StThreeVectorD> setVectors3D(const StThreeVectorD vec) {
    if ( cleared ) {
      Vectors3D = new StInlineContainer<StThreeVectorD>;
    }
    else {
      const char* err_msg =
        "Make sure to call clearContainers() function"
        "every time a correction of a particle is done!"
        "Otherwise you're using the same container over and over again!";
      Error("StV0TofCorrection::setVectors3D", err_msg);
    }
    Vectors3D->setNrArgs(0);
    Vectors3D->setPointer2Container(Vectors3D);
    cleared = kFALSE;
    return (*Vectors3D)(vec);
  }

  StInlineContainer<StLorentzVectorD> setMotherTracks(const StLorentzVectorD tr) {
    if ( cleared2 ) {
      tracks  = new StInlineContainer<StLorentzVectorD>;
      tracks->setNrArgs(0);
      tracks->setPointer2Container(tracks);
      cleared2 = kFALSE;
      return (*tracks)(tr);
    }
    else {
      Error(
          "StV0TofCorrection::setMotherTracks",
          "Again: Don't forget clearContainers()!"
          );
      return (*tracks);
    }
  }

  Bool_t correctBeta(
      const StPhysicalHelixD&, const Float_t&, Float_t&,
      const Float_t& MomentumA = -999.,
      const std::string& particle = ""
      );
 
  //  (free allocated memory and set pointers to NULL)
  void clearContainers() {
    delete Vectors3D; delete tracks;
    Vectors3D = NULL; tracks = NULL;
    cleared = kTRUE; cleared2 = kTRUE;
  }

  inline Float_t calcM2(const Float_t& mom, const Float_t& beta) {
    Float_t f2 = 1./(beta*beta) - 1.;
    return mom*mom * f2;
  }

  static M2CutType mM2CutMap;

  ClassDef(StV0TofCorrection,1)
};
#endif