ConfigurationInfo.h

Go to the documentation of this file.

#if !defined(CONFIGURATIONINFO)
#define CONFIGURATIONINFO

//******************************************************************************
// This file is part of AmpTools, a package for performing Amplitude Analysis
// 
// Copyright Trustees of Indiana University 2010, all rights reserved
// 
// This software written by Matthew Shepherd, Ryan Mitchell, and 
//                  Hrayr Matevosyan at Indiana University, Bloomington
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
//    notice and author attribution, this list of conditions and the
//    following disclaimer. 
// 2. Redistributions in binary form must reproduce the above copyright
//    notice and author attribution, this list of conditions and the
//    following disclaimer in the documentation and/or other materials
//    provided with the distribution.
// 3. Neither the name of the University nor the names of its contributors
//    may be used to endorse or promote products derived from this software
//    without specific prior written permission.
// 
// Creation of derivative forms of this software for commercial
// utilization may be subject to restriction; written permission may be
// obtained from the Trustees of Indiana University.
// 
// INDIANA UNIVERSITY AND THE AUTHORS MAKE NO REPRESENTATIONS OR WARRANTIES, 
// EXPRESS OR IMPLIED.  By way of example, but not limitation, INDIANA 
// UNIVERSITY MAKES NO REPRESENTATIONS OR WARRANTIES OF MERCANTABILITY OR 
// FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THIS SOFTWARE OR 
// DOCUMENTATION WILL NOT INFRINGE ANY PATENTS, COPYRIGHTS, TRADEMARKS, 
// OR OTHER RIGHTS.  Neither Indiana University nor the authors shall be 
// held liable for any liability with respect to any claim by the user or 
// any other party arising from use of the program.
//******************************************************************************


#include <iostream>
#include <utility>
#include <string>
#include <vector>
#include <map>
#include <complex>
#include <fstream>

using namespace std;

class ConfigurationInfo;
class ReactionInfo;
class CoherentSumInfo;
class AmplitudeInfo;
class ParameterInfo;


class ConfigurationInfo
{
public:
  
  ConfigurationInfo(const string& fitName) { m_fitName = fitName; }
  ~ConfigurationInfo();
  
  string fitName() const { return m_fitName; }


  string fitOutputFileName() const { return m_fitName + ".fit"; }


  vector< string > userKeywords() const;

  vector< vector<string> > userKeywordArguments(const string& userKeyword) const;

  
  // Return lists of reactions, sums, amplitudes, or parameters.
  //   (If an argument to the call is empty, it is treated as
  //    a wildcard.  For example, reactionList("") returns all
  //    reactions.)
  
  vector<ReactionInfo*>    reactionList    (const string& reactionName="") const;
  
  vector<CoherentSumInfo*> coherentSumList (const string& reactionName="",
                                            const string& sumName="") const;
  
  vector<AmplitudeInfo*>   amplitudeList   (const string& reactionName="",
                                            const string& sumName="",
                                            const string& ampName="") const;
  
  vector<ParameterInfo*>   parameterList   (const string& reactionName="",
                                            const string& sumName="",
                                            const string& ampName="",
                                            const string& parName="") const;
  
  
  // Return a specific reaction, sum, amplitude, or parameter.
  
  ReactionInfo*    reaction    (const string& reactionName) const;
  
  CoherentSumInfo* coherentSum (const string& reactionName,
                                const string& sumName) const;
  
  AmplitudeInfo*   amplitude   (const string& reactionName,
                                const string& sumName,
                                const string& ampName) const;
  
  ParameterInfo*   parameter   (const string& parName) const;
  
  
  
  // Create a new reaction, sum, amplitude or parameter.
  //   (If the object already exists, the old is replaced and
  //    its contents are cleared.)
  
  ReactionInfo*    createReaction    (const string&         reactionName, 
                                      const vector<string>& particleList);
  
  CoherentSumInfo* createCoherentSum (const string& reactionName, 
                                      const string& sumName);
  
  AmplitudeInfo*   createAmplitude   (const string& reactionName, 
                                      const string& sumName, 
                                      const string& ampName);
  
  ParameterInfo*   createParameter   (const string& parName,
                                      double        value);
  
  
  // Remove reactions, sums, amplitudes, or parameters.
  //   (Blank arguments are treated like wildcards.
  //    This also removes associated objects -- for example,
  //    removeReaction("") removes all reactions but also all sums
  //    and amplitudes associated with those reactions.
  
  void removeReaction    (const string& reactionName="");
  
  void removeCoherentSum (const string& reactionName="",
                          const string& sumName="");

