MappedDalitzArea Class Reference

#include <MappedDalitzArea.h>

Public Member Functions
	MappedDalitzArea ()
	MappedDalitzArea (const DalitzEventPattern &pat, TRandom *rnd=gRandom)
	MappedDalitzArea (const DalitzEventPattern &pat, const DalitzCoordinate &oneLimit, TRandom *rnd=gRandom)
	MappedDalitzArea (const DalitzEventPattern &pat, const DalitzCoordinate &oneLimit, const DalitzCoordinate &otherLimit, TRandom *rnd=gRandom)
	MappedDalitzArea (const DalitzEventPattern &pat, const std::vector< DalitzCoordinate > &limits, TRandom *rnd=gRandom)
	MappedDalitzArea (const MappedDalitzArea &other)
virtual	~MappedDalitzArea ()
MINT::counted_ptr< DalitzEvent >	makeEventForOwner () const
MINT::counted_ptr< DalitzEvent >	makeEventForOwner (double scale0, double scale1, double scale2, double scale3, double scale4) const
std::vector< DalitzCoordinate >	centre () const
bool	isInside (const DalitzEvent &evt) const
bool	isInside (const DalitzCoordinate &dc) const
bool	isInside (const std::vector< DalitzCoordinate > &dcList) const
double	size () const
void	print (std::ostream &os=std::cout) const
void	encloseInPhaseSpaceArea ()
std::vector< MappedDalitzArea >	split (unsigned int nWays) const
std::vector< MappedDalitzArea >	split (unsigned int limitIndex, unsigned int nWays) const
std::vector< MappedDalitzArea >	splitIfWiderThan (double maxWidth) const
std::vector< MappedDalitzArea >	splitIfWiderThan (unsigned int limitIndex, double maxWidth) const
DalitzCoordinate	limit_s (const std::vector< int > &indices) const
DalitzCoordinate	limit_s (int i, int j, int k=-1) const
bool	setRnd (TRandom *rnd=gRandom)
bool	similar (const MappedDalitzArea &ma) const
bool	less (const MappedDalitzArea &ma) const
MappedDalitzArea &	operator= (const MappedDalitzArea &other)
bool	operator< (const MappedDalitzArea &rhs) const
bool	operator<= (const MappedDalitzArea &rhs) const
bool	operator> (const MappedDalitzArea &rhs) const
bool	operator>= (const MappedDalitzArea &rhs) const
bool	operator== (const MappedDalitzArea &ma) const
bool	operator!= (const MappedDalitzArea &ma) const

Private Member Functions
void	setup ()
void	findMapping ()
void	applyLimits ()
bool	allConsecutive () const
bool	allStandardised () const

Static Private Member Functions
static std::vector< TLorentzVector >	mapP4 (const DalitzEvent &evt, const Permutation &mapping)
static std::vector< TLorentzVector > &	mapP4 (const DalitzEvent &evt, const Permutation &mapping, std::vector< TLorentzVector > &p4)

Private Attributes
TRandom *	_rnd
DalitzEventPattern	_pat
DalitzEventPattern	_mappedPat
DalitzArea	_area
std::vector< DalitzCoordinate >	_limits
Permutation	_mapping
Permutation	_inverseMapping

Detailed Description

Definition at line 20 of file MappedDalitzArea.h.

Constructor & Destructor Documentation

MappedDalitzArea() [1/6]

MappedDalitzArea::MappedDalitzArea

(

)

Definition at line 25 of file MappedDalitzArea.cpp.

  : _rnd(0)
  , _pat()
  , _mappedPat()
  , _area()
  , _limits()
  , _mapping()
  , _inverseMapping()
{
  setup();
}

MappedDalitzArea() [2/6]

MappedDalitzArea::MappedDalitzArea	(	const DalitzEventPattern &	pat,
		TRandom *	rnd = gRandom
	)

Definition at line 36 of file MappedDalitzArea.cpp.

  : _rnd(rnd)
  , _pat(pat)
  , _mappedPat(pat)
  , _area(pat)
  , _limits()
  , _mapping(pat.size())
  , _inverseMapping(pat.size())
{
  setup();
}

MappedDalitzArea() [3/6]

MappedDalitzArea::MappedDalitzArea	(	const DalitzEventPattern &	pat,
		const DalitzCoordinate &	oneLimit,
		TRandom *	rnd = gRandom
	)

Definition at line 48 of file MappedDalitzArea.cpp.

  : _rnd(rnd)
  , _pat(pat)
  , _mappedPat(pat)
  , _limits(1)
  , _mapping(pat.size())
  , _inverseMapping(pat.size())
{
  _limits[0] = oneLimit;
  setup();
}

