Page MenuHomeHEPForge
Files F8308534

ScannerSModelclasses.h
No OneTemporary
Actions

ScannerSModelclasses.h
View Options

#ifndef SCANNERSMODELCLASSES_H
#define SCANNERSMODELCLASSES_H
#include "ScannerSTools.h"
#include <cmath>
class PhiVec;
class MmixingRef;
typedef PhiVec PhiParamVec;
typedef VecTriplet MLparamVec;
typedef VecTriplet MixingparamVec;
class PhiVec: public VecTriplet {
public:
friend class Monomial;
void generate(); //function to generate the vev space uniformly
void generate(double (*)(const std::vector<double> &)); // version with a function defining a pdf to re-weigh or reject regions
//void Parametrization(const PhiParamVec & PhiPar,void (*PhiParametrization)(const PhiParamVec &,PhiVec &));//Use parametrization instead
void setphi(const std::vector<double> & phi_in); // Function to reset the values of phi
PhiVec(){}//Consructor must include a reference to the random number generator
private:
RandGen r; // reference to random number generator in use
};
class Couplings{
public:
typedef VecTriplet::size_type size_type;
friend std::istream & operator>>(std::istream & in, Couplings & C){in>>C.L>>C.Mass; return in;} //Overloaded input operator to initialise
friend std::ostream & operator<<(std::ostream & os, const Couplings & C){os<<C.L<<"\t"<<C.Mass; return os;} //Overloaded input operator to initialise
Couplings(){}//Consructor must include a reference to the random number generator
size_type size()const{return L.size();}
double & operator[](size_type i){return L[i];}
double operator[](size_type i)const{return L[i];}
VecTriplet L; // Triplet to hold lagrangian couplings and ranges
std::vector<unsigned int> Lindp;
VecTriplet Mass; //Triplet to hold masses squared and ranges
std::vector<unsigned int> Mindp;
private:
RandGen r; // reference to random number generator in use
};
class deriv2V{
public:
typedef std::vector<double>::size_type size_type;
typedef std::vector< std::vector< std::vector<double> > >::iterator iterator;
std::vector< std::vector<double> > & operator[](size_type i){return d2V[i];}
deriv2V(){}
deriv2V(const std::vector< std::vector< std::vector<double> > > & Vec):d2V(Vec),Mag(Vec.size()){}
double mag(size_type i)const{return Mag[i];}
iterator begin(){return d2V.begin();}
iterator end(){return d2V.end();}
size_type size(){return d2V.size();}
std::vector<double> Mag;
private:
std::vector< std::vector< std::vector<double> > > d2V;
};
class Potential{
friend class PhiRef;
friend class LambdaRef;
friend class MassRef;
friend class MmixingRef;
friend void PrintHeader(class PhiRef & Phi,class LambdaRef & L,class MassRef & Mass,Potential & V,unsigned int seed);
public:
typedef VecTriplet::size_type size_type;
Potential(){}
friend std::istream & operator>>(std::istream & in, Potential & V);
friend std::ostream & operator<<(std::ostream & os, const Potential & V);
double operator()() const;
double operator()(size_type a) const;
double operator()(std::vector< std::vector<Monomial> >::const_iterator aiter) const;
double operator()(size_type i, size_type a) const;
double operator()(size_type i, size_type j,size_type a) const;
bool generate();
void rules_fast();// NEW FUNCTION DEVELOPING
void check_rules_fast_stable();// NEW FUNCTION DEVELOPING
void a0treeIni();
bool FindMixing();
void printdV();
void printd2V();
void printa0tree();
void BoundTreeUni();
void printpoint(); //used only in verbose
void setprint(int num_points,int data_point); //sets up print options
void print_or_store(std::ostream & out);
void print_remaining_points(std::ostream & out);
protected:
RandGen r; // reference to random number generator in use
PhiVec Phi;
PhiParamVec PhiPar;
MLparamVec MLpars;
MixingparamVec MixingPars;
Couplings Cp;
std::vector<int> degeneracies;
std::vector< std::vector<Monomial> > Mon; // For each coupling we need a vector of monomials.
std::vector< std::vector<double> > dV;
std::vector< std::vector<double> > d2Vreduced;
unsigned int NIC,NIC2,Nmixed,NnoMixCurv,NGold,Nblocks;
std::vector<int> BlockInfo; // NEW
std::vector<unsigned int> BlockDims; //NEW
std::vector<unsigned int> BlockPermutLabels; //NEW
std::vector<unsigned int> orderdV;
std::vector<unsigned int> orderd2V;
deriv2V d2V,d2Vnew;
//std::vector< std::vector< std::vector< std::vector<double> > > > d2V;
std::vector< std::vector< std::vector<double> > > a0tree;
double * a0treeSum;
double * TempM;
double * TempM2;
double * TempOut;
//points to store before printing.
int store_vector_index,points_per_print,data_per_point;
std::vector<double> extra_data; //to be used when you want what2print to have acess to more than class data
std::vector< std::vector<double> > points2print;
std::vector< std::vector<double> > Mbasis,Maux,Mrot,Mrot2,Mmixing;
/***************VIRTUAL FUNCTIONS*****************/
public:
virtual void PrintHeader();
void openinput(std::istream & in);
virtual void readfile(std::istream & in);
virtual std::string name();
virtual void what2print(void);
virtual void UserInitCalcs();
virtual bool CheckTreeUni();
virtual bool CheckBounds();
virtual bool CheckGlobal(PhiRef & Phi,LambdaRef & L,Potential & V)const;
virtual bool CheckStability(LambdaRef & L)const;
virtual bool UserAnalysis(PhiRef & Phi,LambdaRef & L,MassRef & Mass, MmixingRef & Mixing);
virtual void MyPhiParametrization(const PhiParamVec & PhiPar,PhiVec & Phi);
virtual void MyInternalMixing(const PhiParamVec & PhiPar,const PhiVec & Phi,MixingparamVec & MixPar,std::vector< std::vector<double> > & MixInternal);
virtual void MyCoupMassRelations(const PhiParamVec & PhiPar,const PhiVec & Phi,const std::vector< std::vector<double> > & Mixing,const MixingparamVec & MixPar,std::vector<double> & L,std::vector<double> & Mass, MLparamVec & MLPar, std::vector<double> & IndependentMs,std::vector<double> & IndependentLs);
};
class PhiRef{
public:
PhiRef(Potential & Vin):Phi_(Vin.Phi){}
void copy(PhiRef & PhiIn){for(size_t i=0;i!=PhiIn.size();++i){(*this)[i]=PhiIn[i];} }
double & operator[](size_t i){return Phi_[i];}
size_t size()const{return Phi_.size();}
friend std::ostream & operator<<(std::ostream & os, const PhiRef & P);
PhiVec & Phi_;
};
class LambdaRef{
public:
LambdaRef(Potential & Vin):L_(Vin.Cp.L){}
void copy(LambdaRef & LIn){for(size_t i=0;i!=LIn.size();++i){(*this)[i]=LIn[i];} }
double & operator[](size_t i){return L_[i];}
size_t size()const{return L_.size();}
friend std::ostream & operator<<(std::ostream & os, const LambdaRef & L);
VecTriplet & L_;
};
class MassRef{
public:
MassRef(Potential & Vin):M_(Vin.Cp.Mass){}
double operator[](size_t i){return M_[i];}
size_t size()const{return M_.size();}
const VecTriplet & M_;
};
class MmixingRef{
public:
MmixingRef(Potential & Vin):Mmix_(Vin.Mmixing),Nmixed_(Vin.Nmixed),NnoMixCurv_(Vin.NnoMixCurv),NGold_(Vin.NGold){}
const std::vector<double> & operator[](size_t i){return Mmix_[i];}
size_t size()const{return Mmix_.size();}
size_t Nmixed(){return Nmixed_;}
size_t NDiagMassive(){return NnoMixCurv_;}
size_t Nmassless(){return NGold_;}
private:
const std::vector< std::vector<double> > & Mmix_;
unsigned int & Nmixed_,NnoMixCurv_,NGold_;
};
std::istream & operator>>(std::istream & in, Potential & V);
std::ostream & operator<<(std::ostream & os, const Potential & V);
std::ostream & operator<<(std::ostream & os, const PhiRef & P);
std::ostream & operator<<(std::ostream & os, const LambdaRef & L);
void MyPhiParametrization(const PhiParamVec &,PhiVec &);
void MyInternalMixing(const PhiParamVec & PhiPar,const PhiVec & Phi, MixingparamVec & MixingPars,std::vector< std::vector<double> > & MixInternal);
void MyCoupMassRelations(const PhiParamVec & PhiPar,const PhiVec & Phi,const std::vector< std::vector<double> > & Mixing,const MixingparamVec & MixPars,std::vector<double> & L,std::vector<double> & Mass, MLparamVec & MLparams, std::vector<double> & InDependentMs,std::vector<double> & InDependentLs);
#endif

File Metadata

Mime Type
text/x-c++
Expires
Sat, Dec 21, 12:21 PM (1 d, 17 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
4022746
Default Alt Text
ScannerSModelclasses.h (7 KB)

Event Timeline