AmpToolsInterface.h

Go to the documentation of this file.

#if !defined(AMPTOOLSINTERFACE)
#define AMPTOOLSINTERFACE

//******************************************************************************
// 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>

#include "MinuitInterface/MinuitMinimizationManager.h"
#include "IUAmpTools/IntensityManager.h"
#include "IUAmpTools/Amplitude.h"
#include "IUAmpTools/AmpVecs.h"
#include "IUAmpTools/Kinematics.h"
#include "IUAmpTools/NormIntInterface.h"
#include "IUAmpTools/ConfigFileParser.h"
#include "IUAmpTools/ConfigurationInfo.h"
#include "IUAmpTools/ParameterManager.h"
#include "IUAmpTools/LikelihoodCalculator.h"

class FitResults;

using namespace std;

class AmpToolsInterface{

  public:

  enum FunctionalityFlag { kFull, kMCGeneration, kPlotGeneration };

  AmpToolsInterface( FunctionalityFlag flag = kFull );
  
    AmpToolsInterface( ConfigurationInfo* cfgInfo, FunctionalityFlag flag = kFull );

    virtual ~AmpToolsInterface() { clear(); }

    static void registerAmplitude( const Amplitude& defaultAmplitude);

    static void registerDataReader( const DataReader& defaultDataReader);

    void resetConfigurationInfo(ConfigurationInfo* cfgInfo);


    ConfigurationInfo* configurationInfo() const
                                 { return m_configurationInfo; }


    MinuitMinimizationManager* minuitMinimizationManager() const
                                 { return m_minuitMinimizationManager; }

    ParameterManager*          parameterManager() const
                                 { return m_parameterManager;}


    IntensityManager*     intensityManager     (const string& reactionName) const;


    DataReader*           dataReader           (const string& reactionName) const;

    DataReader*           bkgndReader           (const string& reactionName) const;

    DataReader*           accMCReader          (const string& reactionName) const;


    DataReader*           genMCReader          (const string& reactionName) const;


    NormIntInterface*     normIntInterface     (const string& reactionName) const;

    const FitResults* fitResults() const { return m_fitResults; }
  

    LikelihoodCalculator* likelihoodCalculator (const string& reactionName) const;


    double likelihood() const;

    double likelihood(const string& reactionName) const;


    virtual void finalizeFit();


    void clearEvents(unsigned int iDataSet = 0);

    void loadEvents(DataReader* dataReader,
                    unsigned int iDataSet = 0);

    void loadEvent(Kinematics* kin, int iEvent = 0, int nEventsTotal = 1,
                    unsigned int iDataSet = 0);

    double processEvents(string reactionName,
                    unsigned int iDataSet = 0);


    int numEvents(unsigned int iDataSet = 0) const;


    double intensity(int iEvent,
                    unsigned int iDataSet = 0) const;


    double alternateIntensity(int iEvent,
                    unsigned int iDataSet = 0) const;


    complex<double> decayAmplitude (int iEvent, string ampName,
                    unsigned int iDataSet = 0) const;


    complex<double> scaledProductionAmplitude (string ampName,
                                               unsigned int iDataSet = 0) const;


    Kinematics* kinematics(int iEvent,
                           unsigned int iDataSet = 0);


    void printKinematics   (string reactionName, Kinematics* kin) const;


    void printAmplitudes   (string reactionName, Kinematics* kin) const;

    void printIntensity    (string reactionName, Kinematics* kin) const;

    void printEventDetails (string reactionName, Kinematics* kin) const;


  protected:
  
    AmpToolsInterface( const AmpToolsInterface& ati );
    AmpToolsInterface& operator=( AmpToolsInterface& ati );

    FunctionalityFlag m_functionality;
  
    void clear();

    ConfigurationInfo*          m_configurationInfo;
    MinuitMinimizationManager*  m_minuitMinimizationManager;
    ParameterManager*           m_parameterManager;

    vector<IntensityManager*>  m_intensityManagers;


    map<string,DataReader*> m_dataReaderMap;
    map<string,DataReader*> m_bkgndReaderMap;
    map<string,DataReader*> m_genMCReaderMap;
    map<string,DataReader*> m_accMCReaderMap;

    map<string,NormIntInterface*>     m_normIntMap;
    map<string,LikelihoodCalculator*> m_likCalcMap;

    static vector<Amplitude*>  m_userAmplitudes;
    static vector<DataReader*> m_userDataReaders;

    static const int MAXAMPVECS = 50;
    AmpVecs m_ampVecs[MAXAMPVECS];
    string  m_ampVecsReactionName[MAXAMPVECS];
   
    FitResults* m_fitResults;

};



#endif