void Scrollbar::processEvent(Event* event)
{
// 非活性の時はイベントを受け付けない
if (getEnabled() == false) return;
if (event->getType() == MouseEvent::MOUSE_PRESSED) {
MouseEvent* me = (MouseEvent *)event;
int mx = me->getX();
int my = me->getY();
// 垂直スクロールバー
if (this->orientation == VERTICAL) {
if (0 < my && my < 16) {
setValue(this->value - this->blocksize);
} else if (getHeight() - 16 < my && my < getHeight()) {
setValue(this->value + this->blocksize);
}
// 水平スクロールバー
} else {
if (0 < mx && mx < 16) {
setValue(this->value - this->blocksize);
} else if (getWidth() - 16 < mx && mx < getWidth()) {
setValue(this->value + this->blocksize);
}
}
} else if (event->getType() == MouseEvent::MOUSE_DRAGGED) {
MouseEvent* me = (MouseEvent *)event;
int mx = me->getX();
int my = me->getY();
// 垂直スクロールバー
if (this->orientation == VERTICAL && 16 <= my && my <= getHeight() - 16) {
setValue((my - 16) * (getMaximum() - getMinimum()) / (getHeight() - 32) + getMinimum());
// 水平スクロールバー
} else if (this->orientation == HORIZONTAL && 16 <= mx && mx <= getWidth() - 16) {
setValue((mx - 16) * (getMaximum() - getMinimum()) / (getWidth() - 32) + getMinimum());
}
}
}
inline bool IntersectWithLine( const Vector3& rayOrigin, Vector3 rayDirection, float &distanceToFrontCollisionOfCube , float &distanceToBackCollisionOfCube ) const
{
rayDirection.x = ( rayDirection.x == 0.f ) ? 0.0000001f : rayDirection.x;
rayDirection.y = ( rayDirection.y == 0.f ) ? 0.0000001f : rayDirection.y;
rayDirection.z = ( rayDirection.z == 0.f ) ? 0.0000001f : rayDirection.z;
Vector3 divisor = 1.f / rayDirection;
Vector3 oMin = (m_Min - rayOrigin) * divisor;
Vector3 oMax = (m_Max - rayOrigin) * divisor;
Vector3 bMax = VectorMax(oMax, oMin);
Vector3 bMin = VectorMin(oMax, oMin);
distanceToBackCollisionOfCube = getMinimum(bMax.x, bMax.y, bMax.z);
distanceToBackCollisionOfCube = getMinimum(bMax.x, bMax.y, bMax.z);
distanceToFrontCollisionOfCube = getMaximum(bMin.x, 0.0f, bMin.y, bMin.z );
return distanceToBackCollisionOfCube > distanceToFrontCollisionOfCube;
}
void LoudnessBarRangeSlider::valueChanged()
{
const int minimalIntervalBetweenMinAndMax = 1;
if (getMinValue() == getMaxValue())
{
if (getMaxValue() + minimalIntervalBetweenMinAndMax <= getMaximum())
{
setMaxValue(getMaxValue() + minimalIntervalBetweenMinAndMax);
}
else
{
setMinValue(getMinValue() - minimalIntervalBetweenMinAndMax);
}
}
}
void MoveAwayForFineAdjustmentSlider::mouseDown (const MouseEvent& e)
{
Slider::mouseDown(e);
mouseDragStartPos = e.position;
if (isEnabled())
{
if (getMaximum() > getMinimum())
{
valueOnMouseDown = getValue();
valueWhenLastDragged = getValue();
lastMousePos = e.position.y;
}
}
}
int32_t
Calendar::getActualMaximum(UCalendarDateFields field, UErrorCode& status) const
{
int32_t fieldValue = getLeastMaximum(field);
int32_t endValue = getMaximum(field);
// if we know that the maximum value is always the same, just return it
if (fieldValue == endValue) {
return fieldValue;
}
// clone the calendar so we don't mess with the real one, and set it to
// accept anything for the field values
Calendar *work = (Calendar*)this->clone();
work->setLenient(TRUE);
// if we're counting weeks, set the day of the week to Sunday. We know the
// last week of a month or year will contain the first day of the week.
if (field == UCAL_WEEK_OF_YEAR || field == UCAL_WEEK_OF_MONTH)
work->set(UCAL_DAY_OF_WEEK, fFirstDayOfWeek);
// now try each value from getLeastMaximum() to getMaximum() one by one until
// we get a value that normalizes to another value. The last value that
// normalizes to itself is the actual maximum for the current date
int32_t result = fieldValue;
do {
work->set(field, fieldValue);
if(work->get(field, status) != fieldValue) {
break;
}
else {
result = fieldValue;
fieldValue++;
}
} while (fieldValue <= endValue);
delete work;
/* Test for buffer overflows */
if(U_FAILURE(status)) {
return 0;
}
return result;
}
FieldContainerMap Slider::createStandardLabels(UInt32 increment, Int32 start)
{
FieldContainerMap NewMap;
for(Int32 i(start) ; i<=getMaximum() ; i += increment)
{
LabelRefPtr NewLabel;
NewLabel = dynamic_pointer_cast<Label>(getLabelPrototype()->shallowCopy());
std::stringstream TempSStream;
TempSStream << i;
NewLabel->setText(TempSStream.str());
NewMap[i] = NewLabel;
}
return NewMap;
}
void ParameterSlider::paint(Graphics& g)
{
ColourGradient grad = ColourGradient(Colour(40, 40, 40), 0.0f, 0.0f,
Colour(80, 80, 80), 0.0, 40.0f, false);
Path p;
p.addPieSegment(3, 3, getWidth()-6, getHeight()-6, 5*double_Pi/4-0.2, 5*double_Pi/4+3*double_Pi/2+0.2, 0.5);
g.setGradientFill(grad);
g.fillPath(p);
//g.fillEllipse(3, 3, getWidth()-6, getHeight()-6);
//g.setColour(Colours::lightgrey);
//g.fillEllipse(12, 12, getWidth()-24, getHeight()-24);
p = makeRotaryPath(getMinimum(), getMaximum(), getValue());
if (isEnabled)
g.setColour(Colour(240,179,12));
else
g.setColour(Colour(75,75,75));
g.fillPath(p);
//g.setColour(Colours::darkgrey);
font.setHeight(9.0);
g.setFont(font);
String valueString = String( (int) getValue());
int stringWidth = font.getStringWidth(valueString);
g.setFont(font);
g.setColour(Colours::darkgrey);
g.drawSingleLineText(valueString, getWidth()/2 - stringWidth/2, getHeight()/2+3);
}
String SynthSlider::getTextFromValue(double value) {
if (string_lookup_) {
int lookup = mopo::utils::iclamp(value, 0, getMaximum());
return string_lookup_[lookup];
}
float display_value = value;
switch (scaling_type_) {
case mopo::ValueDetails::kQuadratic:
display_value = powf(display_value, 2.0f);
break;
case mopo::ValueDetails::kExponential:
display_value = powf(2.0f, display_value);
break;
default:
break;
}
display_value *= post_multiply_;
return String(synthRound(display_value)) + " " + units_;
}
Pnt2f ScrollBar::calculateScrollBarPosition(void) const
{
Pnt2f Position;
UInt16 MajorAxis, MinorAxis;
if(getOrientation() == ScrollBar::VERTICAL_ORIENTATION)
{
MajorAxis = 1;
}
else
{
MajorAxis = 0;
}
MinorAxis = (MajorAxis+1)%2;
Position[MajorAxis] = editScrollField()->getPosition()[MajorAxis] +
(static_cast<Real32>(getValue() - getMinimum())/static_cast<Real32>(getMaximum() - getMinimum() - getExtent())) * (editScrollField()->getSize()[MajorAxis] - editScrollBar()->getSize()[MajorAxis]);
Position[MinorAxis] = editScrollField()->getPosition()[MinorAxis];
return Position;
}
/**
* Retrieve logged values from non-HKL dimensions
* @param skipNormalization [InOut] Updated to false if any values are outside
* range measured by input workspace
* @return A vector of values from other dimensions to be include in normalized
* MD position calculation
*/
std::vector<coord_t>
MDNormDirectSC::getValuesFromOtherDimensions(bool &skipNormalization) const {
const auto &runZero = m_inputWS->getExperimentInfo(0)->run();
std::vector<coord_t> otherDimValues;
for (size_t i = 4; i < m_inputWS->getNumDims(); i++) {
const auto dimension = m_inputWS->getDimension(i);
float dimMin = static_cast<float>(dimension->getMinimum());
float dimMax = static_cast<float>(dimension->getMaximum());
auto *dimProp = dynamic_cast<Kernel::TimeSeriesProperty<double> *>(
runZero.getProperty(dimension->getName()));
if (dimProp) {
coord_t value = static_cast<coord_t>(dimProp->firstValue());
otherDimValues.push_back(value);
// in the original MD data no time was spent measuring between dimMin and
// dimMax
if (value < dimMin || value > dimMax) {
skipNormalization = true;
}
}
}
return otherDimValues;
}
void Plot::addValue(qreal val){
list.append(val);
qreal sum = 0;
for(QList<qreal>::iterator it = list.begin() ; it < list.end() ; it++){
sum += (*it);
}
average = sum/list.count();
if(val > max){
max = val;
}
if(plotter != NULL) plotter->fit(getMaximum());
points.clear();
qreal step = boundingRect().width()/(list.count()-1);
qreal x = 0;
qreal yfix = boundingRect().height();
for(QList<qreal>::iterator it = list.begin() ; it < list.end() ; it++){
points.append(QPointF(x,yfix-((plotter!=NULL)?(*it)*plotter->getScale():(*it))));
x+=step;
}
update();
}
void AssociatedSlider::setValueFromLinearNormalized(const float& inValue, NotificationType notification)
{
float rawMin = getMinimum();
setValue( (rawMin + (getMaximum() - rawMin) * inValue), notification);
}
int Camera::getStopCount(const Parameter & p) const
{
return (getMaximum(p) - getMinimum(p)).asExposureSteps();
}
void Slider::updateSliderTrack(void)
{
Pnt2f BorderTopLeft, BorderBottomRight;
getInsideInsetsBounds(BorderTopLeft, BorderBottomRight);
UInt16 MajorAxis, MinorAxis;
if(getOrientation() == VERTICAL_ORIENTATION)
{
MajorAxis = 1;
}
else
{
MajorAxis = 0;
}
MinorAxis = (MajorAxis+1)%2;
//Update the Knob position
if(getKnobButton() != NULL && getRangeModel() != NULL)
{
Vec2f Size;
Size[MinorAxis] = getKnobButton()->getPreferredSize().x();
Size[MajorAxis] = getKnobButton()->getPreferredSize().y();
Pnt2f AlignedPosition;
//Size[MajorAxis] = getSize()[MajorAxis] - 2;
Vec2f Alignment(0.5,0.5);
Alignment[MajorAxis] = static_cast<Real32>(getValue() - getMinimum())/static_cast<Real32>(getMaximum() - getMinimum());
AlignedPosition = calculateSliderAlignment(getSliderTrackTopLeft(), getSliderTrackSize(), getKnobButton()->getPreferredSize(), Alignment.y(), Alignment.x());
getKnobButton()->setPosition(AlignedPosition);
getKnobButton()->setSize(Size);
}
}
void Slider::updateLayout(void)
{
UInt16 MajorAxis, MinorAxis;
if(getOrientation() == VERTICAL_ORIENTATION)
{
MajorAxis = 1;
}
else
{
MajorAxis = 0;
}
MinorAxis = (MajorAxis+1)%2;
updateSliderTrack();
//Update the Track
if(getDrawTrack() && getTrackDrawObject() != NULL)
{
Pnt2f BorderTopLeft, BorderBottomRight;
getInsideInsetsBounds(BorderTopLeft, BorderBottomRight);
Vec2f Size(getTrackDrawObject()->getPreferredSize());
Pnt2f AlignedPosition;
Size[MajorAxis] = getTrackLength();
if(getOrientation() == VERTICAL_ORIENTATION)
{
AlignedPosition = calculateAlignment(BorderTopLeft, (BorderBottomRight-BorderTopLeft), Size, 0.5, getAlignment());
}
else
{
AlignedPosition = calculateAlignment(BorderTopLeft, (BorderBottomRight-BorderTopLeft), Size, getAlignment(), 0.5);
}
getTrackDrawObject()->setPosition(AlignedPosition);
getTrackDrawObject()->setSize(Size);
}
//Update the MinorTickMarks
if(getDrawMinorTicks() && getRangeModel() != NULL)
{
Pnt2f MinorTickTopLeft, MinorTickBottomRight;
getDrawObjectBounds(*editMFMinorTickDrawObjects(), MinorTickTopLeft, MinorTickBottomRight);
Vec2f Alignment;
Real32 MaxLength(0.0);
for(UInt32 i(0) ; i<getMFMinorTickDrawObjects()->size() ; ++i)
{
Pnt2f DrawObjectTopLeft, DrawObjectBottomRight;
getMinorTickDrawObjects(i)->getBounds(DrawObjectTopLeft, DrawObjectBottomRight);
MaxLength = osgMax(MaxLength, DrawObjectBottomRight.x()-DrawObjectTopLeft.x());
}
editMFMinorTickPositions()->clear();
for(UInt32 i(0) ; i< osgAbs<Int32>(getMaximum() - getMinimum())/getMinorTickSpacing() ; ++i)
{
if( (i * getMinorTickSpacing())%getMajorTickSpacing() != 0 )
{
Alignment[MajorAxis] = static_cast<Real32>(i * getMinorTickSpacing())/static_cast<Real32>(getMaximum() - getMinimum());
editMFMinorTickPositions()->push_back(
calculateSliderAlignment(getSliderTrackTopLeft(), getSliderTrackSize(), (MinorTickBottomRight - MinorTickTopLeft), Alignment.y(), Alignment.x()));
if(getTicksOnRightBottom())
{
editMFMinorTickPositions()->back()[MinorAxis] = getTrackDrawObject()->getPosition()[MinorAxis] + getTrackDrawObject()->getSize()[MinorAxis] + getTrackToTickOffset();
}
else
{
editMFMinorTickPositions()->back()[MinorAxis] = getTrackDrawObject()->getPosition()[MinorAxis] - getTrackToTickOffset() - MaxLength;
}
}
}
}
//Update the MajorTickMarks
if(getDrawMajorTicks() && getRangeModel() != NULL)
{
Pnt2f MajorTickTopLeft, MajorTickBottomRight;
getDrawObjectBounds(*editMFMajorTickDrawObjects(), MajorTickTopLeft, MajorTickBottomRight);
Vec2f Alignment;
Real32 MaxLength(0.0);
for(UInt32 i(0) ; i<getMFMajorTickDrawObjects()->size() ; ++i)
{
Pnt2f DrawObjectTopLeft, DrawObjectBottomRight;
getMajorTickDrawObjects(i)->getBounds(DrawObjectTopLeft, DrawObjectBottomRight);
MaxLength = osgMax(MaxLength, DrawObjectBottomRight.x()-DrawObjectTopLeft.x());
}
editMFMajorTickPositions()->clear();
for(UInt32 i(0) ; i<= osgAbs<Int32>(getMaximum() - getMinimum())/getMajorTickSpacing() ; ++i)
{
Alignment[MajorAxis] = static_cast<Real32>(i * getMajorTickSpacing())/static_cast<Real32>(getMaximum() - getMinimum());
editMFMajorTickPositions()->push_back(
calculateSliderAlignment(getSliderTrackTopLeft(), getSliderTrackSize(), (MajorTickBottomRight - MajorTickTopLeft), Alignment.y(), Alignment.x()));
if(getTicksOnRightBottom())
{
editMFMajorTickPositions()->back()[MinorAxis] = getTrackDrawObject()->getPosition()[MinorAxis] + getTrackDrawObject()->getSize()[MinorAxis] + getTrackToTickOffset();
}
else
{
editMFMajorTickPositions()->back()[MinorAxis] = getTrackDrawObject()->getPosition()[MinorAxis] - getTrackToTickOffset() - MaxLength;
}
}
}
//Update the Labels
if(getDrawLabels() && getRangeModel() != NULL)
{
Vec2f Alignment;
Pnt2f Pos;
FieldContainerMap::const_iterator Itor;
for(Itor = getLabelMap().begin() ; Itor != getLabelMap().end() ; ++Itor)
{
Alignment[MajorAxis] = static_cast<Real32>((*Itor).first - getMinimum())/static_cast<Real32>(getMaximum() - getMinimum());
Pos = calculateSliderAlignment(getSliderTrackTopLeft(), getSliderTrackSize(), dynamic_pointer_cast<Component>((*Itor).second)->getPreferredSize(), Alignment.y(), Alignment.x());
if(getTicksOnRightBottom())
{
Pos[MinorAxis] = getTrackDrawObject()->getPosition()[MinorAxis] + getTrackDrawObject()->getSize()[MinorAxis] + getTrackToLabelOffset();
}
else
{
Pos[MinorAxis] = getTrackDrawObject()->getPosition()[MinorAxis] - getTrackToLabelOffset() - dynamic_pointer_cast<Component>((*Itor).second)->getPreferredSize()[MinorAxis];
}
dynamic_pointer_cast<Component>((*Itor).second)->setPosition(Pos);
dynamic_pointer_cast<Component>((*Itor).second)->setSize(dynamic_pointer_cast<Component>((*Itor).second)->getPreferredSize());
}
}
}
void LoadOctree( const std::string& file_name, OctreeMetadata& octree_data, CudaHandler& handler )
{
std::string root = getTheFileLoader().getDataFolder();
std::string path = root + std::string( "\\\\" ) + file_name;
octree_data.m_FileHandle = std::ifstream( path.c_str(), std::ifstream::binary );
std::ifstream& fileToLoad = octree_data.m_FileHandle;
octree_data.m_AvgChunkSize = 0.f;
octree_data.m_NeedsToFreeUnusedChunksFromCPU = false;
octree_data.m_CPU_Allocations = 0;
char* root_chunk_data = NULL;
if( fileToLoad )
{
fileToLoad.seekg( 0, std::ios::end );
uint32 total_size = 0;
total_size = (uint32)( fileToLoad.tellg() );
uint32 abs_position = 0;
fileToLoad.seekg( 0, std::ios::beg );
uint32 max_size = 0;
uint32 min_size = 0xFFFFFFFF;
while( abs_position < total_size )
{
const int size = sizeof( int32 ) + sizeof( uint32 );
char data_buffer[ size ];
fileToLoad.read( data_buffer, size );
abs_position += size;
int chunk_id = *reinterpret_cast< int* >( data_buffer );
uint32 chunk_size = *reinterpret_cast< uint32* >( data_buffer + sizeof( int32 ) );
octree_data.m_AvgChunkSize += float( chunk_size );
min_size = getMinimum( chunk_size, min_size );
max_size = getMaximum( chunk_size, max_size );
ChunkData new_chunk( chunk_id, chunk_size, abs_position );
if( octree_data.m_ChunkMetaData.size() < size_t( chunk_id + 1 ) )
{
octree_data.m_ChunkMetaData.resize( size_t( chunk_id + 1 ) );
}
octree_data.m_ChunkMetaData[ chunk_id ] = ChunkDataPriority( new_chunk, -1 );
if( chunk_id == 0 )
{
octree_data.m_ChunkMetaData[ 0 ].priority = 0x7FFFFFFF;
//only load root chunk into memory...
root_chunk_data = new char[ chunk_size ];
octree_data.m_CPU_Allocations += chunk_size;
fileToLoad.seekg( abs_position );
fileToLoad.read( root_chunk_data, chunk_size );
}
abs_position += chunk_size;
fileToLoad.seekg( abs_position );
}
}
else
{
errMessageAndExit( "Cannot find file: %s", path.c_str() );
}
int num_chunks = (int)octree_data.m_ChunkMetaData.size();
octree_data.m_LastFrameChunkStatusGPU.m_ChunksUsedAndLoaded = new int[ num_chunks ];
octree_data.m_LastFrameChunkStatusGPU.m_ChunksUsedAndUnloaded = new int[ num_chunks ];
octree_data.m_TotalNumChunks = num_chunks;
octree_data.m_AvgChunkSize /= (float)octree_data.m_ChunkMetaData.size();
octree_data.m_RawChunkData = new char*[ num_chunks ];
memset( octree_data.m_RawChunkData, 0, num_chunks * sizeof( char* ) );
octree_data.m_RawChunkData[ 0 ] = root_chunk_data;
octree_data.ResetGPUChunks();
handler.InitializeChunkData( octree_data.m_TotalNumChunks );
handler.AllocateDataForBlock( 0, reinterpret_cast< OctreeNode* >( octree_data.m_RawChunkData[ 0 ] ), octree_data.m_ChunkMetaData[ 0 ].m_Data.m_ChunkSize );
handler.SendLookupTableToDevice();
}
main()
{
int a[10] = {1, 2, 3, 4, 5, 6, 5, 4, 3, 1};
printf("%d\n", getMaximum(a, 0, 9));
}
void GFBinarySearchTree< C >::printTree( bool addresses ) {
printTree(head, 0, addresses);
if( getMaximum() ) cout << "Maximum: " << *getMaximum()->getData()->getKey() << " \n";
if( getMaximum() ) cout << "Minimum: " << *getMinimum()->getData()->getKey() << endl;
}
void plotFeedDown(int ntest=1, int centL=0,int centH=100)
{
// B cross-section
TFile *inf = new TFile("output_pp_Bmeson_5TeV_y1.root");
// TFile *inf = new TFile("outputBplus_D_pp_rap24.root");
// TFile *inf = new TFile("outputBplus_pp.root");
TH1D *hBPtMax = (TH1D*)inf->Get("hmaxall");
TH1D *hBPtMin = (TH1D*)inf->Get("hminall");
TH1D *hBPt = (TH1D*)inf->Get("hpt");
hBPt->SetName("hBPt");
hBPtMax->SetName("hBPtMax");
hBPtMin->SetName("hBPtMin");
TH1D *hBMaxRatio = (TH1D*)hBPt->Clone("hBMaxRatio");
hBMaxRatio->Divide(hBPtMax);
TH1D *hBMinRatio = (TH1D*)hBPt->Clone("hBMinRatio");
hBMinRatio->Divide(hBPtMin);
hBPt->Rebin(1);
// D cross-section
// TFile *infD = new TFile("outputD0_D_pp.root");
TFile *infD = new TFile("output_pp_d0meson_5TeV_y1.root");
TH1D *hDPtMax = (TH1D*)infD->Get("hmaxall");
TH1D *hDPtMin = (TH1D*)infD->Get("hminall");
TH1D *hDPt = (TH1D*)infD->Get("hpt");
hDPt->SetName("hDPt");
hDPtMax->SetName("hDPtMax");
hDPtMin->SetName("hDPtMin");
hDPt->Rebin(1);
// ratio of B->D0: not correct85% from PYTHIA
//hBPt->Scale(0.85);
hBPt->Scale(0.598);
// c->D (55.7%)
hDPt->Scale(0.557);
TFile *inf2 = new TFile("/data/HeavyFlavourRun2/BtoDPythia/treefile_merged.root");
// TFile *inf2 = new TFile("test.root");
TTree *hi = (TTree*) inf2->Get("ana/hi");
hi->SetAlias("yD","log((sqrt(1.86484*1.86484+pt*pt*cosh(eta)*cosh(eta))+pt*sinh(eta))/sqrt(1.86484*1.86484+pt*pt))");
hi->SetAlias("yB","log((sqrt(5.3*5.3+pt*pt*cosh(eta)*cosh(eta))+pt*sinh(eta))/sqrt(5.3*5.3+pt*pt))");
hi->SetAlias("yJ","log((sqrt(3.09692*3.09692+pt*pt*cosh(eta)*cosh(eta))+pt*sinh(eta))/sqrt(3.09692*3.09692+pt*pt))");
// 6.5, 8, 10, 13, 30
/*
TH1D *hBNoCut = (TH1D*)hBPt->Clone("hBNoCut");
TH1D *hBHasD = (TH1D*)hBPt->Clone("hBHasD");
hi->Draw("pt>>hBHasD","(abs(pdg)>500&&abs(pdg)<600&&abs(yB)<2.4)&&Sum$(abs(pdg)==421&&abs(yD)<2)>0");
hi->Draw("pt>>hBNoCut","(abs(pdg)>500&&abs(pdg)<600&&abs(yB)<2.4)");
;
hBNoCut->Divide(hBHasD);
hBPt->Divide(hBNoCut);
*/
// 0-100%
int npoint = 7;
double ptBins_npjpsi[8] = {1,3,6.5,8,10,13,30,300};
double raa_npjpsi[7];// = {1,0.6, 0.52,0.43,0.43,0.34,0.5};
double raaStat_npjpsi[7];// = {1,0.4,0.12,0.08,0.09,0.07,0.5};
double raaSyst_npjpsi[7];// = {0,0,0.06,0.05,0.05,0.04,0};
/*
0-10, 10-20, 20-30, 30-40, 40-50, 50-100
double nonPromptJpsiRAA_2012[] = {0.,0.38,0.43,0.48,0.52,0.65,0.69};
double nonPromptJpsiRAAError_2012[] = {0.,0.02,0.03,0.03,0.04,0.06,0.07};
double nonPromptJpsiRAAErrorSyst_2012[] = {0.,0.04,0.05,0.05,0.06,0.07,0.07};
*/
if (centL==0&¢H==100) {
raa_npjpsi[0]=1.0; raaStat_npjpsi[0]=0.0; raaSyst_npjpsi[0]=1.0; // no measurement
raa_npjpsi[1]=0.6; raaStat_npjpsi[1]=0.0; raaSyst_npjpsi[1]=0.4; // prelim
raa_npjpsi[2]=0.52; raaStat_npjpsi[2]=0.12; raaSyst_npjpsi[2]=0.06; // np jpsi pas
raa_npjpsi[3]=0.43; raaStat_npjpsi[3]=0.08; raaSyst_npjpsi[3]=0.05; // np jpsi pas
raa_npjpsi[4]=0.43; raaStat_npjpsi[4]=0.09; raaSyst_npjpsi[4]=0.05; // np jpsi pas
raa_npjpsi[5]=0.34; raaStat_npjpsi[5]=0.07; raaSyst_npjpsi[5]=0.04; // np jpsi pas
raa_npjpsi[6]=0.5; raaStat_npjpsi[6]=0.0; raaSyst_npjpsi[6]=0.25; // b-jet
}
if (centL==0&¢H==10) {
raa_npjpsi[0]=1.0; raaStat_npjpsi[0]=0.0; raaSyst_npjpsi[0]=1.0; // no measurement
raa_npjpsi[1]=1.0; raaStat_npjpsi[1]=0.0; raaSyst_npjpsi[1]=1.0; // no measurement
raa_npjpsi[2]=0.38; raaStat_npjpsi[2]=0.02; raaSyst_npjpsi[2]=0.04; // np jpsi pas
raa_npjpsi[3]=0.38; raaStat_npjpsi[3]=0.02; raaSyst_npjpsi[3]=0.04; // np jpsi pas
raa_npjpsi[4]=0.38; raaStat_npjpsi[4]=0.02; raaSyst_npjpsi[4]=0.04; // np jpsi pas
raa_npjpsi[5]=0.38; raaStat_npjpsi[5]=0.02; raaSyst_npjpsi[5]=0.04; // np jpsi pas
raa_npjpsi[6]=0.39; raaStat_npjpsi[6]=0.0; raaSyst_npjpsi[6]=0.20; // b-jet
}
if (centL==10&¢H==20) {
raa_npjpsi[0]=1.0; raaStat_npjpsi[0]=0.0; raaSyst_npjpsi[0]=1.0; // no measurement
raa_npjpsi[1]=1.0; raaStat_npjpsi[1]=0.0; raaSyst_npjpsi[1]=1.0; // no measurement
raa_npjpsi[2]=0.43; raaStat_npjpsi[2]=0.03; raaSyst_npjpsi[2]=0.05; // np jpsi pas
raa_npjpsi[3]=0.43; raaStat_npjpsi[3]=0.03; raaSyst_npjpsi[3]=0.05; // np jpsi pas
raa_npjpsi[4]=0.43; raaStat_npjpsi[4]=0.03; raaSyst_npjpsi[4]=0.05; // np jpsi pas
raa_npjpsi[5]=0.43; raaStat_npjpsi[5]=0.03; raaSyst_npjpsi[5]=0.05; // np jpsi pas
raa_npjpsi[6]=0.47; raaStat_npjpsi[6]=0.0; raaSyst_npjpsi[6]=0.24; // b-jet
}
if (centL==20&¢H==30) {
raa_npjpsi[0]=1.0; raaStat_npjpsi[0]=0.0; raaSyst_npjpsi[0]=1.0; // no measurement
raa_npjpsi[1]=1.0; raaStat_npjpsi[1]=0.0; raaSyst_npjpsi[1]=1.0; // no measurement
raa_npjpsi[2]=0.48; raaStat_npjpsi[2]=0.03; raaSyst_npjpsi[2]=0.05; // np jpsi pas
raa_npjpsi[3]=0.48; raaStat_npjpsi[3]=0.03; raaSyst_npjpsi[3]=0.05; // np jpsi pas
raa_npjpsi[4]=0.48; raaStat_npjpsi[4]=0.03; raaSyst_npjpsi[4]=0.05; // np jpsi pas
raa_npjpsi[5]=0.48; raaStat_npjpsi[5]=0.03; raaSyst_npjpsi[5]=0.05; // np jpsi pas
raa_npjpsi[6]=0.47; raaStat_npjpsi[6]=0.0; raaSyst_npjpsi[6]=0.24; // b-jet
}
if (centL==30&¢H==40) {
raa_npjpsi[0]=1.0; raaStat_npjpsi[0]=0.0; raaSyst_npjpsi[0]=1.0; // no measurement
raa_npjpsi[1]=1.0; raaStat_npjpsi[1]=0.0; raaSyst_npjpsi[1]=1.0; // no measurement
raa_npjpsi[2]=0.52; raaStat_npjpsi[2]=0.04; raaSyst_npjpsi[2]=0.06; // np jpsi pas
raa_npjpsi[3]=0.52; raaStat_npjpsi[3]=0.04; raaSyst_npjpsi[3]=0.06; // np jpsi pas
raa_npjpsi[4]=0.52; raaStat_npjpsi[4]=0.04; raaSyst_npjpsi[4]=0.06; // np jpsi pas
raa_npjpsi[5]=0.52; raaStat_npjpsi[5]=0.04; raaSyst_npjpsi[5]=0.06; // np jpsi pas
raa_npjpsi[6]=0.61; raaStat_npjpsi[6]=0.0; raaSyst_npjpsi[6]=0.30; // b-jet
}
if (centL==40&¢H==50) {
raa_npjpsi[0]=1.0; raaStat_npjpsi[0]=0.0; raaSyst_npjpsi[0]=1.0; // no measurement
raa_npjpsi[1]=1.0; raaStat_npjpsi[1]=0.0; raaSyst_npjpsi[1]=1.0; // no measurement
raa_npjpsi[2]=0.65; raaStat_npjpsi[2]=0.06; raaSyst_npjpsi[2]=0.07; // np jpsi pas
raa_npjpsi[3]=0.65; raaStat_npjpsi[3]=0.06; raaSyst_npjpsi[3]=0.07; // np jpsi pas
raa_npjpsi[4]=0.65; raaStat_npjpsi[4]=0.06; raaSyst_npjpsi[4]=0.07; // np jpsi pas
raa_npjpsi[5]=0.65; raaStat_npjpsi[5]=0.06; raaSyst_npjpsi[5]=0.07; // np jpsi pas
raa_npjpsi[6]=0.61; raaStat_npjpsi[6]=0.0; raaSyst_npjpsi[6]=0.30; // b-jet
}
if (centL==50&¢H==100) {
raa_npjpsi[0]=1.0; raaStat_npjpsi[0]=0.0; raaSyst_npjpsi[0]=1.0; // no measurement
raa_npjpsi[1]=1.0; raaStat_npjpsi[1]=0.0; raaSyst_npjpsi[1]=1.0; // no measurement
raa_npjpsi[2]=0.69; raaStat_npjpsi[2]=0.07; raaSyst_npjpsi[2]=0.07; // np jpsi pas
raa_npjpsi[3]=0.69; raaStat_npjpsi[3]=0.07; raaSyst_npjpsi[3]=0.07; // np jpsi pas
raa_npjpsi[4]=0.69; raaStat_npjpsi[4]=0.07; raaSyst_npjpsi[4]=0.07; // np jpsi pas
raa_npjpsi[5]=0.69; raaStat_npjpsi[5]=0.07; raaSyst_npjpsi[5]=0.07; // np jpsi pas
raa_npjpsi[6]=0.70; raaStat_npjpsi[6]=0.0; raaSyst_npjpsi[6]=0.35; // b-jet
}
if (centL==0&¢H==20) { //averaged by ncoll
raa_npjpsi[0]=1.0; raaStat_npjpsi[0]=0.0; raaSyst_npjpsi[0]=1.0; // no measurement
raa_npjpsi[1]=1.0; raaStat_npjpsi[1]=0.0; raaSyst_npjpsi[1]=1.0; // no measurement
raa_npjpsi[2]=0.4; raaStat_npjpsi[2]=0.03; raaSyst_npjpsi[2]=0.05; // np jpsi pas
raa_npjpsi[3]=0.4; raaStat_npjpsi[3]=0.03; raaSyst_npjpsi[3]=0.05; // np jpsi pas
raa_npjpsi[4]=0.4; raaStat_npjpsi[4]=0.03; raaSyst_npjpsi[4]=0.05; // np jpsi pas
raa_npjpsi[5]=0.4; raaStat_npjpsi[5]=0.03; raaSyst_npjpsi[5]=0.05; // np jpsi pas
raa_npjpsi[6]=0.42; raaStat_npjpsi[6]=0.0; raaSyst_npjpsi[6]=0.21; // b-jet
}
if (centL==10&¢H==30) { //averaged by ncoll
raa_npjpsi[0]=1.0; raaStat_npjpsi[0]=0.0; raaSyst_npjpsi[0]=1.0; // no measurement
raa_npjpsi[1]=1.0; raaStat_npjpsi[1]=0.0; raaSyst_npjpsi[1]=1.0; // no measurement
raa_npjpsi[2]=0.45; raaStat_npjpsi[2]=0.03; raaSyst_npjpsi[2]=0.05; // np jpsi pas
raa_npjpsi[3]=0.45; raaStat_npjpsi[3]=0.03; raaSyst_npjpsi[3]=0.05; // np jpsi pas
raa_npjpsi[4]=0.45; raaStat_npjpsi[4]=0.03; raaSyst_npjpsi[4]=0.05; // np jpsi pas
raa_npjpsi[5]=0.45; raaStat_npjpsi[5]=0.03; raaSyst_npjpsi[5]=0.05; // np jpsi pas
raa_npjpsi[6]=0.47; raaStat_npjpsi[6]=0.0; raaSyst_npjpsi[6]=0.24; // b-jet
}
if (centL==30&¢H==50) { //averaged by ncoll
raa_npjpsi[0]=1.0; raaStat_npjpsi[0]=0.0; raaSyst_npjpsi[0]=1.0; // no measurement
raa_npjpsi[1]=1.0; raaStat_npjpsi[1]=0.0; raaSyst_npjpsi[1]=1.0; // no measurement
raa_npjpsi[2]=0.57; raaStat_npjpsi[2]=0.06; raaSyst_npjpsi[2]=0.07; // np jpsi pas
raa_npjpsi[3]=0.57; raaStat_npjpsi[3]=0.06; raaSyst_npjpsi[3]=0.07; // np jpsi pas
raa_npjpsi[4]=0.57; raaStat_npjpsi[4]=0.06; raaSyst_npjpsi[4]=0.07; // np jpsi pas
raa_npjpsi[5]=0.57; raaStat_npjpsi[5]=0.06; raaSyst_npjpsi[5]=0.07; // np jpsi pas
raa_npjpsi[6]=0.61; raaStat_npjpsi[6]=0.0; raaSyst_npjpsi[6]=0.30; // b-jet
}
TH1D *hNPJpsiRAA = new TH1D("hNPJpsiRAA","",npoint,ptBins_npjpsi);
for (int i=1;i<=npoint;i++)
{
hNPJpsiRAA->SetBinContent(i,raa_npjpsi[i-1]);
hNPJpsiRAA->SetBinError(i,sqrt(raaSyst_npjpsi[i-1]*raaSyst_npjpsi[i-1]+raaStat_npjpsi[i-1]*raaStat_npjpsi[i-1])); }
TCanvas *cJpsiRAA = new TCanvas("cJpsiRAA","",600,600);
cJpsiRAA->SetLogx();
TExec *setex2 = new TExec("setex2","gStyle->SetErrorX(0.5)");
setex2->Draw();
hNPJpsiRAA->SetXTitle("Non-prompt J/psi R_{AA} (GeV/c)");
hNPJpsiRAA->SetXTitle("Non-prompt J/psi p_{T} (GeV/c)");
hNPJpsiRAA->SetYTitle("R_{AA}");
hNPJpsiRAA->Draw("e1");
TCanvas *c = new TCanvas("c","",600,600);
TH2D *hJpsi= new TH2D("hJpsi","",hBPt->GetNbinsX(),hBPt->GetBinLowEdge(1),hBPt->GetBinLowEdge(hBPt->GetNbinsX()+1),
299*4,1,300);
TH2D *hD= new TH2D("hD","",hBPt->GetNbinsX(),hBPt->GetBinLowEdge(1),hBPt->GetBinLowEdge(hBPt->GetNbinsX()+1),
299*4,1,300);
hi->Draw("pt:BPt>>hJpsi","pdg==443&&BPt>0&&abs(yJ)<1");
hi->Draw("pt:BPt>>hD","abs(pdg)==421&&BPt>0&&abs(yD)<1");
hJpsi->Sumw2();
hD->Sumw2();
reweighthisto(hBPt,hD);
reweighthisto(hBPt,hJpsi);
hJpsi->ProjectionY()->Draw("hist");
hD->SetLineColor(4);
hD->SetMarkerColor(4);
hD->ProjectionY()->Draw("hist same");
hBPt->Draw("hist same");
hJpsi->SetXTitle("B p_{T} (GeV/c)");
hJpsi->SetYTitle("J/#psi p_{T} (GeV/c)");
hD->SetXTitle("B p_{T} (GeV/c)");
hD->SetYTitle("D^{0} p_{T} (GeV/c)");
TCanvas *c2= new TCanvas("c2","B RAA band",600,600);
TRandom2 rnd;
// hJpsi ->ProjectionX()->Draw("hist");
TH2D *hRAATmp = new TH2D("hRAATmp","",97,3,100,100,0,2);
hRAATmp->SetXTitle("B p_{T} (GeV/c)");
hRAATmp->SetYTitle("R_{AA}");
hRAATmp->Draw();
TCanvas *c3= new TCanvas("c3","D RAA band",600,600);
TH2D *hDRAATmp = new TH2D("hDRAATmp","",47,3,50,100,0,2);
hDRAATmp->SetXTitle("D^{0} p_{T} (GeV/c)");
hDRAATmp->SetYTitle("R_{AA}");
hDRAATmp->Draw();
TCanvas *c4= new TCanvas("c4","B->D fraction band",600,600);
TH2D *hBtoDTmp = new TH2D("hBtoDTmp","",47,3,50,100,0,2);
hBtoDTmp->SetXTitle("D^{0} p_{T} (GeV/c)");
hBtoDTmp->SetYTitle("Non-prompt D fraction");
hBtoDTmp->Draw();
TH1D *hDFromBPt= (TH1D*)hD->ProjectionY()->Clone("hDFromBPt");
TH1D *hDFromBPtFraction= (TH1D*)hD->ProjectionY()->Clone("hDFromBPtFraction");
hDFromBPtFraction->Divide(hDPt);
TH1D *hDFromBPtMax= (TH1D*)hD->ProjectionY()->Clone("hDFromBPtMax");
TH1D *hDFromBPtMin= (TH1D*)hD->ProjectionY()->Clone("hDFromBPtMin");
setHist(hDFromBPtMax,-1e10);
setHist(hDFromBPtMin,1e10);
for (int i=0;i<ntest;i++)
{
if (i%10==0) cout <<i<<endl;
TH1D *hRAASample = (TH1D*)hNPJpsiRAA->Clone(Form( "hRAASample_%d",i));
for (int j=1;j<=hRAASample->GetNbinsX();j++) {
double RAA = (rnd.Rndm()*2-1)*hNPJpsiRAA->GetBinError(j)+hNPJpsiRAA->GetBinContent(j);
hRAASample->SetBinContent(j,RAA);
}
TH2D *hJpsiClone = (TH2D*)hJpsi->Clone(Form("hJpsiClone_%d",i));
reweighthisto(hBPt,hJpsiClone,hRAASample,1);
TH1D *hBRAA = hJpsiClone->ProjectionX(Form("hBRAA_%d",i));
c2->cd();
hBRAA->Divide(hBPt);
hBRAA->SetLineWidth(3);
hBRAA->SetLineColor(kGray);
hBRAA->Rebin(4);
hBRAA->Scale(1./4.);
hBRAA->Draw("hist c same");
delete hJpsiClone;
TH2D *hDClone = (TH2D*)hD->Clone(Form("hDClone_%d",i));
reweighthisto(hBPt,hDClone,hBRAA,0,1);
TH1D *hDRAA = hDClone->ProjectionY(Form("hDRAA_%d",i));
getMaximum(hDFromBPtMax,hDRAA);
getMinimum(hDFromBPtMin,hDRAA);
c3->cd();
hDRAA->Divide(hDFromBPt);
hDRAA->SetLineWidth(3);
hDRAA->SetLineColor(kGray);
hDRAA->Draw("hist c same");
c4->cd();
TH1D *hBtoDFrac = hDClone->ProjectionY(Form("hBtoDFrac_%d",i));
hBtoDFrac->Divide(hDPt);
hBtoDFrac->SetLineWidth(3);
hBtoDFrac->SetLineColor(kGray);
hBtoDFrac->Draw("hist same");
delete hDClone;
// delete hBRAA;
// delete hDRAA;
}
TFile *outf = new TFile(Form("BtoD-%d-%d.root",centL,centH),"recreate");
TH1D *hDFromBPtCentral=(TH1D*)hDFromBPtMax->Clone("hDFromBPtCentral");
hDFromBPtCentral->Add(hDFromBPtMin);
hDFromBPtCentral->Scale(1./2);
hNPJpsiRAA->Write();
hDFromBPtMax->Write();
hDFromBPtMin->Write();
hDFromBPtCentral->Write();
hDFromBPt->Write();
hJpsi->Write();
hD->Write();
hDFromBPtFraction->Write();
outf->Write();
}
std::string CSimpleStat::toStr(const std::string& unitString) const
{
std::stringstream ss;
if ((mBufPos <= 0) && !mHasWrapped)
ss << "No data";
else
{
double avg = getAverage();
double stdev = getStdev();
ss.setf(std::ios::fixed,std::ios::floatfield);
ss.precision(2);
ss << "Avg: " << avg << unitString << "\tStdev: " << stdev << unitString << " (" << 100.0*stdev/avg << "%)\tMin: " << getMinimum() << unitString << "\tMax:" << getMaximum() << unitString;
}
return ss.str();
}
PhysicsInterface::BodyTemplateObject Bullet::createBodyTemplateFromGeometry(const Vector<Vec3>& vertices,
const Vector<RawIndexedTriangle>& triangles,
bool deleteOnceUnused,
float customCollisionMargin)
{
if (vertices.empty() || triangles.empty())
return nullptr;
auto bodyTemplate = new BodyTemplate(deleteOnceUnused);
bodyTemplates_.append(bodyTemplate);
// Copy the geometry data
bodyTemplate->vertices = vertices;
bodyTemplate->triangles = triangles;
// Create interface to the geometry data for Bullet to use
auto mesh = btIndexedMesh();
mesh.m_numTriangles = bodyTemplate->triangles.size();
mesh.m_triangleIndexBase = reinterpret_cast<byte_t*>(bodyTemplate->triangles.getData());
mesh.m_triangleIndexStride = 3 * sizeof(unsigned int);
mesh.m_numVertices = bodyTemplate->vertices.size();
mesh.m_vertexBase = bodyTemplate->vertices.as<byte_t>();
mesh.m_vertexStride = 3 * sizeof(float);
auto meshInterface = new btTriangleIndexVertexArray();
meshInterface->addIndexedMesh(mesh);
// Calculate an AABB around the geometry
auto aabb = AABB(bodyTemplate->vertices);
// Create the collision shape
bodyTemplate->collisionShape =
new btBvhTriangleMeshShape(meshInterface, true, toBullet(aabb.getMinimum()), toBullet(aabb.getMaximum()));
if (customCollisionMargin > 0.0f)
bodyTemplate->collisionShape->setMargin(customCollisionMargin);
return bodyTemplate;
}
Vec2f ScrollBar::calculateScrollBarSize(void) const
{
Vec2f Size;
UInt16 MajorAxis, MinorAxis;
if(getOrientation() == ScrollBar::VERTICAL_ORIENTATION)
{
MajorAxis = 1;
}
else
{
MajorAxis = 0;
}
MinorAxis = (MajorAxis+1)%2;
Size[MajorAxis] = osgMax<Real32>( getScrollBarMinLength(),(static_cast<Real32>(getExtent())/static_cast<Real32>(getMaximum() - getMinimum())) * (editScrollField()->getSize()[MajorAxis]));
Size[MinorAxis] = editScrollField()->getSize()[MinorAxis];
return Size;
}
Int32 ScrollBar::calculateValueFromPosition(const Pnt2f Position) const
{
Int32 Value;
UInt16 MajorAxis, MinorAxis;
if(getOrientation() == ScrollBar::VERTICAL_ORIENTATION)
{
MajorAxis = 1;
}
else
{
MajorAxis = 0;
}
MinorAxis = (MajorAxis+1)%2;
Value = (Position[MajorAxis] - editScrollField()->getPosition()[MajorAxis])/(editScrollField()->getSize()[MajorAxis] - editScrollBar()->getSize()[MajorAxis])*static_cast<Real32>(getMaximum() - getMinimum() - getExtent()) + getMinimum();
return Value;
}
UBool
GregorianCalendar::boundsCheck(int32_t value, UCalendarDateFields field) const
{
return value >= getMinimum(field) && value <= getMaximum(field);
}
/**
* Checks the normalization workspace against the indices of the original
* dimensions.
* If not found, the corresponding dimension is integrated
* @param otherDimValues Values from non-HKL dimensions
* @param skipNormalization [InOut] Sets the flag true if normalization values
* are outside of original inputs
* @return Affine trasform matrix
*/
Kernel::Matrix<coord_t> MDNormDirectSC::findIntergratedDimensions(
const std::vector<coord_t> &otherDimValues, bool &skipNormalization) {
// Get indices of the original dimensions in the output workspace,
// and if not found, the corresponding dimension is integrated
Kernel::Matrix<coord_t> affineMat =
m_normWS->getTransformFromOriginal(0)->makeAffineMatrix();
const size_t nrm1 = affineMat.numRows() - 1;
const size_t ncm1 = affineMat.numCols() - 1;
for (size_t row = 0; row < nrm1; row++) // affine matrix, ignore last row
{
const auto dimen = m_normWS->getDimension(row);
const auto dimMin(dimen->getMinimum()), dimMax(dimen->getMaximum());
if (affineMat[row][0] == 1.) {
m_hIntegrated = false;
m_hIdx = row;
m_hmin = std::max(m_hmin, dimMin);
m_hmax = std::min(m_hmax, dimMax);
if (m_hmin > dimMax || m_hmax < dimMin) {
skipNormalization = true;
}
}
if (affineMat[row][1] == 1.) {
m_kIntegrated = false;
m_kIdx = row;
m_kmin = std::max(m_kmin, dimMin);
m_kmax = std::min(m_kmax, dimMax);
if (m_kmin > dimMax || m_kmax < dimMin) {
skipNormalization = true;
}
}
if (affineMat[row][2] == 1.) {
m_lIntegrated = false;
m_lIdx = row;
m_lmin = std::max(m_lmin, dimMin);
m_lmax = std::min(m_lmax, dimMax);
if (m_lmin > dimMax || m_lmax < dimMin) {
skipNormalization = true;
}
}
if (affineMat[row][3] == 1.) {
m_dEIntegrated = false;
m_eIdx = row;
m_dEmin = std::max(m_dEmin, dimMin);
m_dEmax = std::min(m_dEmax, dimMax);
if (m_dEmin > dimMax || m_dEmax < dimMin) {
skipNormalization = true;
}
}
for (size_t col = 4; col < ncm1; col++) // affine matrix, ignore last column
{
if (affineMat[row][col] == 1.) {
double val = otherDimValues.at(col - 3);
if (val > dimMax || val < dimMin) {
skipNormalization = true;
}
}
}
}
return affineMat;
}
/*
* Reads values form the database and stores the features in in, the targets (mapped according to the set policy) in targets as one-of-n coding
*/
size_t Trainer::readDatabase(Array<double>& in, Array<double>& target) throw(Kompex::SQLiteException) {
// if no query has been set, use default query
if(query.size() == 0)
genDefaultQuery();
// read the maximum of the column in measurement for which to train
double max = 0.0, min = 0.0;
if(genOut != GenNNoutput::ML_KEEP_INT && genOut != GenNNoutput::ML_FUZZY_VECTOR)
max = getMaximum(trainForName), min = getMinimum(trainForName);
Kompex::SQLiteStatement *localStmt = new Kompex::SQLiteStatement(pDatabase);
unsigned int nClasses = model.getOutputDimension();
localStmt->Sql(query);
size_t nRows = localStmt->GetNumberOfRows();
in = Array<double>(nRows, nFeatures());
LOG(INFO) << "Queried Rows: " << nRows << ", Number of features: " << staticFeatures.size() << " + " << dynamicFeatures.size() <<
" + " << pcaFeatures.size() << std::endl;
if(nRows == 0)
throw MachineLearningException("No dataset for the requested features could be found");
std::list<std::pair<double, size_t> > measurements;
Array<double> oneOfN(nClasses);
for(Array<double>::iterator I = oneOfN.begin(); I != oneOfN.end() && model.usesOneOfNCoding(); ++I) {
*I = NEG;
}
//Train machine
size_t i = 0;
// fetch all results
while(localStmt->FetchRow()){
// std::cout << "Result: " << localStmt->GetColumnName(2) << " " << localStmt->GetColumnName(3) << " " << localStmt->GetColumnName(4) << std::endl;
// std::cout << "Data: " << localStmt->GetColumnInt(2) << " " << localStmt->GetColumnInt(3) << " " << localStmt->GetColumnInt(4) << std::endl;
//std::cout << "[";
// construct training vectors
for(size_t j = 0; j < nFeatures(); ++j) {
in(i, j) = localStmt->GetColumnDouble(j);
//std::cout << in(i, j) << " ";
}
// translate index to one-of-n coding
if(genOut == ML_MAP_TO_N_CLASSES)
measurements.push_back(std::make_pair(localStmt->GetColumnDouble(nFeatures()), i));
else
appendToTrainArray(target, localStmt, nFeatures(), max, min, oneOfN);
//std::cout << target(i) << "]\n";
++i;
}
if(genOut == ML_MAP_TO_N_CLASSES)
mapToNClasses(measurements, model.getOutputDimension(), NEG, POS, target);
// reset the prepared statement
localStmt->Reset();
// do not forget to clean-up
localStmt->FreeQuery();
delete localStmt;
FeaturePreconditioner fp;
featureNormalization = fp.normalize(in, -1, 1);
return nRows;
}
