LauAbsCoeffSet.hh

Go to the documentation of this file.

 
/*
Copyright 2006 University of Warwick
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
    http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
 
/*
Laura++ package authors:
John Back
Paul Harrison
Thomas Latham
*/
 
#ifndef LAU_ABS_COEFF_SET
#define LAU_ABS_COEFF_SET
 
#include "TString.h"
 
#include <iosfwd>
#include <vector>
 
class TRandom;
class LauComplex;
class LauParameter;
 
class LauAbsCoeffSet {
 
  public:
    enum CloneOption {
        All,          
        TiePhase,     
        TieMagnitude, 
        TieRealPart,  
        TieImagPart,  
        TieCPPars     
    };
 
    virtual ~LauAbsCoeffSet() {}
 
 
    virtual std::vector<LauParameter*> getParameters() = 0;
 
    virtual void printParValues() const = 0;
 
 
    virtual void printTableHeading( std::ostream& stream ) const = 0;
 
 
    virtual void printTableRow( std::ostream& stream ) const = 0;
 
    virtual void randomiseInitValues() = 0;
 
    virtual void finaliseValues() = 0;
 
 
    virtual const LauComplex& particleCoeff() = 0;
 
 
    virtual const LauComplex& antiparticleCoeff() = 0;
 
 
    virtual void setCoeffValues( const LauComplex& coeff, const LauComplex& coeffBar, Bool_t init ) = 0;
 
 
    virtual LauParameter acp() = 0;
 
 
    virtual LauAbsCoeffSet* createClone( const TString& newName,
                                         CloneOption cloneOption = All,
                                         Double_t constFactor    = 1.0 ) = 0;
 
 
    virtual TString name() const { return name_; }
 
 
    virtual void name( const TString& theName ) { name_ = theName; }
 
 
    virtual const TString& baseName() const { return basename_; }
 
 
    virtual void baseName( const TString& theBasename ) { basename_ = theBasename; }
 
 
    virtual UInt_t index() const { return index_; }
 
 
    virtual void index( UInt_t newIndex );
 
 
    virtual void setParameterValue( const TString& parName, Double_t value, Bool_t init );
 
 
    virtual void setParameterError( const TString& parName, Double_t error );
 
 
    virtual void fixParameter( const TString& parName );
 
 
    virtual void floatParameter( const TString& parName );
 
 
    virtual void blindParameter( const TString& parName,
                                 const TString& blindingString,
                                 const Double_t width );
 
 
    virtual void addGaussianConstraint( const TString& parName,
                                        const Double_t mean,
                                        const Double_t width );
 
 
    virtual void addSuffixToParameterName( const TString& parName, const TString& suffix );
 
 
    static void setMagnitudeRange( Double_t minMag, Double_t maxMag )
    {
        minMagnitude_ = minMag;
        maxMagnitude_ = maxMag;
    }
 
 
    static void setPhaseRange( Double_t minPhase, Double_t maxPhase )
    {
        minPhase_ = minPhase;
        maxPhase_ = maxPhase;
    }
 
 
    static void setRealImagRange( Double_t minPar, Double_t maxPar )
    {
        minRealImagPart_ = minPar;
        maxRealImagPart_ = maxPar;
    }
 
 
    static void setCPParRange( Double_t minPar, Double_t maxPar )
    {
        minDelta_ = minPar;
        maxDelta_ = maxPar;
    }
 
 
    static void setRandomiser( TRandom* randomiser ) { randomiser_ = randomiser; }
 
 
    static TRandom* getRandomiser();
 
  protected:
 
    LauAbsCoeffSet( const TString& theName, const TString& theBaseName = "A" );
 
 
    LauParameter* findParameter( const TString& parName );
 
 
    virtual void adjustName( LauParameter* par, const TString& oldBaseName );
 
    static Double_t minMagnitude_;
    static Double_t maxMagnitude_;
    static Double_t minPhase_;
    static Double_t maxPhase_;
    static Double_t minRealImagPart_;
    static Double_t maxRealImagPart_;
    static Double_t minDelta_;
    static Double_t maxDelta_;
 
 
    LauAbsCoeffSet( const LauAbsCoeffSet& rhs );
 
 
    LauAbsCoeffSet& operator=( const LauAbsCoeffSet& rhs );
 
  private:
    static TRandom* randomiser_;
 
    TString name_;
 
    TString basename_;
 
    UInt_t index_;
 
    ClassDef( LauAbsCoeffSet, 0 )
};
 
#endif