massDependence.h

Go to the documentation of this file.

//
//    Copyright 2010
//
//    This file is part of rootpwa
//
//    rootpwa is free software: you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation, either version 3 of the License, or
//    (at your option) any later version.
//
//    rootpwa is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with rootpwa. If not, see <http://www.gnu.org/licenses/>.
//
//-------------------------------------------------------------------------
// File and Version Information:
// $Rev::                             $: revision of last commit
// $Author::                          $: author of last commit
// $Date::                            $: date of last commit
//
// Description:
//      class hierarchy for mass-dependent part of the amplitude
//
//
// Author List:
//      Boris Grube          TUM            (original author)
//
//
//-------------------------------------------------------------------------


#ifndef MASSDEPENDENCE_H
#define MASSDEPENDENCE_H


#include <iostream>
#include <complex>

#include <boost/shared_ptr.hpp>
#include <boost/numeric/ublas/matrix.hpp>


namespace ublas = boost::numeric::ublas;


namespace rpwa {

        class isobarDecayVertex;
        typedef boost::shared_ptr<isobarDecayVertex> isobarDecayVertexPtr;


        class massDependence {

        public:

                massDependence()          { }
                virtual ~massDependence() { }

                virtual std::complex<double> amp(const isobarDecayVertex& v) = 0;

                virtual std::complex<double> operator ()(const isobarDecayVertex& v) { return amp(v); }

                virtual std::string name() const { return "massDependence"; }  

                bool operator ==(const massDependence& rhsMassDep) const { return this->isEqualTo(rhsMassDep); }
                bool operator !=(const massDependence& rhsMassDep) const { return not (*this == rhsMassDep);   }

                virtual std::ostream& print(std::ostream& out) const;

                static bool debug() { return _debug; }                             
                static void setDebug(const bool debug = true) { _debug = debug; }  


        protected:

                virtual bool isEqualTo(const massDependence& massDep) const
                { return typeid(massDep) == typeid(*this); }  

                static bool _debug;  

        };


        typedef boost::shared_ptr<massDependence> massDependencePtr;


        inline
        std::ostream&
        operator <<(std::ostream&         out,
                    const massDependence& massDep)
        {
                return massDep.print(out);
        }


        class flatMassDependence : public massDependence {

        public:

                flatMassDependence() : massDependence() { }
                virtual ~flatMassDependence()           { }

                virtual std::complex<double> amp(const isobarDecayVertex&);

                virtual std::string name() const { return "flatMassDependence"; }  

        };


        typedef boost::shared_ptr<flatMassDependence> flatMassDependencePtr;


        inline
        flatMassDependencePtr
        createFlatMassDependence()
        {
                flatMassDependencePtr massDep(new flatMassDependence());
                return massDep;
        }


        class relativisticBreitWigner : public massDependence {

        public:

                relativisticBreitWigner() : massDependence() { }
                virtual ~relativisticBreitWigner()           { }

                virtual std::complex<double> amp(const isobarDecayVertex& v);

                virtual std::string name() const { return "relativisticBreitWigner"; }  

        };


        typedef boost::shared_ptr<relativisticBreitWigner> relativisticBreitWignerPtr;


        inline
        relativisticBreitWignerPtr
        createRelativisticBreitWigner()
        {
                relativisticBreitWignerPtr massDep(new relativisticBreitWigner());
                return massDep;
        }


        class constWidthBreitWigner : public massDependence {

        public:

                constWidthBreitWigner() : massDependence() { }
                virtual ~constWidthBreitWigner()           { }

                virtual std::complex<double> amp(const isobarDecayVertex& v);

                virtual std::string name() const { return "constWidthBreitWigner"; }  

        };


        typedef boost::shared_ptr<constWidthBreitWigner> constWidthBreitWignerPtr;


        inline
        constWidthBreitWignerPtr
        createConstWidthBreitWigner()
        {
                constWidthBreitWignerPtr massDep(new constWidthBreitWigner());
                return massDep;
        }


        class rhoBreitWigner : public massDependence {

        public:

                rhoBreitWigner() : massDependence() { }
                virtual ~rhoBreitWigner()           { }

                virtual std::complex<double> amp(const isobarDecayVertex& v);

                virtual std::string name() const { return "rhoBreitWigner"; }  

        };


        typedef boost::shared_ptr<rhoBreitWigner> rhoBreitWignerPtr;