MappedDalitzArea() [4/6]

MappedDalitzArea::MappedDalitzArea	(	const DalitzEventPattern &	pat,
		const DalitzCoordinate &	oneLimit,
		const DalitzCoordinate &	otherLimit,
		TRandom *	rnd = gRandom
	)

Definition at line 62 of file MappedDalitzArea.cpp.

  : _rnd(rnd)
  , _pat(pat)
  , _mappedPat(pat)
  , _limits(2)
  , _mapping(pat.size())
  , _inverseMapping(pat.size())
{
  _limits[0] = oneLimit;
  _limits[1] = otherLimit;
  /*
  cout << " just made a MappedDalitzArea with limits :"
       << oneLimit << ", " << otherLimit << " or "
       << _limits[0] << ", " << _limits[1] << endl;
  */
  setup();
  /*
  cout << " ..after setup: "
       << _limits[0] << ", " << _limits[1] << endl;
  */
}

MappedDalitzArea() [5/6]

MappedDalitzArea::MappedDalitzArea	(	const DalitzEventPattern &	pat,
		const std::vector< DalitzCoordinate > &	limits,
		TRandom *	rnd = gRandom
	)

Definition at line 88 of file MappedDalitzArea.cpp.

  : _rnd(rnd)
  , _pat(pat)
  , _mappedPat(pat)
  , _limits(lim)
  , _mapping(pat.size())
  , _inverseMapping(pat.size())
{
  setup();
}

MappedDalitzArea() [6/6]

MappedDalitzArea::MappedDalitzArea

(

const MappedDalitzArea &

other

)

Definition at line 102 of file MappedDalitzArea.cpp.

  : _rnd(other._rnd)
  , _pat(other._pat)
  , _mappedPat(other._mappedPat)
  , _area(other._area)
  , _limits(other._limits)
  , _mapping(other._mapping)
  , _inverseMapping(other._inverseMapping)
{
}

~MappedDalitzArea()

MappedDalitzArea::~MappedDalitzArea ( )

virtual

Definition at line 124 of file MappedDalitzArea.cpp.

                                   {
}

Member Function Documentation

allConsecutive()

bool MappedDalitzArea::allConsecutive ( ) const

private

Definition at line 127 of file MappedDalitzArea.cpp.

                                           {
  for(unsigned int i=0; i < _limits.size(); i++){
    DalitzCoordinate newCoordinates = (_limits[i]).mapMe(_mapping);
    /*
    cout << "mapped new coordinates: " 
     << i << ": " << newCoordinates << endl;
    */
    if(! (newCoordinates.I_am_Consecutive())) return false;
  }
  return true;
}

allStandardised()

bool MappedDalitzArea::allStandardised ( ) const

private

applyLimits()

void MappedDalitzArea::applyLimits ( )

private

Definition at line 190 of file MappedDalitzArea.cpp.

                                  {

  for(unsigned int i=0; i < _limits.size(); i++){
    cout << "mapped co-ordinates " << _limits[i].mapMe(_mapping) << endl;
    _area.setCoordinate(_limits[i].mapMe(_mapping));
  }
  _area.encloseInPhaseSpaceArea();
}

centre()

std::vector< DalitzCoordinate > MappedDalitzArea::centre

(

)

const

Definition at line 240 of file MappedDalitzArea.cpp.

                                                          {
  std::vector<DalitzCoordinate> c(_limits);
  for(unsigned int i=0; i < c.size(); i++){
    c[i].setVal(0.5*(c[i].min() + c[i].max()));
  }
  return c;
}

encloseInPhaseSpaceArea()

void MappedDalitzArea::encloseInPhaseSpaceArea ( )

inline

Definition at line 81 of file MappedDalitzArea.h.

                                {
    _area.encloseInPhaseSpaceArea();
  }

findMapping()

void MappedDalitzArea::findMapping ( )

private

