L1Menu/src/MenuFitter.cpp

#include "l1menu/MenuFitter.h"

#include <stdexcept>
#include <fstream>
#include <iostream>
#include <cmath>
#include "l1menu/ICachedTrigger.h"
#include "l1menu/ISample.h"
#include "l1menu/IEvent.h"
#include "l1menu/IMenuRate.h"
#include "l1menu/ITriggerRate.h"
#include "l1menu/TriggerMenu.h"
#include "l1menu/ITrigger.h"
#include "l1menu/TriggerRatePlot.h"
#include "l1menu/tools/tools.h"
#include "l1menu/tools/stringManipulation.h"

namespace // Use the unnamed namespace for things only used here
{
        /** @brief Structure to collate a few things about triggers that can be scaled
         * @author Mark Grimes (mark.grimes@bristol.ac.uk)
         * @date 08/Jul/2013
         */
        struct TriggerScalingDetails
        {
                size_t triggerNumber; ///< The number of the trigger in the trigger table
                float bandwidthFraction; ///< The fraction of the total bandwidth requested for this trigger
                l1menu::TriggerRatePlot ratePlot; ///< The rate plot for this trigger
                std::string mainThreshold;
                std::vector< std::pair<std::string,float> > thresholdScalings; ///< The constant to scale each threshold compared to the main threshold
        };
} // end of the unnamed namespace


//
// Need to declare the pimple. So far it's just been forward declared.
//
namespace l1menu
{
        /** @brief Private members for the MenuFitter wrapped up in a compiler firewall.
         * @author Mark Grimes (mark.grimes@bristol.ac.uk)
         * @date 08/Jul/2013
         */
        class MenuFitterPrivateMembers
        {
        public:
                MenuFitterPrivateMembers( const l1menu::ISample& newSample, const l1menu::MenuRatePlots* pRatePlots ) : sample(newSample), pMenuRatePlots(pRatePlots) {}
                const l1menu::ISample& sample;
                const l1menu::MenuRatePlots* pMenuRatePlots;
                l1menu::TriggerMenu menu;
                std::vector< ::TriggerScalingDetails > scalableTriggers;
                std::vector<std::pair<size_t,float> > bandwidthFractions;
                std::vector<l1menu::TriggerRatePlot> ratePlots;
                void initiateOtherTriggerInfo( size_t triggerNumber, bool lockThresholds, float fractionOfTotalBandwidth );
        };

}

l1menu::MenuFitter::MenuFitter( const l1menu::ISample& sample )
        : pImple_( new MenuFitterPrivateMembers(sample,NULL) )
{

}

l1menu::MenuFitter::MenuFitter( const l1menu::ISample& sample, const l1menu::MenuRatePlots& menuRatePlots )
        : pImple_( new MenuFitterPrivateMembers(sample,&menuRatePlots) )
{

}

l1menu::MenuFitter::~MenuFitter()
{
        // No operation
}

const l1menu::TriggerMenu& l1menu::MenuFitter::menu() const
{
        return pImple_->menu;
}

