IntensityManager.h

Go to the documentation of this file.

#if !defined(INTENSITYMANAGER)
#define INTENSITYMANAGER

//******************************************************************************
// 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 "IUAmpTools/AmpVecs.h"
#include "IUAmpTools/AmpParameter.h"

#include <string>
#include <vector>
#include <map>
#include <complex>

class ConfigurationInfo;
class NormIntInterface;

using namespace std;

class IntensityManager {

public:
  
  enum Type { kAmplitude, kMoment };
  
  IntensityManager( const vector< string >& reaction,
                    const string& reactionName);

  virtual ~IntensityManager() {}
  
  virtual Type type() const = 0;
  
  
  virtual unsigned int maxFactorStoragePerEvent() const = 0;
  
  virtual unsigned int termStoragePerEvent() const = 0;

  /*
   * These functions perform computations based on the current state
   * of the IntensityManager and should be defined by the the derived class.
   */
  
  virtual bool calcTerms( AmpVecs& ampVecs ) const = 0;
  
  virtual double calcIntensities( AmpVecs& ampVecs ) const = 0;

  virtual double calcSumLogIntensity( AmpVecs& ampVecs ) const = 0;
  
  virtual void calcIntegrals( AmpVecs& ampVecs, int iNGenEvents ) const = 0;
 
  double calcIntensity( const Kinematics* kinematics ) const;
  
  //
  // The functions below all return information that describes the
  // state and configuration of the AmplitudeManager.
  //
  
  const vector< string >& getTermNames() const;
  
  const AmpParameter& getScale( const string& name ) const;
  
  
  virtual bool hasTermWithFreeParam() const = 0;
  
  int termIndex( const string& termName ) const;
  
  string reactionName() const {return m_reactionName;}
  
  complex< double > productionFactor( const string& termName ) const;
  
  complex< double > productionFactor( int termIndex ) const;
  
  void prodFactorArray( double* array ) const;
  
  bool hasTerm( const string& termName ) const;
    
  //
  // The functions below modify the state of the AmplitudeManager
  //
  
  virtual void setupFromConfigurationInfo( const ConfigurationInfo* configInfo ) = 0;

  int addTerm( const string& termName, const string& scale = "1.0" );
  
  void setDefaultProductionFactor( const string& termName,
                                   complex< double > prodAmp );
  
  void setExternalProductionFactor( const string& ampName,
                                    const complex< double >* prodAmpPtr );
  
  virtual void setParPtr( const string& termName, const string& parName,
                          const double* ampParPtr );
  
  virtual void setParValue( const string& termName, const string& parName,
                            double ampParValue );
  
  virtual void updatePar( const string& parName ) const {}
  
  void resetProductionFactors();
  
  //  void renormalizeTerms( const NormIntInterface* normInt );
  
  //  void disableRenormalization();
  
  bool termsAreRenormalized() const { return m_renormalizeTerms; }
  
protected:
  
  const NormIntInterface* normInt() const { return m_normInt; }
  
private:
  
  string m_reactionName;
  
  // term name -> production term
  map< string, const complex< double >* > m_prodFactor;
  
  // term index -> production amplitude
  vector< const complex< double >* > m_prodFactorVec;
  
  // a vector of amplitude names -- keep also a set of amplitude indices
  // these can be useful speeding up intesity calculations by removing
  // slower map element look-ups
  vector< string > m_termNames;
  map< string, int > m_termIndex;
  
  // a map to hold a set of default production factors
  map< string, complex< double > > m_defaultProdFactor;
   
  // a flag to track if we are renormalizing the terms
  bool m_renormalizeTerms;
  const NormIntInterface* m_normInt;
  
  vector< AmpParameter > m_termScaleVec;
    
};


#endif