Definition at line 139 of file MappedDalitzArea.cpp.

                                  {
  _mapping.makeUnity();
  if(allConsecutive()) return;

  DalitzEventPattern tmpPat(_pat);
  tmpPat[0] =1;
  for(unsigned int i=1; i< _pat.size(); i++){
    tmpPat[i]=0;
  }

  Permutator ptor(tmpPat);// this finds all mappings
  // leaving the 0th particle alone (the mother) and
  // swapping all the daughters - the pattern
  // is set up to achieve this ('particles' 1,2,3,4,.. are identical)

  for(unsigned int i=0; i< ptor.size(); i++){
    _mapping = ptor[i];
    cout << " trying out mapping\n " << _mapping << endl;
    if(allConsecutive()){
      break;
    }
  }
  _inverseMapping = _mapping.getInverse();
  for(unsigned int i=0; i < _pat.size(); i++){
    int mappedIndex = _mapping[i];
    if(mappedIndex < 0 || mappedIndex >= (int) _mappedPat.size()){
      cout << "ERROR in MappedDalitzArea::findMapping()"
       << "\n   Index out of range: " << mappedIndex
       << " not in [0, " << _mappedPat.size()-1
       << endl;
      throw "index out of range.";
    }
    cout << " mapped index of " << i << " = " << mappedIndex << endl;
    _mappedPat[mappedIndex] = _pat[i];
  }

  cout << " using the following mapping:\n "
       << _mapping << endl;
  cout << "_mappedPat " << _mappedPat << endl;
}

isInside() [1/3]

bool MappedDalitzArea::isInside

(

const DalitzEvent &

evt

)

const

Definition at line 270 of file MappedDalitzArea.cpp.

                                                           {

  vector<TLorentzVector> p4 = 
    mapP4(evt, _mapping );

  DalitzEvent mappedEvt(_mappedPat, p4);
  return _area.isInside(mappedEvt);
}

isInside() [2/3]

bool MappedDalitzArea::isInside

(

const DalitzCoordinate &

dc

)

const

Definition at line 279 of file MappedDalitzArea.cpp.

                                                               {
  return _area.isInside(dc.mapMe(_mapping));
}

isInside() [3/3]

bool MappedDalitzArea::isInside

(

const std::vector< DalitzCoordinate > &

dcList

)

const

Definition at line 282 of file MappedDalitzArea.cpp.

                                                                              {
  //  cout << " inside this: " << *this << endl;
  for(unsigned int i=0; i < dcList.size(); i++){
    if(! isInside(dcList[i])){
      //     cout << "Not inside: " << dcList[i]
      //       << "\n\tmapped: " << dcList[i].mapMe(_mapping)
      //       << endl;
      return false;
    }
  }
  return true;

}

less()

bool MappedDalitzArea::less

(

const MappedDalitzArea &

ma

)

const

Definition at line 430 of file MappedDalitzArea.cpp.

                                                            {
  if(_limits.size() < rhs._limits.size()) return true;
  if(_limits.size() > rhs._limits.size()) return false;

  for(unsigned int i=0; i < _limits.size(); i++){
    if(_limits[i].size() < rhs._limits[i].size()) return true;
    if(_limits[i].size() > rhs._limits[i].size()) return false;
    for(unsigned int j=0; j < _limits[i].size(); j++){
      if( (_limits[i])[j] < (rhs._limits[i])[j]) return true;
      if( (_limits[i])[j] > (rhs._limits[i])[j]) return false;
    }

    if( (_limits[i].min() < rhs._limits[i].min()) ) return true;
    if( (_limits[i].min() > rhs._limits[i].min()) ) return false;

    if( (_limits[i].max() < rhs._limits[i].max()) ) return true;
    if( (_limits[i].max() > rhs._limits[i].max()) ) return false;
  }
  return false;
}

limit_s() [1/2]

DalitzCoordinate MappedDalitzArea::limit_s

(

const std::vector< int > &

indices

)

const

Definition at line 388 of file MappedDalitzArea.cpp.

                                                                             {
  DalitzCoordinate dc(indices);

  for(unsigned int i=0; i < _limits.size(); i++){
    if(_limits[i].size() != dc.size()) continue;
    for(unsigned int j=0; j < dc.size(); j++){
      if(_limits[i][j] != dc[j]){
    continue;
      }
    }
    return _limits[i];
  }
  return dc;
}

limit_s() [2/2]

DalitzCoordinate MappedDalitzArea::limit_s	(	int	i,
		int	j,
		int	k = -1
	)		const

Definition at line 402 of file MappedDalitzArea.cpp.

                                                                   {
    std::vector<int> v;
    v.push_back(i);
    v.push_back(j);
    if(k >=0)v.push_back(k);
    return limit_s(v);
}

makeEventForOwner() [1/2]

counted_ptr< DalitzEvent > MappedDalitzArea::makeEventForOwner

(

)

const

Definition at line 228 of file MappedDalitzArea.cpp.

                                                                  {
  counted_ptr<DalitzEvent> mappedEvt( _area.makeEventForOwner());
  if(0 == mappedEvt){
    return mappedEvt;
  }
  static vector<TLorentzVector> p4; 
  mapP4( *mappedEvt, _inverseMapping, p4 );
  
  counted_ptr<DalitzEvent> evt(new DalitzEvent(_pat, p4));
  return evt;
}