std::unique_ptr<const l1menu::IMenuRate> l1menu::MenuFitter::fit( float totalRate, float tolerance )
{
        //
        // First set all the thresholds to be the ratio of the total bandwidth that
        // the user specified. With correlations this will probably mean the total
        // will come out less than the requested rate, but it's a good first step.
        // Loop over all of the triggers whose thresholds are not fixed.
        //
        for( const auto& triggerScalingDetails : pImple_->scalableTriggers )
        {
                l1menu::ITrigger& trigger=pImple_->menu.getTrigger( triggerScalingDetails.triggerNumber );

                std::cout << "Trying to find a threshold for " << trigger.name() << " to try and get a rate of " << totalRate*triggerScalingDetails.bandwidthFraction << std::endl;

                float& mainThreshold=trigger.parameter( triggerScalingDetails.mainThreshold );
                // Figure out what threshold should give the target rate for this particular trigger.
                // Note this is a reference so this command changes the trigger.
                mainThreshold=triggerScalingDetails.ratePlot.findThreshold( totalRate*triggerScalingDetails.bandwidthFraction );
                // Then scale all of the others off this
                for( const auto& nameScalePair : triggerScalingDetails.thresholdScalings )
                {
                        trigger.parameter( nameScalePair.first )=mainThreshold*nameScalePair.second;
                }

                std::cout << "Initially setting threshold for " << trigger.name() << " to " << mainThreshold << " to try and get a rate of " << totalRate*triggerScalingDetails.bandwidthFraction << std::endl;
        }

        // Then work out what the total rate is
        std::unique_ptr<const l1menu::IMenuRate> pMenuRate=pImple_->sample.rate( pImple_->menu );

        size_t iterationNumber=0;
        while ( std::fabs(pMenuRate->totalRate()-totalRate)>tolerance )
        {
                if( iterationNumber>10 ) throw std::runtime_error( "Too many iterations" );
                ++iterationNumber;

                float scaleAllRatesBy=totalRate/pMenuRate->totalRate();
                std::cout << "\n" << "New loop. Last iteration had a rate of " << pMenuRate->totalRate() << ". Scaling all rates by " << scaleAllRatesBy << " to try and get " << totalRate << std::endl;

                for( const auto& triggerScalingDetails : pImple_->scalableTriggers )
                {
                        const size_t& triggerNumber=triggerScalingDetails.triggerNumber;
                        l1menu::ITrigger& trigger=pImple_->menu.getTrigger( triggerNumber );
                        const l1menu::ITriggerRate* pTriggerRate=pMenuRate->triggerRates()[triggerNumber];

                        float& mainThreshold=trigger.parameter( triggerScalingDetails.mainThreshold );
                        // Figure out what threshold should give the target rate for this particular trigger.
                        // Note this is a reference so this command changes the trigger.
                        mainThreshold=triggerScalingDetails.ratePlot.findThreshold( pTriggerRate->rate()*scaleAllRatesBy );
                        // Then scale all of the others off this
                        for( const auto& nameScalePair : triggerScalingDetails.thresholdScalings )
                        {
                                trigger.parameter( nameScalePair.first )=mainThreshold*nameScalePair.second;
                        }
                        std::cout << "Changing threshold for " << trigger.name() << " to " << mainThreshold << " to try and change the rate from " << pTriggerRate->rate() << " to " << pTriggerRate->rate()*scaleAllRatesBy << std::endl;

                } // end of loop over triggers I'm allowed to change thresholds for

                pMenuRate=pImple_->sample.rate( pImple_->menu );
        }

        return pMenuRate;
}

void l1menu::MenuFitter::addTrigger( const l1menu::ITrigger& trigger, float fractionOfTotalBandwidth, bool lockThresholds )
{
        if( !lockThresholds && (fractionOfTotalBandwidth<0 || fractionOfTotalBandwidth>1) ) throw std::runtime_error("Invalid fraction of the total bandwidth requested");

        size_t triggerNumber=pImple_->menu.numberOfTriggers(); // This will be the number of the next trigger added
        pImple_->menu.addTrigger( trigger );
        pImple_->initiateOtherTriggerInfo( triggerNumber, lockThresholds, fractionOfTotalBandwidth );
}