  void removeAmplitude   (const string& reactionName="",
                          const string& sumName="",
                          const string& ampName="");
  
  void removeParameter   (const string& parName="");


  void setFitName (const string& fitName) { m_fitName = fitName; }  


  void addUserKeyword(const string& uesrKeyword, const vector<string>& arguments);  


  void removeUserKeyword(const string& userKeyword="");
    
  void display(string fileName = "", bool append = false) const;
  void display(string fileName = "", bool append = false);


  void write( const string& fileName ) const;
  ostream& write( ostream& output ) const;
    
  map< string, vector< string > > constraintMap() const;
  
private:
  
  string                   m_fitName;
  vector<ReactionInfo*>    m_reactions;
  vector<CoherentSumInfo*> m_sums;
  vector<AmplitudeInfo*>   m_amplitudes;
  vector<ParameterInfo*>   m_parameters;
  map<string, vector< vector<string> > > m_userKeywordMap;
    
};


inline ostream& operator<<( ostream& output, const ConfigurationInfo& cfgInfo ){
  
  return cfgInfo.write( output );
}


class ReactionInfo
{
public:
  
  ReactionInfo(const string&         reactionName,
               const vector<string>& particleList):
  m_reactionName(reactionName),
  m_particleList(particleList)  {clear();};
  
  
  // Every reaction has a reactionName and a particleList
  
  string            reactionName()    const {return m_reactionName;}

  const vector<string>&    particleList()    const {return m_particleList;}
  
  
  // Return information about data and MC associated with this reaction
  
  const pair< string, vector<string> >& data()  const {return m_data;}

  const pair< string, vector<string> >& bkgnd()  const {return m_bkgnd;}

  const pair< string, vector<string> >& genMC()  const {return m_genMC;}

  const pair< string, vector<string> >& accMC()  const {return m_accMC;}

  string            normIntFile()     const {return m_normIntFile;}

  bool       normIntFileInput()     const {return m_normIntFileInput;}
  
  
  // Display or clear information for this reaction
  
  void              display(string fileName = "", bool append = true);

  void              clear();
  
  
  // Use these methods to add new information to this reaction
  
  void  setParticleList (const vector<string>& particleList) {m_particleList = particleList;}

  void  setData   (const string& classname, const vector<string>& args)
                            { m_data = pair<string, vector<string> >(classname,args); }
  
  void  setBkgnd  (const string& classname, const vector<string>& args)
  { m_bkgnd = pair<string, vector<string> >(classname,args); }

  void  setGenMC   (const string& classname, const vector<string>& args)
                            { m_genMC = pair<string, vector<string> >(classname,args); }

  void  setAccMC   (const string& classname, const vector<string>& args)
                            { m_accMC = pair<string, vector<string> >(classname,args); }

  void  setNormIntFile  (const string& normIntFile, bool input = false) 
                           { m_normIntFile = normIntFile;
                             m_normIntFileInput = input; }
  
  
private:
  
  string                         m_reactionName;
  vector<string>                 m_particleList;
  pair< string, vector<string> > m_data;
  pair< string, vector<string> > m_bkgnd;
  pair< string, vector<string> > m_genMC;
  pair< string, vector<string> > m_accMC;
  string                         m_normIntFile;
  bool                           m_normIntFileInput;
  
};


class CoherentSumInfo
{
public:
  
  CoherentSumInfo(const string& reactionName,
                  const string& sumName):
  m_reactionName(reactionName),
  m_sumName(sumName)  {clear();};
  
  
  // Every sum is associated with a reaction and has a sumName
  
  string            reactionName()    const {return m_reactionName;}

  string            sumName()         const {return m_sumName;}

  string            fullName()        const {return (m_reactionName + "::" +
                                                     m_sumName);}
  
  //  Display information for this sum
  
  void              display(string fileName = "", bool append = true);

  void              clear() {}
  
private:
  
  string          m_reactionName;
  string          m_sumName;
  
};


class AmplitudeInfo
{
public:
  
  AmplitudeInfo(const string& reactionName,
                const string& sumName,
                const string& ampName):
  m_reactionName(reactionName),
  m_sumName(sumName),
  m_ampName(ampName)  {clear();};
  
  
  //  Every amplitude is identified by a reaction, a sum, and an ampName
  
  string                     reactionName()   const {return m_reactionName;}

  string                     sumName()        const {return m_sumName;}
  
  string                     ampName()        const {return m_ampName;}
  
  string                     fullName()       const {return (m_reactionName + "::" +
                                                             m_sumName + "::" +
                                                             m_ampName);}
  
  //  Return the amplitude factors for this reaction.
  //    Each factor has the form: <amplitude class name> (arg1) (arg2) ...
  