makeEventForOwner() [2/2]

counted_ptr< DalitzEvent > MappedDalitzArea::makeEventForOwner	(	double	scale0,
		double	scale1,
		double	scale2,
		double	scale3,
		double	scale4
	)		const

Definition at line 247 of file MappedDalitzArea.cpp.

                                        {
  counted_ptr<DalitzEvent> mappedEvt( _area.makeEventForOwner(scale0
                                  , scale1
                                  , scale2
                                  , scale3
                                  , scale4
                                  )
                      );
  if(0 == mappedEvt){
    return mappedEvt;
  }
  vector<TLorentzVector> p4 = 
    mapP4( *mappedEvt, _inverseMapping );
  
  counted_ptr<DalitzEvent> evt(new DalitzEvent(_pat, p4));
  return evt;
}

mapP4() [1/2]

vector< TLorentzVector > MappedDalitzArea::mapP4 ( const DalitzEvent &  evt, const Permutation &  mapping  )

staticprivate

Definition at line 199 of file MappedDalitzArea.cpp.

                            {
  vector<TLorentzVector> p4(evt.eventPattern().size());
  return mapP4(evt, mapping, p4);
}

mapP4() [2/2]

static std::vector<TLorentzVector>& MappedDalitzArea::mapP4 ( const DalitzEvent &  evt, const Permutation &  mapping, std::vector< TLorentzVector > &  p4  )

staticprivate

operator!=()

bool MappedDalitzArea::operator!=

(

const MappedDalitzArea &

ma

)

const

Definition at line 472 of file MappedDalitzArea.cpp.

                                                                  {
  return ! ( (*this) == rhs);
}

operator<()

bool MappedDalitzArea::operator<

(

const MappedDalitzArea &

rhs

)

const

Definition at line 451 of file MappedDalitzArea.cpp.

                                                                 {
  return this->less(rhs);
}

operator<=()

bool MappedDalitzArea::operator<=

(

const MappedDalitzArea &

rhs

)

const

Definition at line 454 of file MappedDalitzArea.cpp.

                                                                  {
  return (this->less(rhs) || (*this) == rhs);
}

operator=()

MappedDalitzArea & MappedDalitzArea::operator=

(

const MappedDalitzArea &

other

)

Definition at line 113 of file MappedDalitzArea.cpp.

                                                                          {
  _rnd = other._rnd;
  _pat = other._pat;
  _mappedPat = other._mappedPat;
  _area = other._area;
  _limits = other._limits;
  _mapping = other._mapping;
  _inverseMapping = other._inverseMapping;
  return *this;
}

operator==()

bool MappedDalitzArea::operator==

(

const MappedDalitzArea &

ma

)

const

Definition at line 464 of file MappedDalitzArea.cpp.

                                                                  {
  if(_limits.size() != rhs._limits.size()) return false;
  for(unsigned int i=0; i < _limits.size(); i++){
    if(_limits[i] != rhs._limits[i]) return false;
  }
  return true;
}

operator>()

bool MappedDalitzArea::operator>

(

const MappedDalitzArea &

rhs

)

const

Definition at line 457 of file MappedDalitzArea.cpp.

                                                                 {
  return ! ((*this) < rhs || (*this) == rhs);
}

operator>=()

bool MappedDalitzArea::operator>=

(

const MappedDalitzArea &

rhs

)

const

Definition at line 460 of file MappedDalitzArea.cpp.

                                                                  {
  return ! ((*this) < rhs);
}

print()

void MappedDalitzArea::print

(

std::ostream &

os = std::cout

)

const

Definition at line 477 of file MappedDalitzArea.cpp.

                                                {
  os << " MappedDalitzArea "
     << " limits: ";
  for(unsigned int i=0; i < _limits.size(); i++){
    os << "\n  " << _limits[i] << endl;
  }

  os << "\n  Mapping:\n " << _mapping
     << "\n area: " << _area;
}

setRnd()

bool MappedDalitzArea::setRnd

(

TRandom *

rnd = gRandom

)

Definition at line 488 of file MappedDalitzArea.cpp.

                                         {
  _rnd = rnd;
  _area.setRnd(rnd);
  return true;
}

setup()

void MappedDalitzArea::setup ( )

private

Definition at line 180 of file MappedDalitzArea.cpp.

                            {
  sort(_limits.begin(), _limits.end());

  findMapping();
  cout << " mappedPat " << _mappedPat << endl;
  _area.setPattern(_mappedPat);
  _area.setRnd(_rnd);
  applyLimits();
}