        inline
        rhoBreitWignerPtr
        createRhoBreitWigner()
        {
                rhoBreitWignerPtr massDep(new rhoBreitWigner());
                return massDep;
        }


        class f0980BreitWigner : public massDependence {

        public:

                f0980BreitWigner() : massDependence() { }
                virtual ~f0980BreitWigner()           { }

                virtual std::complex<double> amp(const isobarDecayVertex& v);

                virtual std::string name() const { return "f0980BreitWigner"; }  

        };


        typedef boost::shared_ptr<f0980BreitWigner> f0980BreitWignerPtr;


        inline
        f0980BreitWignerPtr
        createF0980BreitWigner()
        {
                f0980BreitWignerPtr massDep(new f0980BreitWigner());
                return massDep;
        }


        class piPiSWaveAuMorganPenningtonM : public massDependence {

        public:

                piPiSWaveAuMorganPenningtonM();
                virtual ~piPiSWaveAuMorganPenningtonM() { }

                virtual std::complex<double> amp(const isobarDecayVertex& v);

                virtual std::string name() const { return "piPiSWaveAuMorganPenningtonM"; }  

        protected:

                ublas::matrix<std::complex<double> >               _T;
                std::vector<ublas::matrix<std::complex<double> > > _a;
                std::vector<ublas::matrix<std::complex<double> > > _c;
                ublas::matrix<double>                              _sP;
                int                                                _vesSheet;

                double _piChargedMass;
                double _piNeutralMass;
                double _kaonChargedMass;
                double _kaonNeutralMass;
                double _kaonMeanMass;

        };


        typedef boost::shared_ptr<piPiSWaveAuMorganPenningtonM> piPiSWaveAuMorganPenningtonMPtr;


        inline
        piPiSWaveAuMorganPenningtonMPtr
        createPiPiSWaveAuMorganPenningtonM()
        {
                piPiSWaveAuMorganPenningtonMPtr massDep(new piPiSWaveAuMorganPenningtonM());
                return massDep;
        }


        class piPiSWaveAuMorganPenningtonVes : public piPiSWaveAuMorganPenningtonM {

        public:

                piPiSWaveAuMorganPenningtonVes();
                virtual ~piPiSWaveAuMorganPenningtonVes() { }

                virtual std::complex<double> amp(const isobarDecayVertex& v);

                virtual std::string name() const { return "piPiSWaveAuMorganPenningtonVes"; }  

        };


        typedef boost::shared_ptr<piPiSWaveAuMorganPenningtonVes> piPiSWaveAuMorganPenningtonVesPtr;


        inline
        piPiSWaveAuMorganPenningtonVesPtr
        createPiPiSWaveAuMorganPenningtonVes()
        {
                piPiSWaveAuMorganPenningtonVesPtr massDep(new piPiSWaveAuMorganPenningtonVes());
                return massDep;
        }


        class piPiSWaveAuMorganPenningtonKachaev : public piPiSWaveAuMorganPenningtonM {

        public:

                piPiSWaveAuMorganPenningtonKachaev();
                virtual ~piPiSWaveAuMorganPenningtonKachaev() { }

                virtual std::string name() const { return "piPiSWaveAuMorganPenningtonKachaev"; }  

        };


        typedef boost::shared_ptr<piPiSWaveAuMorganPenningtonKachaev> piPiSWaveAuMorganPenningtonKachaevPtr;


        inline
        piPiSWaveAuMorganPenningtonKachaevPtr
        createPiPiSWaveAuMorganPenningtonKachaev()
        {
                piPiSWaveAuMorganPenningtonKachaevPtr massDep(new piPiSWaveAuMorganPenningtonKachaev());
                return massDep;
        }


        class rhoPrimeMassDep : public massDependence {

        public:

                rhoPrimeMassDep() : massDependence() { }
                virtual ~rhoPrimeMassDep()           { }

                virtual std::complex<double> amp(const isobarDecayVertex& v);

                virtual std::string name() const { return "rhoPrimeMassDep"; }  

        };


        typedef boost::shared_ptr<rhoPrimeMassDep> rhoPrimeMassDepPtr;


        inline
        rhoPrimeMassDepPtr
        createRhoPrimeMassDep()
        {
                rhoPrimeMassDepPtr massDep(new rhoPrimeMassDep());
                return massDep;
        }


}  // namespace rpwa


#endif  // MASSDEPENDENCE_H