void l1menu::MenuFitter::loadMenuFromFile( const std::string& filename )
{
        std::ifstream file( filename.c_str() );
        if( !file.is_open() ) throw std::runtime_error( "Unable to open file "+filename );

        const size_t bufferSize=200;
        char buffer[bufferSize];

        // The old file format provides the rates it wants for each trigger
        // as an absolute value, whereas I want it as a fraction of the total.
        // So I need to run through the whole file and add up each of these
        // to get a total, then divide each value by the total to get the fraction.
        // Hence I can't do that until I've loaded every trigger. I'll keep track
        // of whether each threshold is locked and the absolute rate requested in
        // this vector.
        std::vector< std::pair<bool,float> > triggerAuxiliaryInfo;
        float totalRequestedRate=0; // This is the sum of all the rates requested for each trigger

        while( file.good() )
        {
                try
                {
                        // Get one line at a time
                        file.getline( buffer, bufferSize );

                        // split the line by whitespace into columns
                        std::vector<std::string> tableColumns=l1menu::tools::splitByWhitespace( buffer );

                        if( tableColumns.size()==1 && tableColumns[0].empty() ) continue; // Allow blank lines without giving a warning
                        if( tableColumns.size()!=12 ) throw std::runtime_error( "The line does not have the correct number of columns" );

                        if( pImple_->menu.addTriggerFromOldFormat( tableColumns ) )
                        {
                                // If the trigger was created successfully, keep a note of these
                                // details so that I can later initiate the auxiliary information.
                                // I can't do that until I know the total requestedRate.
                                bool lockThresholds=l1menu::tools::convertStringToFloat( tableColumns[11] );
                                float requestedRate=l1menu::tools::convertStringToFloat( tableColumns[9] );
                                triggerAuxiliaryInfo.push_back( std::make_pair(lockThresholds,requestedRate) );
                                totalRequestedRate+=requestedRate;
                        }

                } // end of try block
                catch( std::runtime_error& exception )
                {
                        std::cout << "Some error occured while processing the line \"" << buffer << "\":" << exception.what() << std::endl;
                }
        }

        // Now I've processed all the lines I should know the total requested rate and I can
        // initiate the auxiliary information.
        size_t triggerNumber=pImple_->menu.numberOfTriggers()-triggerAuxiliaryInfo.size(); // There may have been triggers in there previously
        for( const auto auxiliaryInfo : triggerAuxiliaryInfo )
        {
                pImple_->initiateOtherTriggerInfo( triggerNumber, auxiliaryInfo.first, auxiliaryInfo.second/totalRequestedRate );
                ++triggerNumber;
        }
}

