void
OpenSteer::SharedPointerTest::testAssignment()
{
// Testing assignment of shared pointers pointing to 0.
{
SharedPointer< SharedPointerTester< 0 > > sp0;
SharedPointer< SharedPointerTester< 0 > > sp1( sp0 );
CPPUNIT_ASSERT( 0 == sp0.get() );
CPPUNIT_ASSERT( 0 == sp1.get() );
}
CPPUNIT_ASSERT_EQUAL( 0, SharedPointerTester< 0 >::static_counter_ );
// Testing assignment to a shared pointer holding 0.
{
SharedPointerTester< 0 >* rawPointer = new SharedPointerTester< 0 >();
SharedPointer< SharedPointerTester< 0 > > sp0;
SharedPointer< SharedPointerTester< 0 > > sp1( rawPointer );
SharedPointer< SharedPointerTester< 0 > > sp2( sp0 );
sp0 = sp1;
CPPUNIT_ASSERT( 2 == sp0.useCount() );
CPPUNIT_ASSERT( 2 == sp1.useCount() );
CPPUNIT_ASSERT_EQUAL( rawPointer, sp0.get() );
CPPUNIT_ASSERT_EQUAL( rawPointer, sp1.get() );
CPPUNIT_ASSERT( 0 == sp2.get() );
}
CPPUNIT_ASSERT_EQUAL( 0, SharedPointerTester< 0 >::static_counter_ );
// Testing assignment that should lead to a destruction.
{
SharedPointerTester< 0 >* rawPointer0 = new SharedPointerTester< 0 >();
SharedPointerTester< 0 >* rawPointer1 = new SharedPointerTester< 0 >();
CPPUNIT_ASSERT_EQUAL( 2, SharedPointerTester< 0 >::static_counter_ );
SharedPointer< SharedPointerTester< 0 > > sp0( rawPointer0 );
SharedPointer< SharedPointerTester< 0 > > sp1( rawPointer1 );
sp1 = sp0;
CPPUNIT_ASSERT_EQUAL( 1, SharedPointerTester< 0 >::static_counter_ );
CPPUNIT_ASSERT( 2 == sp0.useCount() );
CPPUNIT_ASSERT( 2 == sp1.useCount() );
CPPUNIT_ASSERT_EQUAL( rawPointer0, sp0.get() );
CPPUNIT_ASSERT_EQUAL( rawPointer0, sp1.get() );
}
CPPUNIT_ASSERT_EQUAL( 0, SharedPointerTester< 0 >::static_counter_ );
}
int IconLabel::prepare(const QString &text, qreal scale, bool elided) {
m_text = text;
m_elided = elided;
QHBoxLayout *layout = new QHBoxLayout;
layout->setContentsMargins(0,0,0,0);
setLayout(layout);
m_label = new QLabel(text, this);
QFont font = m_label->font();
font.setPointSize(font.pointSize()*scale);
m_label->setFont(font);
if(!elided)
m_label->setWordWrap(true);
else {
QSizePolicy sp1(QSizePolicy::Ignored, QSizePolicy::Fixed);
m_label->setSizePolicy(sp1);
}
QFontMetrics(m_label->font()).height();
layout->addWidget(m_label, 1);
return QFontMetrics(font).height();
}
void testvector()
{
std::vector<boost::shared_ptr<A> > v(10);
A *pA = new A();
A *pB = new A();
boost::shared_ptr<A> sp1(pA);
boost::shared_ptr<A> sp2(pB);
std::cout<<"The Smartptr now has "<<sp1.use_count()<<" references\n";
v[0] = sp1;
std::cout<<"The Smartptr now has "<<sp1.use_count()<<" references\n";
std::vector<boost::shared_ptr<A> > ::iterator k = v.begin();
//v.erase(k);//删除第一个元素
//v.pop_back();
v[0] = sp2;
std::cout<<"The Smartptr now has "<<sp1.use_count()<<" references\n";
// std::cout<<"vertor size :"<<v.len()<<" references\n";
}
void
OpenSteer::SharedPointerTest::testComparisons()
{
Super* rawSuperPointer0 = new Super();
SharedPointer< Super > sp0( rawSuperPointer0 );
Sub* rawSubPointer1 = new Sub();
SharedPointer< Super > sp1( rawSubPointer1 );
CPPUNIT_ASSERT( sp0 != sp1 );
CPPUNIT_ASSERT( ( sp0 < sp1 ) || ( sp1 < sp0 ) );
sp1 = sp0;
CPPUNIT_ASSERT( sp0 == sp1 );
CPPUNIT_ASSERT( !( sp0 < sp1 ) && !( sp1 < sp0 ) );
sp0.reset();
sp1.reset();
CPPUNIT_ASSERT( sp0 == sp1 );
// @todo Are these semantics really a good idea?
CPPUNIT_ASSERT( ( sp0 < sp1 ) || ( sp1 < sp0 ) );
}
void
OpenSteer::SharedPointerTest::testInheritance()
{
{
Sub* rawSubPointer0 = new Sub();
SharedPointer< Super > sp0( rawSubPointer0 );
CPPUNIT_ASSERT_EQUAL( 1, Super::superCount_ );
}
CPPUNIT_ASSERT_EQUAL( 0, Super::superCount_ );
{
Super* rawSuperPointer0 = new Super();
SharedPointer< Super > sp0( rawSuperPointer0 );
CPPUNIT_ASSERT_EQUAL( 1, Super::superCount_ );
CPPUNIT_ASSERT_EQUAL( 0, Sub::subCount_ );
Sub* rawSubPointer0 = new Sub();
SharedPointer< Sub > sp1( rawSubPointer0 );
CPPUNIT_ASSERT_EQUAL( 2, Super::superCount_ );
CPPUNIT_ASSERT_EQUAL( 1, Sub::subCount_ );
sp0 = sp1;
CPPUNIT_ASSERT_EQUAL( 1, Super::superCount_ );
CPPUNIT_ASSERT_EQUAL( 1, Sub::subCount_ );
}
CPPUNIT_ASSERT_EQUAL( 0, Super::superCount_ );
CPPUNIT_ASSERT_EQUAL( 0, Sub::subCount_ );
}
void testmap()
{
std::map<std::string, boost::shared_ptr<A> > m;
A *pA = new A();
A *pB = new A();
boost::shared_ptr<A> sp1(pA);
boost::shared_ptr<A> sp2(pB);
std::cout<<"The Smartptr now has "<<sp1.use_count()<<" references\n";
m["1"] = sp1;
std::cout<<"The Smartptr now has "<<sp1.use_count()<<" references\n";
// std::vector<boost::shared_ptr<A> > ::iterator k = v.begin();
//v.erase(k);//删除第一个元素
//v.pop_back();
//v[0] = sp2;
m["1"] = SMART_PTR_NULL_A;
std::cout<<"The Smartptr now has "<<sp1.use_count()<<" references\n";
// std::cout<<"vertor size :"<<v.len()<<" references\n";
m["1"] = sp1;
std::cout<<"The Smartptr now has "<<sp1.use_count()<<" references\n";
}
int main(int, const char * []) {
IloEnv env;
try {
IloIntVarArray x(env);
for (IloInt i = 0; i < 10; i++) {
char name[6];
sprintf(name, "X%ld", i);
x.add(IloIntVar(env, 0, 100 - 2*(i / 2), name));
}
IloModel mdl(env);
mdl.add(IloAllDiff(env, x));
mdl.add(x);
IloIntVarChooser varChooser = ChooseSmallestCentroid(env);
IloIntValueChooser valChooser = ChooseSmallestDistanceFromCentroid(env);
IloSearchPhase sp1(env, x, varChooser, valChooser);
IloIntVarEval varEval = Centroid(env);
IloIntValueEval valEval = DistanceFromCentroid(env);
IloSearchPhase sp2(env, x, IloSelectSmallest(varEval),
IloSelectSmallest(valEval));
// sp2 can have ties as two variable or values could evaluate
// to the same values. sp3 shows how to break these ties
// choosing, for equivalent centroid and distance-to-centroid
// evaluations, the lowest indexed variable in x and the
// lowest value.
IloVarSelectorArray selVar(env);
selVar.add(IloSelectSmallest(varEval));
selVar.add(IloSelectSmallest(IloVarIndex(env, x))); // break ties on index
IloValueSelectorArray selValue(env);
selValue.add(IloSelectSmallest(valEval));
selValue.add(IloSelectSmallest(IloValue(env))); // break ties on smallest
IloSearchPhase sp3(env, x, selVar, selValue);
IloCP cp(mdl);
cp.setParameter(IloCP::Workers, 1);
cp.setParameter(IloCP::SearchType, IloCP::DepthFirst);
cp.setParameter(IloCP::LogPeriod, 1);
cp.out() << "Choosers" << std::endl;
cp.solve(sp1);
cp.out() << cp.domain(x) << std::endl;
cp.out() << "Evaluators" << std::endl;
cp.solve(sp2);
cp.out() << cp.domain(x) << std::endl;
cp.out() << "Evaluators (with tie-break)" << std::endl;
cp.solve(sp3);
cp.out() << cp.domain(x) << std::endl;
cp.end();
} catch (IloException & ex) {
env.out() << "Caught: " << ex << std::endl;
}
env.end();
return 0;
}
/* main entry */
submain(int argc, char **argv)
{
int c;
/* get command line options */
while ((c = getopt(argc, argv, "?")) != EOF)
{
/* get options */
switch (c)
{
case '?':
/* help message */
usage(argv[0]);
return(0);
default:
/* error */
ERROR("invalid option.", EINVAL);
usage(argv[0]);
return(2);
}
}
/* check if spectra and output file were given */
if ((optind + 3) > argc)
{
ERROR("missing spectrum or output file.", EINVAL);
usage(argv[0]);
return(2);
}
/* create spectra */
Spectrum sp1(argv[optind]);
if ((errno = sp1.getStatus()) != OK)
{
ERRORS("spectrum constructor failed for spectrum.",
argv[optind], errno);
exit(2);
}
Spectrum sp2(argv[optind+1]);
if ((errno = sp2.getStatus()) != OK)
{
ERRORS("spectrum constructor failed for spectrum.",
argv[optind+1], errno);
exit(2);
}
/* do correlation */
Spectrum corrsp = correlation(sp1, sp2);
/* write out spectrum */
corrsp.writeSpectrum(argv[optind+2]);
/* all done */
return(0);
}
TEST(Test, Correction) {
StringPiece s1(g_s1, sizeof(g_s1) - 1);
StringPiece s2(g_s2, sizeof(g_s2) - 1);
StringPiece sp1(g_s1, sizeof(g_s1) - 1);
StringPiece sp2(g_s2, sizeof(g_s2) - 1);
EXPECT_EQ(s1 == s2, sp1 == sp2);
EXPECT_EQ(s1 != s2, sp1 != sp2);
EXPECT_EQ(s1 < s2, sp1 < sp2);
EXPECT_EQ(s1 <= s2, sp1 <= sp2);
EXPECT_EQ(s1 > s2, sp1 > sp2);
EXPECT_EQ(s1 >= s2, sp1 >= sp2);
}
void test()
{
boost::shared_ptr<implementation> sp1(new implementation());
std::cout<<"The Sample now has "<<sp1.use_count()<<" references\n";
boost::shared_ptr<implementation> sp2 = sp1;
std::cout<<"The Sample now has "<<sp2.use_count()<<" references\n";
//sp1.reset();
std::cout<<"After Reset sp1. The Sample now has "<<sp2.use_count()<<" references\n";
//sp2.reset();
std::cout<<"After Reset sp2.\n";
}
void test()
{
boost::shared_ptr<A> sp1(new A());
std::cout<<"The Smartptr now has "<<sp1.use_count()<<" references\n";
boost::shared_ptr<A> sp2 = sp1;
std::cout<<"The Smartptr now has "<<sp2.use_count()<<" references\n";
sp1.reset();
std::cout<<"After Reset sp1. The Smartptr now has "<<sp2.use_count()<<" references\n";
sp2.reset();
std::cout<<"After Reset sp2.\n";
}
int main()
{
shared_ptr<resource> sp0;
show("empty object before reset", sp0);
sp0.reset();
show("empty object after reset", sp0);
shared_ptr<resource> sp1(new resource(1));
show("non-empty object before reset", sp1);
sp1.reset();
show("non-empty object after reset", sp1);
return 0;
}
void
OpenSteer::SharedPointerTest::testConstruction()
{
// Testing automatic destruction of a raw pointer hold by a single
// shared pointer.
CPPUNIT_ASSERT_EQUAL( 0, SharedPointerTester< 0 >::static_counter_ );
SharedPointerTester< 0 >* rawPointer = new SharedPointerTester< 0 >();
CPPUNIT_ASSERT_EQUAL( 1, SharedPointerTester< 0 >::static_counter_ );
{
SharedPointer< SharedPointerTester< 0 > > sp( rawPointer );
}
CPPUNIT_ASSERT_EQUAL( 0, SharedPointerTester< 0 >::static_counter_ );
// Testing copy constructor.
rawPointer = new SharedPointerTester< 0 >();
{
SharedPointer< SharedPointerTester< 0 > > sp0( rawPointer );
CPPUNIT_ASSERT_EQUAL( 1, SharedPointerTester< 0 >::static_counter_ );
CPPUNIT_ASSERT_EQUAL( static_cast<size_t>( 1 ), sp0.useCount() );
{
SharedPointer< SharedPointerTester< 0 > > sp1( sp0 );
CPPUNIT_ASSERT_EQUAL( 1, SharedPointerTester< 0 >::static_counter_ );
CPPUNIT_ASSERT_EQUAL( static_cast<size_t>( 2 ), sp0.useCount() );
CPPUNIT_ASSERT_EQUAL( static_cast<size_t>( 2 ), sp1.useCount() );
CPPUNIT_ASSERT_EQUAL( rawPointer, sp0.get() );
CPPUNIT_ASSERT_EQUAL( rawPointer, sp1.get() );
}
CPPUNIT_ASSERT_EQUAL( 1, SharedPointerTester< 0 >::static_counter_ );
CPPUNIT_ASSERT_EQUAL( static_cast<size_t>( 1 ), sp0.useCount() );
CPPUNIT_ASSERT_EQUAL( rawPointer, sp0.get() );
}
CPPUNIT_ASSERT_EQUAL( 0, SharedPointerTester< 0 >::static_counter_ );
// Testing construction of an empty shared pointer.
{
SharedPointer< SharedPointerTester< 0 > > sp0;
CPPUNIT_ASSERT( 0 == sp0.get() );
}
CPPUNIT_ASSERT_EQUAL( 0, SharedPointerTester< 0 >::static_counter_ );
}
void test3(){
SharePtr<int> sp(new int(1));
SharePtr<int> sp1(sp);
SharePtr<int> sp5(sp);
SharePtr<int> sp6(sp);
SharePtr<int> sp7(sp);
SharePtr<int> sp3(new int(2));
SharePtr<int> sp4(sp3);
SharePtr<int> sp8(sp3);
SharePtr<int> sp9(sp3);
SharePtr<int> sp10(sp3);
//sp3 = sp1;
//*sp3 = 20;
}
int main(int argc, char * argv[]){
Triangle t1(3,3,3,1,1);
Square s1(6,2,2);
Circle c1(7,3,3);
Sphere sp1(10,4,4,4);
Cube cu1(10,5,5,5);
Tetrahedron te1(5,6,7,8,9,10,6,6,6);
Cube cu2(5,7,7,7);
Square s2(16,8,8);
Circle c2(1,9,9);
Circle c3(55,10,10);
Square s3(3,11,11);
Tetrahedron te2(3,3,3,3,3,3,12,12,12);
Shape * arr = new Shape[12];
arr[0] = t1;
arr[1] = s1;
arr[2] = c1;
arr[3] = sp1;
arr[4] = cu1;
arr[5] = te1;
arr[6] = cu2;
arr[7] = s2;
arr[8] = c2;
arr[9] = c3;
arr[10] = s3;
arr[11] = te2;
for(int i = 0; i < 11; ++i){
cout << endl;
if(arr[i].getT() == 2){
cout << "2-D Shape Found" << endl;
cout << "Points are: (" << arr[i].getX() << ", " << arr[i].getY() << ")" << endl;
cout << "Area is: " << arr[i].getArea() << endl;
}
else{
cout << "3-D Shape" << endl;
cout << "At Pt: (" << arr[i].getX() << ", " << arr[i].getY() << ", " << arr[i].getZ() <<")" << endl;
cout << "Surface Area is: " << arr[i].getSurface() << endl;
cout << "Volume is: " << arr[i].getVolume() << endl;
}
}
delete[] arr;
return 0;
}
int main()
{
shared_ptr<resource> sp0(new resource(0));
shared_ptr<resource> sp1(new resource(1));
show("sp0 before swap", sp0);
show("sp1 before swap", sp1);
sp0.swap(sp1);
show("sp0 after swap", sp0);
show("sp1 after swap", sp1);
swap(sp0, sp1);
show("sp0 after second swap", sp0);
show("sp1 after second swap", sp1);
return 0;
}
float calVelUpdateStepLen(const FwiParams ¶ms,
const float *wlt,
const float *dobs,
const float *derr,
float epsil,
const EnquistAbc2d &fmMethod,
const ShotPosition &allSrcPos,
const ShotPosition &allGeoPos
)
{
int nt = params.nt;
int nz = params.nz;
int nx = params.nx;
int ng = params.ng;
int ns = params.ns;
std::vector<float> dcal(ng, 0); /* calculated/synthetic seismic data */
std::vector<float> sp0(nz * nx); /* source wavefield p0 */
std::vector<float> sp1(nz * nx); /* source wavefield p1 */
std::vector<float> sp2(nz * nx); /* source wavefield p2 */
std::vector<float> alpha1(ng, 0); /* numerator of alpha, length=ng */
std::vector<float> alpha2(ng, 0); /* denominator of alpha, length=ng */
for (int is = 0; is < ns; is++) {
std::fill(sp0.begin(), sp0.end(), 0);
std::fill(sp1.begin(), sp1.end(), 0);
ShotPosition currSrcPos = allSrcPos.clip(is);
for (int it = 0; it < nt; it++) {
fmMethod.addSource(&sp1[0], &wlt[it], currSrcPos);
fmMethod.stepForward(&sp0[0], &sp1[0], &sp2[0]);
cycleSwap(sp0, sp1, sp2);
fmMethod.recordSeis(&dcal[0], &sp0[0], allGeoPos);
sum_alpha12(&alpha1[0], &alpha2[0], &dcal[0], &dobs[is * nt * ng + it * ng], &derr[is * ng * nt + it * ng], ng);
}
}
float alpha = cal_alpha(&alpha1[0], &alpha2[0], epsil, ng);
return alpha;
}
int main()
{
iset data;
spi sp0(new int(0));
spi sp1(new int(1));
spi sp2(new int(2));
spi sp3(sp1);
spi sp4(new int(1));
data.insert(sp0);
data.insert(sp1);
data.insert(sp2);
lookup(data, sp1);
lookup(data, sp3);
lookup(data, sp4);
return 0;
}
void
OpenSteer::SharedPointerTest::testSwap()
{
Super* rawSuperPointer0 = new Super();
SharedPointer< Super > sp0( rawSuperPointer0 );
Super* rawSuperPointer1 = new Super();
SharedPointer< Super > sp1( rawSuperPointer1 );
CPPUNIT_ASSERT_EQUAL( 2, Super::superCount_ );
sp0.swap( sp1 );
CPPUNIT_ASSERT( rawSuperPointer0 == sp1.get() );
CPPUNIT_ASSERT( rawSuperPointer1 == sp0.get() );
CPPUNIT_ASSERT_EQUAL( 2, Super::superCount_ );
}
//Create a triangle that contains all other vertices
Triangle createSuperTriangle(const std::vector<Vector2>& vertices)
{
float M = vertices[0].mX;
//Get max X and Y
for (std::vector<Vector2>::const_iterator it = vertices.begin(); it != vertices.end(); ++it)
{
float xAbs = fabs(it->mX);
float yAbs = fabs(it->mY);
if (xAbs > M) M = xAbs;
if (yAbs > M) M = yAbs;
}
//Create super triangle
Vector2 sp1(10 * M, 0);
Vector2 sp2(0, 10 * M);
Vector2 sp3(-10 * M, -10 * M);
return Triangle(sp1, sp2, sp3);
}
void testwhile()
{
A *pA = new A();
boost::shared_ptr<A> sp1(pA);
int i=0;
while(i < 10)
{
i++;
std::cout<<"begin The Smartptr now has "<<sp1.use_count()<<" references\n";
{
boost::shared_ptr<A> sp2 = sp1;
std::cout<<"in The Smartptr now has "<<sp1.use_count()<<" references\n";
}
std::cout<<"end The Smartptr now has "<<sp1.use_count()<<" references\n";
}
}
void testcopy()
{
A *pA = new A();
A *pB = new A();
boost::shared_ptr<A> sp1(pA);
boost::shared_ptr<A> sp2(pB);
boost::shared_ptr<A> sp3;
std::cout<<"testcopy The Smartptr now has "<<sp1.use_count()<<" references\n";
sp3= sp1;
std::cout<<"testcopy The Smartptr now has "<<sp1.use_count()<<" references\n";
//sp3= sp2;
std::cout<<"testcopy The Smartptr now has "<<sp1.use_count()<<" references\n";
}
int main()
{
std::shared_ptr<int> sp1(new int(5));
std::weak_ptr<int> wp1 = sp1; // sp1 owns the memory.
{
std::shared_ptr<int> sp2 = wp1.lock(); // Now sp1 and sp2 own the memory.
if (sp2) // Always check to see if the memory still exists.
{
std::cout << "Do something with sp2." << std::endl;
}
} // sp2 is destroyed. Memory is owned by sp1.
sp1.reset(); // Memory is deleted.
std::shared_ptr<int> sp3 = wp1.lock(); // Memory is gone, so we get an empty
if (sp3) // shared_ptr.
{
// Will not execute this.
std::cout << "This should NOT be printed!" << std::endl;
}
}
void testSharePtrFree()
{
SharedPtr<int,Free<int>> sp1((int *)malloc(sizeof(int)*10));
SharedPtr<int,Free<int>> sp2(sp1);
}
void testSharePtrDelete()
{
SharedPtr<int> sp1(new int(5));
SharedPtr<int> sp2(sp1);
}
bool ossimImageUtil::initialize(ossimArgumentParser& ap)
{
static const char M[] = "ossimImageUtil::initialize(ossimArgumentParser&)";
if ( traceDebug() )
{
ossimNotify(ossimNotifyLevel_DEBUG) << M << " entered...\n";
}
bool result = true;
if ( (ap.argc() == 1) || ap.read("-h") || ap.read("--help") )
{
usage(ap);
// continue_after_init to false
result = false;
}
else
{
//---
// Start with clean options keyword list.
//---
m_kwl->clear();
while ( 1 ) // While forever loop...
{
// Used throughout below:
std::string ts1;
ossimArgumentParser::ossimParameter sp1(ts1);
std::string ts2;
ossimArgumentParser::ossimParameter sp2(ts2);
if( ap.read("-a") || ap.read("--include-fullres") )
{
setCopyAllFlag( true );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("--compression-quality", sp1) )
{
if ( ts1.size() )
{
setCompressionQuality( ts1 );
}
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("--compression-type", sp1) )
{
if ( ts1.size() )
{
setCompressionType( ts1 );
}
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("--ch") || ap.read("--create-histogram") )
{
setCreateHistogramFlag( true );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("--chf") || ap.read("--create-histogram-fast") )
{
setCreateHistogramFastFlag( true );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("--create-histogram-r0") )
{
setCreateHistogramR0Flag( true );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("-d", sp1) )
{
setOutputDirectory( ts1 );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("--dump-filtered-image-list") )
{
setDumpFilteredImageListFlag( true );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("-i") || ap.read("--internal-overviews") )
{
setInternalOverviewsFlag( true );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("--of") || ap.read("--output-files") )
{
setOutputFileNamesFlag( true );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("-o") )
{
setCreateOverviewsFlag( true );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("--ot", sp1) )
{
setOverviewType( ts1 );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("--override-filtered-images") )
{
setOverrideFilteredImagesFlag( true );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("-r") || ap.read("--rebuild-overviews") )
{
setRebuildOverviewsFlag( true );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("--rebuild-histogram") )
{
setRebuildHistogramFlag( true );
if ( ap.argc() < 2 )
{
break;
}
}
while(ap.read("--reader-prop", sp1))
{
if (ts1.size())
{
std::string key = READER_PROP_KW;
key += ossimString::toString( getNextReaderPropIndex() ).string();
addOption( key, ts1 );
}
}
if ( ap.argc() < 2 )
{
break;
}
if( ap.read("--scanForMinMax" ) )
{
setScanForMinMax( true );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("--scanForMinMaxNull" ) )
{
setScanForMinMaxNull( true );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("-s", sp1) )
{
setOverviewStopDimension( ts1 );
if ( ap.argc() < 2 )
{
break;
}
}
if ( ap.read("-tile-size", sp1))
{
setTileSize( ossimString(ts1).toInt32() );
if ( ap.argc() < 2 )
{
break;
}
}
if( ap.read("--threads", sp1) )
{
m_kwl->addPair( THREADS_KW, ts1 );
if ( ap.argc() < 2 )
{
break;
}
}
while(ap.read("--writer-prop", sp1))
{
if (ts1.size())
{
std::string key = WRITER_PROP_KW;
key += ossimString::toString( getNextWriterPropIndex() ).string();
addOption( key, ts1 );
}
}
if ( ap.argc() < 2 )
{
break;
}
// End of arg parsing.
ap.reportRemainingOptionsAsUnrecognized();
if ( ap.errors() )
{
ap.writeErrorMessages(ossimNotify(ossimNotifyLevel_NOTICE));
std::string errMsg = "Unknown option...";
throw ossimException(errMsg);
}
break; // Break from while forever.
} // End while (forever) loop.
if(ap.argc() > 1)
{
for (ossim_int32 i = 0; i < (ap.argc()-1); ++i)
{
ossimString kw = "file";
kw += ossimString::toString(i);
std::string value = ap[i+1];
m_kwl->addPair(kw.string(), value, true);
}
}
else
{
if ( getDumpFilterImagesFlag() )
{
// Caller wants to see filtered image names:
dumpFilteredImageList();
}
else
{
usage(ap);
result = false;
}
}
} // not usage
if ( traceDebug() )
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "m_kwl:\n" << *(m_kwl.get()) << "\n"
<< M << " exit result = " << (result?"true":"false")
<< "\n";
}
return result;
}
bool ossimViewshedUtil::initialize(ossimArgumentParser& ap)
{
// Base class first:
if (!ossimUtility::initialize(ap))
return false;
std::string ts1;
ossimArgumentParser::ossimParameter sp1(ts1);
std::string ts2;
ossimArgumentParser::ossimParameter sp2(ts2);
std::string ts3;
ossimArgumentParser::ossimParameter sp3(ts3);
if (ap.read("--dem", sp1) || ap.read("--dem-file", sp1))
m_demFile = ts1;
if ( ap.read("--fov", sp1, sp2) )
{
m_startFov = ossimString(ts1).toDouble();
m_stopFov = ossimString(ts2).toDouble();
if (m_startFov < 0)
m_startFov += 360.0;
}
if ( ap.read("--gsd", sp1) )
m_gsd = ossimString(ts1).toDouble();
if ( ap.read("--hgt-of-eye", sp1) || ap.read("--height-of-eye", sp1) )
m_obsHgtAbvTer = ossimString(ts1).toDouble();
if ( ap.read("--horizon", sp1) || ap.read("--horizon-file", sp1))
m_horizonFile = ossimString(ts1);
if ( ap.read("--lut", sp1) || ap.read("--lut-file", sp1))
m_lutFile = ts1;
if ( ap.read("--observer", sp1, sp2) )
{
m_observerGpt.lat = ossimString(ts1).toDouble();
m_observerGpt.lon = ossimString(ts2).toDouble();
m_observerGpt.hgt = 0.0;
}
if ( ap.read("--radius", sp1) )
m_visRadius = ossimString(ts1).toDouble();
if ( ap.read("--reticle", sp1) )
m_reticleSize = ossimString(ts1).toInt32();
if ( ap.read("--tbs") )
m_threadBySector = true;
if ( ap.read("--simulation") )
m_simulation = true;
if ( ap.read("--summary") )
m_outputSummary = true;
if ( ap.read("--size", sp1) )
m_halfWindow = ossimString(ts1).toUInt32() / 2;
if ( ap.read("--threads", sp1) )
m_numThreads = ossimString(ts1).toUInt32();
if ( ap.read("--values", sp1, sp2, sp3) )
{
m_visibleValue = ossimString(ts1).toUInt8();
m_hiddenValue = ossimString(ts2).toUInt8();
m_observerValue = ossimString(ts3).toUInt8();
}
// There should only be the required command line args left:
if ( (m_observerGpt.hasNans() && (ap.argc() != 4)) ||
(!m_observerGpt.hasNans() && (ap.argc() != 2)) )
{
setUsage(ap);
return false;
}
// Verify minimum required args were specified:
if (m_demFile.empty() && (m_visRadius == 0) && (m_halfWindow == 0))
{
ossimNotify(ossimNotifyLevel_WARN)
<< "ossimViewshedUtil::initialize ERR: Command line is underspecified."
<< std::endl;
setUsage(ap);
return false;
}
// Parse the required command line params:
int ap_idx = 1;
if (m_observerGpt.hasNans())
{
m_observerGpt.lat = ossimString(ap[1]).toDouble();
m_observerGpt.lon = ossimString(ap[2]).toDouble();
m_observerGpt.hgt = 0;
ap_idx = 3;
}
m_filename = ap[ap_idx];
return initializeChain();
}
void run()
{
const Real world_size(1e-6);
const Position3 edge_lengths(world_size, world_size, world_size);
const Real volume(world_size * world_size * world_size);
const Integer N(60);
const std::string D("1e-12"), radius("2.5e-9");
// const Real kD(
// 4 * M_PI * (2 * std::atof(D.c_str())) * (2 * std::atof(radius.c_str())));
const Real kd(0.1), U(0.5);
const Real ka(kd * volume * (1 - U) / (U * U * N));
#if (STYPE == EGFRD_MODE) || (STYPE == BD_MODE)
const Real k2(ka), k1(kd);
#else
const Real k2(ka * kD / (ka + kD));
const Real k1(k2 * kd / ka);
#endif
Species sp1("A", radius, D), sp2("B", radius, D), sp3("C", radius, D);
ReactionRule rr1(create_unbinding_reaction_rule(sp1, sp2, sp3, k1)),
rr2(create_binding_reaction_rule(sp2, sp3, sp1, k2));
boost::shared_ptr<NetworkModel> model(new NetworkModel());
model->add_species_attribute(sp1);
model->add_species_attribute(sp2);
model->add_species_attribute(sp3);
model->add_reaction_rule(rr1);
model->add_reaction_rule(rr2);
boost::shared_ptr<GSLRandomNumberGenerator>
rng(new GSLRandomNumberGenerator());
rng->seed(time(NULL));
#if STYPE == EGFRD_MODE
const Integer matrix_size(3);
boost::shared_ptr<world_type> world(
new world_type(world_size, matrix_size, rng));
#elif STYPE == BD_MODE
boost::shared_ptr<world_type> world(new world_type(edge_lengths, rng));
#elif STYPE == ODE_MODE
boost::shared_ptr<world_type> world(new world_type(volume));
#else // STYPE == GILLESPIE_MODE
boost::shared_ptr<world_type> world(new world_type(volume, rng));
#endif
world->add_molecules(sp1, N);
simulator_type sim(model, world);
#if STYPE == BD_MODE
sim.set_dt(1e-3);
#endif
Real next_time(0.0), dt(0.02);
// sim.save_hdf5_init(std::string("mapk.hdf5"));
std::cout << sim.t()
<< "\t" << world->num_molecules(sp1)
<< "\t" << world->num_molecules(sp2)
<< "\t" << world->num_molecules(sp3)
<< std::endl;
for (unsigned int i(0); i < 100; ++i)
{
next_time += dt;
while (sim.step(next_time)) {}
std::cout << sim.t()
<< "\t" << world->num_molecules(sp1)
<< "\t" << world->num_molecules(sp2)
<< "\t" << world->num_molecules(sp3)
<< std::endl;
// sim.save_hdf5();
}
}
int main(int argc, char **argv)
{
// Traits typedefs
// {{{
// typedef ::World< ::CyclicWorldTraits<Real> > world_type;
// typedef EGFRDSimulator< ::EGFRDSimulatorTraitsBase<world_type> >
// simulator_type;
typedef ecell4::egfrd::EGFRDWorld world_type;
typedef ecell4::egfrd::EGFRDSimulator simulator_type;
typedef simulator_type::multi_type multi_type;
// }}}
// Constants
// {{{
const ecell4::Real L(1e-6);
const ecell4::Real3 edge_lengths(L, L, L);
const ecell4::Integer3 matrix_sizes(3, 3, 3);
const ecell4::Real volume(L * L * L);
const ecell4::Integer N(60);
const ecell4::Real kd(0.1), U(0.5);
const ecell4::Real ka(kd * volume * (1 - U) / (U * U * N));
const ecell4::Real k2(ka), k1(kd);
const ecell4::Integer dissociation_retry_moves(3);
// }}}
boost::shared_ptr<ecell4::NetworkModel>
model(new ecell4::NetworkModel());
// add ::SpeciesType to ::ParticleModel
// {{{
ecell4::Species sp1(
std::string("A"), std::string("2.5e-09"), std::string("1e-12"));
model->add_species_attribute(sp1);
ecell4::Species sp2(
std::string("B"), std::string("2.5e-09"), std::string("1e-12"));
model->add_species_attribute(sp2);
ecell4::Species sp3(
std::string("C"), std::string("2.5e-09"), std::string("1e-12"));
model->add_species_attribute(sp3);
// }}}
// ReactionRules
// {{{
// A -> B + C k1
// {{{
ecell4::ReactionRule rr1(
ecell4::create_unbinding_reaction_rule(sp1, sp2, sp3, k1));
model->add_reaction_rule(rr1);
// }}}
// B + C -> A k2
// {{{
ecell4::ReactionRule rr2(
ecell4::create_binding_reaction_rule(sp2, sp3, sp1, k2));
model->add_reaction_rule(rr2);
// }}}
// }}}
// Random Number Generator (Instanciate and Initialize)
// {{{
// boost::shared_ptr<ecell4::GSLRandomNumberGenerator>
boost::shared_ptr<ecell4::RandomNumberGenerator>
rng(new ecell4::GSLRandomNumberGenerator());
rng->seed((unsigned long int)0);
// rng->seed(time(NULL));
// }}}
// World Definition
// {{{
boost::shared_ptr<world_type>
world(new world_type(edge_lengths, matrix_sizes, rng));
world->bind_to(model);
// }}}
// add ecell4::Species( ::SpeciesInfo) to ::World
// {{{
// world->add_species(ecell4::Species("A"));
// world->add_species(ecell4::Species("B"));
// world->add_species(ecell4::Species("C"));
// }}}
// Thorow particles into world at random
// {{{
world->add_molecules(ecell4::Species("A"), N);
typedef std::vector<std::pair<ecell4::ParticleID, ecell4::Particle> >
particle_id_pair_list;
const particle_id_pair_list particles(world->list_particles());
for (particle_id_pair_list::const_iterator i(particles.begin());
i != particles.end(); ++i)
{
const ecell4::Real3 pos((*i).second.position());
std::cout << "(" << pos[0] << pos[1] << pos[2] << ")" << std::endl;
}
// }}}
// Logger Settings
// {{{
boost::shared_ptr< ::LoggerManager> logger_mng(
new ::LoggerManager("dummy", ::Logger::L_WARNING));
::LoggerManager::register_logger_manager(
"ecell.EGFRDSimulator", logger_mng);
// }}}
// EGFRDSimulator instance generated
// {{{
boost::shared_ptr<simulator_type> sim(
new simulator_type(world, model, dissociation_retry_moves));
// sim->paranoiac() = true;
sim->initialize();
// }}}
// Simulation Executed
// {{{
ecell4::Real next_time(0.0), dt(0.02);
std::cout << sim->t() << "\t"
<< world->num_molecules_exact(sp1) << "\t"
<< world->num_molecules_exact(sp2) << "\t"
<< world->num_molecules_exact(sp3) << "\t" << std::endl;
// for (int i(0); i < 10; i++)
// for (int i(0); i < 100; i++)
for (int i(0); i < 100; i++)
{
next_time += dt;
while (sim->step(next_time))
{
// if (sim->last_reactions().size() > 0)
// {
// std::cout << sim->t() << "\t"
// << world->num_molecules_exact(sp1) << "\t"
// << world->num_molecules_exact(sp2) << "\t"
// << world->num_molecules_exact(sp3) << "\t" << std::endl;
// }
}
std::cout << sim->t() << "\t"
<< world->num_molecules_exact(sp1) << "\t"
<< world->num_molecules_exact(sp2) << "\t"
<< world->num_molecules_exact(sp3) << "\t" << std::endl;
}
// }}}
// world->save("test.h5");
// Statistics
// {{{
int num_single_steps_per_type[simulator_type::NUM_SINGLE_EVENT_KINDS];
num_single_steps_per_type[simulator_type::SINGLE_EVENT_REACTION]
= sim->num_single_steps_per_type(simulator_type::SINGLE_EVENT_REACTION);
num_single_steps_per_type[simulator_type::SINGLE_EVENT_ESCAPE]
= sim->num_single_steps_per_type(simulator_type::SINGLE_EVENT_ESCAPE);
std::cout << (boost::format("%1%: %2% \n")
% "SINGLE_EVENT_REACTION"
% num_single_steps_per_type[simulator_type::SINGLE_EVENT_REACTION]);
std::cout << (boost::format("%1%: %2% \n")
% "SINGLE_EVENT_ESCAPE"
% num_single_steps_per_type[simulator_type::SINGLE_EVENT_ESCAPE]);
std::cout << (boost::format("%1%: %2% \n")
% "PAIR_EVENT_SINGLE_REACTION_0"
% sim->num_pair_steps_per_type(
simulator_type::PAIR_EVENT_SINGLE_REACTION_0));
std::cout << (boost::format("%1%: %2% \n")
% "PAIR_EVENT_SINGLE_REACTION_1"
% sim->num_pair_steps_per_type(
simulator_type::PAIR_EVENT_SINGLE_REACTION_1));
std::cout << (boost::format("%1%: %2% \n")
% "PAIR_EVENT_COM_ESCAPE"
% sim->num_pair_steps_per_type(simulator_type::PAIR_EVENT_COM_ESCAPE));
std::cout << (boost::format("%1%: %2% \n")
% "PAIR_EVENT_IV_UNDETERMINED"
% sim->num_pair_steps_per_type(
simulator_type::PAIR_EVENT_IV_UNDETERMINED));
std::cout << (boost::format("%1%: %2% \n")
% "PAIR_EVENT_IV_ESCAPE"
% sim->num_pair_steps_per_type(simulator_type::PAIR_EVENT_IV_ESCAPE));
std::cout << (boost::format("%1%: %2% \n")
% "PAIR_EVENT_IV_REACTION"
% sim->num_pair_steps_per_type(simulator_type::PAIR_EVENT_IV_REACTION));
std::cout << (boost::format("%1%: %2% \n")
% "NONE" % sim->num_multi_steps_per_type(multi_type::NONE));
std::cout << (boost::format("%1%: %2% \n")
% "ESCAPE" % sim->num_multi_steps_per_type(multi_type::ESCAPE));
std::cout << (boost::format("%1%: %2% \n")
% "REACTION" % sim->num_multi_steps_per_type(multi_type::REACTION));
// }}}
// {
// boost::scoped_ptr<world_type>
// world2(new world_type(ecell4::Real3(1, 2, 3), ecell4::Integer3(3, 6, 9)));
// std::cout << "edge_lengths:" << world2->edge_lengths()[0] << " " << world2->edge_lengths()[1] << " " << world2->edge_lengths()[2] << std::endl;
// std::cout << "matrix_sizes:" << world2->matrix_sizes()[0] << " " << world2->matrix_sizes()[1] << " " << world2->matrix_sizes()[2] << std::endl;
// std::cout << "num_particles: " << world2->num_particles() << std::endl;
// world2->load("test.h5");
// std::cout << "edge_lengths:" << world2->edge_lengths()[0] << " " << world2->edge_lengths()[1] << " " << world2->edge_lengths()[2] << std::endl;
// std::cout << "matrix_sizes:" << world2->matrix_sizes()[0] << " " << world2->matrix_sizes()[1] << " " << world2->matrix_sizes()[2] << std::endl;
// std::cout << "num_particles: " << world2->num_particles() << std::endl;
// }
return 0;
}
void LinearSMCimproved::predictionPerturbation(const SiconosVector& xTk, SimpleMatrix& CBstar)
{
if (_us->normInf() < _alpha)
{
if (_inDisceteTimeSlidingPhase)
{
SiconosVector& up = *_up;
if (_measuredPert->full())
{
if (_measuredPert->size() > 1)
{
_measuredPert->rotate(_measuredPert->end()-1);
_predictedPert->rotate(_predictedPert->end()-1);
}
}
else
{
// inject new vector in the case where the measurement vector is not full.
SP::SiconosVector sp1(new SiconosVector(_us->size(), 0));
SP::SiconosVector sp2(new SiconosVector(_us->size(), 0));
_measuredPert->push_front(sp1);
_predictedPert->push_front(sp2);
}
// inject new measured value and also perturbation prediction
SiconosVector& predictedPertC = *(*_predictedPert)[0];
SiconosVector& measuredPertC = *(*_measuredPert)[0];
// Cp_k = s_k + Cp_k-tilde
prod(*_Csurface, xTk, measuredPertC);
measuredPertC += *(*_predictedPert)[std::min((unsigned int)1, (unsigned int)_predictedPert->size()-1)];
// compute prediction
switch(_measuredPert->size()-1)
{
case 0:
predictedPertC = measuredPertC;
break;
case 1:
predictedPertC = 2*measuredPertC - *(*_measuredPert)[1];
break;
case 2:
predictedPertC = 3*measuredPertC - 3*(*(*_measuredPert)[1]) + *(*_measuredPert)[2];
break;
default:
RuntimeException::selfThrow("LinearSMCimproved::predictionPerturbation: unknown order " + _measuredPert->size());
}
// Compute the control to counteract the perturbation
up = predictedPertC;
up *= -1;
CBstar.PLUForwardBackwardInPlace(up);
// project onto feasible set
double norm = up.norm2();
if (norm > _ubPerturbation)
{
up *= _ubPerturbation/norm;
predictedPertC *= _ubPerturbation/norm;
}
}
else
_inDisceteTimeSlidingPhase = true;
}
else if (_inDisceteTimeSlidingPhase)
{
_inDisceteTimeSlidingPhase = false;
_up->zero();
}
}