  const vector< vector<string> >&   factors()        const {return m_factors;}
  
  
  //  Return a list of different particle permuations.
  //    (For example, if there are 5 particles in this reaction, specifying
  //     a permutation of 01243 will permute the fourth and fifth particles and the
  //     amplitude becomes A(01234) + A(01243).)
  
  const vector< vector<int> >&      permutations()   const {return m_permutations;}
  
  
  //  Return a list of amplitudes that are constrained to have the same
  //    production parameters as this amplitude.
  
  const vector< AmplitudeInfo* >&   constraints()    const {return m_constraints;}


  bool hasConstraint(AmplitudeInfo* constraint) const;
  
  
  //  Return information about the production parameter for this amplitude.
  
  complex< double >          value()          const {return m_value;}

  bool                       real()           const {return m_real;}
  bool                       fixed()          const {return m_fixed;}
  
  string                     scale()          const {return m_scale;} 


  //  Return a list of parameters (other than the production parameter)
  //    associated with this amplitude.
 
  const vector < ParameterInfo* >&  parameters()     const {return m_parameters;}


  //  Display or clear information for this amplitude

  void                       display(string fileName = "", bool append = true);

  void                       clear();
  
  
  //  Use these methods to set up this ampltiude
  
  void addFactor         (const vector<string>& factor)    {m_factors.push_back(factor);}
  
  void addPermutation    (const vector<int>& permutation)  {m_permutations.push_back(permutation);}
  
  void addConstraint     (AmplitudeInfo* constraint);

  void setValue          (complex<double> value)   {m_value = value;}
  
  void setReal           (bool real)               {m_real = real;}
  void setFixed          (bool fixed)              {m_fixed = fixed;}
  
  void setScale          (string scale)            {m_scale = scale;}


  void addParameter      (ParameterInfo* parameter);
  
  
  //  Use these methods to remove information associated with this amplitude
  
  void removeConstraint (AmplitudeInfo* constraint);

  void removeParameter  (ParameterInfo* parameter);
  
private:
  
  string                       m_reactionName;
  string                       m_sumName;
  string                       m_ampName;
  vector< vector<string> >     m_factors;
  vector< vector<int> >        m_permutations;
  vector< AmplitudeInfo* >     m_constraints;
  complex< double >            m_value;
  bool                         m_real;
  bool                         m_fixed;
  string                       m_scale;
  vector< ParameterInfo* >     m_parameters;
  
};





class ParameterInfo
{
public:
  
  ParameterInfo(const string& parName,
                double        value):
  m_parName(parName),
  m_value(value) {clear();};
  
  
  // Every parameter has a parameter name and an initial value
  
  string parName()         const  {return m_parName;}
  double value()           const  {return m_value;}
  
  
  // If true, the parameter is fixed to its initial value.
  
  bool   fixed()           const  {return m_fixed;}
  
  
  // If the parameter is bounded, it is bounded between its
  //   lowerBound and upperBound.
  
  bool   bounded()         const  {return m_bounded;}
  double lowerBound()      const  {return m_lowerBound;}
  double upperBound()      const  {return m_upperBound;}
  
  
  // If the parameter is "gaussianBounded," an additional likelihood
  //   factor is created based on the parameter's position within a 
  //   a gaussian distribution with mean centralValue and error
  //   gaussianError.
  
  bool   gaussianBounded() const  {return m_gaussianBounded;}
  double centralValue()    const  {return m_centralValue;}
  double gaussianError()   const  {return m_gaussianError;}
  
  
  // Display or clear inforamtion for this parameter
  
  void display(string fileName = "", bool append = true);
  void clear();
  
  
  // Use these methods to set up this parameter
  
  void setValue           (double value)         {m_value = value;}
  void setFixed           (bool fixed)           {m_fixed = fixed;}
  void setBounded         (bool bounded)         {m_bounded = bounded;}
  void setLowerBound      (double lowerBound)    {m_lowerBound = lowerBound;}
  void setUpperBound      (double upperBound)    {m_upperBound = upperBound;}
  void setGaussianBounded (bool gaussianBounded) {m_gaussianBounded = gaussianBounded;}
  void setCentralValue    (double centralValue)  {m_centralValue = centralValue;}
  void setGaussianError   (double gaussianError) {m_gaussianError = gaussianError;}
  
  
private:
  
  string m_parName;
  double m_value;
  bool   m_fixed;
  bool   m_bounded;
  double m_lowerBound;
  double m_upperBound;
  bool   m_gaussianBounded;
  double m_centralValue;
  double m_gaussianError;
  
};




#endif