void l1menu::MenuFitterPrivateMembers::initiateOtherTriggerInfo( size_t triggerNumber, bool lockThresholds, float fractionOfTotalBandwidth )
{
        const l1menu::ITrigger& newTrigger=menu.getTrigger( triggerNumber );

        if( !lockThresholds )
        {

                //
                // Create a rate plot for this trigger
                //
                const std::vector<std::string> thresholdNames=l1menu::tools::getThresholdNames(newTrigger);
                const std::string& mainThreshold=thresholdNames.front();
                unsigned int numberOfBins=100;
                float lowerEdge=0;
                float upperEdge=100;
                try
                {
                        l1menu::TriggerTable& triggerTable=l1menu::TriggerTable::instance();
                        numberOfBins=triggerTable.getSuggestedNumberOfBins( newTrigger.name(), mainThreshold );
                        lowerEdge=triggerTable.getSuggestedLowerEdge( newTrigger.name(), mainThreshold );
                        upperEdge=triggerTable.getSuggestedUpperEdge( newTrigger.name(), mainThreshold );
                }
                catch( std::exception& error) { /* Do nothing. If no binning suggestions have been set for this trigger use the defaults I set above. */ }

                l1menu::TriggerRatePlot ratePlot(newTrigger,newTrigger.name()+"_v_allThresholdsScaled",numberOfBins,lowerEdge,upperEdge,mainThreshold,thresholdNames);
                ratePlot.addSample( sample );

                // Record the scaling between the main threshold and all of the others, so that
                // when they get increased/decreased it's all done proportionally.
                std::vector< std::pair<std::string,float> > thresholdScalings;
                const float mainThresholdValue=newTrigger.parameter(mainThreshold);
                for( const auto& thresholdName : thresholdNames )
                {
                        if( thresholdName==mainThreshold ) continue;
                        thresholdScalings.push_back( std::make_pair( thresholdName, newTrigger.parameter(thresholdName)/mainThresholdValue ) );
                }

                //
                // Bundle all of this information in the helper structure I wrote in
                // the unnamed namespace.
                //
                scalableTriggers.push_back( ::TriggerScalingDetails{triggerNumber,fractionOfTotalBandwidth,std::move(ratePlot),mainThreshold,std::move(thresholdScalings)} );
        }

}
Revision:	1.1
Committed:	Wed Jul 24 11:48:55 2013 UTC (11 years, 9 months ago) by grimes
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	Big commit of lots of changes before migrating to Git.
#	Content
1	#include "l1menu/MenuFitter.h"
2
3	#include <stdexcept>
4	#include <fstream>
5	#include <iostream>
6	#include <cmath>
7	#include "l1menu/ICachedTrigger.h"
8	#include "l1menu/ISample.h"
9	#include "l1menu/IEvent.h"
10	#include "l1menu/IMenuRate.h"
11	#include "l1menu/ITriggerRate.h"
12	#include "l1menu/TriggerMenu.h"
13	#include "l1menu/ITrigger.h"
14	#include "l1menu/TriggerRatePlot.h"
15	#include "l1menu/tools/tools.h"
16	#include "l1menu/tools/stringManipulation.h"
17
18	namespace // Use the unnamed namespace for things only used here
19	{
20	/** @brief Structure to collate a few things about triggers that can be scaled
21	* @author Mark Grimes (mark.grimes@bristol.ac.uk)
22	* @date 08/Jul/2013
23	*/
24	struct TriggerScalingDetails
25	{
26	size_t triggerNumber; ///< The number of the trigger in the trigger table
27	float bandwidthFraction; ///< The fraction of the total bandwidth requested for this trigger
28	l1menu::TriggerRatePlot ratePlot; ///< The rate plot for this trigger
29	std::string mainThreshold;
30	std::vector< std::pair<std::string,float> > thresholdScalings; ///< The constant to scale each threshold compared to the main threshold
31	};
32	} // end of the unnamed namespace
33
34
35	//
36	// Need to declare the pimple. So far it's just been forward declared.
37	//
38	namespace l1menu
39	{
40	/** @brief Private members for the MenuFitter wrapped up in a compiler firewall.
41	* @author Mark Grimes (mark.grimes@bristol.ac.uk)
42	* @date 08/Jul/2013
43	*/
44	class MenuFitterPrivateMembers
45	{
46	public:
47	MenuFitterPrivateMembers( const l1menu::ISample& newSample, const l1menu::MenuRatePlots* pRatePlots ) : sample(newSample), pMenuRatePlots(pRatePlots) {}
48	const l1menu::ISample& sample;
49	const l1menu::MenuRatePlots* pMenuRatePlots;
50	l1menu::TriggerMenu menu;
51	std::vector< ::TriggerScalingDetails > scalableTriggers;
52	std::vector<std::pair<size_t,float> > bandwidthFractions;
53	std::vector<l1menu::TriggerRatePlot> ratePlots;
54	void initiateOtherTriggerInfo( size_t triggerNumber, bool lockThresholds, float fractionOfTotalBandwidth );
55	};
56
57	}
58
59	l1menu::MenuFitter::MenuFitter( const l1menu::ISample& sample )
60	: pImple_( new MenuFitterPrivateMembers(sample,NULL) )
61	{
62
63	}
64
65	l1menu::MenuFitter::MenuFitter( const l1menu::ISample& sample, const l1menu::MenuRatePlots& menuRatePlots )
66	: pImple_( new MenuFitterPrivateMembers(sample,&menuRatePlots) )
67	{
68
69	}
70
71	l1menu::MenuFitter::~MenuFitter()
72	{
73	// No operation
74	}
75
76	const l1menu::TriggerMenu& l1menu::MenuFitter::menu() const
77	{
78	return pImple_->menu;
79	}
80
81	std::unique_ptr<const l1menu::IMenuRate> l1menu::MenuFitter::fit( float totalRate, float tolerance )
82	{
83	//
84	// First set all the thresholds to be the ratio of the total bandwidth that
85	// the user specified. With correlations this will probably mean the total
86	// will come out less than the requested rate, but it's a good first step.
87	// Loop over all of the triggers whose thresholds are not fixed.
88	//
89	for( const auto& triggerScalingDetails : pImple_->scalableTriggers )
90	{
91	l1menu::ITrigger& trigger=pImple_->menu.getTrigger( triggerScalingDetails.triggerNumber );
92
93	std::cout << "Trying to find a threshold for " << trigger.name() << " to try and get a rate of " << totalRate*triggerScalingDetails.bandwidthFraction << std::endl;
94
95	float& mainThreshold=trigger.parameter( triggerScalingDetails.mainThreshold );
96	// Figure out what threshold should give the target rate for this particular trigger.
97	// Note this is a reference so this command changes the trigger.
98	mainThreshold=triggerScalingDetails.ratePlot.findThreshold( totalRate*triggerScalingDetails.bandwidthFraction );
99	// Then scale all of the others off this
100	for( const auto& nameScalePair : triggerScalingDetails.thresholdScalings )
101	{
102	trigger.parameter( nameScalePair.first )=mainThreshold*nameScalePair.second;
103	}
104
105	std::cout << "Initially setting threshold for " << trigger.name() << " to " << mainThreshold << " to try and get a rate of " << totalRate*triggerScalingDetails.bandwidthFraction << std::endl;
106	}
107
108	// Then work out what the total rate is
109	std::unique_ptr<const l1menu::IMenuRate> pMenuRate=pImple_->sample.rate( pImple_->menu );
110
111	size_t iterationNumber=0;
112	while ( std::fabs(pMenuRate->totalRate()-totalRate)>tolerance )
113	{
114	if( iterationNumber>10 ) throw std::runtime_error( "Too many iterations" );
115	++iterationNumber;
116
117	float scaleAllRatesBy=totalRate/pMenuRate->totalRate();
118	std::cout << "\n" << "New loop. Last iteration had a rate of " << pMenuRate->totalRate() << ". Scaling all rates by " << scaleAllRatesBy << " to try and get " << totalRate << std::endl;
119
120	for( const auto& triggerScalingDetails : pImple_->scalableTriggers )
121	{
122	const size_t& triggerNumber=triggerScalingDetails.triggerNumber;
123	l1menu::ITrigger& trigger=pImple_->menu.getTrigger( triggerNumber );
124	const l1menu::ITriggerRate* pTriggerRate=pMenuRate->triggerRates()[triggerNumber];
125
126	float& mainThreshold=trigger.parameter( triggerScalingDetails.mainThreshold );
127	// Figure out what threshold should give the target rate for this particular trigger.
128	// Note this is a reference so this command changes the trigger.
129	mainThreshold=triggerScalingDetails.ratePlot.findThreshold( pTriggerRate->rate()*scaleAllRatesBy );
130	// Then scale all of the others off this
131	for( const auto& nameScalePair : triggerScalingDetails.thresholdScalings )
132	{
133	trigger.parameter( nameScalePair.first )=mainThreshold*nameScalePair.second;
134	}
135	std::cout << "Changing threshold for " << trigger.name() << " to " << mainThreshold << " to try and change the rate from " << pTriggerRate->rate() << " to " << pTriggerRate->rate()*scaleAllRatesBy << std::endl;
136
137	} // end of loop over triggers I'm allowed to change thresholds for
138
139	pMenuRate=pImple_->sample.rate( pImple_->menu );
140	}
141
142	return pMenuRate;
143	}
144
145	void l1menu::MenuFitter::addTrigger( const l1menu::ITrigger& trigger, float fractionOfTotalBandwidth, bool lockThresholds )
146	{
147	if( !lockThresholds && (fractionOfTotalBandwidth<0 \|\| fractionOfTotalBandwidth>1) ) throw std::runtime_error("Invalid fraction of the total bandwidth requested");
148
149	size_t triggerNumber=pImple_->menu.numberOfTriggers(); // This will be the number of the next trigger added
150	pImple_->menu.addTrigger( trigger );
151	pImple_->initiateOtherTriggerInfo( triggerNumber, lockThresholds, fractionOfTotalBandwidth );
152	}
153
154	void l1menu::MenuFitter::loadMenuFromFile( const std::string& filename )
155	{
156	std::ifstream file( filename.c_str() );
157	if( !file.is_open() ) throw std::runtime_error( "Unable to open file "+filename );
158
159	const size_t bufferSize=200;
160	char buffer[bufferSize];
161
162	// The old file format provides the rates it wants for each trigger
163	// as an absolute value, whereas I want it as a fraction of the total.
164	// So I need to run through the whole file and add up each of these
165	// to get a total, then divide each value by the total to get the fraction.
166	// Hence I can't do that until I've loaded every trigger. I'll keep track
167	// of whether each threshold is locked and the absolute rate requested in
168	// this vector.
169	std::vector< std::pair<bool,float> > triggerAuxiliaryInfo;
170	float totalRequestedRate=0; // This is the sum of all the rates requested for each trigger
171
172	while( file.good() )
173	{
174	try
175	{
176	// Get one line at a time
177	file.getline( buffer, bufferSize );
178
179	// split the line by whitespace into columns
180	std::vector<std::string> tableColumns=l1menu::tools::splitByWhitespace( buffer );
181
182	if( tableColumns.size()==1 && tableColumns[0].empty() ) continue; // Allow blank lines without giving a warning
183	if( tableColumns.size()!=12 ) throw std::runtime_error( "The line does not have the correct number of columns" );
184
185	if( pImple_->menu.addTriggerFromOldFormat( tableColumns ) )
186	{
187	// If the trigger was created successfully, keep a note of these
188	// details so that I can later initiate the auxiliary information.
189	// I can't do that until I know the total requestedRate.
190	bool lockThresholds=l1menu::tools::convertStringToFloat( tableColumns[11] );
191	float requestedRate=l1menu::tools::convertStringToFloat( tableColumns[9] );
192	triggerAuxiliaryInfo.push_back( std::make_pair(lockThresholds,requestedRate) );
193	totalRequestedRate+=requestedRate;
194	}
195
196	} // end of try block
197	catch( std::runtime_error& exception )
198	{
199	std::cout << "Some error occured while processing the line \"" << buffer << "\":" << exception.what() << std::endl;
200	}
201	}
202
203	// Now I've processed all the lines I should know the total requested rate and I can
204	// initiate the auxiliary information.
205	size_t triggerNumber=pImple_->menu.numberOfTriggers()-triggerAuxiliaryInfo.size(); // There may have been triggers in there previously
206	for( const auto auxiliaryInfo : triggerAuxiliaryInfo )
207	{
208	pImple_->initiateOtherTriggerInfo( triggerNumber, auxiliaryInfo.first, auxiliaryInfo.second/totalRequestedRate );
209	++triggerNumber;
210	}
211	}
212
213	void l1menu::MenuFitterPrivateMembers::initiateOtherTriggerInfo( size_t triggerNumber, bool lockThresholds, float fractionOfTotalBandwidth )
214	{
215	const l1menu::ITrigger& newTrigger=menu.getTrigger( triggerNumber );
216
217	if( !lockThresholds )
218	{
219
220	//
221	// Create a rate plot for this trigger
222	//
223	const std::vector<std::string> thresholdNames=l1menu::tools::getThresholdNames(newTrigger);
224	const std::string& mainThreshold=thresholdNames.front();
225	unsigned int numberOfBins=100;
226	float lowerEdge=0;
227	float upperEdge=100;
228	try
229	{
230	l1menu::TriggerTable& triggerTable=l1menu::TriggerTable::instance();
231	numberOfBins=triggerTable.getSuggestedNumberOfBins( newTrigger.name(), mainThreshold );
232	lowerEdge=triggerTable.getSuggestedLowerEdge( newTrigger.name(), mainThreshold );
233	upperEdge=triggerTable.getSuggestedUpperEdge( newTrigger.name(), mainThreshold );
234	}
235	catch( std::exception& error) { /* Do nothing. If no binning suggestions have been set for this trigger use the defaults I set above. */ }
236
237	l1menu::TriggerRatePlot ratePlot(newTrigger,newTrigger.name()+"_v_allThresholdsScaled",numberOfBins,lowerEdge,upperEdge,mainThreshold,thresholdNames);
238	ratePlot.addSample( sample );
239
240	// Record the scaling between the main threshold and all of the others, so that
241	// when they get increased/decreased it's all done proportionally.
242	std::vector< std::pair<std::string,float> > thresholdScalings;
243	const float mainThresholdValue=newTrigger.parameter(mainThreshold);
244	for( const auto& thresholdName : thresholdNames )
245	{
246	if( thresholdName==mainThreshold ) continue;
247	thresholdScalings.push_back( std::make_pair( thresholdName, newTrigger.parameter(thresholdName)/mainThresholdValue ) );
248	}
249
250	//
251	// Bundle all of this information in the helper structure I wrote in
252	// the unnamed namespace.
253	//
254	scalableTriggers.push_back( ::TriggerScalingDetails{triggerNumber,fractionOfTotalBandwidth,std::move(ratePlot),mainThreshold,std::move(thresholdScalings)} );
255	}
256
257	}