similar()

bool MappedDalitzArea::similar

(

const MappedDalitzArea &

ma

)

const

Definition at line 410 of file MappedDalitzArea.cpp.

                                                               {
  // doesn't work, don't know why.
  if(_limits.size() != rhs._limits.size()) return false;
  double epsilon = 1.e-4;
  for(unsigned int i=0; i < _limits.size(); i++){
    if(_limits[i].size() != rhs._limits[i].size()) return false;
    for(unsigned int j=0; j < _limits[i].size(); j++){
      if( (_limits[i])[j] != (rhs._limits[i])[j]) return false;
    }

    if( (_limits[i].min() - rhs._limits[i].min()) 
    > epsilon * (_limits[i].min() + rhs._limits[i].min()) 
    ) return false;
    if( (_limits[i].max() - rhs._limits[i].max()) 
    > epsilon * (_limits[i].max() + rhs._limits[i].max()) 
    ) return false;
  }
  return true;
}

size()

double MappedDalitzArea::size ( ) const

inline

Definition at line 76 of file MappedDalitzArea.h.

                     {
    return _area.size();}

split() [1/2]

std::vector< MappedDalitzArea > MappedDalitzArea::split

(

unsigned int

nWays

)

const

Definition at line 318 of file MappedDalitzArea.cpp.

                                           {
  std::vector<MappedDalitzArea> returnList;
  if(n ==0 ) return returnList;

  std::vector<MappedDalitzArea> newList;
  returnList.push_back(*this);
  for(unsigned int limitIndex=0; limitIndex< _limits.size(); limitIndex++){
    std::vector<MappedDalitzArea> thisIterationsList;
    for(unsigned int j=0; j < returnList.size(); j++){
      std::vector<MappedDalitzArea> tempList = 
    returnList[j].split(limitIndex, n);
      thisIterationsList.insert(thisIterationsList.end()
                , tempList.begin(), tempList.end()
                );
    }
    returnList = thisIterationsList;
  }

  return returnList;
}

split() [2/2]

std::vector<MappedDalitzArea> MappedDalitzArea::split	(	unsigned int	limitIndex,
		unsigned int	nWays
	)		const

splitIfWiderThan() [1/2]

std::vector< MappedDalitzArea > MappedDalitzArea::splitIfWiderThan

(

double

maxWidth

)

const

Definition at line 367 of file MappedDalitzArea.cpp.

                                                       {
  std::vector<MappedDalitzArea> returnList;
  if(maxWidth <= 0 ) return returnList;

  std::vector<MappedDalitzArea> newList;
  returnList.push_back(*this);
  for(unsigned int limitIndex=0; limitIndex< _limits.size(); limitIndex++){
    std::vector<MappedDalitzArea> thisIterationsList;
    for(unsigned int j=0; j < returnList.size(); j++){
      std::vector<MappedDalitzArea> tempList = 
    returnList[j].splitIfWiderThan(limitIndex, maxWidth);
      thisIterationsList.insert(thisIterationsList.end()
                , tempList.begin(), tempList.end()
                );
    }
    returnList = thisIterationsList;
  }

  return returnList;
}

splitIfWiderThan() [2/2]

std::vector<MappedDalitzArea> MappedDalitzArea::splitIfWiderThan	(	unsigned int	limitIndex,
		double	maxWidth
	)		const

Member Data Documentation

_area

DalitzArea MappedDalitzArea::_area

private

Definition at line 25 of file MappedDalitzArea.h.

_inverseMapping

Permutation MappedDalitzArea::_inverseMapping

private

Definition at line 29 of file MappedDalitzArea.h.

_limits

std::vector<DalitzCoordinate> MappedDalitzArea::_limits

private

Definition at line 27 of file MappedDalitzArea.h.

_mappedPat

DalitzEventPattern MappedDalitzArea::_mappedPat

private

Definition at line 23 of file MappedDalitzArea.h.

_mapping

Permutation MappedDalitzArea::_mapping

private

Definition at line 29 of file MappedDalitzArea.h.

_pat

DalitzEventPattern MappedDalitzArea::_pat

private

Definition at line 23 of file MappedDalitzArea.h.

_rnd

TRandom* MappedDalitzArea::_rnd

private

Definition at line 21 of file MappedDalitzArea.h.

---

The documentation for this class was generated from the following files:

• Mint/MappedDalitzArea.h
• src/Mojito/BetterMC/MappedDalitzArea.cpp